Reference

import { createEarnClient } from "@zerodev/earn";

const earn = createEarnClient({
  projectId: "<ZERODEV_PROJECT_ID>",
});

type DepositParams = {
  owner: Address;
  amount: number | string;      // display units
  token: TokenSymbol | Address;
  srcChainId: number;
  destChainId?: number;
  into?: string | Vault;
  slippage?: number;            // 1–5000 bps; default 100
};

type AaveDepositParams = DepositParams & {
  destChainId: number;
};

type VaultDepositParams = DepositParams & {
  into: string | Vault;
};

type ListVaultsParams = {
  asset?: TokenSymbol | Address;
  chains?: number[];
  protocol?: string;
  minTvl?: number; // USD; omitted means $100,000
  minApy?: number; // percent
  page?: number;   // zero-based
};

type VaultPage = {
  vaults: Vault[];
  nextPage: number | null;
};

type ListOpportunitiesParams = {
  chainId?: number;
  category?: "lend" | "liquid-staking" | "fixed-yield";
  protocol?: string;
  minTvl?: number;
  minApy?: number;
  page?: number;
};

type WatchStatusOptions = {
  interval?: number;    // default 4000 ms
  timeout?: number;     // default 600000 ms; 0 disables timeout
  maxRetries?: number;  // default 5 consecutive failures
  onStatusChange: (status: EarnStatus) => void;
  onError?: (error: unknown) => void;
};

type Watcher = {
  (): void;
  stop(): void;
  done: Promise<void>;
};

type EarnState =
  | "PENDING"
  | "BRIDGING"
  | "EXECUTING"
  | "COMPLETED"
  | "FAILED"
  | "ABANDONED";

type WithdrawCallsResult = {
  data: {
    chainId: number;
    calls: {
      to: Address;
      data?: Hex;
      value: string;
    }[];
  }[];
  receiver: Address;
};

earn.withdrawFromVault(params: VaultWithdrawParams): Promise<VaultWithdrawResult>;

type VaultWithdrawParams = {
  owner: Address;
  vaultId: string;
  chainId: number;
  amount?: number | string;
  max?: boolean;
};

type VaultWithdrawResult = {
  chainId: number;
  protocol: string;
  target: Address;
  asset: Address;
  assetSymbol: string;
  decimals: number;
  amount: string;
  exitAll: boolean;
  available: string;
  receiver: Address;
  calls: OnChainCall[];
};

type Quote = {
  quoteId: string;
  expiresAt: string;
  sra: Address | null;
  transaction: {
    chainId: number;
    calls: OnChainCall[];
  };
  userOp: {
    callData: Hex;
    calls: OnChainCall[];
    chainId: number;
  };
  estimatedFees: {
    totalFeeAmount: string | null;
    totalFeeToken: Address | null;
    perChain: {
      chainId: number;
      feeAmount: string | null;
      feeToken: Address | null;
    }[];
  };
  estimatedReceiveAmount: string;
  estimatedShares?: string;
  vaultApy?: number;
  route?: {
    bridgeTokenType: string | null;
    bridgeTokenSrc?: Address;
    bridgeTokenDest?: Address;
    sameChain: boolean;
  };
};

type OnChainCall = {
  to: Address;
  data: Hex;
  value: string;
};

import {
  EarnError,
  VaultCapExceededError,
} from "@zerodev/earn";

try {
  await earn.morpho.deposit(params);
} catch (error) {
  if (error instanceof VaultCapExceededError) {
    suggestSmallerAmount();
  } else if (error instanceof EarnError) {
    reportError(error.code, error.message, error.requestId);
  }
}

import {
  createEarnClient,
  DEFAULT_SERVER_URL,
  TOKENS,
  EarnError,
  VaultCapExceededError,
  VaultDepositsDisabledError,
  WatchTimeoutError,
} from "@zerodev/earn";