Deposits

This guide demonstrates complete deposit flows using the unified deposit API, which automatically detects the optimal authorization method (permit vs approval).

Breaking change in v0.5.0: Transaction functions now use vaultName instead of yieldType. Discover vault names with getVaultsByConfig() before making deposit calls. See the migration guide.

The unified deposit API handles three authorization paths automatically:

Method	Description
Permit	Gas-efficient off-chain signature (EIP-2612). Single transaction — no separate approval needed.
Approval	Standard ERC-20 `approve` transaction followed by the deposit transaction.
Already Approved	Direct deposit when sufficient allowance already exists.

Prerequisites

Node.js 22+
Amplify API key from Paxos Labs
SDK initialized with initAmplifySDK()

Installation

Privy
Wagmi
Viem

pnpm add @paxoslabs/amplify-sdk @privy-io/react-auth viem @tanstack/react-query

pnpm add @paxoslabs/amplify-sdk wagmi viem @tanstack/react-query

pnpm add @paxoslabs/amplify-sdk viem

Imports

Privy
Wagmi
Viem

// SDK imports
import {
  getVaultsByConfig,
  prepareDepositAuthorization,
  prepareDeposit,
  isPermitAuth,
  isApprovalAuth,
  isAlreadyApprovedAuth,
  YieldType,
} from "@paxoslabs/amplify-sdk";

// Privy imports
import { usePrivy, useWallets } from "@privy-io/react-auth";

// Viem imports
import { encodeFunctionData } from "viem";
import { mainnet } from "viem/chains";

// SDK imports
import {
  getVaultsByConfig,
  prepareDepositAuthorization,
  prepareDeposit,
  isPermitAuth,
  isApprovalAuth,
  isAlreadyApprovedAuth,
  YieldType,
} from "@paxoslabs/amplify-sdk";

// Wagmi imports
import { useAccount, useWriteContract, useSignTypedData } from "wagmi";

// SDK imports
import {
  initAmplifySDK,
  getVaultsByConfig,
  prepareDepositAuthorization,
  prepareDeposit,
  isPermitAuth,
  isApprovalAuth,
  isAlreadyApprovedAuth,
  YieldType,
} from "@paxoslabs/amplify-sdk";

// Viem imports
import { createWalletClient, createPublicClient, custom, http } from "viem";
import { mainnet } from "viem/chains";

Step 0: Fetch Available Vaults

Retrieve all vaults accessible with your API key. This is the data you need to build a vault selector for your users.

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

const vaults = await getVaultsByConfig()

for (const vault of vaults) {
  console.log(`${vault.name} — ${vault.yieldType} on chain ${vault.chainId}`)
  for (const asset of vault.supportedAssets) {
    console.log(`  ${asset.symbol}: deposit=${asset.depositable}, withdraw=${asset.withdrawable}`)
  }
}

You can also narrow the list with filters:

const coreVaults = await getVaultsByConfig({ yieldType: YieldType.CORE })
const ethVaults = await getVaultsByConfig({ chainId: 1 })
const usdcVaults = await getVaultsByConfig({ depositAssetAddress: USDC_ADDRESS })

Step 1: Select a Vault

Once the user picks a vault from your UI, record its vault.name — all subsequent transaction calls require it.

const selectedVault = vaults[0] // or from user selection

const vaultName = selectedVault.name
const depositAsset = selectedVault.vault.baseTokenAddress
const chainId = selectedVault.chainId

Step 2: Check Authorization

Determine the optimal authorization method for this deposit. The SDK auto-detects permit support.

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

const auth = await prepareDepositAuthorization({
  vaultName,
  depositAsset,
  depositAmount: '1000',
  to: userAddress,
  chainId,
})

if (isPermitAuth(auth)) {
  // Sign EIP-712 typed data off-chain (gasless)
} else if (isApprovalAuth(auth)) {
  // Send an ERC-20 approve transaction first
} else if (isAlreadyApprovedAuth(auth)) {
  // Sufficient allowance exists — skip straight to deposit
}

Step 3: Execute Deposit

After authorization, prepare and submit the deposit transaction.

import { prepareDeposit } from '@paxoslabs/amplify-sdk'

const prepared = await prepareDeposit({
  vaultName,
  depositAsset,
  depositAmount: '1000',
  to: userAddress,
  chainId,
  // For permit path, also pass: signature, deadline
})

// Submit prepared.txData via your wallet provider

Complete Examples

Privy
Wagmi
Viem

useDeposit Hook

// src/hooks/useDeposit.ts
import { useState, useCallback } from "react";
import { encodeFunctionData } from "viem";
import { mainnet } from "viem/chains";
import {
  prepareDepositAuthorization,
  prepareDeposit,
  isPermitAuth,
  isApprovalAuth,
  isAlreadyApprovedAuth,
  YieldType,
} from "@paxoslabs/amplify-sdk";

declare const usePrivy: () => { sendTransaction: (tx: any) => Promise<string> };
declare const useWallets: () => { wallets: Array<{ address: string; getEthereumProvider: () => Promise<any> }> };

interface DepositParams {
  amount: string;
  depositAsset: `0x${string}`;
  vaultName: string;
}

export function useDeposit() {
  const { sendTransaction } = usePrivy();
  const { wallets } = useWallets();
  const [status, setStatus] = useState<string>("");
  const [isLoading, setIsLoading] = useState(false);

  const deposit = useCallback(
    async ({ amount, depositAsset, vaultName }: DepositParams) => {
      const wallet = wallets[0];
      if (!wallet) {
        throw new Error("Connect a wallet first");
      }

      setIsLoading(true);
      const to = wallet.address as `0x${string}`;

      try {
        const params = {
          vaultName,
          depositAsset,
          depositAmount: amount,
          to,
          chainId: mainnet.id,
        };

        // Step 1: Get authorization method
        setStatus("Checking authorization...");
        const auth = await prepareDepositAuthorization(params);

        // Step 2: Handle based on method using type guards
        if (isPermitAuth(auth)) {
          setStatus("Please sign permit in your wallet...");
          const provider = await wallet.getEthereumProvider();
          const signature = (await provider.request({
            method: "eth_signTypedData_v4",
            params: [
              to,
              JSON.stringify({
                domain: auth.permitData.domain,
                types: auth.permitData.types,
                primaryType: auth.permitData.primaryType,
                message: auth.permitData.message,
              }),
            ],
          })) as `0x${string}`;

          setStatus("Submitting deposit...");
          const prepared = await prepareDeposit({
            ...params,
            signature,
            deadline: auth.permitData.message.deadline,
          });

          // Permit path: txData has nested .data structure
          await sendTransaction({
            chainId: prepared.txData.chainId,
            to: prepared.txData.address,
            data: encodeFunctionData({
              abi: prepared.txData.data.abi,
              functionName: prepared.txData.data.functionName,
              args: prepared.txData.data.args,
            }),
          });
        } else if (isApprovalAuth(auth)) {
          setStatus("Approving token spend...");
          await sendTransaction({
            chainId: mainnet.id,
            to: auth.txData.address,
            data: encodeFunctionData({
              abi: auth.txData.abi,
              functionName: auth.txData.functionName,
              args: auth.txData.args,
            }),
          });

          // Important: In production, wait for the approval transaction
          // to be confirmed before proceeding with the deposit.
          // See the Node.js example for the full pattern using
          // publicClient.waitForTransactionReceipt().

          setStatus("Submitting deposit...");
          const prepared = await prepareDeposit(params);
          await sendTransaction({
            chainId: prepared.txData.chainId,
            to: prepared.txData.address,
            data: encodeFunctionData({
              abi: prepared.txData.abi,
              functionName: prepared.txData.functionName,
              args: prepared.txData.args,
            }),
          });
        } else if (isAlreadyApprovedAuth(auth)) {
          setStatus("Submitting deposit...");
          const prepared = await prepareDeposit(params);
          await sendTransaction({
            chainId: prepared.txData.chainId,
            to: prepared.txData.address,
            data: encodeFunctionData({
              abi: prepared.txData.abi,
              functionName: prepared.txData.functionName,
              args: prepared.txData.args,
            }),
          });
        }

        setStatus("Deposit successful!");
      } catch (error) {
        setStatus(`Error: ${error instanceof Error ? error.message : "Unknown"}`);
        throw error;
      } finally {
        setIsLoading(false);
      }
    },
    [wallets, sendTransaction]
  );

  return { deposit, status, isLoading };
}

Deposit Component

// src/components/DepositForm.tsx
import { useState } from "react";
import { useQuery } from "@tanstack/react-query";
import { getVaultsByConfig, YieldType } from "@paxoslabs/amplify-sdk";
import { useDeposit } from "../hooks/useDeposit";
import { mainnet } from "viem/chains";

export function DepositForm() {
  const [amount, setAmount] = useState("100");
  const { deposit, status, isLoading } = useDeposit();

  const { data: vaults } = useQuery({
    queryKey: ["vaults", YieldType.CORE, mainnet.id],
    queryFn: () => getVaultsByConfig({ yieldType: YieldType.CORE, chainId: mainnet.id }),
  });

  const vault = vaults?.[0];

  const handleSubmit = async (e: React.FormEvent) => {
    e.preventDefault();
    if (!vault) return;
    await deposit({
      amount,
      depositAsset: vault.vault.baseTokenAddress as `0x${string}`,
      vaultName: vault.name,
    });
  };

  return (
    <form onSubmit={handleSubmit}>
      <label>
        Amount (USDC):
        <input
          type="number"
          value={amount}
          onChange={(e) => setAmount(e.target.value)}
          disabled={isLoading}
          min="0"
          step="0.01"
        />
      </label>
      <button type="submit" disabled={isLoading}>
        {isLoading ? "Processing..." : "Deposit"}
      </button>
      {status && <p>{status}</p>}
    </form>
  );
}

useDeposit Hook

// src/hooks/useDeposit.ts
import { useState, useCallback } from "react";
import { useAccount, useWriteContract, useSignTypedData } from "wagmi";
import {
  prepareDepositAuthorization,
  prepareDeposit,
  isPermitAuth,
  isApprovalAuth,
  isAlreadyApprovedAuth,
} from "@paxoslabs/amplify-sdk";

interface DepositParams {
  amount: string;
  depositAsset: `0x${string}`;
  vaultName: string;
}

export function useDeposit() {
  const { address, chainId } = useAccount();
  const { writeContractAsync } = useWriteContract();
  const { signTypedDataAsync } = useSignTypedData();
  const [status, setStatus] = useState<string>("");
  const [isLoading, setIsLoading] = useState(false);

  const deposit = useCallback(
    async ({ amount, depositAsset, vaultName }: DepositParams) => {
      if (!address || !chainId) {
        throw new Error("Connect a wallet first");
      }

      setIsLoading(true);

      try {
        const params = {
          vaultName,
          depositAsset,
          depositAmount: amount,
          to: address,
          chainId,
        };

        // Step 1: Get authorization method
        setStatus("Checking authorization...");
        const auth = await prepareDepositAuthorization(params);

        // Step 2: Handle based on method using type guards
        if (isPermitAuth(auth)) {
          setStatus("Please sign permit in your wallet...");
          const signature = await signTypedDataAsync(auth.permitData);

          setStatus("Submitting deposit...");
          const prepared = await prepareDeposit({
            ...params,
            signature,
            deadline: auth.permitData.message.deadline,
          });

          // Permit path: txData has nested .data structure
          await writeContractAsync({
            address: prepared.txData.address,
            abi: prepared.txData.data.abi,
            functionName: prepared.txData.data.functionName,
            args: prepared.txData.data.args,
            account: address,
          });
        } else if (isApprovalAuth(auth)) {
          setStatus("Approving token spend...");
          await writeContractAsync({
            ...auth.txData,
            account: address,
          });

          // Important: In production, wait for the approval transaction
          // to be confirmed before proceeding with the deposit.
          // See the Node.js example for the full pattern using
          // publicClient.waitForTransactionReceipt().

          setStatus("Submitting deposit...");
          const prepared = await prepareDeposit(params);
          await writeContractAsync({
            address: prepared.txData.address,
            abi: prepared.txData.abi,
            functionName: prepared.txData.functionName,
            args: prepared.txData.args,
            account: address,
          });
        } else if (isAlreadyApprovedAuth(auth)) {
          setStatus("Submitting deposit...");
          const prepared = await prepareDeposit(params);
          await writeContractAsync({
            address: prepared.txData.address,
            abi: prepared.txData.abi,
            functionName: prepared.txData.functionName,
            args: prepared.txData.args,
            account: address,
          });
        }

        setStatus("Deposit successful!");
      } catch (error) {
        setStatus(`Error: ${error instanceof Error ? error.message : "Unknown"}`);
        throw error;
      } finally {
        setIsLoading(false);
      }
    },
    [address, chainId, writeContractAsync, signTypedDataAsync]
  );

  return { deposit, status, isLoading };
}

Deposit Component

// src/components/DepositForm.tsx
import { useState } from "react";
import { useAccount } from "wagmi";
import { getVaultsByConfig, YieldType } from "@paxoslabs/amplify-sdk";
import { useDeposit } from "../hooks/useDeposit";
import { useQuery } from "@tanstack/react-query";

const USDC_ADDRESS = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48" as const;

export function DepositForm() {
  const { isConnected, chainId } = useAccount();
  const [amount, setAmount] = useState("100");
  const { deposit, status, isLoading } = useDeposit();

  const { data: vault } = useQuery({
    queryKey: ["vault", chainId],
    queryFn: async () => {
      const [v] = await getVaultsByConfig({
        yieldType: YieldType.CORE,
        chainId,
        depositAssetAddress: USDC_ADDRESS,
      });
      return v;
    },
    enabled: !!chainId,
  });

  if (!isConnected) {
    return <p>Please connect your wallet</p>;
  }

  const handleSubmit = async (e: React.FormEvent) => {
    e.preventDefault();
    if (!vault) return;
    await deposit({
      amount,
      depositAsset: USDC_ADDRESS,
      vaultName: vault.name,
    });
  };

  return (
    <form onSubmit={handleSubmit}>
      <label>
        Amount (USDC):
        <input
          type="number"
          value={amount}
          onChange={(e) => setAmount(e.target.value)}
          disabled={isLoading}
          min="0"
          step="0.01"
        />
      </label>
      <button type="submit" disabled={isLoading}>
        {isLoading ? "Processing..." : "Deposit"}
      </button>
      {status && <p>{status}</p>}
    </form>
  );
}

Complete Script

This example uses pure viem without React, suitable for Node.js scripts or vanilla TypeScript applications.

// deposit.ts
import { createWalletClient, createPublicClient, custom, http } from "viem";
import { mainnet } from "viem/chains";
import {
  initAmplifySDK,
  getVaultsByConfig,
  prepareDepositAuthorization,
  prepareDeposit,
  isPermitAuth,
  isApprovalAuth,
  isAlreadyApprovedAuth,
  YieldType,
} from "@paxoslabs/amplify-sdk";

declare const window: { ethereum: any };
declare const process: { env: { AMPLIFY_API_KEY: string } };

// Configuration
const CONFIG = {
  apiKey: process.env.AMPLIFY_API_KEY!,
  depositAsset: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48" as `0x${string}`, // USDC
  depositAmount: "1000",
};

async function main() {
  // Step 1: Initialize SDK
  console.log("Initializing SDK...");
  await initAmplifySDK(CONFIG.apiKey);

  // Step 2: Connect wallet
  console.log("Connecting wallet...");
  const ethereum = window.ethereum;
  if (!ethereum) {
    throw new Error("No wallet found");
  }

  const [account] = (await ethereum.request({
    method: "eth_requestAccounts",
  })) as `0x${string}`[];

  const walletClient = createWalletClient({
    account,
    chain: mainnet,
    transport: custom(ethereum),
  });

  const publicClient = createPublicClient({
    chain: mainnet,
    transport: http(),
  });

  // Step 3: Discover vault and prepare deposit parameters
  const [vault] = await getVaultsByConfig({
    yieldType: YieldType.CORE,
    chainId: mainnet.id,
    depositAssetAddress: CONFIG.depositAsset,
  });

  const params = {
    vaultName: vault.name,
    depositAsset: CONFIG.depositAsset,
    depositAmount: CONFIG.depositAmount,
    to: account,
    chainId: mainnet.id,
  };

  // Step 4: Get authorization method
  console.log("Checking authorization method...");
  const auth = await prepareDepositAuthorization(params);

  // Step 5: Handle based on method using type guards
  if (isPermitAuth(auth)) {
    console.log("Authorization method: permit");
    console.log("Signing permit...");
    const signature = await walletClient.signTypedData({
      account,
      domain: auth.permitData.domain,
      types: auth.permitData.types,
      primaryType: auth.permitData.primaryType,
      message: auth.permitData.message,
    });

    console.log("Submitting deposit with permit...");
    const prepared = await prepareDeposit({
      ...params,
      signature,
      deadline: auth.permitData.message.deadline,
    });

    // Permit path: txData has nested .data structure
    const permitHash = await walletClient.writeContract({
      address: prepared.txData.address,
      abi: prepared.txData.data.abi,
      functionName: prepared.txData.data.functionName,
      args: prepared.txData.data.args,
      account,
    });

    console.log(`Deposit submitted: ${permitHash}`);
    await publicClient.waitForTransactionReceipt({ hash: permitHash });
    console.log("Deposit confirmed!");
  } else if (isApprovalAuth(auth)) {
    console.log("Authorization method: approval");
    console.log("Sending approval transaction...");

    const approvalHash = await walletClient.writeContract({
      ...auth.txData,
      account,
    });

    console.log(`Approval submitted: ${approvalHash}`);
    await publicClient.waitForTransactionReceipt({ hash: approvalHash });
    console.log("Approval confirmed!");

    console.log("Submitting deposit...");
    const prepared = await prepareDeposit(params);

    const depositHash = await walletClient.writeContract({
      address: prepared.txData.address,
      abi: prepared.txData.abi,
      functionName: prepared.txData.functionName,
      args: prepared.txData.args,
      account,
    });

    console.log(`Deposit submitted: ${depositHash}`);
    await publicClient.waitForTransactionReceipt({ hash: depositHash });
    console.log("Deposit confirmed!");
  } else if (isAlreadyApprovedAuth(auth)) {
    console.log("Authorization method: already_approved");
    console.log(`Existing allowance: ${auth.allowance}`);
    console.log("Submitting deposit directly...");

    const prepared = await prepareDeposit(params);

    const directHash = await walletClient.writeContract({
      address: prepared.txData.address,
      abi: prepared.txData.abi,
      functionName: prepared.txData.functionName,
      args: prepared.txData.args,
      account,
    });

    console.log(`Deposit submitted: ${directHash}`);
    await publicClient.waitForTransactionReceipt({ hash: directHash });
    console.log("Deposit confirmed!");
  }
}

main().catch(console.error);

Running the Script

# Set environment variable
export AMPLIFY_API_KEY=pxl_your_api_key

# Run with tsx or ts-node
npx tsx deposit.ts

Expected Output

Initializing SDK...
Connecting wallet...
Checking authorization method...
Authorization method: permit
Signing permit...
Submitting deposit with permit...
Deposit submitted: 0x1234...
Deposit confirmed!

Customization

Custom Slippage

const prepared = await prepareDeposit({
  ...params,
  slippage: 100, // 1% instead of default 0.5%
})

Distributor Code

const prepared = await prepareDeposit({
  ...params,
  distributorCode: 'your_distributor_code',
})

Force Approval Flow

const auth = await prepareDepositAuthorization({
  ...params,
  forceMethod: 'approval', // Skip permit detection
})

Troubleshooting

Issue	Solution
”SDK not initialized”	Call `initAmplifySDK()` before using hooks
”Connect a wallet first”	Ensure user has connected wallet
Permit signature fails	Token may not support EIP-2612, falls back to approval
Transaction reverts	Check token balance and allowance

For more details on the deposit API, see Deposit Workflow.

Getting started

Origin - Branded Stablecoins

Amplify - Stablecoin Earn

Access - Borrow

USDG0

Prerequisites

Installation

Imports

Step 0: Fetch Available Vaults

Step 1: Select a Vault

Step 2: Check Authorization

Step 3: Execute Deposit

Complete Examples

useDeposit Hook

Deposit Component

useDeposit Hook

Deposit Component

Complete Script

Running the Script

Expected Output

Customization

Custom Slippage

Distributor Code

Force Approval Flow

Troubleshooting

Getting started

Origin - Branded Stablecoins

Amplify - Stablecoin Earn

Access - Borrow

USDG0

​Prerequisites

​Installation

​Imports

​Step 0: Fetch Available Vaults

​Step 1: Select a Vault

​Step 2: Check Authorization

​Step 3: Execute Deposit

​Complete Examples

​useDeposit Hook

​Deposit Component

​useDeposit Hook

​Deposit Component

​Complete Script

​Running the Script

​Expected Output

​Customization

​Custom Slippage

​Distributor Code

​Force Approval Flow

​Troubleshooting

Prerequisites

Installation

Imports

Step 0: Fetch Available Vaults

Step 1: Select a Vault

Step 2: Check Authorization

Step 3: Execute Deposit

Complete Examples

useDeposit Hook

Deposit Component

useDeposit Hook

Deposit Component

Complete Script

Running the Script

Expected Output

Customization

Custom Slippage

Distributor Code

Force Approval Flow

Troubleshooting