Wallet integration

curl 'https://api.xoxno.com/stellar-lending/v1/assets'
curl 'https://api.xoxno.com/stellar-lending/v1/assets?usage=borrow'
curl 'https://api.xoxno.com/stellar-lending/v1/users/GAVWFZK5BGCGBWH4O2CXAHXVRIYVAMGCTZJ24IPLVNLT2WQ2LJBDEEBP/positions'

npm install @xoxno/sdk-js@1.0.228

import {
  createStellarLendingReadClient,
  type LendingPosition,
} from '@xoxno/sdk-js/stellar-lending/read'

const network = 'mainnet' as const
const apiUrl = {
  mainnet: 'https://api.xoxno.com',
  testnet: 'https://testnet-api.xoxno.com',
}[network]
const read = createStellarLendingReadClient({ baseUrl: apiUrl })

export async function portfolio(owner: string) {
  const [positions, assets] = await Promise.all([
    read.positions(owner),
    read.assets(),
  ])
  return { positions, assets }
}

npm install @xoxno/sdk-js@1.0.228 @stellar/stellar-sdk@16.3.0

import { rpc } from '@stellar/stellar-sdk'
import {
  assertStellarPreparedTxAuth,
  buildStellarSupplyTx,
  getStellarDeployment,
  prepareStellarTxXdr,
  parseStellarTokenAmount,
  type StellarSupplyArgs,
} from '@xoxno/sdk-js/stellar-lending'

const deployment = getStellarDeployment(network)
const server = new rpc.Server(deployment.sorobanRpcUrl)

export async function prepareSupply(caller: string, selection: StellarSupplyArgs) {
  const source = await server.getAccount(caller)
  const built = buildStellarSupplyTx({
    network,
    caller,
    sourceSequence: source.sequenceNumber(),
    controllerAddress: deployment.lendingController,
    timeoutSeconds: 300,
  }, selection)
  const preparedXdr = await prepareStellarTxXdr(server, built.xdr, {
    network,
    invokedContractId: deployment.lendingController,
  })
  assertStellarPreparedTxAuth(preparedXdr, {
    network, caller, builtXdr: built.xdr,
  })
  return preparedXdr
}

const amount = parseStellarTokenAmount(inputAmount, selectedAsset.decimals)

import { Transaction, TransactionBuilder } from '@stellar/stellar-sdk'

export async function signAndSubmit(
  preparedXdr: string,
  sign: (xdr: string, networkPassphrase: string) => Promise<string>,
  persistPending: (hash: string, signedXdr: string, network: 'mainnet' | 'testnet') => Promise<void>,
) {
  const prepared = TransactionBuilder.fromXDR(preparedXdr, deployment.passphrase)
  const signedXdr = await sign(preparedXdr, deployment.passphrase)
  const signed = TransactionBuilder.fromXDR(signedXdr, deployment.passphrase)
  if (!(signed instanceof Transaction) || signed.signatures.length === 0
      || !signed.hash().equals(prepared.hash())) {
    throw new Error('Wallet must sign the prepared transaction unchanged')
  }
  const hash = signed.hash().toString('hex')
  await persistPending(hash, signedXdr, network) // Must survive reload/app switching.

  let sent: Awaited<ReturnType<typeof server.sendTransaction>>
  try {
    sent = await server.sendTransaction(signed)
  } catch {
    return { status: 'UNKNOWN' as const, hash, signedXdr }
  }
  if (sent.status === 'ERROR') {
    return { status: 'REJECTED' as const, hash, signedXdr, result: sent }
  }
  try {
    const result = await server.pollTransaction(hash, { attempts: 30 })
    if (result.status === 'SUCCESS' || result.status === 'FAILED') {
      return { status: result.status, hash, result }
    }
  } catch {
    // A polling error cannot prove whether the transaction landed.
  }
  return { status: 'UNKNOWN' as const, hash, signedXdr }
}

export function positionSummary(position: LendingPosition) {
  const percent = (value: number | null) =>
    value === null ? 'Unavailable' : `${(value * 100).toFixed(2)}%`
  return {
    title: position.spokeName ?? `Account ${position.accountId}`,
    health: position.hasDebt === false ? 'No debt'
      : position.healthFactor === null ? 'Unavailable'
      : position.healthFactor.toFixed(2),
    netApy: percent(position.netApy),
    supplied: position.supplied.map(leg => ({
      key: `${leg.hubId}:${leg.sac}`,
      label: `${leg.amount ?? 'Unavailable'} ${leg.symbol}`,
      apy: percent(leg.apy),
      logoUrl: leg.logoUrl,
    })),
    borrow: position.borrow.map(leg => ({
      key: `${leg.hubId}:${leg.sac}`,
      label: `${leg.amount ?? 'Unavailable'} ${leg.symbol}`,
      apy: percent(leg.apy),
      logoUrl: leg.logoUrl,
    })),
  }
}