You can access all the main functions after you've added the mercurial-vault dependency to your code.
Access Vault information through Vault State
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(),
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:
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_data.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
To deposit liquidity into the vault
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())?;
Execute the instruction to deposit liquidity into the pool
let builder = program_client
.request()
.accounts(mercurial_vault::accounts::DepositWithdrawLiquidity {
vault: vault,
token_vault: token_vault,
lp_mint: 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 pool
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())?;
Execute the instruction to withdraw liquidity from pool.
let builder = program_client
.request()
.accounts(mercurial_vault::accounts::DepositWithdrawLiquidity {
vault: vault,
token_vault: token_vault,
lp_mint: 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 direct 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.
You can 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);
}
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,
)?
You can find the example implementation for withdrawing from a Mango via the link below:
