Skip to main content
The unified deposit API simplifies deposits by automatically detecting the optimal authorization method. Use prepareDepositAuthorization() to determine the method, then prepareDeposit() to execute.

​
Import

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

​
prepareDepositAuthorization()

Determines the optimal authorization method for a deposit operation.

​
Function Signature

async function prepareDepositAuthorization(
  params: PrepareDepositAuthorizationParams
): Promise<DepositAuthorizationResult>;

​
Parameters

interface PrepareDepositAuthorizationParams {
  /** Yield strategy type (e.g., YieldType.CORE) */
  yieldType: YieldType;

  /** Token contract address to deposit */
  depositAsset: Address;

  /** Amount of assets to deposit as decimal string (e.g., "100.25") */
  depositAmount: string;

  /** User's wallet address (permit owner / approval sender) */
  to: Address;

  /** Blockchain network ID */
  chainId: ChainId;

  /** Optional deadline for permit signature (defaults to 1 hour from now) */
  deadline?: bigint;

  /** Force specific authorization method (bypasses automatic detection) */
  forceMethod?: "permit" | "approval";
}
ParameterTypeRequiredDescription
yieldTypeYieldTypeYesYield strategy type (e.g., YieldType.CORE)
depositAssetAddressYesToken contract address to deposit
depositAmountstringYesAmount as decimal string (e.g., “100.25”)
toAddressYesRecipient address for vault shares
chainIdnumberYesBlockchain network ID
deadlinebigintNoPermit deadline (defaults to 1 hour)
forceMethod"permit" | "approval"NoOverride automatic detection

​
Return Type (Discriminated Union)

type DepositAuthorizationResult =
  | PermitAuthorizationResult
  | ApprovalAuthorizationResult
  | AlreadyApprovedAuthorizationResult;

​
Decision Logic

The function follows this priority order:
  1. Check forceMethod - If specified, use that method
  2. Check permit support - If token is in permit allowlist, return permit data
  3. Check existing allowance - If sufficient, return ALREADY_APPROVED
  4. Default to approval - Return approval transaction data

​
prepareDeposit()

Prepares transaction data for a deposit, automatically using the correct method based on provided parameters.

​
Function Signature

async function prepareDeposit(
  params: PrepareDepositParams
): Promise<PrepareDepositResult>;

​
Parameters

interface PrepareDepositParams {
  /** Yield strategy type (e.g., YieldType.CORE) */
  yieldType: YieldType;

  /** Token contract address to deposit */
  depositAsset: Address;

  /** Amount of assets to deposit as decimal string (e.g., "100.25") */
  depositAmount: string;

  /** Recipient address for vault shares */
  to: Address;

  /** Blockchain network ID */
  chainId: ChainId;

  /** Permit signature (required for permit flow) */
  signature?: Hex;

  /** Permit deadline (required for permit flow) */
  deadline?: bigint;

  /** Optional slippage in basis points (default: 50 = 0.5%) */
  slippage?: number;

  /** Optional partner code for fee attribution */
  partnerCode?: string;
}

​
Return Type

interface PrepareDepositResult {
  txData: {
    abi: Abi;
    address: Address;
    functionName: string;
    args: unknown[];
    chainId: number;
  };
}

​
Complete Flow Example

import { mainnet } from "viem/chains";
import {
  prepareDepositAuthorization,
  prepareDeposit,
  isPermitAuth,
  isApprovalAuth,
  isAlreadyApprovedAuth,
  YieldType,
} from "@paxoslabs/amplify-sdk";

const params = {
  yieldType: YieldType.CORE,
  depositAsset: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48" as `0x${string}`, // USDC
  depositAmount: "1000",
  to: userAddress,
  chainId: mainnet.id,
};

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

// Step 2: Handle based on method using type guards
if (isPermitAuth(auth)) {
  // Sign permit off-chain
  const signature = await walletClient.signTypedData({
    account: userAddress,
    ...auth.permitData,
  });

  // Prepare and execute deposit with permit
  const prepared = await prepareDeposit({
    ...params,
    signature,
    deadline: BigInt(auth.permitData.message.deadline),
  });

  await walletClient.writeContract(prepared.txData);
} else if (isApprovalAuth(auth)) {
  // Execute approval first
  await walletClient.writeContract(auth.txData);

  // Then deposit
  const prepared = await prepareDeposit(params);
  await walletClient.writeContract(prepared.txData);
} else if (isAlreadyApprovedAuth(auth)) {
  // Deposit directly
  const prepared = await prepareDeposit(params);
  await walletClient.writeContract(prepared.txData);
}

​
Force Specific Method

Override automatic detection when needed: 
// Force permit even if automatic detection would choose approval
const authForcePermit = await prepareDepositAuthorization({
  ...params,
  forceMethod: "permit",
});

// Force approval even for permit-supporting tokens (useful for smart wallets)
const authForceApproval = await prepareDepositAuthorization({
  ...params,
  forceMethod: "approval",
});

​
Slippage Configuration

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

​
Error Handling

Error CodeDescriptionResolution
SDK_NOT_INITIALIZEDSDK used before initCall initAmplifySDK() first
VAULT_NOT_FOUNDNo vault matches paramsVerify yieldType, token, chainId
PERMIT_NOT_SUPPORTEDToken doesn’t support EIP-2612Use approval flow instead
INSUFFICIENT_ALLOWANCEApproval amount too lowIncrease approval or use permit