Request Zap Quotes

import { DZapClient } from "@dzapio/sdk";

const dZap = DZapClient.getInstance();

const zapQuoteRequest: ZapQuoteRequest = {
  srcChainId: 42161, // Arbitrum
  destChainId: 42161, // Same chain for simplicity
  account: userAccount,
  srcToken: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831", // USDC
  destToken: "0x724dc807b04555b71ed48a6896b6F41593b8C637", // Aave USDC
  amount: "1000000", // 1 USDC (6 decimals)
  recipient: userAccount,
  slippage: 1, // 1% slippage
};

const zapQuote = await dZap.getZapQuote(zapQuoteRequest);
console.log("Zap quote:", zapQuote);

type ZapIntegratorConfig = {
  id: string; // Unique integrator identifier
  feeBps: number; // Fee in basis points (1 bps = 0.01%)
  wallet: string; // Wallet address to receive integrator fees
};

const zapQuoteRequest: ZapQuoteRequest = {
  srcChainId: 42161,
  destChainId: 42161,
  account: userAccount,
  srcToken: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
  destToken: "0x724dc807b04555b71ed48a6896b6F41593b8C637",
  amount: "1000000",
  recipient: userAccount,
  slippage: 1,
  integrator: {
    id: "my-integration-id",
    feeBps: 10, // 0.1% fee
    wallet: "0x1234567890123456789012345678901234567890",
  },
};

const zapQuote = await dZap.getZapQuote(zapQuoteRequest);

type ZapQuoteResponse = {
  approvalData: {
    callTo: string; // Token contract address to call for approval
    approveTo: string; // Address to approve for spending
    amount: string; // Amount to approve in token units
  }[]; // One entry per token that needs approval; empty if none needed
  dust: ZapPathOutput[]; // Any leftover/unswept amounts from the route
  output: ZapPathOutput[]; // Final output amount(s) of the whole zap
  path: ZapPath[]; // Array of steps in the zap operation
};

type ZapPathOutput = {
  asset: ZapPathAsset; // Asset details
  amount: string; // Output amount in token units
  amountUSD: string; // USD value of output
  minAmount: string; // Minimum guaranteed return amount
};

type ZapPath = {
  action: string; // Type of action (swap, deposit, stake, etc.)
  protocol: {
    name: string; // Protocol name
    id: string; // Protocol identifier
    icon: string; // Protocol icon URL
  };
  input: Array<{
    amount: string; // Input amount in token units
    amountUSD: string; // USD value of input
    asset: ZapPathAsset; // Asset details
  }>;
  output: ZapPathOutput[];
  fee: ZapFee[]; // Fees for this step
  estimatedDuration: number; // Time estimate in seconds
};

type ZapPathAsset = {
  chainId: number;
  address: string;
  symbol: string;
  logo: string;
  decimals: number;
  price: string;
  type: string;
  name: string;
  provider?: { id: string; name: string; icon: string };
  underlyingTokens?: {
    chainId: number;
    address: string;
    name?: string;
    symbol: string;
    decimals: number;
    logo?: string | null;
  }[];
};

const zapQuote = await dZap.getZapQuote(zapQuoteRequest);

// Check if approval is needed (approvalData is an array, one entry per token)
if (zapQuote.approvalData.length > 0) {
  console.log("Approval required:");
  zapQuote.approvalData.forEach((approval) => {
    console.log(`Approve ${approval.amount} tokens to ${approval.approveTo}`);
  });
}

// Examine the path
console.log("Zap will execute", zapQuote.path.length, "steps:");

zapQuote.path.forEach((step, index) => {
  console.log(`\nStep ${index + 1}: ${step.action}`);
  console.log(`Protocol: ${step.protocol.name}`);

  // Show input details
  step.input.forEach((input, inputIndex) => {
    console.log(
      `Input ${inputIndex + 1}: ${input.amount} ${input.asset.symbol} ($${
        input.amountUSD
      })`
    );
  });

  // Show output details
  step.output.forEach((output, outputIndex) => {
    console.log(
      `Output ${outputIndex + 1}: ${output.amount} ${output.asset.symbol} ($${
        output.amountUSD
      })`
    );
    if (output.minAmount) {
      console.log(`Minimum return: ${output.minAmount} ${output.asset.symbol}`);
    }
  });

  console.log(`Estimated duration: ${step.estimatedDuration}s`);

  // Show fees if any
  if (step.fee.length > 0) {
    const stepFees = step.fee.reduce(
      (acc, fee) => acc + parseFloat(fee.amountUSD),
      0
    );
    console.log(`Step fees: $${stepFees.toFixed(5)}`);
  }
});

// Calculate total fees across all steps
const totalFees = zapQuote.path.reduce((acc, step) => {
  return (
    acc +
    step.fee.reduce(
      (stepTotal, fee) => stepTotal + parseFloat(fee.amountUSD),
      0
    )
  );
}, 0);

// Calculate total duration
const totalDuration = zapQuote.path.reduce(
  (acc, step) => acc + step.estimatedDuration,
  0
);

console.log(`\nSummary:`);
zapQuote.output.forEach((out) => {
  console.log(`Expected output: ${out.amount} ${out.asset.symbol} ($${out.amountUSD})`);
});
console.log(`Total fees: $${totalFees.toFixed(5)}`);
console.log(`Total duration: ${totalDuration}s`);

// Bridge USDC from Ethereum to Arbitrum and provide liquidity to Uniswap V3
const crossChainLpQuote = await dZap.getZapQuote({
  srcChainId: 8453, // Base
  destChainId: 42161, // Arbitrum
  account: userAddress,
  srcToken: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", // USDC on Ethereum
  destToken: "0xC6962004f452bE9203591991D15f6b388e09E8D0", // Uniswap V3 ETH/USDC LP
  amount: "1000000000", // 1000 USDC
  recipient: userAddress,
  slippage: 2, // Higher slippage for cross-chain
});

console.log("Cross-chain LP quote received:");
crossChainLpQuote.output.forEach((out) => {
  console.log(`Expected LP tokens: ${out.amount} ${out.asset.symbol}`);
});
console.log(`Steps required: ${crossChainLpQuote.path.length}`);

import type { ZapBundleRequest } from "@dzapio/sdk";

const bundleRequest: ZapBundleRequest = {
  account: userAccount,
  recipient: userAccount,
  refundee: userAccount,
  slippage: 1,
  actions: [
    {
      action: "swap",
      srcChainId: 42161,
      srcToken: { address: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831", amount: "1000000" },
      destToken: "0x724dc807b04555b71ed48a6896b6F41593b8C637",
    },
  ],
};

const bundleQuote = await dZap.getZapBundleQuote(bundleRequest);