Approve & Deposit

const approval = await prepareApproveDepositToken({
  yieldType, // e.g. YieldType.CORE
  depositToken, // Token contract address to Approve spend
  depositAmount, // Optional: Decimal string, defaults to max approval
  chainId,
});

const deposit = await prepareDepositTxData({
  yieldType, // e.g. YieldType.CORE
  recipientAddress, // Address of the user. Must be the same as the address used to sign the deposit transaction.
  depositToken, // Token contract address to deposit. Must be supported by the vault.
  depositAmount, // Amount of assets to deposit as a decimal string (e.g., "1.5")
  chainId, // ID of the chain where the deposit will occur
  slippage, // Optional (default 50 bps aka 0.5%): Maximum acceptable slippage in basis points (e.g., 100 for 1%)
  partnerCode, // Optional (default is empty string): Partner code to credit deposit fees to the partner used for the deposit
});

import { encodeFunctionData, erc20Abi, createPublicClient, custom } from "viem";
import { mainnet } from "viem/chains";
import {
  prepareApproveDepositToken,
  prepareDepositTxData,
  YieldType,
} from "@paxoslabs/amplify-sdk";
import { usePrivy, useWallets } from "@privy-io/react-auth";

const { sendTransaction } = usePrivy();
const { wallets } = useWallets();
const wallet = wallets[0];
if (!wallet) {
  throw new Error("Connect a wallet before preparing transactions.");
}

const owner = wallet.address as `0x${string}`;
const client = createPublicClient({
  chain: mainnet,
  transport: custom(await wallet.getEthereumProvider()),
});

const approval = await prepareApproveDepositToken({
  yieldType: YieldType.CORE,
  depositToken: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
  depositAmount: "1000",
  chainId: mainnet.id,
});

const allowance = await client.readContract({
  abi: erc20Abi,
  address: approval.address,
  functionName: "allowance",
  args: [owner, approval.args[0]],
});

if (allowance < approval.args[1]) {
  await sendTransaction({
    chainId: mainnet.id,
    to: approval.address,
    data: encodeFunctionData({
      abi: approval.abi,
      functionName: approval.functionName,
      args: approval.args,
    }),
  });
}

const deposit = await prepareDepositTxData({
  yieldType: YieldType.CORE,
  recipientAddress: owner,
  depositToken: approval.address,
  depositAmount: "1000",
  chainId: mainnet.id,
});

await sendTransaction({
  chainId: deposit.chainId,
  to: deposit.address,
  data: encodeFunctionData({
    abi: deposit.abi,
    functionName: deposit.functionName,
    args: deposit.args,
  }),
});

import {
  prepareApproveDepositToken,
  prepareDepositTxData,
  YieldType,
} from "@paxoslabs/amplify-sdk";
import { useAccount, useWriteContract } from "wagmi";

const { address, chainId } = useAccount();
const { writeContractAsync } = useWriteContract();
if (!address || !chainId) {
  throw new Error("Connect a wallet before preparing transactions.");
}

const approval = await prepareApproveDepositToken({
  yieldType: YieldType.CORE,
  depositToken: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
  depositAmount: "1000",
  chainId,
});

await writeContractAsync({ ...approval, account: address });

const { chainId: _ignored, ...deposit } = await prepareDepositTxData({
  yieldType: YieldType.CORE,
  recipientAddress: address,
  depositToken: approval.address,
  depositAmount: "1000",
  chainId,
});

await writeContractAsync({ ...deposit, account: address });

import { createWalletClient, custom } from "viem";
import { mainnet } from "viem/chains";
import {
  prepareApproveDepositToken,
  prepareDepositTxData,
  YieldType,
} from "@paxoslabs/amplify-sdk";

// ethereum is window.ethereum from an injected wallet.
const [account] = (await ethereum.request({
  method: "eth_requestAccounts",
})) as `0x${string}`[];

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

const approval = await prepareApproveDepositToken({
  yieldType: YieldType.CORE,
  depositToken: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
  depositAmount: "1000",
  chainId: mainnet.id,
});

await client.writeContract({ ...approval, account });

const { chainId: _ignored, ...deposit } = await prepareDepositTxData({
  yieldType: YieldType.CORE,
  recipientAddress: account,
  depositToken: approval.address,
  depositAmount: "1000",
  chainId: mainnet.id,
});

await client.writeContract({ ...deposit, account });