Integration Guide - Multiliquid Protocol

Integration Overview

The Multiliquid Protocol on Solana can be integrated via the official TypeScript SDK, which provides a complete interface for quoting, building, and executing swaps against the on-chain program, along with liquidity-provider administration flows. The SDK is built on Solana Kit (@solana/kit) and uses native bigint values for token amounts. There is no Anchor or @solana/web3.js runtime dependency.

SDK Installation

Install and configure the TypeScript SDK

Pair Discovery

Find available trading pairs

Quoting

Get swap quotes using client-side math or simulation

Executing Swaps

Build and submit swap transactions

LP Admin

Create, update, and close pairs and manage liquidity

Ladder Pricing Model

Implement a rolling 24-hour laddered pricing model as an LP

Installation

npm install @uniformlabs/multiliquid-svm-sdk@latest @solana/kit

The package declares runtime dependencies on:

@solana/kit
@solana-program/token-2022

Install @solana/kit directly when importing Kit helpers such as address, createSolanaRpc, and signTransaction in application code. Node.js >=24 is required.

Client Initialization

The SDK provides a MultiliquidClient class that wraps all functionality. Addresses are Kit Address values (branded strings), created with address():

import { address, createSolanaRpc } from "@solana/kit";
import { MultiliquidClient } from "@uniformlabs/multiliquid-svm-sdk";

const rpc = createSolanaRpc("https://api.mainnet-beta.solana.com");

const client = new MultiliquidClient({
  rpc,
  cluster: "mainnet-beta", // "devnet" | "mainnet-beta"
  commitment: "confirmed", // optional, default: "confirmed"
});

const user = address("...");

cluster selects the built-in pair registry and default program address. Both devnet and mainnet use the same swap program ID: HaWDr94LKJQT2fXuHJGsSGeQf6M7S68FXpEQLcE5RYs6. Pass programAddress to override that default. Optional registryApiUrl, registryFetchTimeoutMs, and onRegistryError configure metadata-API pair discovery.

Pair Discovery

Metadata Registry

getPairs() queries the Multiliquid metadata API and falls back to the bundled registry:

const pairs = await client.getPairs();
// Returns registered pairs for the configured cluster

const usdcPairs = await client.getPairs({
  quoteMint: address("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"),
});

Each returned entry includes the pair PDA, both mints in the pair account’s stored quote/base order, the liquidity provider, and token decimals:

for (const pair of pairs) {
  console.log(pair.label); // e.g. "USDC / USTB"
  console.log(pair.pair);
  console.log(pair.quoteMint);
  console.log(pair.baseMint);
  console.log(pair.liquidityProvider);
  console.log(pair.quoteDecimals); // e.g. 6
  console.log(pair.baseDecimals); // e.g. 6 for USTB
}

// Use the entry directly in swap params
const pair = pairs[0];
const quote = await client.getQuote({
  user,
  liquidityProvider: pair.liquidityProvider,
  inputMint: pair.quoteMint,
  outputMint: pair.baseMint,
  amount: 1_000_000_000n,
  swapType: SwapType.ExactIn,
});

getOfflinePairs() returns the bundled registry without an HTTP call.

On-Chain Discovery (RPC)

For dynamically discovering pairs not in the registry:

const pairs = await client.discoverPairs({
  quoteMint: USDC,
});
// Returns the same PairRegistryEntry format as getPairs()

Checking Pair Status

Before executing a swap, verify the pair is active. Callers pass the tokens being spent and received; the SDK resolves pair ordering:

const status = await client.checkPauseStatus(inputMint, outputMint, lp);

if (status.anyPaused) {
  console.log("Swap blocked:", status.pauseReasons);
  // e.g. ["ProgramPaused"], ["PairPaused"], ["InputPaused"], ["OutputPaused"]
}

Pause checks cover the global config, the pair, the input and output asset configs, and any LP-stable configs on those sides. All must be unpaused for swaps to execute. Pass pairAddress when both on-chain pair orderings exist for the same LP and mint pair.

Quoting

The SDK offers two quoting methods: client-side math replication and on-chain simulation. Callers specify the tokens spent and received. The SDK checks both possible on-chain pair orderings and translates the result to the protocol’s quote-to-base or base-to-quote direction internally. If both orderings exist for the same LP and mint pair, pass pairAddress to disambiguate.

Client-Side Quote

Replicates the on-chain Rust math exactly using bigint. Fetches current NAV prices from oracles and computes the swap result:

import { address } from "@solana/kit";
import { SwapType, toHumanReadable } from "@uniformlabs/multiliquid-svm-sdk";

const USDC = address("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
const USTB = address("CCz3SGVziFeLYk2xfEstkiqJfYkjaSWb2GCABYsVcjo2");
const LP = address("C8Mi6kn7ajFWuNe4ZmsR9A6fdqRYhzXFoqVBGMsdJ2Uf");

const quote = await client.getQuote({
  user,
  liquidityProvider: LP,
  inputMint: USDC,
  outputMint: USTB,
  amount: 1_000_000_000n, // 1000 USDC (6 decimals)
  swapType: SwapType.ExactIn,
});

console.log("Output:", toHumanReadable(quote.amountOut, 6));
console.log("Protocol fees:", quote.protocolFees.toString());
console.log("Input NAV:", quote.inputNav.toString());
console.log("Output NAV:", quote.outputNav.toString());
console.log("Fee token:", quote.feeTokenMint);

protocolFees is denominated in feeTokenMint and is paid from the LP fee vault. It is not deducted from the trader’s input. The SwapQuote includes:

Field	Description
`amountIn`	Total input amount
`amountOut`	Output amount received
`protocolFees`	Protocol fee collected in `feeTokenMint`
`issuerProtocolFees`	Issuer protocol-fee component
`spreadProtocolFees`	Spread protocol-fee component
`discountAmount`	LP fee amount (redemption or discount)
`amountInForVault`	Input amount credited to the LP vault
`inputNav`	Input-asset NAV price (9 decimals)
`outputNav`	Output-asset NAV price (9 decimals)
`feeTokenMint`	Mint used to collect protocol fees
`feeTokenNav`	Fee-token NAV price (9 decimals)

Simulation Quote

Builds a swap instruction with ATA creation disabled, simulates it against the validator, and parses the emitted event:

const simQuote = await client.getQuoteViaSimulation({
  user,
  liquidityProvider: LP,
  inputMint: USDC,
  outputMint: USTB,
  amount: 1_000_000_000n,
  swapType: SwapType.ExactIn,
});

console.log("Output:", simQuote.amountOut.toString());
console.log("Compute units:", simQuote.computeUnitsConsumed.toString());

The simulation quote also returns computeUnitsConsumed as bigint, which is useful for setting compute-budget instructions.

Executing Swaps

The SDK is instruction-first: the primary API returns Kit Instruction objects for maximum composability. A convenience method for building unsigned Kit transactions is also available.

Building a Swap Transaction

import { getBase64EncodedWireTransaction, signTransaction } from "@solana/kit";

const { transaction } = await client.buildSwapTransaction({
  user,
  liquidityProvider: LP,
  inputMint: USDC,
  outputMint: USTB,
  amount: 1_000_000_000n, // 1000 USDC
  swapType: SwapType.ExactIn,
  minAmountOut: 990_000_000n, // slippage protection
});

const signedTransaction = await signTransaction([userSigner.keyPair], transaction);
const signature = await rpc
  .sendTransaction(getBase64EncodedWireTransaction(signedTransaction), {
    encoding: "base64",
    preflightCommitment: "confirmed",
  })
  .send();

The returned transaction is unsigned. A signer whose address matches user must sign before submission.

Building Individual Instructions

For more control, build the swap instruction separately and compose it with other instructions (for example, compute budget):

import {
  getSetComputeUnitLimitInstruction,
  getSetComputeUnitPriceInstruction,
} from "@solana-program/compute-budget";
import { buildUnsignedTransaction } from "@uniformlabs/multiliquid-svm-sdk";

const { instruction, setupInstructions } = await client.buildSwapInstruction({
  user,
  liquidityProvider: LP,
  inputMint: USDC,
  outputMint: USTB,
  amount: 1_000_000_000n,
  swapType: SwapType.ExactIn,
  minAmountOut: 990_000_000n,
});

// setupInstructions contains ATA creation if needed (autoCreateAta defaults to true).
// The builder also resolves Token-2022 transfer-hook accounts for known hook mints.
const transaction = await buildUnsignedTransaction(rpc, user, [
  getSetComputeUnitLimitInstruction({ units: 150_000 }),
  getSetComputeUnitPriceInstruction({ microLamports: 50_000 }),
  ...setupInstructions,
  instruction,
]);

The SDK does not include compute-budget instructions automatically. Integrators that need priority fees or explicit compute limits can compose @solana-program/compute-budget instructions as shown above. Use getQuoteViaSimulation() to measure actual compute units consumed.

Convenience swap and liquidity builders automatically plan treasury CPI accounts, associated token accounts, NAV and APY remaining accounts, and Token-2022 transfer-hook accounts when the LP has treasury enabled.

Swap Examples

Buy RWA with USDC (ExactIn) Swap exactly 1000 USDC for USTB, accepting at minimum 990 USTB:

const { transaction } = await client.buildSwapTransaction({
  user,
  liquidityProvider: LP,
  inputMint: USDC,
  outputMint: USTB,
  amount: 1_000_000_000n, // 1000 USDC (6 decimals)
  swapType: SwapType.ExactIn,
  minAmountOut: 990_000_000n, // min 990 USTB (6 decimals)
});

Sell RWA for USDC (ExactIn) Swap exactly 100 USTB for USDC, accepting at minimum 95 USDC:

const { transaction } = await client.buildSwapTransaction({
  user,
  liquidityProvider: LP,
  inputMint: USTB,
  outputMint: USDC,
  amount: 100_000_000n, // 100 USTB (6 decimals)
  swapType: SwapType.ExactIn,
  minAmountOut: 95_000_000n, // min 95 USDC (6 decimals)
});

Buy Exact RWA Amount (ExactOut) Receive exactly 100 USTB, spending at most 105 USDC:

const { transaction } = await client.buildSwapTransaction({
  user,
  liquidityProvider: LP,
  inputMint: USDC,
  outputMint: USTB,
  amount: 100_000_000n, // exact 100 USTB out (6 decimals)
  swapType: SwapType.ExactOut,
  maxAmountIn: 105_000_000n, // max 105 USDC (6 decimals)
});

Sell RWA for Exact USDC (ExactOut) Receive exactly 1000 USDC, spending at most 1010 USTB:

const { transaction } = await client.buildSwapTransaction({
  user,
  liquidityProvider: LP,
  inputMint: USTB,
  outputMint: USDC,
  amount: 1_000_000_000n, // exact 1000 USDC out (6 decimals)
  swapType: SwapType.ExactOut,
  maxAmountIn: 1_010_000_000n, // max 1010 USTB (6 decimals)
});

Swap Parameters Reference

Parameter	Type	Description
`user`	`Address`	Transaction fee payer and swap signer
`liquidityProvider`	`Address`	LP that owns the pair
`inputMint`	`Address`	Token the trader spends
`outputMint`	`Address`	Token the trader receives
`pairAddress`	`Address` (optional)	Required only when both on-chain pair orderings exist
`amount`	`bigint`	Primary amount in native token units (input for ExactIn, output for ExactOut)
`swapType`	`SwapType`	`ExactIn` or `ExactOut`
`minAmountOut`	`bigint` (optional)	Minimum output for ExactIn swaps
`maxAmountIn`	`bigint` (optional)	Maximum input for ExactOut swaps
`userInputTokenAccount`	`Address` (optional)	Override the user’s input ATA
`userOutputTokenAccount`	`Address` (optional)	Override the user’s output ATA
`autoCreateAta`	`boolean` (optional)	Auto-create ATAs if missing (default: `true`)
`remainingAccounts`	`AccountMeta[]` (optional)	Extra accounts appended after SDK-derived oracle, treasury, and transfer-hook accounts

Swap instruction and transaction results expose the resolved onchainDirection (SwapDirection.QuoteToBase or SwapDirection.BaseToQuote).

LP Admin and Liquidity

Liquidity providers create, configure, and close their own pairs, and manage vault balances, using the same instruction-first API. The SDK derives PDAs, vault authorities, token program IDs, and Token-2022 transfer-hook accounts automatically. The LP signs every builder below. For close_pair, the global-config admin is referenced as a non-signing account; the SDK fetches it from GlobalConfig when it is not supplied via admin.

Permissioned Token Whitelisting

For every permissioned mint used by an LP, the token issuer must separately whitelist (allowlist) both of these addresses:

LP admin address — the liquidityProvider wallet that owns and authorizes the LP’s source and recipient token accounts.
Vault authority PDA — the LP-specific PDA derived from ["vault_authority", liquidityProvider] that owns the program’s vault ATAs.

These are different addresses with independent issuer permissions. Whitelisting the LP admin address does not whitelist the vault authority PDA, and whitelisting the vault authority PDA does not whitelist the LP admin address. After the relevant token accounts exist, confirm that the issuer has thawed both the LP-owned token account and the PDA-owned vault ATA for each permissioned mint. init_pair can create the vault ATA, but the Multiliquid program and SDK cannot grant issuer approval or bypass a frozen-account restriction. add_liquidity, remove_liquidity, and swaps involving that vault will fail until the required accounts are authorized and thawed. Derive the address that must be submitted to the issuer before funding the pair. Kit PDA helpers are asynchronous:

const lpAdmin = liquidityProvider;
const [vaultAuthority] = await client.deriveVaultAuthority(lpAdmin);

console.log("LP admin to whitelist:", lpAdmin);
console.log("Vault authority PDA to whitelist:", vaultAuthority);

Token-2022 program detection and transfer-hook account resolution are automatic, but issuer whitelisting and token-account thawing are external onboarding steps.

Create a Pair

init_pair is LP-signed: the liquidity provider pays for the Pair PDA, LP-stable configs, vault ATAs, and UserVaultInfo accounts. Callers pass unordered mintA and mintB values. The builder compares the decoded 32-byte public keys, derives the canonical quote/base PDA order, and places optional LP-stable configs according to each side’s on-chain AssetType. Stable-on-base, stable-on-quote, and RWA-to-RWA pairs are supported. Fee combinations where redemptionFeeBps + discountRateBps >= 10_000 are rejected.

const { instruction: initPairIx } = await client.buildInitPairInstruction({
  liquidityProvider,
  mintA: USDC,
  mintB: USTB,
  redemptionFeeBps: 50, // 0.5% quote → base fee
  discountRateBps: 25, // 0.25% base → quote fee
});

// Or get an unsigned Kit transaction directly:
const { transaction: initPairTx } = await client.buildInitPairTransaction({
  liquidityProvider,
  mintA: USDC,
  mintB: USTB,
  redemptionFeeBps: 50,
  discountRateBps: 25,
});

Update Pair Configuration

Update and close builders resolve both possible PDA mint orders and use the existing pair account’s stored quote/base layout. Pass pairAddress when both orders exist.

const { instruction: updatePairIx } = await client.buildUpdatePairInstruction({
  liquidityProvider,
  mintA: USDC,
  mintB: USTB,
  redemptionFeeBps: 10,
  discountRateBps: 15,
  paused: false,
});

Add and Remove Liquidity

const { instruction: addLiquidityIx, setupInstructions } =
  await client.buildAddLiquidityInstruction({
    liquidityProvider,
    mint: USDC,
    amount: 1_000_000_000n,
  });

const { transaction: removeLiquidityTx } =
  await client.buildRemoveLiquidityTransaction({
    liquidityProvider,
    mint: USTB,
    amount: 500_000_000n,
  });

Use lpTokenAccount when the liquidity provider uses a non-ATA token account. Set autoCreateAta: false if token accounts are managed externally, and use remainingAccounts only for extra accounts beyond those derived by the SDK.

Close a Pair

close_pair is LP-signed and reclaims rent for the Pair PDA, and — when the pair was the last consumer of a shared vault — the vault ATA and UserVaultInfo PDA. Any remaining vault balances are returned to the LP’s recipient token accounts. The SDK reads UserVaultInfo.used for both vaults and only resolves Token-2022 transfer-hook accounts when the shared-vault counter shows the close will transfer.

const { instruction: closePairIx, setupInstructions } =
  await client.buildClosePairInstruction({
    liquidityProvider,
    mintA: USDC,
    mintB: USTB,
    // Optional overrides:
    // lpMintATokenAccount, lpMintBTokenAccount — non-ATA recipient accounts
    // autoCreateAta: false                     — manage recipient ATAs externally
    // admin                                    — cached GlobalConfig admin
  });

const { transaction: closePairTx } = await client.buildClosePairTransaction({
  liquidityProvider,
  mintA: USDC,
  mintB: USTB,
});

For Token-2022 mints with a transfer hook, the LP recipient token account must already exist on-chain when the builder runs if the close will transfer vault balances. The builder resolves hook accounts from current on-chain data, so a recipient ATA that only exists as a setup instruction will be rejected. Pre-create the recipient account or pass it via lpMintATokenAccount / lpMintBTokenAccount.Hook account resolution uses a build-time snapshot of the vault balance, while the program transfers the execution-time balance during close_pair.

Event Parsing

Parse SwapExecuted events from transaction logs:

// From a transaction signature
const events = await client.parseSwapEventsFromTransaction(signature);

for (const event of events) {
  console.log("Amount in:", event.amountIn.toString());
  console.log("Amount out:", event.amountOut.toString());
  console.log("Protocol fee:", event.protocolFeeAmount.toString());
  console.log("Direction:", event.swapDirection);
}

// From raw logs (e.g., from websocket subscription)
const events = client.parseSwapEventsFromLogs(logs);

Error Handling

The SDK provides structured error parsing for on-chain program errors:

try {
  const signedTransaction = await signTransaction([userSigner.keyPair], transaction);
  await rpc
    .sendTransaction(getBase64EncodedWireTransaction(signedTransaction), {
      encoding: "base64",
      preflightCommitment: "confirmed",
    })
    .send();
} catch (error) {
  const parsed = client.parseSwapError(error);

  if (parsed && "category" in parsed) {
    console.log("Error:", parsed.name, "-", parsed.message);
    console.log("Category:", parsed.category);

    switch (parsed.category) {
      case "slippage":
        // AmountOutTooLow or AmountInTooHigh — re-quote with fresh state
        break;
      case "paused":
        // ProgramPaused, PairPaused, or asset/LP pause — wait or skip
        break;
      case "oracle":
        // InvalidNav — NAV source unavailable or divergent
        break;
      case "liquidity":
        // InsufficientLiquidity — try smaller amount or different pair
        break;
      case "user_funds":
        // Trader input account missing or underfunded
        break;
      case "input_validation":
        // Fix input parameters
        break;
      case "math":
        // MathOverflow/Underflow — trade may be too small or too large
        break;
    }
  }
}

Amount Formatting

Convert between native token amounts (with decimals) and human-readable strings. Formatting uses decimal strings and bigint; no floating-point arithmetic is involved:

import { toHumanReadable, toNativeAmount } from "@uniformlabs/multiliquid-svm-sdk";

// Native to human-readable
toHumanReadable(100_000_000n, 6); // "100"
toHumanReadable(99_800_000_000n, 9); // "99.8"

// Human-readable to native
toNativeAmount("100", 6); // 100_000_000n
toNativeAmount("99.8", 9); // 99_800_000_000n

Reading On-Chain State

Fetch All Swap State (Single RPC Call)

const state = await client.fetchSwapState(inputMint, outputMint, lp);

console.log("Protocol fees:", state.globalConfig.protocolFeesBps, "bps");
console.log("Redemption fee:", state.pair.redemptionFeeBps, "bps");
console.log("Discount rate:", state.pair.discountRateBps, "bps");
console.log("Pair paused:", state.pair.paused);
console.log("Input LP paused:", state.inputLpStableConfig?.paused);
console.log("Output LP paused:", state.outputLpStableConfig?.paused);
console.log("Program paused:", state.globalConfig.paused);

Fetch Individual Accounts

const globalConfig = await client.fetchGlobalConfig();
const pair = await client.fetchPair(pairAddress);
const assetConfig = await client.fetchAssetConfig(configAddress);
const lpStableConfig = await client.fetchLpStableConfig(lpStableConfigAddress);

PDA Derivation

All program accounts are deterministic PDAs. Kit PDA derivation is asynchronous; every helper returns Promise<ProgramDerivedAddress>, whose resolved value is [address, bump]:

const [globalConfig] = await client.deriveGlobalConfig();
const [assetConfig] = await client.deriveAssetConfig(mint);
const [pair] = await client.derivePair(lp, quoteMint, baseMint);
const [vaultAuthority] = await client.deriveVaultAuthority(lp);
const [vault] = await client.deriveVault(mint, lp);
const [feeVault] = await client.deriveFeeVault(feeMint);
const [lpStableConfig] = await client.deriveLpStableConfig(stableMint, lp);
const [programAuthority] = await client.deriveProgramAuthority();

Derive an existing pair with the registry entry’s stored quoteMint / baseMint. For a new pair, canonicalize the unordered mints first:

import { canonicalizePairMints } from "@uniformlabs/multiliquid-svm-sdk";

const { quoteMint, baseMint } = canonicalizePairMints(USDC, USTB);
const [pairAddress] = await client.derivePair(lp, quoteMint, baseMint);

LP vault token accounts are ATAs for (mint, vaultAuthority), where vaultAuthority is the LP-specific PDA derived from ["vault_authority", lp]. Fee vault token accounts are ATAs for (feeMint, programAuthority), where programAuthority is the global PDA derived from ["program_authority"]. When deriving vault or fee-vault addresses manually for Token-2022 mints, pass the Token-2022 program ID as the optional tokenProgram argument. Swap and liquidity builders detect the mint owner and derive the correct ATAs automatically.

Integration Best Practices

Security

Use Hardware Wallets: Never store private keys in code or environment variables for production
Simulate First: Always call getQuote() or getQuoteViaSimulation() before executing
Set Slippage: Always provide minAmountOut or maxAmountIn for production swaps
Check Pause State: Call checkPauseStatus() before building transactions

Performance

Use Client-Side Quotes: getQuote() is faster than getQuoteViaSimulation() for most use cases
Set Compute Budget: Use computeUnitsConsumed from simulation to set appropriate compute limits
Reuse Client: Create one MultiliquidClient instance and reuse across operations
Use the Registry: getPairs() uses the metadata API with a bundled fallback; getOfflinePairs() avoids network calls

Operational

Priority Fees: Set appropriate priority fees via compute-budget instructions for time-sensitive operations
Confirmation: Wait for confirmed or finalized commitment before treating a swap as complete
Event Monitoring: Use parseSwapEventsFromTransaction() to verify swap results after execution
Error Recovery: Use parseSwapError() to categorize failures and implement appropriate retry logic

Testing

Devnet

Configure the client for devnet testing:

const rpc = createSolanaRpc("https://api.devnet.solana.com");
const client = new MultiliquidClient({
  rpc,
  cluster: "devnet",
});

// Devnet pairs use mock tokens — see SDK registry for addresses
const devnetPairs = await client.getPairs();

Mainnet

const rpc = createSolanaRpc("https://api.mainnet-beta.solana.com");
const client = new MultiliquidClient({
  rpc,
  cluster: "mainnet-beta",
});

Support and Resources

Protocol Website: https://www.multiliquid.xyz/
Program IDL: See Program IDL page
Deployment Addresses: See Deployments page

​Integration Overview

SDK Installation

Pair Discovery

Quoting

Executing Swaps

LP Admin

Ladder Pricing Model

​Installation

​Client Initialization

​Pair Discovery

​Metadata Registry

​On-Chain Discovery (RPC)

​Checking Pair Status

​Quoting

​Client-Side Quote

​Simulation Quote

​Executing Swaps

​Building a Swap Transaction

​Building Individual Instructions

​Swap Examples

​Swap Parameters Reference

​LP Admin and Liquidity

​Permissioned Token Whitelisting

​Create a Pair

​Update Pair Configuration

​Add and Remove Liquidity

​Close a Pair

​Event Parsing

​Error Handling

​Amount Formatting

​Reading On-Chain State

​Fetch All Swap State (Single RPC Call)

​Fetch Individual Accounts

​PDA Derivation

​Integration Best Practices

​Security

​Performance

​Operational

​Testing

​Devnet

​Mainnet

​Support and Resources

Integration Overview

Installation

Client Initialization

Pair Discovery

Metadata Registry

On-Chain Discovery (RPC)

Checking Pair Status

Quoting

Client-Side Quote

Simulation Quote

Executing Swaps

Building a Swap Transaction

Building Individual Instructions

Swap Examples

Swap Parameters Reference

LP Admin and Liquidity

Permissioned Token Whitelisting

Create a Pair

Update Pair Configuration

Add and Remove Liquidity

Close a Pair

Event Parsing

Error Handling

Amount Formatting

Reading On-Chain State

Fetch All Swap State (Single RPC Call)

Fetch Individual Accounts

PDA Derivation

Integration Best Practices

Security

Performance

Operational

Testing

Devnet

Mainnet

Support and Resources