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 capital 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

Capital Provider Admin

Create, update, and close pairs and manage liquidity

Ladder Pricing Model

Implement a rolling 24-hour laddered pricing model as a capital provider

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 capital 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, the configured fee asset, and any capital provider 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 capital provider 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 capital provider 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 capital provider 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`	Capital provider fee amount (redemption or discount)
`amountInForVault`	Input amount credited to the capital provider 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, and NAV and APY remaining accounts when the capital provider has treasury enabled. Transfer-hook accounts are resolved for supported routes. Treasury-enabled add/remove-liquidity builders reject transfer-hook mints; swap builders reject hooks on stable inputs that may be swept or stable outputs that may require Treasury redemption. Those routes require raw builders with explicitly resolved remaining accounts.

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`	Capital provider 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).

Capital Provider Admin and Liquidity

Capital 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 capital provider 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 a capital provider, the token issuer must separately whitelist (allowlist) both of these addresses:

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

These are different addresses with independent issuer permissions. Whitelisting the capital provider admin address does not whitelist the vault authority PDA, and whitelisting the vault authority PDA does not whitelist the capital provider admin address. After the relevant token accounts exist, confirm that the issuer has thawed both the capital provider’s 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("Capital provider 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 signed by the capital provider: the capital provider pays for the Pair PDA, capital provider 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 capital provider 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

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

const { instruction: addLiquidityIx, setupInstructions } =
  await client.buildAddLiquidityInstruction({
    liquidityProvider,
    mint: USDC,
    amount: 1_000_000_000n,
    amountThreshold: 990_000_000n, // Minimum Treasury tokens minted if deposited
  });

const { transaction: removeLiquidityTx } =
  await client.buildRemoveLiquidityTransaction({
    liquidityProvider,
    mint: USDC,
    amount: 500_000_000n,
    exactMode: ExactMode.ExactOut, // Asset amount to receive
    amountThreshold: 510_000_000n, // Maximum Treasury tokens burned if redeemed
  });

Use lpTokenAccount when the capital 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. For Treasury-backed removal, ExactOut specifies asset output and uses idle vault liquidity before redeeming the shortfall. ExactIn (the SDK default) specifies value in Treasury token units; yield accounting can make the actual receipt-token burn smaller. amountThreshold is a minimum asset output for ExactIn and a maximum receipt-token burn for ExactOut. Add-liquidity always uses ExactIn and treats the threshold as minimum receipt output. These optional bounds apply only when the corresponding Treasury CPI occurs; the SDK does not infer a bound when it is omitted. The capital provider enables routing with the swap program’s set_lp_treasury_enabled instruction, available through swapProgramClient. Enabling routing does not move existing balances. The Pair Management page describes sweep conditions and account ownership.

Close a Pair

close_pair is signed by the capital provider 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 capital provider’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. The capital provider’s Treasury position must be empty before a pair can close, including after routing is disabled. After withdrawing and settling principal, yield, and pending deposits, the capital provider can use close_treasury_position to recover Treasury account rent and close_lp_fee_account to recover the fee account after closing its pairs.

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 capital provider 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/capital provider 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

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 capital provider paused:", state.inputLpStableConfig?.paused);
console.log("Output capital provider 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);

Treasury account reads and instruction builders are available through treasuryProgramClient. Its fetchUserPosition and getUserPositionDecoder include pending deposits beyond the initial 50 slots. The Treasury IDL defines the direct deposit, redeem, rate-posting, and administration interfaces.

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);

Capital provider vault token accounts are ATAs for (mint, vaultAuthority), where vaultAuthority is the capital provider’s 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();

The Deployments page records the devnet program status. The SDK’s configured program address does not establish that the matching swap and Treasury interfaces are deployed on that cluster.

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

Capital Provider 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

​Capital Provider 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

​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

Capital Provider 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

Fetch Individual Accounts

PDA Derivation

Integration Best Practices

Security

Performance

Operational

Testing

Devnet

Mainnet

Support and Resources