Track Zap Status

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

const dZap = DZapClient.getInstance();

const zapStatus = await dZap.getZapTxnStatus({
  chainId: 8453, // Chain ID where the zap was executed
  txnHash: "0x1234567890abcdef...", // Transaction hash from zap execution
});

console.log("Zap Status:", zapStatus);

type ZapStatus = "PENDING" | "COMPLETED" | "FAILED" | "REFUNDED";

type ZapStatusResponse = {
  status: ZapStatus; // Overall zap status
  account: string; // Wallet that initiated the zap
  recipient: string; // Address receiving the final tokens/position
  input: ZapStatusAsset[]; // Overall input asset(s) for the whole zap
  output: ZapStatusAsset[]; // Overall output asset(s) for the whole zap
  steps: ZapStatusStep[];
  timestamp: number; // When the zap started
  completedAt: number; // When the zap reached a terminal state
};

type ZapStatusAsset = {
  amount: string; // Amount
  amountUSD: string; // USD value
  asset: {
    chainId: number;
    address: string;
    symbol: string;
    decimals: number;
    type: string;
    logo: string;
    name: string;
    price: string;
    provider?: { id: string; name: string; icon: string };
    underlyingTokens?: {
      chainId: number;
      address: string;
      name?: string;
      symbol: string;
      decimals: number;
      logo?: string | null;
    }[];
  };
};

type ZapStatusStep = {
  chainId: number; // Chain where step was executed
  hash?: string; // Transaction hash for this step (may be absent before it's mined)
  status: ZapStatus;
  action: string; // Action type (swap, bridge, deposit, etc.)
  protocol: {
    id: string; // Protocol identifier
    name: string; // Protocol name
    icon: string; // Protocol icon URL
  };
  input: ZapStatusAsset[];
  output: ZapStatusAsset[];
};

const zapStatus = await dZap.getZapTxnStatus({
  chainId: 8453,
  txnHash: "0x1234567890abcdef...",
});

console.log(`Overall zap status: ${zapStatus.status}`);
console.log(`Number of steps: ${zapStatus.steps.length}`);

// Process each step
zapStatus.steps.forEach((step, index) => {
  console.log(`\nStep ${index + 1}:`);
  console.log(`  Action: ${step.action}`);
  console.log(`  Protocol: ${step.protocol.name}`);
  console.log(`  Status: ${step.status}`);
  console.log(`  Chain: ${step.chainId}`);
  console.log(`  Transaction: ${step.hash}`);

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

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

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

const dZap = DZapClient.getInstance();

async function waitForZapCompletion(
  txnHash: string,
  chainId: number,
  options?: { intervalMs?: number; timeoutMs?: number }
) {
  const interval = options?.intervalMs ?? 10_000; // 10 seconds
  const timeout = options?.timeoutMs ?? 600_000; // 10 minutes
  const start = Date.now();

  while (Date.now() - start < timeout) {
    const status = await dZap.getZapTxnStatus({ txnHash, chainId });

    // Log step progress
    const completed = status.steps.filter((s) => s.status === "COMPLETED").length;
    console.log(
      `Zap ${status.status} - ${completed}/${status.steps.length} steps done`
    );

    switch (status.status) {
      case "COMPLETED":
        return status;
      case "FAILED":
        throw new Error("Zap failed. Check step details for the failing action.");
      case "REFUNDED":
        console.log("Zap was refunded - funds returned to sender.");
        return status;
      case "PENDING":
        break; // Keep polling
    }

    await new Promise((resolve) => setTimeout(resolve, interval));
  }

  throw new Error(`Zap timed out after ${timeout / 1000}s`);
}

// Usage after executing a zap
const zapResult = await dZap.zap({ request, signer });
if (zapResult.status === "success") {
  const finalStatus = await waitForZapCompletion(
    zapResult.txnHash!,
    request.srcChainId
  );
  console.log("Zap completed:", finalStatus);
}