Skip to main content
Amplify SDK supports vaults across multiple chains. This guide shows how to:
  1. Discover chain-specific vaults/assets
  2. Route users to supported chains
  3. Execute chain-correct deposit/withdraw flows

​
Discover by Chain

import {
  getVaults,
  getSupportedAssets,
  YieldType,
} from '@paxoslabs/amplify-sdk'

const chainId = 1

const vaults = await getVaults({
  chainId,
  yieldType: YieldType.CORE,
})

const assets = await getSupportedAssets({
  chains: [chainId],
  yieldType: YieldType.CORE,
})

​
Chain Guard Before Write

function assertChain(expected: number, connected: number) {
  if (expected !== connected) {
    throw new Error(`Wrong network: expected ${expected}, got ${connected}`)
  }
}
Use this before signing transactions.

​
Deposit Flow (Chain-Safe)

import {
  getVaultsByConfig,
  prepareDepositAuthorization,
  prepareDeposit,
  isPermitAuth,
  isApprovalAuth,
  isAlreadyApprovedAuth,
  YieldType,
} from '@paxoslabs/amplify-sdk'

async function depositOnChain(params: {
  chainId: number
  user: `0x${string}`
  asset: `0x${string}`
  amount: string
}) {
  const [vault] = await getVaultsByConfig({
    yieldType: YieldType.CORE,
    chainId: params.chainId,
    depositAssetAddress: params.asset,
  })

  const depositParams = {
    vaultName: vault.name,
    depositAsset: params.asset,
    depositAmount: params.amount,
    to: params.user,
    chainId: params.chainId,
  }

  const auth = await prepareDepositAuthorization(depositParams)

  if (isPermitAuth(auth)) {
    const signature = await walletClient.signTypedData({
      account: params.user,
      ...auth.permitData,
    })

    const prepared = await prepareDeposit({
      ...depositParams,
      signature,
      deadline: auth.permitData.message.deadline,
    })

    return walletClient.writeContract({
      address: prepared.txData.address,
      abi: prepared.txData.data.abi,
      functionName: prepared.txData.data.functionName,
      args: prepared.txData.data.args,
    })
  }

  if (isApprovalAuth(auth)) {
    const approvalHash = await walletClient.writeContract(auth.txData)
    await publicClient.waitForTransactionReceipt({ hash: approvalHash })
  }

  const prepared = await prepareDeposit(depositParams)
  return walletClient.writeContract(prepared.txData)
}

​
Withdrawal Flow (Chain-Safe)

import {
  getVaultsByConfig,
  prepareWithdrawalAuthorization,
  prepareWithdrawal,
  isWithdrawApprovalAuth,
  YieldType,
} from '@paxoslabs/amplify-sdk'

async function withdrawOnChain(params: {
  chainId: number
  user: `0x${string}`
  wantAsset: `0x${string}`
  amount: string
}) {
  // Discover vault for this chain
  const [vault] = await getVaultsByConfig({
    yieldType: YieldType.CORE,
    chainId: params.chainId,
  })

  const auth = await prepareWithdrawalAuthorization({
    vaultName: vault.name,
    wantAsset: params.wantAsset,
    withdrawAmount: params.amount,
    userAddress: params.user,
    chainId: params.chainId,
  })

  if (isWithdrawApprovalAuth(auth)) {
    const approvalHash = await walletClient.writeContract(auth.txData)
    await publicClient.waitForTransactionReceipt({ hash: approvalHash })
  }

  const txData = await prepareWithdrawal({
    vaultName: vault.name,
    wantAsset: params.wantAsset,
    withdrawAmount: params.amount,
    userAddress: params.user,
    chainId: params.chainId,
  })

  return walletClient.writeContract(txData)
}