​
Core Functions

​
createPermissionlessVaultInstruction

Creates an instruction to initialize a new permissionless vault. Function 
static async createPermissionlessVaultInstruction(
  connection: Connection,
  payer: PublicKey,
  tokenMint: PublicKey,
  opt?: {
    cluster?: Cluster;
    programId?: string;
  }
): Promise<TransactionInstruction>
Parameters 
interface CreatePermissionlessVaultParams {
  connection: Connection;       // Solana connection instance
  payer: PublicKey;            // The wallet paying for the transaction
  tokenMint: PublicKey;        // The mint address of the token for the vault
  opt?: {
    cluster?: Cluster;         // Network cluster (mainnet-beta, devnet, testnet)
    programId?: string;        // Custom program ID (optional)
  };
}
Returns A transaction instruction that can be used to initialize the vault. Example 
const instruction = await VaultImpl.createPermissionlessVaultInstruction(
  connection,
  wallet.publicKey,
  usdcMint,
  {
    cluster: 'mainnet-beta',
    programId: CUSTOM_PROGRAM_ID // optional
  }
);

const transaction = new Transaction().add(instruction);
const signature = await wallet.sendTransaction(transaction, connection);
Notes
  • Creates all necessary PDAs for the vault including vault account, token vault, and LP mint
  • The vault will be permissionless, allowing anyone to deposit and withdraw
  • Payer will cover the rent costs for the new accounts

​
fetchMultipleUserBalance

Fetches LP token balances for multiple vaults for a specific user. Function 
static async fetchMultipleUserBalance(
  connection: Connection,
  lpMintList: Array<PublicKey>,
  owner: PublicKey
): Promise<Array<BN>>
Parameters 
interface FetchMultipleUserBalanceParams {
  connection: Connection;       // Solana connection instance
  lpMintList: Array<PublicKey>; // Array of LP mint addresses
  owner: PublicKey;            // The user's wallet address
}
Returns An array of BN values representing the user’s LP token balance for each vault. Example 
const lpMints = [vault1LpMint, vault2LpMint, vault3LpMint];
const balances = await VaultImpl.fetchMultipleUserBalance(
  connection,
  lpMints,
  wallet.publicKey
);

balances.forEach((balance, index) => {
  console.log(`Vault ${index} LP balance: ${balance.toString()}`);
});
Notes
  • Returns 0 for vaults where the user has no LP tokens
  • Efficiently fetches multiple balances in a single call
  • Useful for portfolio overview displays

​
createMultiple

Creates multiple vault instances from token mint addresses. Function 
static async createMultiple(
  connection: Connection,
  tokenMints: Array<PublicKey>,
  opt?: {
    seedBaseKey?: PublicKey;
    allowOwnerOffCurve?: boolean;
    cluster?: Cluster;
    programId?: string;
    affiliateId?: PublicKey;
    affiliateProgramId?: string;
  }
): Promise<Array<VaultImpl>>
Parameters 
interface CreateMultipleParams {
  connection: Connection;           // Solana connection instance
  tokenMints: Array<PublicKey>;     // Array of token mint addresses
  opt?: {
    seedBaseKey?: PublicKey;        // Optional seed for deterministic PDAs
    allowOwnerOffCurve?: boolean;   // Allow off-curve owner accounts
    cluster?: Cluster;              // Network cluster
    programId?: string;             // Custom vault program ID
    affiliateId?: PublicKey;        // Affiliate partner ID
    affiliateProgramId?: string;    // Affiliate program ID
  };
}
Returns An array of VaultImpl instances for the specified token mints. Example 
const tokenMints = [usdcMint, solMint, btcMint];
const vaults = await VaultImpl.createMultiple(connection, tokenMints, {
  cluster: 'mainnet-beta',
  affiliateId: partnerPublicKey
});

vaults.forEach((vault, index) => {
  console.log(`Vault ${index}: ${vault.vaultPda.toString()}`);
});
Notes
  • Efficiently creates multiple vault instances in parallel
  • All vaults must already exist on-chain
  • Useful for initializing a portfolio of vaults

​
createMultipleWithPda

Creates multiple vault instances from vault PDA addresses. Function 
static async createMultipleWithPda(
  connection: Connection,
  vaultsPda: Array<PublicKey>,
  opt?: {
    seedBaseKey?: PublicKey;
    allowOwnerOffCurve?: boolean;
    cluster?: Cluster;
    programId?: string;
    affiliateId?: PublicKey;
    affiliateProgramId?: string;
  }
): Promise<Array<VaultImpl>>
Parameters 
interface CreateMultipleWithPdaParams {
  connection: Connection;           // Solana connection instance
  vaultsPda: Array<PublicKey>;      // Array of vault PDA addresses
  opt?: {
    seedBaseKey?: PublicKey;        // Optional seed for deterministic PDAs
    allowOwnerOffCurve?: boolean;   // Allow off-curve owner accounts
    cluster?: Cluster;              // Network cluster
    programId?: string;             // Custom vault program ID
    affiliateId?: PublicKey;        // Affiliate partner ID
    affiliateProgramId?: string;    // Affiliate program ID
  };
}
Returns An array of VaultImpl instances for the specified vault PDAs. Example 
const vaultPdas = [vault1Pda, vault2Pda, vault3Pda];
const vaults = await VaultImpl.createMultipleWithPda(connection, vaultPdas, {
  affiliateId: partnerPublicKey,
  affiliateProgramId: CUSTOM_AFFILIATE_PROGRAM_ID
});

console.log(`Created ${vaults.length} vault instances`);
Notes
  • Use this when you already have the vault PDA addresses
  • More direct than createMultiple when PDAs are known
  • Supports affiliate integration for revenue sharing

​
create

Creates a single vault instance from a token mint address. Function 
static async create(
  connection: Connection,
  tokenAddress: PublicKey,
  opt?: {
    seedBaseKey?: PublicKey;
    allowOwnerOffCurve?: boolean;
    cluster?: Cluster;
    programId?: string;
    affiliateId?: PublicKey;
    affiliateProgramId?: string;
  }
): Promise<VaultImpl>
Parameters 
interface CreateParams {
  connection: Connection;           // Solana connection instance
  tokenAddress: PublicKey;          // Token mint address
  opt?: {
    seedBaseKey?: PublicKey;        // Optional seed for deterministic PDAs
    allowOwnerOffCurve?: boolean;   // Allow off-curve owner accounts
    cluster?: Cluster;              // Network cluster
    programId?: string;             // Custom vault program ID
    affiliateId?: PublicKey;        // Affiliate partner ID
    affiliateProgramId?: string;    // Affiliate program ID
  };
}
Returns A VaultImpl instance for the specified token. Example 
const vault = await VaultImpl.create(connection, usdcMint, {
  cluster: 'mainnet-beta',
  affiliateId: partnerPublicKey
});

console.log(`Vault PDA: ${vault.vaultPda.toString()}`);
console.log(`Token Mint: ${vault.tokenMint.address.toString()}`);
console.log(`LP Supply: ${vault.tokenLpMint.supply.toString()}`);
Notes
  • Use this for creating a single vault instance
  • The vault must already exist on-chain
  • Automatically fetches and caches vault state information

​
getUserBalance

Gets the user’s LP token balance for this vault. Function 
async getUserBalance(owner: PublicKey): Promise<BN>
Parameters 
interface GetUserBalanceParams {
  owner: PublicKey;    // The user's wallet address
}
Returns A BN representing the user’s LP token balance. Example 
const vault = await VaultImpl.create(connection, usdcMint);
const userBalance = await vault.getUserBalance(wallet.publicKey);

console.log(`User LP balance: ${userBalance.toString()}`);

// Convert to human readable format
const balanceInTokens = userBalance.div(new BN(10).pow(new BN(vault.tokenLpMint.decimals)));
console.log(`User balance: ${balanceInTokens.toString()} LP tokens`);
Notes
  • Returns 0 if the user has no LP tokens
  • Handles both direct deposits and affiliate deposits
  • Balance represents share of the vault’s total assets

​
getVaultSupply

Gets the total LP token supply for the vault. Function 
async getVaultSupply(): Promise<BN>
Returns A BN representing the total LP token supply. Example 
const vault = await VaultImpl.create(connection, usdcMint);
const totalSupply = await vault.getVaultSupply();

console.log(`Total LP supply: ${totalSupply.toString()}`);

// Calculate user's share percentage
const userBalance = await vault.getUserBalance(wallet.publicKey);
const userSharePercentage = userBalance.mul(new BN(100)).div(totalSupply);
console.log(`User owns ${userSharePercentage.toString()}% of the vault`);
Notes
  • Refetches the latest LP mint supply from the blockchain
  • Updates the cached tokenLpMint property
  • Use the cached vault.tokenLpMint.supply for performance if recent data is sufficient

​
getWithdrawableAmount

Gets the amount of assets that can be immediately withdrawn from the vault. Function 
async getWithdrawableAmount(): Promise<BN>
Returns A BN representing the withdrawable amount in base token units. Example 
const vault = await VaultImpl.create(connection, usdcMint);
const withdrawableAmount = await vault.getWithdrawableAmount();

console.log(`Withdrawable amount: ${withdrawableAmount.toString()}`);

// Convert to human readable format (assuming USDC with 6 decimals)
const withdrawableUsdc = withdrawableAmount.div(new BN(1_000_000));
console.log(`Withdrawable: ${withdrawableUsdc.toString()} USDC`);
Notes
  • Amount may be less than total vault assets due to strategy allocations
  • Uses current on-chain time for calculations
  • Does not account for user’s specific LP token balance

​
refreshVaultState

Refreshes the cached vault state and token mint information. Function 
async refreshVaultState(): Promise<void>
Returns Void. Updates the instance’s vaultState and tokenMint properties. Example 
const vault = await VaultImpl.create(connection, usdcMint);

// Check current state
console.log(`Current liquidity: ${vault.vaultState.totalLiquidity.toString()}`);

// Refresh state to get latest data
await vault.refreshVaultState();

// Check updated state
console.log(`Updated liquidity: ${vault.vaultState.totalLiquidity.toString()}`);
Notes
  • Call this before deposit/withdraw operations to ensure latest state
  • Updates both vault state and token mint data
  • Essential for accurate calculations in dynamic environments

​
deposit

Deposits tokens into the vault and receives LP tokens in return. Function 
async deposit(owner: PublicKey, baseTokenAmount: BN): Promise<Transaction>
Parameters 
interface DepositParams {
  owner: PublicKey;           // The depositor's wallet address
  baseTokenAmount: BN;        // Amount of base tokens to deposit
}
Returns A Transaction ready to be signed and sent. Example 
const vault = await VaultImpl.create(connection, usdcMint, {
  affiliateId: partnerPublicKey
});

// Deposit 1,000 USDC (with 6 decimals)
const depositAmount = new BN(1_000_000_000);
const depositTx = await vault.deposit(wallet.publicKey, depositAmount);

// Sign and send transaction
const signature = await wallet.sendTransaction(depositTx, connection);
console.log(`Deposit transaction: ${signature}`);
Notes
  • Automatically handles SOL wrapping for native SOL vaults
  • Creates necessary token accounts if they don’t exist
  • Supports affiliate revenue sharing if configured
  • The transaction includes all necessary pre-instructions
  • LP tokens are minted proportional to the deposit amount

​
withdraw

Withdraws tokens from the vault by burning LP tokens. Function 
async withdraw(owner: PublicKey, baseTokenAmount: BN): Promise<Transaction>
Parameters 
interface WithdrawParams {
  owner: PublicKey;           // The withdrawer's wallet address
  baseTokenAmount: BN;        // Amount of LP tokens to burn for withdrawal
}
Returns A Transaction ready to be signed and sent. Example 
const vault = await VaultImpl.create(connection, usdcMint);

// Get user's LP token balance
const userBalance = await vault.getUserBalance(wallet.publicKey);

// Withdraw half of user's position
const withdrawAmount = userBalance.div(new BN(2));
const withdrawTx = await vault.withdraw(wallet.publicKey, withdrawAmount);

// Sign and send transaction
const signature = await wallet.sendTransaction(withdrawTx, connection);
console.log(`Withdraw transaction: ${signature}`);
Notes
  • Automatically handles SOL unwrapping for native SOL vaults
  • May withdraw from vault reserves or underlying strategies
  • Supports affiliate revenue sharing if configured
  • The baseTokenAmount parameter refers to LP tokens to burn, not underlying tokens to receive
  • Automatically selects the optimal withdrawal strategy based on liquidity availability

​
getStrategiesState

Gets the state of all strategies associated with the vault. Function 
async getStrategiesState(): Promise<Array<StrategyState>>
Returns An array of StrategyState objects representing the vault’s strategies. Example 
const vault = await VaultImpl.create(connection, usdcMint);
const strategies = await vault.getStrategiesState();

strategies.forEach((strategy, index) => {
  console.log(`Strategy ${index}:`);
  console.log(`  Current Liquidity: ${strategy.currentLiquidity.toString()}`);
  console.log(`  Performance Fee: ${strategy.performanceFee.toString()}`);
});

console.log(`Total strategies: ${strategies.length}`);
Notes
  • Excludes the vault’s internal strategy (VAULT_STRATEGY_ADDRESS)
  • Useful for understanding vault composition and performance
  • Each strategy represents a different yield farming or liquidity provision approach

​
getAffiliateInfo

Gets affiliate partnership information for the vault. Function 
async getAffiliateInfo(): Promise<AffiliateInfo>
Returns An AffiliateInfo object containing partnership details. Example 
const vault = await VaultImpl.create(connection, usdcMint, {
  affiliateId: partnerPublicKey
});

try {
  const affiliateInfo = await vault.getAffiliateInfo();
  console.log(`Partner fee rate: ${affiliateInfo.feeRate}%`);
  console.log(`Total fees earned: ${affiliateInfo.totalFeesEarned.toString()}`);
} catch (error) {
  console.log('No affiliate information found');
}
Notes
  • Only available when vault is created with an affiliateId
  • Throws an error if no affiliate program is configured
  • Contains fee rates, total fees earned, and partnership terms

​
State Functions

​
getAllVaultState

Fetches state information for multiple vaults by token mint addresses. Function 
async getAllVaultState(
  tokensAddress: Array<PublicKey>,
  program: VaultProgram,
  seedBaseKey?: PublicKey
): Promise<Array<VaultStateAndLp>>
Parameters
  • tokensAddress: Array of token mint addresses
  • program: The vault program instance
  • seedBaseKey: Optional seed for deterministic PDAs
Returns Array of vault state information including PDA, state, and mint data. Example 
const provider = new AnchorProvider(connection, wallet, {});
const program = new Program(IDL, PROGRAM_ID, provider);

const tokenMints = [usdcMint, solMint];
const vaultsInfo = await getAllVaultState(tokenMints, program);

vaultsInfo.forEach((vaultInfo, index) => {
  console.log(`Vault ${index}: ${vaultInfo.vaultPda.toString()}`);
  console.log(`Total Liquidity: ${vaultInfo.vaultState.totalLiquidity.toString()}`);
});

​
getAllVaultStateByPda

Fetches state information for multiple vaults by their PDA addresses. Function 
async getAllVaultStateByPda(
  vaultsPda: Array<PublicKey>,
  program: VaultProgram
): Promise<Array<VaultStateAndLp>>
Parameters
  • vaultsPda: Array of vault PDA addresses
  • program: The vault program instance
Returns Array of vault state information including PDA, state, and mint data. Example 
const vaultPdas = [vault1Pda, vault2Pda];
const vaultsInfo = await getAllVaultStateByPda(vaultPdas, program);

console.log(`Fetched ${vaultsInfo.length} vault states`);

​
getVaultState

Fetches state information for a single vault by token mint address. Function 
async getVaultState(
  tokenAddress: PublicKey,
  program: VaultProgram,
  seedBaseKey?: PublicKey
): Promise<VaultStateAndLp>
Parameters
  • tokenAddress: Token mint address
  • program: The vault program instance
  • seedBaseKey: Optional seed for deterministic PDAs
Returns Vault state information including PDA, state, and mint data. Example 
const vaultInfo = await getVaultState(usdcMint, program);
console.log(`Vault PDA: ${vaultInfo.vaultPda.toString()}`);
console.log(`LP Mint: ${vaultInfo.vaultState.lpMint.toString()}`);

​
getVaultStateByPda

Fetches state information for a single vault by its PDA address. Function 
async getVaultStateByPda(
  vaultPda: PublicKey,
  program: VaultProgram
): Promise<VaultStateAndLp>
Parameters
  • vaultPda: Vault PDA address
  • program: The vault program instance
Returns Vault state information including PDA, state, and mint data. Example 
const vaultInfo = await getVaultStateByPda(vaultPda, program);
console.log(`Token Mint: ${vaultInfo.vaultState.tokenMint.toString()}`);
console.log(`Total Supply: ${vaultInfo.vaultLpMint.supply.toString()}`);

​
getVaultLiquidity

Gets the current liquidity amount in the vault’s token account. Function 
async getVaultLiquidity(
  connection: Connection,
  tokenVaultPda: PublicKey
): Promise<string | null>
Parameters
  • connection: Solana connection instance
  • tokenVaultPda: The vault’s token account PDA
Returns The liquidity amount as a string, or null if the account doesn’t exist. Example 
const liquidity = await getVaultLiquidity(connection, vault.tokenVaultPda);
if (liquidity) {
  console.log(`Vault liquidity: ${liquidity} tokens`);
} else {
  console.log('Vault account not found');
}

​
Helper Functions

​
calculateWithdrawableAmount

Calculates the amount that can be withdrawn based on current time and vault state. Function 
function calculateWithdrawableAmount(currentTime: BN, vaultState: VaultState): BN
Parameters
  • currentTime: Current blockchain timestamp
  • vaultState: The vault’s current state
Returns The withdrawable amount as a BN. Example 
import { getOnchainTime } from './utils';

const currentTime = await getOnchainTime(connection);
const withdrawable = calculateWithdrawableAmount(currentTime, vault.vaultState);
console.log(`Withdrawable: ${withdrawable.toString()}`);
Notes
  • Accounts for time-based withdrawal restrictions
  • Used internally by the getWithdrawableAmount method
  • Essential for implementing withdrawal limits and unlock schedules