Pair Management - Multiliquid Protocol

Overview

Pair accounts link two registered tokens, including RWA/stablecoin and RWA/RWA pairs, enabling trading between them. Each pair is owned by a specific capital provider who controls its configuration, fees, and liquidity.

Account Structures

Pair Account

pub struct Pair {
    pub redemption_fee_bps: u16,            // Fee for Quote → Base swaps
    pub discount_rate_bps: u16,             // Fee for Base → Quote swaps
    pub quote_token_mint_address: Pubkey,   // Quote token mint
    pub base_token_mint_address: Pubkey,    // Base token mint
    pub liquidity_provider: Pubkey,         // Capital provider owner address
    pub paused: bool,                       // Pair-level pause flag
    pub bump: u8,                           // PDA bump seed
    pub padding: [u8; 128],
}

PDA Seeds: ["pair", liquidity_provider, quote_mint, base_mint] New pairs require quote/base mints in ascending byte order. Existing pairs retain their stored order; quote does not necessarily mean stablecoin.

LpStableConfig Account

pub struct LpStableConfig {
    pub quote_token_mint_address: Pubkey,   // Stablecoin mint
    pub paused: bool,                       // Pause all pairs with this config
    pub liquidity_provider: Pubkey,         // Capital provider address
    pub bump: u8,                           // PDA bump seed
    pub padding: [u8; 128],
}

PDA Seeds: ["lp_stable_config", stable_mint, liquidity_provider]

UserVaultInfo Account

pub struct UserVaultInfo {
    pub user: Pubkey,                       // Capital provider wallet
    pub mint_address: Pubkey,               // Token mint
    pub used: u16,                          // Number of pairs using this vault
    pub bump: u8,                           // PDA bump seed
    pub padding: [u8; 128],
}

PDA Seeds: ["user_vault_info", mint_address, liquidity_provider]

VaultAuthority PDA

PDA Seeds: ["vault_authority", liquidity_provider]

For permissioned mints (tokens), the issuer must separately whitelist (allowlist) both the liquidity_provider address and the derived vault_authority PDA. The capital provider address owns the source token account; the PDA owns the destination vault ATA. Approval of one address does not apply to the other.The corresponding capital provider’s token account and PDA-owned vault ATA must also be thawed before a transfer can succeed. Creating the pair or vault ATA does not perform issuer whitelisting or thawing.

The vault_authority PDA is specific to each capital provider and owns that capital provider’s vault token accounts. The vault token accounts themselves are associated token accounts for (mint, vault_authority), so they are keyed by capital provider and mint without using the global program authority.

Pair Instructions

init_pair

Create a new trading pair. The capital provider signs and pays for all account creation.

pub fn init_pair(
    ctx: Context<InitPair>,
    redemption_fee_bps: u16,
    discount_rate_bps: u16,
) -> Result<()>

Parameters

Parameter	Type	Description
`redemption_fee_bps`	`u16`	Fee for Quote → Base (0-9900 BPS)
`discount_rate_bps`	`u16`	Fee for Base → Quote (0-9900 BPS)

Required Accounts

#[derive(Accounts)]
pub struct InitPair<'info> {
    #[account(mut)]
    pub liquidity_provider: Signer<'info>,

    #[account(
        init,
        payer = liquidity_provider,
        space = 8 + Pair::INIT_SPACE,
        seeds = [PAIR_PREFIX, liquidity_provider.key().as_ref(), quote_token_mint_address.key().as_ref(), base_token_mint_address.key().as_ref()],
        bump,
        constraint = quote_token_mint_address.key() != base_token_mint_address.key() @ ErrorCode::InvalidAssetType,
    )]
    pub pair: Box<Account<'info, Pair>>,

    pub quote_token_mint_address: Box<InterfaceAccount<'info, Mint>>,

    pub base_token_mint_address: Box<InterfaceAccount<'info, Mint>>,

    #[account(
        seeds = [VAULT_AUTHORITY_PREFIX, liquidity_provider.key().as_ref()],
        bump,
    )]
    pub lp_vault_authority: UncheckedAccount<'info>,

    #[account(
        seeds = [LP_FEE_VAULT_AUTHORITY_PREFIX, liquidity_provider.key().as_ref()],
        bump,
    )]
    pub lp_fee_vault_authority: UncheckedAccount<'info>,

    #[account(
        init_if_needed,
        payer = liquidity_provider,
        associated_token::mint = quote_token_mint_address,
        associated_token::authority = lp_vault_authority,
        associated_token::token_program = token_program_quote,
    )]
    pub quote_token_vault_token_account: Box<InterfaceAccount<'info, TokenAccount>>,

    #[account(
        init_if_needed,
        payer = liquidity_provider,
        associated_token::mint = base_token_mint_address,
        associated_token::authority = lp_vault_authority,
        associated_token::token_program = token_program_base,
    )]
    pub base_token_vault_token_account: Box<InterfaceAccount<'info, TokenAccount>>,

    #[account(
        init_if_needed,
        payer = liquidity_provider,
        space = 8 + UserVaultInfo::INIT_SPACE,
        seeds = [USER_VAULT_PREFIX, quote_token_mint_address.key().as_ref(), liquidity_provider.key().as_ref()],
        bump,
    )]
    pub lp_vault_quote_pda: Box<Account<'info, UserVaultInfo>>,

    #[account(
        init_if_needed,
        payer = liquidity_provider,
        space = 8 + UserVaultInfo::INIT_SPACE,
        seeds = [USER_VAULT_PREFIX, base_token_mint_address.key().as_ref(), liquidity_provider.key().as_ref()],
        bump,
    )]
    pub lp_vault_base_pda: Box<Account<'info, UserVaultInfo>>,

    #[account(
        seeds = [GLOBAL_CONFIG_PREFIX],
        bump = global_config.bump,
    )]
    pub global_config: Box<Account<'info, GlobalConfig>>,

    #[account(
        constraint = fee_token_mint_address.key() == global_config.fee_token_mint @ ErrorCode::InvalidAccountPublicKey,
    )]
    pub fee_token_mint_address: Box<InterfaceAccount<'info, Mint>>,

    #[account(
        init_if_needed,
        payer = liquidity_provider,
        associated_token::mint = fee_token_mint_address,
        associated_token::authority = lp_fee_vault_authority,
        associated_token::token_program = token_program_fee,
    )]
    pub lp_fee_token_account: Box<InterfaceAccount<'info, TokenAccount>>,

    #[account(
        init_if_needed,
        payer = liquidity_provider,
        space = 8 + LpStableConfig::INIT_SPACE,
        seeds = [LP_STABLE_CONFIG_PREFIX, quote_token_mint_address.key().as_ref(), liquidity_provider.key().as_ref()],
        bump,
    )]
    pub lp_stable_config_quote: Option<Box<Account<'info, LpStableConfig>>>,

    #[account(
        init_if_needed,
        payer = liquidity_provider,
        space = 8 + LpStableConfig::INIT_SPACE,
        seeds = [LP_STABLE_CONFIG_PREFIX, base_token_mint_address.key().as_ref(), liquidity_provider.key().as_ref()],
        bump,
    )]
    pub lp_stable_config_base: Option<Box<Account<'info, LpStableConfig>>>,

    #[account(
        mut,
        seeds = [ASSET_CONFIG_PREFIX, quote_token_mint_address.key().as_ref()],
        bump = quote_asset_config.bump,
    )]
    pub quote_asset_config: Box<Account<'info, AssetConfig>>,

    #[account(
        mut,
        seeds = [ASSET_CONFIG_PREFIX, base_token_mint_address.key().as_ref()],
        bump = base_asset_config.bump,
    )]
    pub base_asset_config: Box<Account<'info, AssetConfig>>,

    pub token_program_quote: Interface<'info, TokenInterface>,

    pub token_program_base: Interface<'info, TokenInterface>,

    pub token_program_fee: Interface<'info, TokenInterface>,
    pub associated_token_program: Program<'info, AssociatedToken>,

    pub system_program: Program<'info, System>,
}

Behavior

Creates Pair PDA account, paid for by the capital provider
Validates distinct mints in canonical byte order; both assets may be RWAs
Creates or updates LpStableConfig for each Stable mint in the pair
Creates vault ATAs owned by the capital provider’s vault_authority PDA if they don’t exist
Creates UserVaultInfo accounts to track vault usage
Increments used_in_pairs_count on both asset configs
Initializes redemption_fee_bps and discount_rate_bps from the instruction arguments
Requires program to be unpaused
Pair pause state defaults to unpaused unless the capital provider later pauses it with update_pair

Access Control

Access: Capital provider (signs as liquidity_provider).

Swaps still require every pause gate to be open: global config, both asset configs, applicable capital provider stable configs, the fee asset, and the pair itself.

Example

lpStableConfigQuote and lpStableConfigBase are supplied for Stable sides and null for RWA sides.

await program.methods
  .initPair(
    50,   // 0.5% redemption fee
    25    // 0.25% discount rate
  )
  .accounts({
    liquidityProvider: lpWallet.publicKey,
    pair,
    quoteTokenMintAddress: quoteMint,
    baseTokenMintAddress: baseMint,
    lpVaultAuthority,
    lpFeeVaultAuthority,
    quoteTokenVaultTokenAccount: quoteVault,
    baseTokenVaultTokenAccount: baseVault,
    lpVaultQuotePda: quoteUserVaultInfo,
    lpVaultBasePda,
    globalConfig,
    feeTokenMintAddress,
    lpFeeTokenAccount,
    lpStableConfigQuote,
    lpStableConfigBase,
    quoteAssetConfig,
    baseAssetConfig,
    tokenProgramQuote: TOKEN_PROGRAM_ID,
    tokenProgramBase: TOKEN_PROGRAM_ID,
    tokenProgramFee,
    associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
    systemProgram: SystemProgram.programId,
  })
  .signers([lpWallet])
  .rpc();

update_pair

Update pair configuration (fees and pause state).

pub fn update_pair(
    ctx: Context<UpdatePair>,
    redemption_fee_bps: u16,
    discount_rate_bps: u16,
    paused: bool,
) -> Result<()>

Parameters

Parameter	Type	Description
`redemption_fee_bps`	`u16`	New redemption fee (Quote → Base, 0-9900 BPS)
`discount_rate_bps`	`u16`	New discount rate (Base → Quote, 0-9900 BPS)
`paused`	`bool`	New pause state

Required Accounts

#[derive(Accounts)]
pub struct UpdatePair<'info> {
    pub liquidity_provider: Signer<'info>,

    #[account(
        mut,
        seeds = [PAIR_PREFIX, liquidity_provider.key().as_ref(), quote_token_mint_address.key().as_ref(), base_token_mint_address.key().as_ref()],
        bump = pair.bump,
        has_one = liquidity_provider,
    )]
    pub pair: Account<'info, Pair>,

    pub quote_token_mint_address: InterfaceAccount<'info, Mint>,
    pub base_token_mint_address: InterfaceAccount<'info, Mint>,

    pub global_config: Account<'info, GlobalConfig>,
}

Behavior

Updates fee configuration
Updates pause state
Requires program to be unpaused
Validates both fee values are <= 9900 and their sum is < 10000

Access Control

Access: Capital provider (pair owner) only

Example

// Set final fees and ensure the pair is unpaused
await program.methods
  .updatePair(
    50,    // 0.5% redemption fee
    25,    // 0.25% discount rate
    false  // Unpause
  )
  .accounts({
    liquidityProvider: lpWallet.publicKey,
    pair,
    quoteTokenMintAddress: quoteMint,
    baseTokenMintAddress: baseMint,
    globalConfig,
  })
  .rpc();

close_pair

Permanently close a trading pair. The capital provider signs and receives the reclaimed rent for the pair account and any closed vault accounts; the configured global-config admin is referenced as a non-signing account and checked by has_one.

pub fn close_pair(
    ctx: Context<ClosePair>,
) -> Result<()>

Required Accounts

#[derive(Accounts)]
pub struct ClosePair<'info> {
    pub admin: UncheckedAccount<'info>,

    #[account(mut)]
    pub liquidity_provider: Signer<'info>,

    #[account(
        mut,
        close = liquidity_provider,
        seeds = [PAIR_PREFIX, liquidity_provider.key().as_ref(), quote_token_mint_address.key().as_ref(), base_token_mint_address.key().as_ref()],
        bump = pair.bump,
    )]
    pub pair: Box<Account<'info, Pair>>,

    pub quote_token_mint_address: Box<InterfaceAccount<'info, Mint>>,

    pub base_token_mint_address: Box<InterfaceAccount<'info, Mint>>,

    #[account(
        seeds = [VAULT_AUTHORITY_PREFIX, liquidity_provider.key().as_ref()],
        bump,
    )]
    pub lp_vault_authority: UncheckedAccount<'info>,

    #[account(
        mut,
        associated_token::mint = quote_token_mint_address,
        associated_token::authority = lp_vault_authority,
        associated_token::token_program = token_program_quote,
    )]
    pub quote_token_vault_token_account: InterfaceAccount<'info, TokenAccount>,

    #[account(
        mut,
        associated_token::mint = base_token_mint_address,
        associated_token::authority = lp_vault_authority,
        associated_token::token_program = token_program_base,
    )]
    pub base_token_vault_token_account: InterfaceAccount<'info, TokenAccount>,

    #[account(
        mut,
        token::mint = quote_token_mint_address,
        token::authority = liquidity_provider,
        token::token_program = token_program_quote,
        )]
    pub lp_quote_token_account: Box<InterfaceAccount<'info, TokenAccount>>,

    #[account(
            mut,
            token::mint = base_token_mint_address,
            token::authority = liquidity_provider,
            token::token_program = token_program_base,
            )]
    pub lp_base_token_account: Box<InterfaceAccount<'info, TokenAccount>>,

    #[account(
        mut,
        seeds = [USER_VAULT_PREFIX, quote_token_mint_address.key().as_ref(), liquidity_provider.key().as_ref()],
        bump = lp_vault_quote_pda.bump,
        )]
    pub lp_vault_quote_pda: Box<Account<'info, UserVaultInfo>>,

    #[account(
        mut,
        seeds = [USER_VAULT_PREFIX, base_token_mint_address.key().as_ref(), liquidity_provider.key().as_ref()],
        bump = lp_vault_base_pda.bump,
        )]
    pub lp_vault_base_pda: Box<Account<'info, UserVaultInfo>>,

    #[account(
        mut,
        seeds = [ASSET_CONFIG_PREFIX, quote_token_mint_address.key().as_ref()],
        bump = quote_asset_config.bump,
    )]
    pub quote_asset_config: Box<Account<'info, AssetConfig>>,

    #[account(
        mut,
        seeds = [ASSET_CONFIG_PREFIX, base_token_mint_address.key().as_ref()],
        bump = base_asset_config.bump,
    )]
    pub base_asset_config: Box<Account<'info, AssetConfig>>,

    #[account(
        seeds = [GLOBAL_CONFIG_PREFIX],
        bump = global_config.bump,
        has_one = admin
    )]
    pub global_config: Box<Account<'info, GlobalConfig>>,

    #[account(
        seeds = [LP_PROTOCOL_FEE_CONFIG_PREFIX, liquidity_provider.key().as_ref()],
        bump
    )]
    pub lp_protocol_fee_config: UncheckedAccount<'info>,

    pub treasury_user_position: UncheckedAccount<'info>,

    pub token_program_quote: Interface<'info, TokenInterface>,

    pub token_program_base: Interface<'info, TokenInterface>,
}

Behavior

Closes Pair account
Requires program to be unpaused
Decrements used_in_pairs_count on both asset configs
Requires the capital provider’s Treasury position to be empty, even if Treasury routing has been disabled
Returns remaining vault tokens to the capital provider’s recipient token accounts
Closes vault ATAs if no longer used by other pairs
Closes the corresponding UserVaultInfo PDAs when their used count reaches 0
Returns reclaimed rent (Pair PDA, closed vault ATAs, and closed UserVaultInfo PDAs) to the capital provider

Closing a pair reclaims rent and clears the pair’s configuration (fees, pause state). The capital provider can re-initialize a pair for the same (stable, asset) combination later via init_pair, but it will start with fresh configuration — prior fee settings are not restored.

Access Control

Access: Capital provider (pair owner). The admin account must be provided and is verified against global_config.admin via has_one, but admin does not sign.

set_paused_for_lp_stable_config

Set pause state for all pairs of a capital provider/stablecoin combination.

pub fn set_paused_for_lp_stable_config(
    ctx: Context<SetPausedForLpStableConfig>,
    paused: bool,
) -> Result<()>

Parameters

Parameter	Type	Description
`paused`	`bool`	New pause state

Required Accounts

#[derive(Accounts)]
pub struct SetPausedForLpStableConfig<'info> {
    pub global_config: Account<'info, GlobalConfig>,

    #[account(
        mut,
        seeds = [LP_STABLE_CONFIG_PREFIX, mint_address.key().as_ref(), liquidity_provider.key().as_ref()],
        bump = lp_stable_config.bump,
    )]
    pub lp_stable_config: Account<'info, LpStableConfig>,

    /// CHECK: checked by seeds
    pub mint_address: UncheckedAccount<'info>,

    /// CHECK: checked by seeds
    pub liquidity_provider: UncheckedAccount<'info>,

    // Either admin OR liquidity_provider can call
    pub signer: Signer<'info>,
}

Behavior

Updates pause state on LpStableConfig
Affects ALL pairs using this capital provider/stablecoin combination
Can be updated while the program is paused

Access Control

Access: Admin OR capital provider (config owner)

Liquidity Instructions

Treasury Routing

The capital provider controls routing through set_lp_treasury_enabled(enabled: bool). The flag is stored in LpProtocolFeeConfig, derived from ["lp_protocol_fee_config", liquidity_provider]. Enabling routing funds the capital provider vault-authority PDA for Treasury account rent; it does not move existing token balances by itself. Disabling routing does not redeem an existing position. When the configuration is first created, its protocol-fee rates are copied from the global configuration. The admin can set those rates independently through set_lp_protocol_fee_config. Routing requires an unpaused Treasury program and an unpaused asset registered as Stable in Treasury. For eligible assets, add_liquidity can deposit the entire post-transfer vault balance into Treasury, subject to its

1 minimum NAV value. During swaps, only Stable inputs are swept, and only Stable output shortfalls are redeemed; RWA inventory remains in the capital provider vault. A swap sweep requires at least one whole token, at least

1 of NAV value, and available pending-deposit capacity. Otherwise the input remains in the capital provider vault. Existing idle output liquidity is used before Treasury redemption. The Treasury position and receipt-token account belong to the capital provider’s swap vault-authority PDA. The Treasury manager configures supported assets and their NAV sources separately from the swap program.

add_liquidity

Treasury account counts are zero when Treasury routing is unused. amount_threshold is an optional minimum receipt output for the Treasury deposit. The optional argument must be encoded even when omitted (None). Deposit tokens into a vault.

pub fn add_liquidity(
    ctx: Context<AddLiquidity>,
    amount: u64,
    treasury_nav_account_count: u8,
    treasury_apy_account_count: u8,
    amount_threshold: Option<u64>,
) -> Result<()>

Parameters

Parameter	Type	Description
`amount`	`u64`	Amount of tokens to deposit
`treasury_nav_account_count`	`u8`	Number of Treasury NAV accounts in remaining accounts
`treasury_apy_account_count`	`u8`	Number of APY accounts following the NAV accounts
`amount_threshold`	`Option<u64>`	Minimum Treasury tokens minted, in native units; applies only when a Treasury deposit occurs

Required Accounts

#[derive(Accounts)]
pub struct AddLiquidity<'info> {
    #[account(mut)]
    pub liquidity_provider: Signer<'info>,

    pub mint_address: InterfaceAccount<'info, Mint>,

    #[account(
        mut,
        token::mint = mint_address,
        token::authority = liquidity_provider,
        token::token_program = token_program,
    )]
    pub lp_token_account: InterfaceAccount<'info, TokenAccount>,

    #[account(
        mut,
        associated_token::mint = mint_address,
        associated_token::authority = lp_vault_authority,
        associated_token::token_program = token_program,
    )]
    pub vault_token_account: InterfaceAccount<'info, TokenAccount>,

    #[account(
        mut,
        seeds = [VAULT_AUTHORITY_PREFIX, liquidity_provider.key().as_ref()],
        bump,
    )]
    pub lp_vault_authority: UncheckedAccount<'info>,

    #[account(
        seeds = [GLOBAL_CONFIG_PREFIX],
        bump = global_config.bump,
    )]
    pub global_config: Account<'info, GlobalConfig>,

    #[account(
        seeds = [LP_PROTOCOL_FEE_CONFIG_PREFIX, liquidity_provider.key().as_ref()],
        bump
    )]
    pub lp_protocol_fee_config: UncheckedAccount<'info>,

    #[account(
        seeds = [ASSET_CONFIG_PREFIX, mint_address.key().as_ref()],
        bump = asset_config.bump,
    )]
    pub asset_config: Box<Account<'info, AssetConfig>>,

    #[account(
        seeds = [LP_STABLE_CONFIG_PREFIX, mint_address.key().as_ref(), liquidity_provider.key().as_ref()],
        bump
    )]
    pub lp_stable_config: Option<Box<Account<'info, LpStableConfig>>>,

    pub treasury_program: Option<UncheckedAccount<'info>>,
    pub treasury_global_config: Option<UncheckedAccount<'info>>,
    pub treasury_asset_config: Option<UncheckedAccount<'info>>,
    #[account(mut)]
    pub treasury_user_position: Option<UncheckedAccount<'info>>,
    pub treasury_vault_authority: Option<UncheckedAccount<'info>>,
    #[account(mut)]
    pub treasury_mint: Option<UncheckedAccount<'info>>,
    #[account(mut)]
    pub treasury_asset_vault: Option<UncheckedAccount<'info>>,
    #[account(mut)]
    pub treasury_user_treasury_token_account: Option<UncheckedAccount<'info>>,
    pub treasury_token_program: Option<UncheckedAccount<'info>>,
    pub treasury_associated_token_program: Option<UncheckedAccount<'info>>,
    pub treasury_system_program: Option<UncheckedAccount<'info>>,

    pub token_program: Interface<'info, TokenInterface>,
}

Behavior

Transfers tokens from the capital provider’s account to vault
Vault is the mint’s ATA owned by the capital provider’s vault_authority PDA
Requires program, asset, and applicable capital provider stable config to be unpaused
Amount must be greater than 0
Deposits the whole post-transfer vault balance into Treasury when routing is enabled, Treasury and its Stable asset configuration are unpaused, and pending-deposit capacity is available

Access Control

Access: Capital provider (vault owner) only

Example

await program.methods
  .addLiquidity(new BN(1000_000000), 0, 0, null)  // 1000 tokens
  .accounts({
    liquidityProvider: lpWallet.publicKey,
    mintAddress: stableMint,
    lpTokenAccount: lpStableTokenAccount,
    vaultTokenAccount: stableVault,
    lpVaultAuthority,
    globalConfig,
    lpProtocolFeeConfig,
    assetConfig,
    lpStableConfig,
    treasuryProgram: null,
    treasuryGlobalConfig: null,
    treasuryAssetConfig: null,
    treasuryUserPosition: null,
    treasuryVaultAuthority: null,
    treasuryMint: null,
    treasuryAssetVault: null,
    treasuryUserTreasuryTokenAccount: null,
    treasuryTokenProgram: null,
    treasuryAssociatedTokenProgram: null,
    treasurySystemProgram: null,
    tokenProgram: TOKEN_PROGRAM_ID,
  })
  .rpc();

remove_liquidity

With Treasury routing, exact_mode selects value in Treasury token units (ExactIn) or asset output (ExactOut). amount_threshold bounds minimum asset output or maximum Treasury tokens actually burned respectively; without Treasury routing, amount is the asset amount. Withdraw tokens from a vault.

pub fn remove_liquidity(
    ctx: Context<RemoveLiquidity>,
    amount: u64,
    treasury_nav_account_count: u8,
    treasury_apy_account_count: u8,
    exact_mode: treasury::ExactMode,
    amount_threshold: Option<u64>,
) -> Result<()>

Parameters

Parameter	Type	Description
`amount`	`u64`	Treasury value to redeem for treasury-backed ExactIn; asset amount for ExactOut or direct withdrawal
`treasury_nav_account_count`	`u8`	Number of Treasury NAV accounts in remaining accounts
`treasury_apy_account_count`	`u8`	Number of APY accounts following the NAV accounts
`exact_mode`	`treasury::ExactMode`	`ExactIn` or `ExactOut`
`amount_threshold`	`Option<u64>`	Minimum asset output for ExactIn, or maximum Treasury tokens burned for ExactOut; applies only when redemption occurs

Required Accounts

The common accounts are the capital provider, mint, capital provider token account, vault token account, capital provider vault authority, global config, capital provider protocol-fee config, and token program. Treasury routing uses the same Treasury accounts as add_liquidity, except that treasury_latest_apy_entry replaces treasury_system_program. remove_liquidity does not take swap asset_config or lp_stable_config accounts. Exact account ordering is defined in the Program IDL.

Behavior

Transfers tokens from vault to the capital provider’s account
Vault is the mint’s ATA owned by the capital provider’s vault_authority PDA
Requires program to be unpaused
Amount must be greater than 0
Direct withdrawal requires sufficient idle vault balance
Treasury-backed ExactOut uses idle vault liquidity first and redeems only the shortfall
Treasury-backed ExactIn transfers the assets received from redemption; receipt tokens are burned only for the principal consumed, while yield is accounted for in the position

Access Control

Access: Capital provider (vault owner) only

Closing Treasury and Fee Accounts

After withdrawing and settling the Treasury position, the capital provider can call close_treasury_position to recover its rent. Principal, accumulated yield, and pending deposits must all be zero. The instruction also closes the receipt-token account when empty and returns the capital provider vault-authority PDA’s lamports to the capital provider. close_lp_fee_account returns any remaining fee-token balance and closes the capital provider fee account. The capital provider closes its pairs first, because swaps require that fee account. Both instructions require the swap program to be unpaused.

Vault Architecture

Shared Vault Model

Vaults are shared across pairs for the same capital provider/token combination. Each capital provider has a vault_authority PDA, and each vault is the associated token account for (mint, vault_authority):

Capital provider Alice → vault_authority PDA ["vault_authority", Alice]
USDC mint + Alice vault_authority → One USDC vault ATA
ULTRA mint + Alice vault_authority → One ULTRA vault ATA

Pair 1: Alice's USDC ↔ ULTRA (uses both vaults)
Pair 2: Alice's USDC ↔ USTB (uses USDC vault + new USTB vault)

UserVaultInfo Tracking

The UserVaultInfo account tracks how many pairs use each vault:

Incremented when pair is created
Decremented when pair is closed
Vault closed only when used reaches 0

This ensures vaults aren’t closed while still in use by other pairs.

Error Codes

Error	Description
`Unauthorized`	Caller is not admin or capital provider owner
`ProgramPaused`	Program is paused
`PairPaused`	Pair is paused
`AmountMustBePositive`	Amount is zero
`InsufficientLiquidity`	Vault has insufficient balance
`InvalidAssetType`	Pair mints are identical, or a capital provider stable config is supplied for an RWA side
`OutOfRange`	Pair fee BPS exceeds 9900 during pair creation or update
`AssetConfigInUse`	Cannot change asset type while in use

Next: Price Sources

Learn about NAV pricing sources and oracle integration

​Overview

​Account Structures

​Pair Account

​LpStableConfig Account

​UserVaultInfo Account

​VaultAuthority PDA

​Pair Instructions

​init_pair

​Parameters

​Required Accounts

​Behavior

​Access Control

​Example

​update_pair

​Parameters

​Required Accounts

​Behavior

​Access Control

​Example

​close_pair

​Required Accounts

​Behavior

​Access Control

​set_paused_for_lp_stable_config

​Parameters

​Required Accounts

​Behavior

​Access Control

​Liquidity Instructions

​Treasury Routing

​add_liquidity

​Parameters

​Required Accounts

​Behavior

​Access Control

​Example

​remove_liquidity

​Parameters

​Required Accounts

​Behavior

​Access Control

​Closing Treasury and Fee Accounts

​Vault Architecture

​Shared Vault Model

​UserVaultInfo Tracking

​Error Codes

Next: Price Sources

Overview

Account Structures

Pair Account

LpStableConfig Account

UserVaultInfo Account

VaultAuthority PDA

Pair Instructions

init_pair

Parameters

Required Accounts

Behavior

Access Control

Example

update_pair

Parameters

Required Accounts

Behavior

Access Control

Example

close_pair

Required Accounts

Behavior

Access Control

set_paused_for_lp_stable_config

Parameters

Required Accounts

Behavior

Access Control

Liquidity Instructions

Treasury Routing

add_liquidity

Parameters

Required Accounts

Behavior

Access Control

Example

remove_liquidity

Parameters

Required Accounts

Behavior

Access Control

Closing Treasury and Fee Accounts

Vault Architecture

Shared Vault Model

UserVaultInfo Tracking

Error Codes