Gasless - DZap

Gasless lets a user trade with zero native balance: they sign an authorization off-chain, DZap submits the transaction and pays gas, then recovers the gas cost from the trade output in the source token. Gasless is EVM-only and the source token must be an ERC-20 that supports EIP-2612 permits (or use allowance/Permit2 mode). Pick Swap or Bridge below; the tabs stay in sync across Setup, Steps, End-to-end, and API usage.

Nothing here gives DZap open-ended access to funds. The intent signature is bound to a single txId, carries a deadline, and is consumed by a per-user nonce, so it cannot be replayed.

Setup

Swap
Bridge

A gasless same-chain swap on Arbitrum: 5 USDC to WETH, with 0 ETH in the wallet.

import { DZapClient, PermitTypes, Services, TxnStatus } from '@dzapio/sdk';
import { createWalletClient, http } from 'viem';
import { arbitrum } from 'viem/chains';
import { privateKeyToAccount } from 'viem/accounts';

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

// An API key is recommended: the gasless and build endpoints are rate-limited per IP without one.
const dzap = DZapClient.getInstance(process.env.DZAP_API_KEY);

const USDC = '0xaf88d065e77c8cC2239327C5EDb3A432268e5831';
const WETH = '0x82aF49447D8a07e3bd95BD0d56f35241523fBab1';
const AMOUNT = '5000000';                             // 5 USDC (6 decimals), must clear the $1 minimum
const fromChain = 42161;
const toChain = 42161;                                // same chain as fromChain = swap

A gasless cross-chain bridge: 5 USDC from Arbitrum to Base, with 0 ETH in the wallet.

import { DZapClient, PermitTypes, Services, TxnStatus } from '@dzapio/sdk';
import { createWalletClient, http } from 'viem';
import { arbitrum } from 'viem/chains';
import { privateKeyToAccount } from 'viem/accounts';

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

// An API key is recommended: the gasless and build endpoints are rate-limited per IP without one.
const dzap = DZapClient.getInstance(process.env.DZAP_API_KEY);

const USDC_ARB = '0xaf88d065e77c8cC2239327C5EDb3A432268e5831';
const USDC_BASE = '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913';
const AMOUNT = '5000000';                             // 5 USDC (6 decimals), must clear the $1 minimum
const fromChain = 42161;
const toChain = 8453;                                 // Base, different chain = bridge

Steps

The gasless path is quote, sign a permit, execute, and confirm. tradeGasless() does the whole tail in one call: it builds the transaction, collects the intent signature from the wallet, and submits it to DZap. These steps use the EIP-2612 permit mode, the one that works for a wallet with zero native balance. Allowance and Permit2 are in Authorization modes.

Swap
Bridge

Quote

Pass gasless: true. The returned destAmount is already net of the relayer’s gas.

const quotes = await dzap.getTradeQuotes({
  fromChain,
  account: account.address,
  gasless: true,
  data: [{
    srcToken: USDC,
    destToken: WETH,
    amount: AMOUNT,
    srcDecimals: 6,
    destDecimals: 18,
    toChain,               // same chain as fromChain = swap
    slippage: 1,           // 1 = 1%
  }],
});

const pair = quotes[Object.keys(quotes)[0]];
if (pair.status === 'error') throw new Error(pair.message); // e.g. below the $1 minimum

const source = pair.recommendedSource ?? pair.bestReturnSource;
const route = pair.quoteRates![source];
console.log('you receive:', route.destAmount);                // net of the gasless fee
console.log('estimated fee:', route.fee.protocolFee[0]?.amountUSD);

Confirm the source token supports EIP-2612 permits before offering the zero-gas path: quotes don’t check this. See Fees & limits for the $1 per-pair minimum and the End-to-end tab for the pre-flight check.

Sign the permit

Sign an EIP-2612 permit for the source token. This is off-chain, so it costs zero gas.

const permit = await dzap.sign({
  chainId: fromChain,
  sender: account.address,
  signer: walletClient,
  service: Services.trade,
  permitType: PermitTypes.EIP2612Permit,
  tokens: [{ address: USDC, amount: AMOUNT }],
});

if (permit.status !== TxnStatus.success || !('tokens' in permit)) {
  throw new Error(`permit signing failed: ${permit.code}`);
}
const permitData = permit.tokens[0].permitData;

Signing an EIP-2612 permit for a token that does not implement it throws. If permit.eip2612.supported is false for your token, use allowance or Permit2 mode from Authorization modes.

Execute

Feed the permit back in as permitData and call tradeGasless(). It builds the transaction, prompts the user to sign the intent, and submits it to DZap.

const request = {
  fromChain,
  sender: account.address,
  refundee: account.address,     // receives funds if the trade is refunded
  gasless: true,
  data: [{
    srcToken: USDC,
    destToken: WETH,
    amount: AMOUNT,
    srcDecimals: 6,
    destDecimals: 18,
    toChain,
    protocol: source,            // provider ID from the quote
    recipient: account.address,
    slippage: 1,
    additionalInfo: route.additionalInfo,
    permitData,
  }],
};

const result = await dzap.tradeGasless({
  request,
  signer: walletClient,
  txnStatusCallback: (status) => console.log('gasless status:', status),
});
if (result.status !== TxnStatus.success) throw new Error(result.errorMsg);
console.log('submitted by DZap:', result.txnHash);

DZap pays gas and deducts the equivalent from the output in the source token. Call buildTradeTxn({ ...request }) first only to preview the authoritative fees.executorFee. Full request shape: Execute trade.

Status

tradeGasless() resolves with the hash DZap submitted. Track it like a regular trade.

const status = await dzap.getTradeTxnStatus({ txHash: result.txnHash!, chainId: fromChain });
console.log(status.status);   // COMPLETED once settled

status.gasless is true. Same-chain gasless swaps settle fast; terminal states are COMPLETED, FAILED, PARTIAL, and REFUNDED. See Track trade status.

Quote

Pass gasless: true and set toChain to a different chain. The returned destAmount is already net of the relayer’s gas.

const quotes = await dzap.getTradeQuotes({
  fromChain,
  account: account.address,
  gasless: true,
  data: [{
    srcToken: USDC_ARB,
    destToken: USDC_BASE,
    amount: AMOUNT,
    srcDecimals: 6,
    destDecimals: 6,
    toChain,               // Base, different chain = bridge
    slippage: 1,           // 1 = 1%
  }],
});

const pair = quotes[Object.keys(quotes)[0]];
if (pair.status === 'error') throw new Error(pair.message); // e.g. below the $1 minimum

const source = pair.recommendedSource ?? pair.bestReturnSource;
const route = pair.quoteRates![source];
console.log('you receive:', route.destAmount);                // net of the gasless fee
console.log('estimated fee:', route.fee.protocolFee[0]?.amountUSD);

Gasless applies to the source chain only: the source token must support EIP-2612 permits on fromChain (or use allowance/Permit2 mode). See Fees & limits for the $1 per-pair minimum.

Sign the permit

Sign an EIP-2612 permit for the source token on the source chain. This is off-chain, so it costs zero gas.

const permit = await dzap.sign({
  chainId: fromChain,
  sender: account.address,
  signer: walletClient,
  service: Services.trade,
  permitType: PermitTypes.EIP2612Permit,
  tokens: [{ address: USDC_ARB, amount: AMOUNT }],
});

if (permit.status !== TxnStatus.success || !('tokens' in permit)) {
  throw new Error(`permit signing failed: ${permit.code}`);
}
const permitData = permit.tokens[0].permitData;

Signing an EIP-2612 permit for a token that does not implement it throws. If permit.eip2612.supported is false for your token, use allowance or Permit2 mode from Authorization modes.

Execute

Feed the permit back in as permitData and call tradeGasless(). It builds the transaction, prompts the user to sign the intent, and submits it to DZap.

const request = {
  fromChain,
  sender: account.address,
  refundee: account.address,     // funds return here if the destination leg fails
  gasless: true,
  data: [{
    srcToken: USDC_ARB,
    destToken: USDC_BASE,
    amount: AMOUNT,
    srcDecimals: 6,
    destDecimals: 6,
    toChain,
    protocol: source,            // provider ID from the quote
    recipient: account.address,  // can be a different address on Base
    slippage: 1,
    additionalInfo: route.additionalInfo,
    permitData,
  }],
};

const result = await dzap.tradeGasless({
  request,
  signer: walletClient,
  txnStatusCallback: (status) => console.log('gasless status:', status),
});
if (result.status !== TxnStatus.success) throw new Error(result.errorMsg);
console.log('submitted by DZap:', result.txnHash);

DZap pays gas on the source chain and deducts the equivalent from the source token. Use a refundee you control on the source chain. Full request shape: Execute trade.

Status

Cross-chain settlement is asynchronous, so poll until the status reaches a terminal state.

const status = await dzap.getTradeTxnStatus({ txHash: result.txnHash!, chainId: fromChain });
console.log(status.status);   // PENDING to COMPLETED (or FAILED / PARTIAL / REFUNDED)

For gasless bridges the status covers both legs. Poll until it leaves PENDING; the End-to-end tab shows a ready-made loop. See Track trade status.

End-to-end

Swap
Bridge

import { DZapClient, PermitTypes, Services, TxnStatus, checkEIP2612PermitSupport } from '@dzapio/sdk';
import { createWalletClient, http } from 'viem';
import { arbitrum } from 'viem/chains';
import { privateKeyToAccount } from 'viem/accounts';

const account = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`);
const walletClient = createWalletClient({ account, chain: arbitrum, transport: http() });
const dzap = DZapClient.getInstance(process.env.DZAP_API_KEY);

const USDC = '0xaf88d065e77c8cC2239327C5EDb3A432268e5831';
const WETH = '0x82aF49447D8a07e3bd95BD0d56f35241523fBab1';
const AMOUNT = '5000000'; // 5 USDC, must clear the $1 minimum
const fromChain = 42161;
const toChain = 42161;

// 1. Confirm the source token supports EIP-2612 permits (the zero-gas path needs it)
const { supportsPermit } = await checkEIP2612PermitSupport({ chainId: fromChain, address: USDC, owner: account.address });
if (!supportsPermit) {
  throw new Error('token has no EIP-2612 permit; use allowance/Permit2 mode, or trade() normally');
}

// 2. Quote (gasless)
const quotes = await dzap.getTradeQuotes({
  fromChain,
  account: account.address,
  gasless: true,
  data: [{ srcToken: USDC, destToken: WETH, amount: AMOUNT, srcDecimals: 6, destDecimals: 18, toChain, slippage: 1 }],
});
const pair = quotes[Object.keys(quotes)[0]];
if (pair.status === 'error') throw new Error(pair.message);
const source = pair.recommendedSource ?? pair.bestReturnSource;
const route = pair.quoteRates![source];

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

// 4. Execute (builds + signs the intent + submits)
const result = await dzap.tradeGasless({
  request: {
    fromChain,
    sender: account.address,
    refundee: account.address,
    gasless: true,
    data: [{ srcToken: USDC, destToken: WETH, amount: AMOUNT, srcDecimals: 6, destDecimals: 18, toChain, protocol: source, recipient: account.address, slippage: 1, additionalInfo: route.additionalInfo, permitData: permit.tokens[0].permitData }],
  },
  signer: walletClient,
});
if (result.status !== TxnStatus.success) throw new Error(result.errorMsg);

// 5. Status
const status = await dzap.getTradeTxnStatus({ txHash: result.txnHash!, chainId: fromChain });
console.log('settled:', status.status);

import { DZapClient, PermitTypes, Services, TxnStatus, checkEIP2612PermitSupport } from '@dzapio/sdk';
import { createWalletClient, http } from 'viem';
import { arbitrum } from 'viem/chains';
import { privateKeyToAccount } from 'viem/accounts';

const account = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`);
const walletClient = createWalletClient({ account, chain: arbitrum, transport: http() });
const dzap = DZapClient.getInstance(process.env.DZAP_API_KEY);

const USDC_ARB = '0xaf88d065e77c8cC2239327C5EDb3A432268e5831';
const USDC_BASE = '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913';
const AMOUNT = '5000000'; // 5 USDC, must clear the $1 minimum
const fromChain = 42161;
const toChain = 8453; // Base

// 1. Confirm the source token supports EIP-2612 permits (the zero-gas path needs it)
const { supportsPermit } = await checkEIP2612PermitSupport({ chainId: fromChain, address: USDC_ARB, owner: account.address });
if (!supportsPermit) {
  throw new Error('token has no EIP-2612 permit; use allowance/Permit2 mode, or trade() normally');
}

// 2. Quote (gasless)
const quotes = await dzap.getTradeQuotes({
  fromChain,
  account: account.address,
  gasless: true,
  data: [{ srcToken: USDC_ARB, destToken: USDC_BASE, amount: AMOUNT, srcDecimals: 6, destDecimals: 6, toChain, slippage: 1 }],
});
const pair = quotes[Object.keys(quotes)[0]];
if (pair.status === 'error') throw new Error(pair.message);
const source = pair.recommendedSource ?? pair.bestReturnSource;
const route = pair.quoteRates![source];

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

// 4. Execute (builds + signs the intent + submits)
const result = await dzap.tradeGasless({
  request: {
    fromChain,
    sender: account.address,
    refundee: account.address,
    gasless: true,
    data: [{ srcToken: USDC_ARB, destToken: USDC_BASE, amount: AMOUNT, srcDecimals: 6, destDecimals: 6, toChain, protocol: source, recipient: account.address, slippage: 1, additionalInfo: route.additionalInfo, permitData: permit.tokens[0].permitData }],
  },
  signer: walletClient,
});
if (result.status !== TxnStatus.success) throw new Error(result.errorMsg);

// 5. Poll until settled (cross-chain is async)
for (let i = 0; i < 60; i++) {
  const status = await dzap.getTradeTxnStatus({ txHash: result.txnHash!, chainId: fromChain });
  if (['COMPLETED', 'PARTIAL', 'FAILED', 'REFUNDED'].includes(status.status)) {
    console.log('settled:', status.status);
    break;
  }
  await new Promise((r) => setTimeout(r, 5000));
}

API usage

The REST flow is the same sequence tradeGasless() performs. Unlike a regular trade, the gasless build returns a set of hashes you must sign as an EIP-712 intent, so the sign step is client-side code, not a curl.

Swap
Bridge

Quote

Send gasless: true. Pick a route’s recommendedSource.

curl -X POST https://api.dzap.io/v1/quotes \
  -H "Content-Type: application/json" \
  -H "x-api-key: $DZAP_API_KEY" \
  -d '{
    "fromChain": 42161,
    "gasless": true,
    "data": [{
      "amount": "5000000",
      "srcToken": "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
      "destToken": "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
      "srcDecimals": 6,
      "destDecimals": 18,
      "toChain": 42161,
      "slippage": 1
    }],
    "account": "0xUser"
  }'

Build

The gasless build returns the hashes to sign, not raw calldata. fees.executorFee is the authoritative fee.

curl -X POST https://api.dzap.io/v1/buildTx \
  -H "Content-Type: application/json" \
  -H "x-api-key: $DZAP_API_KEY" \
  -d '{
    "sender": "0xUser",
    "refundee": "0xUser",
    "fromChain": 42161,
    "gasless": true,
    "data": [{
      "amount": "5000000",
      "srcToken": "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
      "destToken": "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
      "srcDecimals": 6,
      "destDecimals": 18,
      "toChain": 42161,
      "protocol": "<recommendedSource from quote>",
      "recipient": "0xUser",
      "slippage": 1
    }]
  }'

Build response (trimmed)

{
  "status": "success",
  "txId": "0x...",
  "gasless": true,
  "transaction": {
    "txType": "swap",
    "executorFeesHash": "0x...",
    "swapDataHash": "0x...",
    "value": "0"
  },
  "fees": { "executorFee": [{ "symbol": "USDC", "amount": "76476", "amountUSD": "0.07656", "included": true }] }
}

Sign the intent (EIP-712)

Read the user’s nonce from the router, then sign a SignedGasLessSwapData intent over the hashes from the build response.

import { createPublicClient, http, keccak256, toBytes } from 'viem';
import { arbitrum } from 'viem/chains';

// Router address for the chain: GET /v1/chains -> contracts.router
const chains = await fetch('https://api.dzap.io/v1/chains').then((r) => r.json());
const router = chains.find((c) => c.chainId === 42161).contracts.router;

const nonce = await createPublicClient({ chain: arbitrum, transport: http() }).readContract({
  address: router,
  abi: [{ name: 'getNonce', type: 'function', stateMutability: 'view', inputs: [{ name: 'user', type: 'address' }], outputs: [{ type: 'uint256' }] }],
  functionName: 'getNonce',
  args: [account.address],
});

const deadline = BigInt(Math.floor(Date.now() / 1000) + 1800); // 30 min, matches SignatureExpiryInSecs

const signature = await walletClient.signTypedData({
  account,
  domain: {
    name: 'DZapVerifier',
    version: '1',
    chainId: 42161,
    verifyingContract: router,
    salt: keccak256(toBytes('DZap-v0.1')),
  },
  types: {
    SignedGasLessSwapData: [
      { name: 'txId', type: 'bytes32' },
      { name: 'user', type: 'address' },
      { name: 'nonce', type: 'uint256' },
      { name: 'deadline', type: 'uint256' },
      { name: 'executorFeesHash', type: 'bytes32' },
      { name: 'swapDataHash', type: 'bytes32' },
    ],
  },
  primaryType: 'SignedGasLessSwapData',
  // txId, executorFeesHash, swapDataHash come from the build response
  message: { txId, user: account.address, nonce, deadline, executorFeesHash, swapDataHash },
});

Execute

Submit the signed intent. The permit object carries the token permit plus the intent signature, nonce, and deadline.

curl -X POST https://api.dzap.io/v1/gasless/executeTx \
  -H "Content-Type: application/json" \
  -H "x-api-key: $DZAP_API_KEY" \
  -d '{
    "chainId": 42161,
    "txId": "0x...",
    "permit": {
      "permitData": [{ "token": "0xaf88d065e77c8cC2239327C5EDb3A432268e5831", "amount": "5000000", "permit": "0x..." }],
      "gaslessIntentSignature": "0x...",
      "gaslessIntentNonce": "3",
      "gaslessIntentDeadline": "1753600000"
    }
  }'

The response carries status and the txnHash DZap submitted.

Status

curl "https://api.dzap.io/v1/status?txHash=0x...&chainId=42161"

Quote

Send gasless: true with a different toChain. Pick a route’s recommendedSource.

curl -X POST https://api.dzap.io/v1/quotes \
  -H "Content-Type: application/json" \
  -H "x-api-key: $DZAP_API_KEY" \
  -d '{
    "fromChain": 42161,
    "gasless": true,
    "data": [{
      "amount": "5000000",
      "srcToken": "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
      "destToken": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
      "srcDecimals": 6,
      "destDecimals": 6,
      "toChain": 8453,
      "slippage": 1
    }],
    "account": "0xUser"
  }'

Build

The gasless build returns the hashes to sign, not raw calldata. For a bridge, the intent carries adapterDataHash instead of swapDataHash.

curl -X POST https://api.dzap.io/v1/buildTx \
  -H "Content-Type: application/json" \
  -H "x-api-key: $DZAP_API_KEY" \
  -d '{
    "sender": "0xUser",
    "refundee": "0xUser",
    "fromChain": 42161,
    "gasless": true,
    "data": [{
      "amount": "5000000",
      "srcToken": "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
      "destToken": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
      "srcDecimals": 6,
      "destDecimals": 6,
      "toChain": 8453,
      "protocol": "<recommendedSource from quote>",
      "recipient": "0xUser",
      "slippage": 1
    }]
  }'

Build response (trimmed)

{
  "status": "success",
  "txId": "0x...",
  "gasless": true,
  "transaction": {
    "txType": "bridge",
    "executorFeesHash": "0x...",
    "adapterDataHash": "0x...",
    "value": "0"
  },
  "fees": { "executorFee": [{ "symbol": "USDC", "amount": "76476", "amountUSD": "0.07656", "included": true }] }
}

Sign the intent (EIP-712)

Read the user’s nonce from the router, then sign a SignedGasLessBridgeData intent over the hashes from the build response.

import { createPublicClient, http, keccak256, toBytes } from 'viem';
import { arbitrum } from 'viem/chains';

// Router address for the source chain: GET /v1/chains -> contracts.router
const chains = await fetch('https://api.dzap.io/v1/chains').then((r) => r.json());
const router = chains.find((c) => c.chainId === 42161).contracts.router;

const nonce = await createPublicClient({ chain: arbitrum, transport: http() }).readContract({
  address: router,
  abi: [{ name: 'getNonce', type: 'function', stateMutability: 'view', inputs: [{ name: 'user', type: 'address' }], outputs: [{ type: 'uint256' }] }],
  functionName: 'getNonce',
  args: [account.address],
});

const deadline = BigInt(Math.floor(Date.now() / 1000) + 1800); // 30 min, matches SignatureExpiryInSecs

const signature = await walletClient.signTypedData({
  account,
  domain: {
    name: 'DZapVerifier',
    version: '1',
    chainId: 42161,
    verifyingContract: router,
    salt: keccak256(toBytes('DZap-v0.1')),
  },
  types: {
    SignedGasLessBridgeData: [
      { name: 'txId', type: 'bytes32' },
      { name: 'user', type: 'address' },
      { name: 'nonce', type: 'uint256' },
      { name: 'deadline', type: 'uint256' },
      { name: 'executorFeesHash', type: 'bytes32' },
      { name: 'adapterDataHash', type: 'bytes32' },
    ],
  },
  primaryType: 'SignedGasLessBridgeData',
  // txId, executorFeesHash, adapterDataHash come from the build response
  message: { txId, user: account.address, nonce, deadline, executorFeesHash, adapterDataHash },
});

Execute

Submit the signed intent. The permit object carries the token permit plus the intent signature, nonce, and deadline.

curl -X POST https://api.dzap.io/v1/gasless/executeTx \
  -H "Content-Type: application/json" \
  -H "x-api-key: $DZAP_API_KEY" \
  -d '{
    "chainId": 42161,
    "txId": "0x...",
    "permit": {
      "permitData": [{ "token": "0xaf88d065e77c8cC2239327C5EDb3A432268e5831", "amount": "5000000", "permit": "0x..." }],
      "gaslessIntentSignature": "0x...",
      "gaslessIntentNonce": "3",
      "gaslessIntentDeadline": "1753600000"
    }
  }'

The response carries status and the txnHash DZap submitted.

Status

Cross-chain settlement is asynchronous, so poll until the status leaves PENDING.

curl "https://api.dzap.io/v1/status?txHash=0x...&chainId=42161"

Fees and limits

The gasless fee is charged in the source token and deducted from what the user receives. The quote returns an estimate; the build returns the authoritative number.

Response	Field	Accuracy
`POST /v1/quotes`	`fee.protocolFee`	Estimate. Good to preview, may move before build.
`POST /v1/buildTx`	`fees.executorFee`	Authoritative. This is what will actually be charged.

Show the quote’s protocolFee while the user is still choosing, and re-read executorFee from the build for the confirmation screen. Both carry the same shape:

Fee entry

{
  "address": "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
  "chainId": 42161,
  "symbol": "USDC",
  "decimals": 6,
  "amount": "76476",
  "amountUSD": "0.07656",
  "included": true
}

amount is in the source token’s smallest unit; amountUSD is the same fee in dollars. included: true means it is already reflected in the quoted output, so do not subtract it again.

Do not read the gasless fee from fee.gasFee. On a gasless quote that array is always empty: the estimate lives in fee.protocolFee, and the final number in the build’s fees.executorFee.

Minimum trade size. The fee has to be covered by the trade, so the API enforces a $1 minimum per pair. Below it, the pair returns an explicit error instead of routes. Branch on status/message rather than inferring the floor from an empty route list, the threshold is server-side and moves with gas prices.

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

Source token must support EIP-2612 permits for the zero-gas path. Quotes and builds don’t enforce this, so verify it yourself before offering gasless:

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

const { supportsPermit } = await checkEIP2612PermitSupport({ chainId: 42161, address: srcToken, owner: userAddress });

If supportsPermit is false, the token can’t use the EIP-2612 path, so fall back to allowance or Permit2 mode (Authorization modes). In a multi-token trade every srcToken must qualify, and the gasless fee is split across tokens proportionally to their USD value.

Gasless or regular?

Situation	Recommendation
User has no native token	Gasless, it is the only way to trade.
User wants to trade their entire token balance	Gasless, no gas reserve needed.
User already holds native token and trades often	Regular, cheaper in aggregate.
Small trade (a few dollars)	Regular, the gas fee dominates and gasless may be unavailable.

Authorization modes

DZap can only move the source token if it is authorized to. The steps above use EIP-2612 permit, the only mode that works for a wallet with zero native balance. The other two need one on-chain approval first, after which every gasless trade is a single intent signature.

Mode	One-time on-chain tx?	Per trade	Use when
EIP-2612 permit	No	2 signatures (permit + intent)	The token supports `permit` and the wallet may have zero native balance.
ERC-20 allowance	Yes, approve the router	1 signature (intent)	An allowance to the router already exists, or the user can afford one approval.
Permit2	Yes, approve Permit2 once	1 batch signature (intent)	Trading many tokens or repeatedly; one approval covers all future trades.

For allowance mode, run getAllowance / approve with ApprovalModes.Default once, then call tradeGasless() with no permitData. For Permit2, approve with ApprovalModes.PermitBatchWitnessTransferFrom, then call tradeGasless() with hasPermit2ApprovalForAllTokens: true. Details: Check allowance and Approval mechanisms.

sign() takes a PermitTypes value (a signature scheme). approve() and getAllowance() take an ApprovalModes value (an on-chain approval target: Default is the router, anything else is Permit2). ApprovalModes has no EIP2612Permit member because an EIP-2612 permit is a signature and never approves anything on-chain.

Reference

Endpoints

Method	Path	Purpose
`POST`	`/v1/quotes`	Quotes; send `gasless: true`
`POST`	`/v1/buildTx`	Gasless build; send `gasless: true`, returns hashes to sign
`POST`	`/v1/gasless/executeTx`	Submit the signed intent for execution
`GET`	`/v1/status`	Status of the executed transaction
`GET`	`/v1/chains`	Chain config, including `contracts.router`

Base URLs: https://api.dzap.io (production), https://staging.dzap.io (staging). Send your API key as the x-api-key header, see Rate Limits for the unauthenticated caps.

SDK methods

Method	Returns
`checkEIP2612PermitSupport({ chainId, address, owner })`	`{ supportsPermit: boolean }`, whether a token supports EIP-2612 permits
`getTradeQuotes({ gasless: true, ... })`	Quotes with gasless routes; fee estimate in `fee.protocolFee`
`sign({ permitType: PermitTypes.EIP2612Permit, ... })`	Tokens with `permitData` populated
`tradeGasless({ request, signer, txnData?, txnStatusCallback? })`	`{ status, code, txnHash }`, builds + signs the intent + submits
`getTradeTxnStatus({ txHash, chainId })`	Execution status, with `gasless: true`

​Setup

​Steps

​End-to-end

​API usage

​Fees and limits

​Authorization modes

​Reference

​Endpoints

​SDK methods

Setup

Steps

End-to-end

API usage

Fees and limits

Authorization modes

Reference

Endpoints

SDK methods