Skip to main content
The rust-client provides a convenient way to interact with the Dynamic Vault program. Before you begin, here are some important resources:

Rust SDK

Meteora Dynamic Vault Rust SDK

​
Dependencies

Add mercurial-vault to dependencies: 
mercurial-vault = { version="0.4.2", features= ["cpi", "mainnet"] }

​
Functions

​
Fetch Vault State

1

Find the vault pubkey based on the token_mint (USDC, USDT, or SOL)

let (vault, _vault_bump) = Pubkey::find_program_address(
    &[b"vault".as_ref(), token_mint.as_ref(), mercurial_vault::get_base_key().as_ref()],
    &mercurial_vault::id(),
);
2

Get the vault_state using the vault pubkey

let vault_state: mercurial_vault::state::Vault = program_client.account(vault)?;
Once you have the vault state, you can retrieve key vault information such as:

​
Total unlocked amount in vault

Get the total amount of tokens that are available for withdrawal. The vault will lock the yield claimed initially and release them over a pre-defined period of time. 
// Total unlocked amount in the vault available for withdrawal
// current_time is current Solana node timestamp
total_unlocked_amount = vault_state.get_unlocked_amount(current_time)

​
Total reserve in the vault

We currently keep 10% of the total deposits in the vault to support swaps and immediate withdrawals. 
// Get the vault reserve value

// Get the token vault data
let token_data: anchor_spl::token::TokenAccount =
    program_client.account(vault_data.token_vault)?;
    
vault_reserves = token_data.amount //vault reserve value

​
Total LP supply for the vault

Retrieve the total LP token amount in the vault. 
// Get total total LP supply
let token_mint: anchor_spl::token::Mint = program_client.account(vault_data.lp_mint)?;
total_lp_supply = token_mint.supply

​
Vault virtual price calculation

Get the current virtual price for the vault. 
// Calculate vault virtual price using unlocked amount and lp supply
virtual_price = total_unlocked_amount / total_lp_supply

​
Deposit Liquidity into the Dynamic Vault

1

Retrieve the vault, token_vault, lp_mint, user_token and user_lp values

// Retrieve the value for vault
// You can use the one of our supported token_mints (you can find the token_mint values in the "Constants" section
let (vault, _vault_bump) = Pubkey::find_program_address(
    &[b"vault".as_ref(), token_mint.as_ref(), mercurial_vault::get_base_key().as_ref()],
    &mercurial_vault::id(),
);

// Retrieve the value of token_vault
let (token_vault, _token_vault_bump) = Pubkey::find_program_address(
    &[b"token_vault".as_ref(), vault.as_ref()],
    &program_client.id(),
);

//Retrieve the value of vault_state to get the lp_mint value
let vault_state: mercurial_vault::state::Vault = program_client.account(vault)?;
let lp_mint = vault_state.lp_mint;

// Retrieve user_token and user_lp values using the get_or_create_ata fn
let user_token = get_or_create_ata(program_client, token_mint, program_client.payer())?;
let user_lp = get_or_create_ata(program_client, lp_mint, program_client.payer())?;
2

Execute the instruction to deposit liquidity into the pool

let builder = program_client
    .request()
    .accounts(mercurial_vault::accounts::DepositWithdrawLiquidity {
        vault,
        token_vault,
        lp_mint,
        user_token,
        user_lp,
        user: program_client.payer(),
        token_program: spl_token::id(),
    })
    .args(mercurial_vault::instruction::Deposit {
        token_amount, // total amount of tokens to be deposited
        minimum_lp_token_amount: 0,
    });

let signature = builder.send()?;

​
Withdraw Liquidity from Dynamic Vault

1

Retrieve the vault, token_vault, lp_mint, user_token and user_lp values

// Retrieve the vault
let (vault, _vault_bump) = Pubkey::find_program_address(
    &[b"vault".as_ref(), token_mint.as_ref(), mercurial_vault::get_base_key().as_ref()],
    &mercurial_vault::id(),
);

// Retrieve the vault of token_vault
let (token_vault, _token_vault_bump) = Pubkey::find_program_address(
    &[b"token_vault".as_ref(), vault.as_ref()],
    &program_client.id(),
);

//Retrieve the value of vault_state to get the lp_mint value
let vault_state: mercurial_vault::state::Vault = program_client.account(vault)?;
let lp_mint = vault_state.lp_mint;

// Retrieve user_token and user_lp values using the get_or_create_ata fn
let user_token = get_or_create_ata(program_client, token_mint, program_client.payer())?;
let user_lp = get_or_create_ata(program_client, lp_mint, program_client.payer())?;
2

Execute the instruction to withdraw liquidity from pool

let builder = program_client
    .request()
    .accounts(mercurial_vault::accounts::DepositWithdrawLiquidity {
        vault,
        token_vault,
        lp_mint,
        user_token,
        user_lp,
        user: program_client.payer(),
        token_program: spl_token::id(),
    })
    .args(mercurial_vault::instruction::Withdraw {
        unmint_amount, //total amount of LP tokens to withdraw
        min_out_amount: 0,
    });

let signature = builder.send()?;

​
Withdraw Directly from Lending Platforms

If you are integrating the vaults directly onto your platform, you can use this function to withdraw funds directly from a selected lending platform.
1

Retrieve the list of pubkeys of the lending platform pools integrated with the vault

// Get the vault pubkey using the token_mint of the vault
let (vault, _) = Pubkey::find_program_address(
    &[b"vault".as_ref(), token_mint.as_ref(), mercurial_vault::get_base_key().as_ref()],
    &mercurial_vault::id(),
);

// Retrieve the vault state
let vault_data: mercurial_vault::state::Vault = program_client.account(vault)?;

// Iterate through all the lending platform pools integrated with the vault
for (i, &strategy_pubkey) in vault_data.strategies.iter().enumerate(){
    // get strategy pubkey
    println!("{}", strategy_pubkey);
}
2

Call the function to withdraw funds from the selected strategy pool

// Get the strategy_state using the strategy_pubkey
let strategy_state: mercurial_vault::state::Strategy =
    program_client.account(strategy_pubkey)?;

// Call the fn to withdraw funds directly from the strategy
let strategy_handler = get_strategy_handler(strategy_state.strategy_type);
strategy_handler.withdraw_directly_from_strategy(
    &program_client,
    strategy,
    token_mint,
    base,
    unmint_amount,
)?