Gasless

{ "status": "error", "message": "Minimum $1 per pair required for gasless" }

import { DZapClient } from '@dzapio/sdk';
import { getAddress } from 'viem';

const dzap = DZapClient.getInstance(process.env.DZAP_API_KEY);

// Every gasless token on every chain: Record<chainId, Record<address, TokenInfo>>
const allGaslessTokens = await dzap.getAllGaslessTokens();
console.log('Gasless chains:', Object.keys(allGaslessTokens));

// Just one chain: Record<address, TokenInfo>
const arbitrumGaslessTokens = await dzap.getGaslessTokens(42161);

// Keys are checksummed. getAddress() throws on anything that is not an address,
// so a bad input fails loudly instead of silently missing the lookup.
const usdc = '0xaf88d065e77c8cC2239327C5EDb3A432268e5831';
const token = arbitrumGaslessTokens[getAddress(usdc)];

if (!token) {
  console.log('Not gasless — execute this trade with dzap.trade() instead.');
} else {
  console.log('eip2612:', token.permit?.eip2612.supported, 'permit2:', token.permit?.permit2.supported);
}

import { DZapClient, getTokensPairKey } from '@dzapio/sdk';

const dzap = DZapClient.getInstance();

const account = '0x...';
const fromChain = 42161;
const toChain = 42161; // same chain = swap; different chain = bridge
const srcToken = '0xaf88d065e77c8cC2239327C5EDb3A432268e5831'; // USDC
const destToken = '0x82aF49447D8a07e3bd95BD0d56f35241523fBab1'; // WETH
const amount = '5000000'; // 5 USDC (6 decimals) — must clear the gas-fee floor

const quotes = await dzap.getTradeQuotes({
  fromChain,
  account,
  gasless: true,
  data: [{ amount, srcToken, srcDecimals: 6, destToken, destDecimals: 18, toChain, slippage: 1 }],
});

const pairKey = getTokensPairKey({ srcToken, destToken, srcChainId: fromChain, destChainId: toChain });
const pair = quotes[pairKey];

// Below the $1 minimum the pair carries an error instead of routes.
if (pair.status === 'error') {
  throw new Error(pair.message); // e.g. "Minimum $1 per pair required for gasless"
}

// Pick a route: recommendedSource, bestReturnSource, fastestSource, or your own choice
const provider = pair.recommendedSource;
const route = pair.quoteRates![provider];

console.log('gasless route:', route.gasless); // true
console.log('user receives:', route.destAmount); // already net of the gasless fee
console.log('estimated fee:', route.fee.protocolFee[0]?.amountUSD); // estimate — build is authoritative

const built = await dzap.buildTradeTxn({ ...request, gasless: true });

console.log('fee:', built.fees.executorFee[0].amountUSD);

const result = await dzap.tradeGasless({ request, signer, txnData: built });

type GaslessBaseParamsResponse = {
  status: 'success';
  txId: HexString;
  transaction: BridgeGaslessTxData | SwapGaslessTxData;
  quotes: Record<string, ParamQuotes>;
  gasless: true;
  onlySwapData: false;
  fees: {
    executorFee: FeeDetails[];
  };
};

import { STATUS_RESPONSE } from '@dzapio/sdk';

const status = await dzap.getTradeTxnStatus({ txHash: result.txnHash!, chainId: fromChain });

console.log(status.gasless); // true

if (status.status === STATUS_RESPONSE.COMPLETED) {
  // settled
}

import { DZapClient, PermitTypes, STATUS_RESPONSE, Services, TxnStatus, getTokensPairKey } from '@dzapio/sdk';
import { getAddress, type WalletClient } from 'viem';

export async function gaslessSwap(signer: WalletClient, account: `0x${string}`) {
  const dzap = DZapClient.getInstance(process.env.DZAP_API_KEY);

  const fromChain = 42161;
  const toChain = 42161;
  const srcToken = '0xaf88d065e77c8cC2239327C5EDb3A432268e5831'; // USDC
  const destToken = '0x82aF49447D8a07e3bd95BD0d56f35241523fBab1'; // WETH
  const amount = '5000000'; // 5 USDC — must clear the $1 minimum

  // 1. Confirm the SOURCE token is gasless-listed. Quotes do not enforce this.
  const gaslessTokens = await dzap.getGaslessTokens(fromChain);
  const listed = gaslessTokens[getAddress(srcToken)];
  if (!listed?.permit?.eip2612?.supported) {
    throw new Error('Not gasless via EIP-2612 — use allowance/Permit2 mode, or trade() normally.');
  }

  // 2. Quote.
  const quotes = await dzap.getTradeQuotes({
    fromChain,
    account,
    gasless: true,
    data: [{ amount, srcToken, srcDecimals: 6, destToken, destDecimals: 18, toChain, slippage: 1 }],
  });

  const pair = quotes[getTokensPairKey({ srcToken, destToken, srcChainId: fromChain, destChainId: toChain })];
  if (pair.status === 'error') throw new Error(pair.message); // e.g. below the $1 minimum

  const protocol = pair.recommendedSource;
  const route = pair.quoteRates![protocol];

  const request = {
    fromChain,
    sender: account,
    refundee: account,
    gasless: true,
    data: [
      {
        amount,
        srcToken,
        srcDecimals: 6,
        destToken,
        destDecimals: 18,
        toChain,
        slippage: 1,
        protocol,
        recipient: account,
        additionalInfo: route.additionalInfo,
      },
    ],
  };

  // 3. The quote's protocolFee is an estimate; build for the authoritative fee.
  console.log('estimated fee:', route.fee.protocolFee[0]?.amountUSD);

  const built = await dzap.buildTradeTxn(request);
  const fee = built.fees.executorFee[0];
  console.log(`gasless fee: ${fee.amount} ${fee.symbol} (~$${fee.amountUSD})`);

  // 4. Sign the EIP-2612 permit (off-chain, no gas).
  const permitResult = await dzap.sign({
    chainId: fromChain,
    sender: account,
    signer,
    service: Services.trade,
    permitType: PermitTypes.EIP2612Permit,
    tokens: [{ address: srcToken, amount }],
  });
  if (permitResult.status !== TxnStatus.success || !('tokens' in permitResult)) {
    throw new Error(`Permit signing failed: ${permitResult.code}`);
  }

  // 5. Execute. permitData changes the request, so this rebuilds — do not pass `built` as txnData.
  const result = await dzap.tradeGasless({
    request: {
      ...request,
      data: [{ ...request.data[0], permitData: permitResult.tokens[0].permitData }],
    },
    signer,
    txnStatusCallback: (status) => console.log('status:', status),
  });

  if (result.status !== TxnStatus.success) throw new Error(result.errorMsg);

  // 6. Poll to a terminal state.
  let status = await dzap.getTradeTxnStatus({ txHash: result.txnHash!, chainId: fromChain });
  while (status.status === STATUS_RESPONSE.PENDING) {
    await new Promise((r) => setTimeout(r, 3000));
    status = await dzap.getTradeTxnStatus({ txHash: result.txnHash!, chainId: fromChain });
  }

  return status; // COMPLETED | FAILED | PARTIAL | REFUNDED
}

import { TxnStatus } from '@dzapio/sdk';

const result = await dzap.tradeGasless({ request, signer });

switch (result.status) {
  case TxnStatus.success:
    break;
  case TxnStatus.rejected:
    // User dismissed the permit or intent prompt in their wallet. Nothing was submitted.
    break;
  case TxnStatus.error:
    console.error(result.errorMsg, result.code, result.action);
    break;
}