Token swaps via API

import { createWalletClient, http, publicActions, parseAbi } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';
import { mainnet } from 'viem/chains';

const account = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`);
const client = createWalletClient({
  account,
  chain: mainnet,
  transport: http(),
}).extend(publicActions);

const ERC20_ABI = parseAbi([
  'function allowance(address owner, address spender) view returns (uint256)',
  'function approve(address spender, uint256 amount) returns (bool)',
]);

async function ensureApproval(
  tokenAddress: `0x${string}`,
  spender: `0x${string}`,
  amount: bigint
) {
  const allowance = await client.readContract({
    address: tokenAddress,
    abi: ERC20_ABI,
    functionName: 'allowance',
    args: [account.address, spender],
  });

  if (allowance < amount) {
    const hash = await client.writeContract({
      address: tokenAddress,
      abi: ERC20_ABI,
      functionName: 'approve',
      args: [spender, amount],
    });
    console.log('Approval tx:', hash);
  }
}

async function sendSwap(signingPayload: {
  to: string;
  data: string;
  value: string;
}) {
  const txHash = await client.sendTransaction({
    to: signingPayload.to as `0x${string}`,
    data: signingPayload.data as `0x${string}`,
    value: BigInt(signingPayload.value),
  });

  console.log('Swap broadcasted:', txHash);
  return txHash;
}

import { createWalletClient, http, publicActions, parseAbi } from 'viem';
import { privateKeyToAccount } from 'viem/accounts';
import { mainnet } from 'viem/chains';

// --- Config ---
const API = 'https://app.dynamicauth.com/api/v0';
const ENV_ID = 'your-environment-id';

const account = privateKeyToAccount(
  process.env.PRIVATE_KEY as `0x${string}`
);
const client = createWalletClient({
  account,
  chain: mainnet,
  transport: http(),
}).extend(publicActions);

// --- Helpers ---
async function api(path: string, body: object) {
  const res = await fetch(`${API}${path}`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(body),
  });
  if (!res.ok) throw new Error(`${res.status}: ${await res.text()}`);
  return res.json();
}

const ERC20_ABI = parseAbi([
  'function allowance(address owner, address spender) view returns (uint256)',
  'function approve(address spender, uint256 amount) returns (bool)',
]);

// --- Swap flow ---
async function swap() {
  // 1. Get quote: swap 10 USDC → ETH on Ethereum
  const quote = await api(`/sdk/${ENV_ID}/swap/quote`, {
    from: {
      address: account.address,
      chainName: 'EVM',
      chainId: '1',
      tokenAddress: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', // USDC
      amount: '10000000', // 10 USDC (6 decimals)
    },
    to: {
      address: account.address,
      chainName: 'EVM',
      chainId: '1',
      tokenAddress: '0x0000000000000000000000000000000000000000', // ETH
    },
    slippage: 0.005,
    order: 'CHEAPEST',
  });

  console.log(
    `Quote: ${quote.from.amountUSD} USDC → ${quote.to.amountUSD} ETH`
  );
  console.log(`Gas: $${quote.gasCostUSD}`);

  // 2. Approve token spend (ERC-20 only)
  if (quote.approvalAddress) {
    const tokenAddress =
      quote.from.token.address as `0x${string}`;
    const spender = quote.approvalAddress as `0x${string}`;

    const allowance = await client.readContract({
      address: tokenAddress,
      abi: ERC20_ABI,
      functionName: 'allowance',
      args: [account.address, spender],
    });

    if (allowance < BigInt(quote.from.amount)) {
      const approvalHash = await client.writeContract({
        address: tokenAddress,
        abi: ERC20_ABI,
        functionName: 'approve',
        args: [spender, BigInt(quote.from.amount)],
      });
      console.log('Approval tx:', approvalHash);
      // Wait for approval confirmation
      await client.waitForTransactionReceipt({ hash: approvalHash });
    }
  }

  // 3. Send the swap transaction
  const txHash = await client.sendTransaction({
    to: quote.signingPayload.to as `0x${string}`,
    data: quote.signingPayload.data as `0x${string}`,
    value: BigInt(quote.signingPayload.value),
  });
  console.log('Swap tx:', txHash);

  // 4. Poll for completion (useful for cross-chain swaps)
  while (true) {
    const status = await api(`/sdk/${ENV_ID}/swap/status`, {
      txHash,
      from: { chainName: 'EVM', chainId: '1' },
      to: { chainName: 'EVM', chainId: '1' },
    });

    console.log(`Status: ${status.status} (${status.substatus ?? ''})`);

    if (status.status === 'COMPLETED') {
      console.log('Swap complete!');
      if (status.explorerLink) console.log('Explorer:', status.explorerLink);
      return;
    }

    if (status.status === 'FAILED') {
      throw new Error(`Swap failed: ${status.message}`);
    }

    await new Promise((r) => setTimeout(r, 3000));
  }
}

swap().catch(console.error);

const quote = await api(`/sdk/${ENV_ID}/swap/quote`, {
  from: {
    address: account.address,
    chainName: 'EVM',
    chainId: '1',      // Ethereum
    tokenAddress: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
    amount: '50000000', // 50 USDC
  },
  to: {
    address: account.address,
    chainName: 'EVM',
    chainId: '137',    // Polygon
    tokenAddress: '0x0000000000000000000000000000000000000000', // MATIC
  },
  slippage: 0.01,
  order: 'FASTEST',
});

// Inspect the multi-step route
for (const step of quote.steps) {
  console.log(`${step.type} via ${step.tool}: ${step.from.token.symbol} → ${step.to.token.symbol}`);
}

// Sign and send (same as above)
// Then poll status with the correct source/destination chains
const status = await api(`/sdk/${ENV_ID}/swap/status`, {
  txHash,
  from: { chainName: 'EVM', chainId: '1' },
  to: { chainName: 'EVM', chainId: '137' },
});