Deposit with Permit

const permit = await prepareDepositPermitSignature({
  yieldType, // e.g. YieldType.CORE
  depositToken, // token that supports permit()
  depositAmount, // decimal string
  recipientAddress, // owner field
  chainId,
  deadline, // optional bigint (seconds)
});

const tx = await prepareDepositWithPermitTxData({
  yieldType, // Yield strategy type e.g. YieldType.CORE
  recipientAddress, // Same as permit.message.owner
  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
  signature, // raw 0x signature from the wallet
  deadline, // Must match the signed permit
  slippage, // Optional (default is 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 } from "viem";
import { mainnet } from "viem/chains";
import {
  prepareDepositPermitSignature,
  prepareDepositWithPermitTxData,
  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 depositToken = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"; // USDC
const chainId = mainnet.id;

const permit = await prepareDepositPermitSignature({
  yieldType: YieldType.CORE,
  depositToken,
  depositAmount: "1000",
  recipientAddress: owner,
  chainId,
});

const provider = await wallet.getEthereumProvider();
const signature = (await provider.request({
  method: "eth_signTypedData_v4",
  params: [
    owner,
    JSON.stringify({
      domain: permit.domain,
      types: permit.types,
      primaryType: permit.primaryType,
      message: permit.message,
    }),
  ],
})) as `0x${string}`;

const tx = await prepareDepositWithPermitTxData({
  yieldType: YieldType.CORE,
  recipientAddress: owner,
  depositToken,
  depositAmount: "1000",
  chainId,
  signature,
  deadline: permit.message.deadline,
});

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

import { encodeFunctionData } from "viem";
import {
  prepareDepositPermitSignature,
  prepareDepositWithPermitTxData,
  YieldType,
} from "@paxoslabs/amplify-sdk";
import { useAccount, useSendTransaction, useSignTypedData } from "wagmi";

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

const permit = await prepareDepositPermitSignature({
  yieldType: YieldType.CORE,
  depositToken: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
  depositAmount: "1000",
  recipientAddress: address,
  chainId,
});

const signature = await signTypedDataAsync({
  account: permit.message.owner,
  domain: permit.domain,
  types: permit.types,
  primaryType: permit.primaryType,
  message: permit.message,
});

const tx = await prepareDepositWithPermitTxData({
  yieldType: YieldType.CORE,
  recipientAddress: address,
  depositToken: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
  depositAmount: "1000",
  chainId,
  signature,
  deadline: permit.message.deadline,
  slippage: 75,
});

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

import { createWalletClient, custom, encodeFunctionData } from "viem";
import { mainnet } from "viem/chains";
import {
  prepareDepositPermitSignature,
  prepareDepositWithPermitTxData,
  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 depositToken = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"; // USDC

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

const permit = await prepareDepositPermitSignature({
  yieldType: YieldType.CORE,
  depositToken,
  depositAmount: "1000",
  recipientAddress: account,
  chainId: mainnet.id,
});

const signature = await client.signTypedData({
  account,
  domain: permit.domain,
  types: permit.types,
  primaryType: permit.primaryType,
  message: permit.message,
});

const tx = await prepareDepositWithPermitTxData({
  yieldType: YieldType.CORE,
  recipientAddress: account,
  depositToken,
  depositAmount: "1000",
  chainId: mainnet.id,
  signature,
  deadline: permit.message.deadline,
  slippage: 75,
});

await client.sendTransaction({
  account,
  to: tx.address,
  data: encodeFunctionData({
    abi: tx.abi,
    functionName: tx.functionName,
    args: tx.args,
  }),
});