Withdraw - DZap

A withdraw (Zap Out) is the reverse of a deposit: the router exits your position and returns a plain token. The source is the position (srcToken = position.address); the destination is any token on any chain (destToken / destChainId). NFT-based LP positions (Uniswap V3 and similar) are identified by positionDetails.nftId. Pick a chain below; the tabs stay in sync across Setup, Steps, and End-to-end.

EVM withdrawals authorize the position token through Permit2 (no EIP-2612). Solana withdrawals carry no approval step, you sign and send the built transactions directly.

Setup

EVM
Solana

Exit a Uniswap V3 position on Base back into USDC.

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

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

const USDC_BASE = '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913';   // token you want back

Protocol IDs (provider) come from getZapProviders, scoped per chain by getZapChains.

Exit a Jupiter Lend position on Solana back into USDC. Needs @solana/web3.js alongside the SDK.

import { DZapClient } from '@dzapio/sdk';
import { Connection, VersionedTransaction } from '@solana/web3.js';

const dzap = DZapClient.getInstance();
const connection = new Connection('https://api.mainnet-beta.solana.com');

// your Solana wallet adapter (wallet-standard, Keypair, etc.)
const account = wallet.publicKey.toBase58();
const USDC_SOL = 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v';   // token you want back

Protocol IDs (provider) come from getZapProviders, scoped per chain by getZapChains.

Steps

EVM
Solana

Find the position

List the account’s open positions for a protocol, then pick the one to exit. Each position carries its address, chainId, amount, and optional nftDetails.

const { positions } = await dzap.getZapPositions({
  account: account.address,
  chainId: 8453,
  provider: 'uniswap',
});

const position = positions[0];   // assumes at least one open position

Withdraw the full balance with position.amount, or pass any smaller amount for a partial exit.

Quote

Build the exit route. The source token is the position; the destination is whatever token and chain you want back. Read-only.

const request = {
  srcChainId: position.chainId,
  srcToken: position.address,   // the position you are exiting
  amount: position.amount,
  destChainId: 8453,
  destToken: USDC_BASE,         // token you want back
  account: account.address,
  recipient: account.address,
  refundee: account.address,
  slippage: 1,                  // 1 = 1%
  ...(position.nftDetails && {
    positionDetails: { nftId: position.nftDetails.id },
  }),
};

const quote = await dzap.getZapQuote(request);
console.log('Route:', quote.path.map((p) => p.protocol.name).join(' -> '));
console.log('Expected:', quote.output[0]?.amount, quote.output[0]?.asset.symbol);

Approve

Authorize the position token through Permit2, approving once on-chain only if the allowance is short.

const { data } = await dzap.getAllowance({
  chainId: position.chainId,
  sender: account.address,
  tokens: [{ address: position.address, amount: position.amount }],
  service: Services.zap,
  mode: ApprovalModes.PermitSingle,
});

if (data[position.address].allowance < BigInt(position.amount)) {
  await dzap.approve({
    chainId: position.chainId,
    signer: walletClient,
    sender: account.address,
    tokens: [{ address: position.address, amount: position.amount }],
    service: Services.zap,
    mode: ApprovalModes.PermitSingle,
  });
}

Build & execute

Sign the Permit2 PermitSingle, attach permitData, build the route, and execute.

const permit = await dzap.sign({
  chainId: position.chainId,
  sender: account.address,
  service: Services.zap,
  signer: walletClient,
  tokens: [{ address: position.address, amount: position.amount }],
  permitType: PermitTypes.PermitSingle,
});

const fullRequest = { ...request, permitData: permit.tokens[0].permitData };
const route = await dzap.buildZapTxn(fullRequest);
const result = await dzap.zap({ request: fullRequest, steps: route.steps, signer: walletClient });
console.log(`Withdrew: ${result.txnHash}`);

Status

Poll to a terminal state. Zap status is uppercase: PENDING, COMPLETED, FAILED, or REFUNDED.

const status = await dzap.getZapTxnStatus({
  chainId: position.chainId,
  txnHash: result.txnHash!,
});

console.log(status.status);   // PENDING -> COMPLETED

Cross-chain withdrawals (destChainId different from the position’s chain) run exit-then-bridge and settle slower. status.steps shows each leg.

Find the position

List the account’s open positions for a protocol on Solana (chain ID 7565164), then pick the one to exit. Each position carries its address, chainId, and amount.

const { positions } = await dzap.getZapPositions({
  account,
  chainId: 7565164,
  provider: 'jupiterlend',
});

const position = positions[0];   // assumes at least one open position

Withdraw the full balance with position.amount, or pass any smaller amount for a partial exit.

Quote

Build the exit route with base58 addresses. The source is the position; the destination is the SPL token you want back. Read-only.

const request = {
  srcChainId: position.chainId,
  srcToken: position.address,   // the position you are exiting
  amount: position.amount,
  destChainId: 7565164,
  destToken: USDC_SOL,          // token you want back
  account,
  recipient: account,
  refundee: account,
  slippage: 1,                  // 1 = 1%
};

const quote = await dzap.getZapQuote(request);
console.log('Route:', quote.path.map((p) => p.protocol.name).join(' -> '));

Set destChainId to an EVM chain and destToken/recipient to 0x addresses to receive the token on an EVM chain instead. Keep refundee as your Solana address.

Build

No approval on Solana, go straight to build. The step data carries an array of base64 transactions and a txnId.

const route = await dzap.buildZapTxn(request);
const step = route.steps[0].data;   // SVM step: { data: string[], txnId, isJitoTx }

Sign & send

Deserialize each base64 transaction, sign with your wallet, and broadcast. Jito-routed zaps go through the Jito block engine.

const txns = step.data.map((b64) =>
  VersionedTransaction.deserialize(Buffer.from(b64, 'base64')),
);

if (step.isJitoTx) {
  const signed = await wallet.signTransaction(txns[0]);
  await fetch('https://mainnet.block-engine.jito.wtf/api/v1/transactions', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: 1,
      method: 'sendTransaction',
      params: [Buffer.from(signed.serialize()).toString('base64'), { encoding: 'base64' }],
    }),
  });
} else {
  const signedAll = await wallet.signAllTransactions(txns);
  for (const tx of signedAll) {
    const sig = await connection.sendRawTransaction(tx.serialize());
    await connection.confirmTransaction(sig, 'confirmed');
  }
}

Status

Track it with the txnId from the build step.

const status = await dzap.getZapTxnStatus({
  chainId: 7565164,
  txnHash: step.txnId,
});

console.log(status.status);   // PENDING -> COMPLETED

End-to-end

EVM
Solana

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

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

const USDC_BASE = '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913';

// 1. Pick a position
const { positions } = await dzap.getZapPositions({
  account: account.address,
  chainId: 8453,
  provider: 'uniswap',
});
const position = positions[0];

// 2. Quote the exit
const request = {
  srcChainId: position.chainId,
  srcToken: position.address,
  amount: position.amount,
  destChainId: 8453,
  destToken: USDC_BASE,
  account: account.address,
  recipient: account.address,
  refundee: account.address,
  slippage: 1,
  ...(position.nftDetails && { positionDetails: { nftId: position.nftDetails.id } }),
};
const quote = await dzap.getZapQuote(request);
console.log('Route:', quote.path.map((p) => p.protocol.name).join(' -> '));

// 3. Approve (Permit2, on-chain only if short)
const { data } = await dzap.getAllowance({
  chainId: position.chainId,
  sender: account.address,
  tokens: [{ address: position.address, amount: position.amount }],
  service: Services.zap,
  mode: ApprovalModes.PermitSingle,
});
if (data[position.address].allowance < BigInt(position.amount)) {
  await dzap.approve({
    chainId: position.chainId,
    signer: walletClient,
    sender: account.address,
    tokens: [{ address: position.address, amount: position.amount }],
    service: Services.zap,
    mode: ApprovalModes.PermitSingle,
  });
}

// 4. Sign permit, build, execute
const permit = await dzap.sign({
  chainId: position.chainId,
  sender: account.address,
  service: Services.zap,
  signer: walletClient,
  tokens: [{ address: position.address, amount: position.amount }],
  permitType: PermitTypes.PermitSingle,
});
const fullRequest = { ...request, permitData: permit.tokens[0].permitData };
const route = await dzap.buildZapTxn(fullRequest);
const result = await dzap.zap({ request: fullRequest, steps: route.steps, signer: walletClient });
if (result.status !== TxnStatus.success) throw new Error(result.errorMsg ?? 'withdraw failed');

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

import { DZapClient } from '@dzapio/sdk';
import { Connection, VersionedTransaction } from '@solana/web3.js';

const dzap = DZapClient.getInstance();
const connection = new Connection('https://api.mainnet-beta.solana.com');

// your Solana wallet adapter (wallet-standard, Keypair, etc.)
const account = wallet.publicKey.toBase58();
const USDC_SOL = 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v';

// 1. Pick a position
const { positions } = await dzap.getZapPositions({
  account,
  chainId: 7565164,
  provider: 'jupiterlend',
});
const position = positions[0];

// 2. Quote the exit
const request = {
  srcChainId: position.chainId,
  srcToken: position.address,
  amount: position.amount,
  destChainId: 7565164,
  destToken: USDC_SOL,
  account,
  recipient: account,
  refundee: account,
  slippage: 1,
};
const quote = await dzap.getZapQuote(request);
console.log('Route:', quote.path.map((p) => p.protocol.name).join(' -> '));

// 3. Build
const route = await dzap.buildZapTxn(request);
const step = route.steps[0].data;

// 4. Sign and send
const txns = step.data.map((b64) =>
  VersionedTransaction.deserialize(Buffer.from(b64, 'base64')),
);
if (step.isJitoTx) {
  const signed = await wallet.signTransaction(txns[0]);
  await fetch('https://mainnet.block-engine.jito.wtf/api/v1/transactions', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: 1,
      method: 'sendTransaction',
      params: [Buffer.from(signed.serialize()).toString('base64'), { encoding: 'base64' }],
    }),
  });
} else {
  const signedAll = await wallet.signAllTransactions(txns);
  for (const tx of signedAll) {
    const sig = await connection.sendRawTransaction(tx.serialize());
    await connection.confirmTransaction(sig, 'confirmed');
  }
}

// 5. Status
const status = await dzap.getZapTxnStatus({ chainId: 7565164, txnHash: step.txnId });
console.log('settled:', status.status);

API usage

The zap API lives on https://zap.dzap.io/v1. List positions and check status with GET; quote and build are POST. The position address is the srcToken, and NFT LPs add positionDetails.

curl "https://zap.dzap.io/v1/user/positions?account=0xUser&chainId=8453&provider=uniswap"

curl -X POST https://zap.dzap.io/v1/quote \
  -H "Content-Type: application/json" \
  -d '{
    "srcChainId": 8453,
    "destChainId": 8453,
    "account": "0xUser",
    "srcToken": "0xPositionAddress",
    "destToken": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
    "amount": "<position amount>",
    "recipient": "0xUser",
    "refundee": "0xUser",
    "slippage": 1,
    "positionDetails": { "nftId": "<nft id, LP positions only>" }
  }'

curl -X POST https://zap.dzap.io/v1/buildTx \
  -H "Content-Type: application/json" \
  -d '{
    "srcChainId": 8453,
    "destChainId": 8453,
    "account": "0xUser",
    "srcToken": "0xPositionAddress",
    "destToken": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
    "amount": "<position amount>",
    "recipient": "0xUser",
    "refundee": "0xUser",
    "slippage": 1,
    "permitData": "0x...",
    "positionDetails": { "nftId": "<nft id, LP positions only>" }
  }'

curl "https://zap.dzap.io/v1/status?chainId=8453&txnHash=0xabc..."

Notes

NFT LP positions: pass positionDetails.nftId. Fungible LP/vault tokens omit it.
Native destination (ETH, SOL): the router unwraps to the native asset, nothing extra to configure.
Partial exit: pass any amount up to position.amount.
Cross-chain: set destChainId to receive the token on another chain; expect bridge latency.

​Setup

​Steps

​End-to-end

​API usage

​Notes

Setup

Steps

End-to-end

API usage

Notes