Lend and borrow with Yield.xyz

import { Portal } from '@portal-hq/core'

const portal = new Portal({
  apiKey: 'YOUR_PORTAL_CLIENT_API_KEY',
  backup: {
    /* ... */
  },
  // Without gatewayConfig, Portal's gateway serves the built-in chains, Base included.
})

const addresses = await portal.addresses
const address = addresses?.eip155
if (!address) throw new Error('No EVM address found')

const { data: integrations } = await portal.borrow.yieldxyz.getIntegrations()

for (const integration of integrations) {
  console.log(
    integration.id, // e.g. 'aave-borrow'
    integration.networks, // e.g. ['eip155:1', 'eip155:8453', ...]
    integration.actions.map((action) => action.id), // e.g. ['supply', 'borrow', 'repay', 'withdraw', ...]
  )
}

const { data: aave } = await portal.borrow.yieldxyz.getIntegration('aave-borrow')
const supplyArgsSchema = aave.actions.find((action) => action.id === 'supply')?.schema
console.log(supplyArgsSchema)

const { data: page } = await portal.borrow.yieldxyz.getMarkets({
  integrationId: 'aave-borrow',
  network: 'eip155:8453',
  scope: 'all',
  limit: 50,
})

for (const market of page.items) {
  console.log(market.id, market.loanToken.symbol, market.borrowRate, market.availableLiquidity)
}

const { data: market } = await portal.borrow.yieldxyz.getMarket(
  'aave-borrow-base-0x833589fcd6edb6e08f4c7c32d4f71b54bda02913',
)
for (const { token, maxLtv, liquidationThreshold } of market.collateralTokens) {
  console.log(`${token.symbol}: max LTV ${maxLtv}, liquidation threshold ${liquidationThreshold}`)
}

const { data: action } = await portal.borrow.yieldxyz.createAction({
  integrationId: 'aave-borrow',
  action: 'supply',
  address,
  args: {
    marketId: 'aave-borrow-base-0x833589fcd6edb6e08f4c7c32d4f71b54bda02913',
    tokenAddress: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', // USDC on Base
    amount: '5',
  },
})

// Show the predicted impact before the user signs. A `null` health factor means unknown, never safe.
console.log('Predicted health factor:', action.metadata?.predictedHealthFactor ?? 'unknown')
console.log('Predicted LTV:', action.metadata?.predictedLtv ?? 'unknown')
console.log(action.transactions.map((transaction) => transaction.type)) // e.g. ['APPROVAL', 'SUPPLY']

const result = await portal.borrow.yieldxyz.signAndSubmitAction(action)
console.log(result.status, result.transactions.map((transaction) => transaction.transactionHash))

const marketId = 'aave-borrow-base-0x833589fcd6edb6e08f4c7c32d4f71b54bda02913'

const { data: borrow } = await portal.borrow.yieldxyz.createAction({
  integrationId: 'aave-borrow',
  action: 'borrow',
  address,
  args: { marketId, amount: '2' },
})

const healthFactor = borrow.metadata?.predictedHealthFactor ?? null
console.log(`Health factor after borrowing: ${healthFactor ?? 'unknown'}`)

await portal.borrow.yieldxyz.signAndSubmitAction(borrow)

const { data: position } = await portal.borrow.yieldxyz.getPositions({
  integrationId: 'aave-borrow',
  network: 'eip155:8453',
  address,
})

console.log('Health factor:', position.healthFactor ?? 'unknown')
console.log('Supplied:', position.totalSuppliedUsd, 'Borrowed:', position.totalBorrowedUsd)

for (const balance of position.debtBalances) {
  console.log(balance.tokenSymbol, balance.balance, balance.pendingActions.map((pending) => pending.type))
}

const repay = position.debtBalances[0]?.pendingActions.find((pending) => pending.type === 'repay')

if (repay) {
  const { data: action } = await portal.borrow.yieldxyz.createAction({
    integrationId: position.integrationId,
    action: 'repay',
    address,
    args: repay.args,
  })
  await portal.borrow.yieldxyz.signAndSubmitAction(action)
}

const marketId = 'aave-borrow-base-0x833589fcd6edb6e08f4c7c32d4f71b54bda02913'

const { data: repay } = await portal.borrow.yieldxyz.createAction({
  integrationId: 'aave-borrow',
  action: 'repay',
  address,
  args: { marketId, repayAll: true },
})
await portal.borrow.yieldxyz.signAndSubmitAction(repay)

const { data: withdraw } = await portal.borrow.yieldxyz.createAction({
  integrationId: 'aave-borrow',
  action: 'withdraw',
  address,
  args: {
    marketId,
    tokenAddress: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913',
    amount: '5',
  },
})
await portal.borrow.yieldxyz.signAndSubmitAction(withdraw)

const result = await portal.borrow.yieldxyz.executeAction(
  {
    integrationId: 'aave-borrow',
    action: 'borrow',
    address,
    args: { marketId: 'aave-borrow-base-0x833589fcd6edb6e08f4c7c32d4f71b54bda02913', amount: '2' },
  },
  { onProgress: (event) => console.log(event.step, event.transactionId ?? '') },
)

import type { YieldXyzBorrowExecutionProgress } from '@portal-hq/core'

function onProgress(event: YieldXyzBorrowExecutionProgress) {
  switch (event.step) {
    case 'signing':
      console.log(`Signing transaction ${event.transactionId}`)
      break
    case 'confirming':
      console.log(`Broadcast ${event.broadcastHash}`)
      break
    case 'confirmed':
      console.log(`Confirmed ${event.transactionHash}`)
      break
    case 'nextStep':
      console.log(`Step ${event.currentStep} of ${event.totalSteps}`)
      break
    case 'failed':
      console.error(`Stopped: ${event.error?.reason}`)
      break
  }
}

await portal.borrow.yieldxyz.signAndSubmitAction(action, { onProgress })

import { Alert } from 'react-native'
import { PortalRequestMethod, type YieldXyzBorrowSignAndSendTransaction } from '@portal-hq/core'

function confirmWithUser(message: string): Promise<boolean> {
  return new Promise((resolve) =>
    Alert.alert('Confirm transaction', message, [
      { text: 'Cancel', style: 'cancel', onPress: () => resolve(false) },
      { text: 'Send', onPress: () => resolve(true) },
    ]),
  )
}

const signAndSendTransaction: YieldXyzBorrowSignAndSendTransaction = async (transaction, chainId) => {
  if (!(await confirmWithUser(`Send this transaction to ${transaction.to} on ${chainId}?`))) {
    return undefined // stops the execution with SIGNATURE_REJECTED
  }
  return portal.request(PortalRequestMethod.EthSendTransaction, [transaction], chainId)
}

await portal.borrow.yieldxyz.signAndSubmitAction(action, { signAndSendTransaction })

import {
  YieldXyzBorrowExecutionError,
  YieldXyzBorrowExecutionErrorReason,
  type YieldXyzBorrowAction,
} from '@portal-hq/core'

function recordBroadcastHash(error: YieldXyzBorrowExecutionError, broadcastHashes: Record<string, string>) {
  if (!error.transactionId) return
  if (error.reason === YieldXyzBorrowExecutionErrorReason.UserOperationFailed) {
    delete broadcastHashes[error.transactionId]
  } else if (error.broadcastHash) {
    broadcastHashes[error.transactionId] = error.broadcastHash
  }
}

const broadcastHashes: Record<string, string> = {}
let pending: YieldXyzBorrowAction = action

// Call once to execute, and again only when the user chooses to retry.
async function execute() {
  try {
    return await portal.borrow.yieldxyz.signAndSubmitAction(pending, { broadcastHashes })
  } catch (error) {
    if (YieldXyzBorrowExecutionError.is(error)) {
      recordBroadcastHash(error, broadcastHashes)
      pending = error.action ?? pending
    }
    throw error
  }
}

try {
  await execute()
} catch (error) {
  if (!YieldXyzBorrowExecutionError.is(error)) throw error
  if (
    error.reason === YieldXyzBorrowExecutionErrorReason.SigningFailed &&
    error.transactionId &&
    !error.broadcastHash
  ) {
    // The transaction may still have been sent. Don't offer a retry until you have checked the wallet's
    // transactions on that chain; if you find it, add its hash to broadcastHashes under error.transactionId.
  } else {
    // Persist `pending` and `broadcastHashes`, and call execute() again when the user retries.
    // The table below lists the reasons that can't be retried as is.
  }
}

import {
  YieldXyzBorrowExecutionError,
  getYieldXyzBorrowApiError,
  isYieldXyzBorrowRateLimitError,
  isYieldXyzBorrowSchemaDriftError,
} from '@portal-hq/core'

try {
  await portal.borrow.yieldxyz.signAndSubmitAction(action)
} catch (error) {
  if (isYieldXyzBorrowSchemaDriftError(error)) {
    console.error('Yield.xyz Borrow is temporarily unavailable.')
  } else if (isYieldXyzBorrowRateLimitError(error)) {
    console.error('Rate limited by Yield.xyz; try again shortly.')
  } else if (YieldXyzBorrowExecutionError.is(error)) {
    console.error(error.reason, error.actionId, error.transactionId, error.broadcastHash)
  }

  const apiError = getYieldXyzBorrowApiError(error)
  if (apiError) {
    console.error(apiError.status, apiError.id, apiError.errorMessage, apiError.details)
  }
}

const { data: actions } = await portal.borrow.yieldxyz.getActions({
  address,
  integrationId: 'aave-borrow',
  statuses: ['SUCCESS', 'FAILED'],
  limit: 20,
})

for (const item of actions.items) {
  console.log(item.id, item.action, item.status, item.createdAt)
}

// Read one action back by id, for example the one createAction returned
const { data: current } = await portal.borrow.yieldxyz.getAction(action.id)
console.log(current.status, current.currentStep, current.totalSteps)

const { data: liquidations } = await portal.borrow.yieldxyz.getLiquidations({
  integrationId: 'morpho-blue-borrow',
  network: 'eip155:1',
  address,
})
console.log(liquidations.total)

const transactionId = action.transactions[0].id

// Reports the hash to Yield.xyz; it does not wait for the transaction to confirm.
const { data: submitted } = await portal.borrow.yieldxyz.submitTransaction(transactionId, {
  transactionHash: '0x...',
})
console.log(submitted.status, submitted.link)

// Advance only once the current step is confirmed and another step follows.
const { data: current } = await portal.borrow.yieldxyz.getAction(action.id)
const stepConfirmed = current.transactions.every(
  ({ status }) => status === 'CONFIRMED' || status === 'SKIPPED',
)
if (current.hasNextStep && stepConfirmed) {
  const { data: next } = await portal.borrow.yieldxyz.stepAction(action.id)
  console.log(next.currentStep, next.transactions.length)
}