> ## Documentation Index
> Fetch the complete documentation index at: https://developers.paxoslabs.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Multi-Chain Integration

> Build chain-aware discovery and transaction flows

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

```typescript theme={null}
import { fetchVaults, fetchSupportedAssets, YieldType } from "@paxoslabs/amplify-sdk";

const chainId = 1;

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

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

## Chain Guard Before Write

```typescript theme={null}
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)

```typescript theme={null}
import {
  prepareDepositAuthorization,
  prepareDeposit,
  isPermitAuth,
  isApprovalAuth,
} from "@paxoslabs/amplify-sdk";

async function depositOnChain(params: {
  chainId: number;
  user: `0x${string}`;
  asset: `0x${string}`;
  amount: string;
}) {
  const auth = await prepareDepositAuthorization({
    yieldType: "CORE",
    depositAsset: params.asset,
    depositAmount: params.amount,
    to: params.user,
    chainId: params.chainId,
  });

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

    const prepared = await prepareDeposit({
      yieldType: "CORE",
      depositAsset: params.asset,
      depositAmount: params.amount,
      to: params.user,
      chainId: params.chainId,
      signature,
      deadline: auth.permitData.message.deadline,
    });

    return walletClient.writeContract(prepared.txData);
  }

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

  const prepared = await prepareDeposit({
    yieldType: "CORE",
    depositAsset: params.asset,
    depositAmount: params.amount,
    to: params.user,
    chainId: params.chainId,
  });

  return walletClient.writeContract(prepared.txData);
}
```

## Withdrawal Flow (Chain-Safe)

```typescript theme={null}
import {
  prepareWithdrawalAuthorization,
  prepareWithdrawal,
  isWithdrawApprovalAuth,
} from "@paxoslabs/amplify-sdk";

async function withdrawOnChain(params: {
  chainId: number;
  user: `0x${string}`;
  wantAsset: `0x${string}`;
  amount: string;
}) {
  const auth = await prepareWithdrawalAuthorization({
    yieldType: "CORE",
    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({
    yieldType: "CORE",
    wantAsset: params.wantAsset,
    withdrawAmount: params.amount,
    userAddress: params.user,
    chainId: params.chainId,
  });

  return walletClient.writeContract(txData);
}
```

## Related

* [Vault Discovery Deep Dive](/v0.4.2/intro/products/earn/developers/api/fetchSupportedAssets)
* [Deposits Guide](/v0.4.2/intro/products/earn/developers/guides/deposits)
* [Withdrawals Guide](/v0.4.2/intro/products/earn/developers/guides/withdrawals)