Gasless - DZap

Trade without holding any native gas token. The user signs a permit and an intent instead of a transaction, and DZap’s relayer sends the transaction and pays the gas, charging its fee in the source token. Gasless is EVM-only. Pick Swap or Bridge in any tab, and the rest of the page switches with it.

Setup

Swap
Bridge

This example swaps 100 USDC for WETH on Arbitrum from a wallet with no ETH, signing with walletClient, a viem wallet client built from the private key in PRIVATE_KEY. Amounts are strings in the token’s smallest unit, and no API key is needed.

import { DZapClient, PermitTypes, Services, TxnStatus, type TradeStatusResponse } 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();

const USDC = '0xaf88d065e77c8cC2239327C5EDb3A432268e5831';
const WETH = '0x82aF49447D8a07e3bd95BD0d56f35241523fBab1';
const AMOUNT = '100000000';                           // 100 USDC (6 decimals)

This example bridges 100 USDC from Arbitrum to your own address on Base from a wallet with no ETH, signing with walletClient, a viem wallet client built from the private key in PRIVATE_KEY. Amounts are strings in the token’s smallest unit, and no API key is needed.

import { DZapClient, PermitTypes, Services, TxnStatus, type TradeStatusResponse } 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();

const USDC_ARB = '0xaf88d065e77c8cC2239327C5EDb3A432268e5831';
const USDC_BASE = '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913';
const AMOUNT = '100000000';                           // 100 USDC (6 decimals)

Steps

Swap
Bridge

Quote

getTradeQuotes with gasless: true prices the swap as a gasless trade. pair.quoteRates lists every route and recommendedSource names DZap’s pick. The gasless fee is charged in USDC and already taken out of destAmount: fee.protocolFee shows an estimate, and the build sets the final fee. Pairs under $1 return an error instead of routes.

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

const [pair] = Object.values(quotes);
const route = pair.quoteRates?.[pair.recommendedSource];
console.log(route?.destAmount, route?.fee.protocolFee[0]?.amount); // WETH out after the fee, fee estimate in USDC units

Sign the permit

The user signs an EIP-2612 permit that lets the DZap router move the USDC. It’s a signature, not a transaction, so it costs no gas, and it’s valid for 30 minutes. sign() throws if the token doesn’t support EIP-2612.

const permit = await dzap.sign({
  chainId: 42161,
  sender: account.address,
  signer: walletClient,
  service: Services.trade,
  permitType: PermitTypes.EIP2612Permit,
  tokens: [{ address: USDC, amount: AMOUNT }],
});
if (!('tokens' in permit)) throw new Error('Permit signature failed');

Execute

tradeGasless() builds the transaction, has the user sign an intent that lets DZap execute exactly this trade once before a deadline, and submits both signatures. DZap’s relayer then sends the transaction and pays the gas. If DZap’s check of the trade fails, nothing is sent and result.status is error.

const request = {
  fromChain: 42161,
  sender: account.address,
  refundee: account.address,
  gasless: true,
  data: [{
    srcToken: USDC,
    destToken: WETH,
    amount: AMOUNT,
    toChain: 42161,
    protocol: pair.recommendedSource,
    recipient: account.address,
    slippage: 1,
    permitData: permit.tokens[0].permitData,
  }],
};

const result = await dzap.tradeGasless({ request, signer: walletClient });
if (result.status !== TxnStatus.success) throw new Error(result.errorMsg);

Status

result.txnHash is the relayer’s transaction. Poll getTradeTxnStatus with it until the status leaves PENDING; COMPLETED means the swap went through, and status.gasless is true. DZap answers 404 until it sees the transaction, and 429 once the keyless limit of 5 requests a minute is used up, so the catch skips only those two and rethrows anything else. The loop gives up after 5 minutes, and the check after it throws unless the status is COMPLETED.

let status: TradeStatusResponse | undefined;
for (let i = 0; i < 20; i++) {  // gives up after 5 minutes
  await new Promise((r) => setTimeout(r, 15_000));
  try {
    status = await dzap.getTradeTxnStatus({ txHash: result.txnHash!, chainId: 42161 });
  } catch (e: any) {
    if (![404, 429].includes(e.response?.status)) throw e;
  }
  if (status && status.status !== 'PENDING') break;
}
if (status?.status !== 'COMPLETED') throw new Error(`Not completed: ${status?.status ?? 'no status'}`);

console.log(status.status); // 'COMPLETED'

Quote

getTradeQuotes with gasless: true prices the bridge as a gasless trade; a toChain different from fromChain makes it a bridge. pair.quoteRates lists every route and recommendedSource names DZap’s pick. The gasless fee is charged in USDC on Arbitrum and already taken out of destAmount: fee.protocolFee shows an estimate, and the build sets the final fee. Pairs under $1 return an error instead of routes.

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

const [pair] = Object.values(quotes);
const route = pair.quoteRates?.[pair.recommendedSource];
console.log(route?.destAmount, route?.fee.protocolFee[0]?.amount); // USDC out on Base after the fee, fee estimate in USDC units

Sign the permit

The user signs an EIP-2612 permit that lets the DZap router on Arbitrum move the USDC. It’s a signature, not a transaction, so it costs no gas, and it’s valid for 30 minutes. sign() throws if the token doesn’t support EIP-2612.

const permit = await dzap.sign({
  chainId: 42161,
  sender: account.address,
  signer: walletClient,
  service: Services.trade,
  permitType: PermitTypes.EIP2612Permit,
  tokens: [{ address: USDC_ARB, amount: AMOUNT }],
});
if (!('tokens' in permit)) throw new Error('Permit signature failed');

Execute

tradeGasless() builds the transaction, has the user sign an intent that lets DZap execute exactly this bridge once before a deadline, and submits both signatures. DZap’s relayer then sends the transaction on Arbitrum and pays the gas. recipient receives the USDC on Base, and refundee gets it back on Arbitrum if the bridge refunds. If DZap’s check of the trade fails, nothing is sent and result.status is error.

const request = {
  fromChain: 42161,
  sender: account.address,
  refundee: account.address,
  gasless: true,
  data: [{
    srcToken: USDC_ARB,
    destToken: USDC_BASE,
    amount: AMOUNT,
    toChain: 8453,
    protocol: pair.recommendedSource,
    recipient: account.address,
    slippage: 1,
    permitData: permit.tokens[0].permitData,
  }],
};

const result = await dzap.tradeGasless({ request, signer: walletClient });
if (result.status !== TxnStatus.success) throw new Error(result.errorMsg);

Status

The USDC reaches Base only after the bridge finishes, so poll getTradeTxnStatus with result.txnHash, the relayer’s transaction on Arbitrum, until the status leaves PENDING; COMPLETED means it arrived. DZap answers 404 until it sees the transaction, and 429 once the keyless limit of 5 requests a minute is used up, so the catch skips only those two and rethrows anything else. The loop gives up after 30 minutes, and the check after it throws unless the status is COMPLETED.

let status: TradeStatusResponse | undefined;
for (let i = 0; i < 120; i++) {  // gives up after 30 minutes
  await new Promise((r) => setTimeout(r, 15_000));
  try {
    status = await dzap.getTradeTxnStatus({ txHash: result.txnHash!, chainId: 42161 });
  } catch (e: any) {
    if (![404, 429].includes(e.response?.status)) throw e;
  }
  if (status && status.status !== 'PENDING') break;
}
if (status?.status !== 'COMPLETED') throw new Error(`Not completed: ${status?.status ?? 'no status'}`);

console.log(status.status); // 'COMPLETED'

End-to-end

Swap
Bridge

import { DZapClient, PermitTypes, Services, TxnStatus, type TradeStatusResponse } 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();

const USDC = '0xaf88d065e77c8cC2239327C5EDb3A432268e5831';
const WETH = '0x82aF49447D8a07e3bd95BD0d56f35241523fBab1';
const AMOUNT = '100000000'; // 100 USDC

// 1. Quote
const quotes = await dzap.getTradeQuotes({
  fromChain: 42161,
  account: account.address,
  gasless: true,
  data: [{ srcToken: USDC, destToken: WETH, amount: AMOUNT, toChain: 42161, slippage: 1 }],
});
const [pair] = Object.values(quotes);

// 2. Sign the permit (no gas)
const permit = await dzap.sign({
  chainId: 42161,
  sender: account.address,
  signer: walletClient,
  service: Services.trade,
  permitType: PermitTypes.EIP2612Permit,
  tokens: [{ address: USDC, amount: AMOUNT }],
});
if (!('tokens' in permit)) throw new Error('Permit signature failed');

// 3. Execute (build, sign the intent, submit)
const request = {
  fromChain: 42161,
  sender: account.address,
  refundee: account.address,
  gasless: true,
  data: [{ srcToken: USDC, destToken: WETH, amount: AMOUNT, toChain: 42161, protocol: pair.recommendedSource, recipient: account.address, slippage: 1, permitData: permit.tokens[0].permitData }],
};
const result = await dzap.tradeGasless({ request, signer: walletClient });
if (result.status !== TxnStatus.success) throw new Error(result.errorMsg);

// 4. Status
let status: TradeStatusResponse | undefined;
for (let i = 0; i < 20; i++) {  // gives up after 5 minutes
  await new Promise((r) => setTimeout(r, 15_000));
  try {
    status = await dzap.getTradeTxnStatus({ txHash: result.txnHash!, chainId: 42161 });
  } catch (e: any) {
    if (![404, 429].includes(e.response?.status)) throw e;
  }
  if (status && status.status !== 'PENDING') break;
}
if (status?.status !== 'COMPLETED') throw new Error(`Not completed: ${status?.status ?? 'no status'}`);
console.log('settled:', status.status);

import { DZapClient, PermitTypes, Services, TxnStatus, type TradeStatusResponse } 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();

const USDC_ARB = '0xaf88d065e77c8cC2239327C5EDb3A432268e5831';
const USDC_BASE = '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913';
const AMOUNT = '100000000'; // 100 USDC

// 1. Quote
const quotes = await dzap.getTradeQuotes({
  fromChain: 42161,
  account: account.address,
  gasless: true,
  data: [{ srcToken: USDC_ARB, destToken: USDC_BASE, amount: AMOUNT, toChain: 8453, slippage: 1 }],
});
const [pair] = Object.values(quotes);

// 2. Sign the permit (no gas)
const permit = await dzap.sign({
  chainId: 42161,
  sender: account.address,
  signer: walletClient,
  service: Services.trade,
  permitType: PermitTypes.EIP2612Permit,
  tokens: [{ address: USDC_ARB, amount: AMOUNT }],
});
if (!('tokens' in permit)) throw new Error('Permit signature failed');

// 3. Execute (build, sign the intent, submit)
const request = {
  fromChain: 42161,
  sender: account.address,
  refundee: account.address,
  gasless: true,
  data: [{ srcToken: USDC_ARB, destToken: USDC_BASE, amount: AMOUNT, toChain: 8453, protocol: pair.recommendedSource, recipient: account.address, slippage: 1, permitData: permit.tokens[0].permitData }],
};
const result = await dzap.tradeGasless({ request, signer: walletClient });
if (result.status !== TxnStatus.success) throw new Error(result.errorMsg);

// 4. Status
let status: TradeStatusResponse | undefined;
for (let i = 0; i < 120; i++) {  // gives up after 30 minutes
  await new Promise((r) => setTimeout(r, 15_000));
  try {
    status = await dzap.getTradeTxnStatus({ txHash: result.txnHash!, chainId: 42161 });
  } catch (e: any) {
    if (![404, 429].includes(e.response?.status)) throw e;
  }
  if (status && status.status !== 'PENDING') break;
}
if (status?.status !== 'COMPLETED') throw new Error(`Not completed: ${status?.status ?? 'no status'}`);
console.log('settled:', status.status);

API usage

The same flow over REST. The gasless build returns hashes to sign instead of a transaction, and the signed result goes to Execute.

Swap
Bridge

curl -X POST https://api.dzap.io/v1/quotes \
  -H "Content-Type: application/json" \
  -d '{
    "fromChain": 42161,
    "gasless": true,
    "data": [{
      "amount": "100000000",
      "srcToken": "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
      "destToken": "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
      "toChain": 42161,
      "slippage": 1
    }]
  }'

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

curl -X POST https://api.dzap.io/v1/gasless/executeTx \
  -H "Content-Type: application/json" \
  -d '{
    "chainId": 42161,
    "txId": "<txId from build>",
    "permit": {
      "permitData": [{
        "token": "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
        "amount": "100000000",
        "permit": "<signed EIP-2612 permit>"
      }],
      "gaslessIntentSignature": "<signed intent>",
      "gaslessIntentNonce": "<intent nonce>",
      "gaslessIntentDeadline": "<intent deadline>"
    }
  }'

curl "https://api.dzap.io/v1/status?txHash=<txnHash from execute>&chainId=42161"

Before Execute, the user signs an EIP-2612 permit for the USDC and an EIP-712 intent over the build’s txId and hashes; the SDK’s sign() and tradeGasless() do this for you. Full reference: Quote, Build Tx, Execute, Status.

curl -X POST https://api.dzap.io/v1/quotes \
  -H "Content-Type: application/json" \
  -d '{
    "fromChain": 42161,
    "gasless": true,
    "data": [{
      "amount": "100000000",
      "srcToken": "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
      "destToken": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
      "toChain": 8453,
      "slippage": 1
    }]
  }'

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

curl -X POST https://api.dzap.io/v1/gasless/executeTx \
  -H "Content-Type: application/json" \
  -d '{
    "chainId": 42161,
    "txId": "<txId from build>",
    "permit": {
      "permitData": [{
        "token": "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
        "amount": "100000000",
        "permit": "<signed EIP-2612 permit>"
      }],
      "gaslessIntentSignature": "<signed intent>",
      "gaslessIntentNonce": "<intent nonce>",
      "gaslessIntentDeadline": "<intent deadline>"
    }
  }'

curl "https://api.dzap.io/v1/status?txHash=<txnHash from execute>&chainId=42161"

Fees

The gasless fee covers the gas DZap’s relayer pays, so it depends on the source chain. It’s charged in the source token and already taken out of the quoted output (included: true), so don’t subtract it again. On a gasless quote, fee.gasFee is empty.

Response	Field	What it is
`POST /v1/quotes`	`fee.protocolFee`	An estimate, for showing while the user compares routes
`POST /v1/buildTx`	`fees.executorFee`	The final fee, fixed by what the user signs

The two can differ noticeably, so show the build’s number on the confirmation screen.

Other ways to authorize

Tokens without EIP-2612 can still go gasless after an on-chain approval, which needs gas:

Mode	Before the trade	User signs	In the request
EIP-2612 permit (the steps above)	Nothing	The permit and the intent	`permitData` from `sign()`
Router allowance	Approve the DZap router for the amount, as in the swap Approve step	The intent	No `permitData`
Permit2	Approve Permit2 for the amount with `approve()` and `ApprovalModes.PermitBatchWitnessTransferFrom`	One Permit2 message	No `permitData`, and `hasPermit2ApprovalForAllTokens: true`

What can go wrong

**Under $1**: the pair comes back with `status: 'error'` and `Minimum$ 1 per pair required for gasless` instead of routes.
Token without EIP-2612: quotes don’t check this, but sign() throws Token does not support EIP-2612 permits. Call checkEIP2612PermitSupport({ chainId, address, owner }) before offering gasless, or use one of the approvals above.
Simulation Failed from tradeGasless(): DZap’s check of the trade failed. Make sure the wallet holds the amount and that the permit or approval covers it; over REST, the Execute response’s error.message and error.action say which.
Not completed: no status: DZap never returned a status, usually because the transaction failed on-chain. Check the hash in a block explorer.
HTTP 429: without an API key, the trade API allows 5 requests a minute in total, shared by every endpoint, and retryAfter says how many seconds to wait. The status loop skips 429s and polls again.

See Error codes for the full catalog.

​Setup

​Steps

​End-to-end

​API usage

​Fees

​Other ways to authorize

​What can go wrong