Swap - Swig

Introduction

Swap exchanges one token for another from a Swig wallet. Use it for portfolio rebalancing or payments that need a different asset. The SDK prepares a swap transaction; review its amounts and destination before signing and submitting.

SDK examples

Prepare a swap

Use a wallet handle with its requester authority, or WalletClient in Rust.

const preparedSwap = await wallet.swap.jupiter({
  feePayer,
  inputMint,
  outputMint,
  amount: 10_000n,
  slippageBps: 100,
  destinationAccount,
  wrapAndUnwrapSol: true,
});

prepared_swap = await wallet.swap.jupiter(
    fee_payer=fee_payer,
    input_mint=input_mint,
    output_mint=output_mint,
    amount=10_000,
    slippage_bps=100,
    destination_account=destination_account,
    wrap_and_unwrap_sol=True,
)

use swig_developer_sdk::{PrepareSwapArgs, SwapOptions};

let prepared_swap = wallet
    .prepare_swap(PrepareSwapArgs {
        swig_config_address,
        fee_payer,
        requester_authority: requester_authority.clone(),
        input_mint,
        output_mint,
        amount: 10_000,
        options: Some(SwapOptions {
            slippage_bps: Some(100),
            destination_owner: Some(destination_owner),
            wrap_and_unwrap_sol: Some(true),
            ..SwapOptions::default()
        }),
    })
    .await?;

Bound execution settings

Limit routing account count and transaction lifetime when preparing a swap for your application’s execution budget.

const prepared = await wallet.swap({
  feePayer,
  inputMint,
  outputMint,
  amount: '10000000',
  slippageBps: 50,
  destinationAccount: recipientOwner,
  wrapAndUnwrapSol: true,
  maxAccounts: 32,
  blockhashSlotsToExpiry: 30,
});

prepared = await wallet.swap(
    fee_payer=fee_payer,
    input_mint=input_mint,
    output_mint=output_mint,
    amount=10_000_000,
    slippage_bps=50,
    destination_account=recipient_owner,
    wrap_and_unwrap_sol=True,
    max_accounts=32,
    blockhash_slots_to_expiry=30,
)

Input

Input	Requirement
Wallet, network, requester	Existing wallet with input-asset spending and required program permissions. Rust accepts Ed25519 or secp256r1.
`feePayer` / `fee_payer`	Public key paying transaction fees and required account rent.
`inputMint`, `outputMint`, `amount`	Source/destination mints and positive exact input base units. Python uses snake_case.
`slippageBps` / `slippage_bps`	Allowed slippage in basis points; 50 means 0.5%.
`destinationAccount` / `destination_account`	Recipient owner; the backend resolves its output ATA or native SOL destination. Rust names this `destination_owner`.
`wrapAndUnwrapSol` / `wrap_and_unwrap_sol`	Whether to wrap or unwrap native SOL.
Execution options	Tips, maximum accounts, blockhash expiry slots, and compute-unit-price percentile. Percentile is at most 10,000 basis points.

Errors

Error	Meaning
Invalid swap input	Missing/invalid mints, nonpositive amount, or an out-of-range execution option.
No usable route	The requested asset pair, amount, or routing constraints cannot produce a swap.
Permission or balance failure	The role lacks required program/asset permission or the wallet/fee payer cannot fund the operation.
Expired or changed market state	A prepared transaction can expire or fail its execution constraints. Reconcile submission before preparing a replacement.