Execution Types

// Hinkal's AUTHORIZE steps. `execute(body, idempotencyKey)`: your POST /execute call.
let res = await execute({ quoteToken }, crypto.randomUUID());
while (res.data.executionType === "AUTHORIZE") {
  const { authorization, sign } = res.data;
  // Check the step first (see above), then sign with the paying wallet.
  const signature = sign.method === "personal_sign"
    ? await wallet.signMessage({ message: sign.message })
    : await wallet.signTypedData(sign.typedData);  // wallet on the input chain
  res = await execute({ quoteToken, authorization, signature }, crypto.randomUUID());
}
// res.data is now the TRANSACTION: handle it as in the switch below, within 10 minutes of step 2's arrival.

// `quote`: the /quote response's `data`. `wallet`: a viem WalletClient extended with publicActions
// (sendTransaction, writeContract, waitForTransactionReceipt, signTypedData; erc20Abi from viem).
// RAVN's `value` fields are decimal strings: viem needs a bigint, so every send goes through tx().
const tx = ({ to, data, value }) => ({ to: to.toLowerCase(), data, value: BigInt(value ?? "0") });
let feeTxHash;  // a fee paid beside the swap (fee.transaction): report it to /status as txHash
switch (res.data.executionType) {
  case "TRANSACTION": {
    if (res.data.submit) {  // broadcastViaRavn quotes only: RAVN checks it, then sends it
      const signed = await solanaWallet.signTransaction(res.data.transaction.serialized);  // base64 in, signed base64 out, not sent
      await submitTransaction(res.data.quoteToken, signed);
      await pollStatus(res.data.quoteToken, res.data.statusRef);
      break;
    }
    if (res.data.approval) {
      const hash = await wallet.sendTransaction(tx(res.data.approval));
      await wallet.waitForTransactionReceipt({ hash });  // must be mined first
    }
    const hash = await wallet.sendTransaction(tx(res.data.transaction));
    // Eco, Layerswap, a Mayan route paying no referrer, or a Fly Trade coin sell outside Ethereum,
    // Base and Polygon, with a fee-bearing key: also send the fee
    // payment (or batch it with the swap in one confirmation, see "Paying a fee in one confirmation"),
    // only once the swap has succeeded, and confirmed before polling.
    if (res.data.fee?.transaction) {
      const receipt = await wallet.waitForTransactionReceipt({ hash });
      // The swap's own receipt: viem resolves a cancelled tx with its replacement's.
      if (receipt.status === "success" && receipt.transactionHash === hash) {
        feeTxHash = await wallet.sendTransaction(tx(res.data.fee.transaction));
        await wallet.waitForTransactionReceipt({ hash: feeTxHash });
      }
    }
    // With no fee sent, a two-hop route's hop 1 (a statusRef is present) proves its fee instead.
    await pollStatus(res.data.quoteToken, res.data.statusRef ?? hash, feeTxHash ?? (res.data.statusRef ? hash : undefined));
    break;
  }
  case "SIGNATURE": {
    // Gasless still needs an allowance. Without it the order never fills, silently.
    if (res.data.approval) {
      const hash = await wallet.sendTransaction(tx(res.data.approval));
      await wallet.waitForTransactionReceipt({ hash });
    }
    // 0x Gasless: `approvalData` is a second signature that approves the token gaslessly.
    const approvalSig = res.data.approvalData ? await wallet.signTypedData(res.data.approvalData) : undefined;
    const sig = await wallet.signTypedData(res.data.typedData);
    await submitSignature(res.data.quoteToken, sig, approvalSig);  // execute's token, not /quote's
    break;
  }
  case "DEPOSIT": {
    // The deposit names no token: send the quote's input token, exactly deposit.amount.
    const { address, amount } = res.data.deposit;
    const depositHash = quote.input.token.isNative
      ? await wallet.sendTransaction(tx({ to: address, value: amount }))
      : await wallet.writeContract({ address: quote.input.token.address.toLowerCase(), abi: erc20Abi, functionName: "transfer", args: [address.toLowerCase(), BigInt(amount)] });
    // Rift or a private swap with a fee-bearing key, from an EVM chain: also send the fee payment
    // once the deposit has confirmed (or batch an ERC-20 fee with a token deposit), and report it
    // to /status. From Bitcoin or a Solana deposit there's no `transaction`: the fee goes in the
    // deposit's own transaction instead.
    if (res.data.fee?.transaction) {
      const receipt = await wallet.waitForTransactionReceipt({ hash: depositHash });
      if (receipt.status === "success" && receipt.transactionHash === depositHash) {
        feeTxHash = await wallet.sendTransaction(tx(res.data.fee.transaction));
        await wallet.waitForTransactionReceipt({ hash: feeTxHash });
      }
    }
    await pollStatus(res.data.quoteToken, res.data.statusRef, feeTxHash);
    break;
  }
}

"approval": {
  "to": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",  // the TOKEN contract
  "data": "0x095ea7b3…",                                // encoded approve(spender, amount)
  "value": "0",
  "chainId": 8453,
  "spender": "0x337685fdaB40D39bd02028545a4FfA7D287cC3E2",
  "amount": "25000000",
  "unlimitedRecommended": true                          // optional, see below
}

// EIP-5792, viem. Only when `batch` is true: any other native-coin fee must be its own transaction
// (see below). `calls`: approval.reset, approval, the swap (or the deposit transfer), then the fee.
// Simulate the batch first; if that fails or the swap's call needs more than ~400k gas, send `calls`
// one by one instead, each once the one before it has succeeded.
const call = ({ to, data, value }) => ({ to, data, value: BigInt(value ?? "0") });
if (res.data.fee?.transaction && res.data.batch) {
  const calls = res.data.calls.map(call);
  const { id } = await wallet.sendCalls({ calls, forceAtomic: true });  // one transaction
  const { receipts } = await wallet.waitForCallsStatus({ id });
  const txHash = receipts[0].transactionHash;  // the on-chain hash, not the batch `id`
  await pollStatus(res.data.quoteToken, res.data.statusRef ?? txHash, txHash);
}