Voltr Vault Integration

Learn how to interact with Voltr vaults for deposits, withdrawals, and position management

Solana Agent Kit provides comprehensive integration with Voltr vaults for managing deposits, withdrawals, and viewing position values. The integration supports both Token Program and Token-2022 assets.

Key Features

• Strategy deposits
• Strategy withdrawals
• Position value tracking
• Token-2022 support
• Remaining accounts handling
• LangChain tool integration

Basic Usage

Getting Position Values

const values = await agent.methods.voltrGetPositionValues(
  new PublicKey("vault_address")
);

Depositing into a Strategy

const signature = await agent.methods.voltrDepositStrategy(
  new BN("1000000"),  // Amount in base units
  new PublicKey("vault_address"),
  new PublicKey("strategy_address")
);

Withdrawing from a Strategy

const signature = await agent.methods.voltrWithdrawStrategy(
  new BN("1000000"),  // Amount in base units
  new PublicKey("vault_address"),
  new PublicKey("strategy_address")
);

Input Parameters

Strategy Operation Parameters

interface StrategyParams {
  depositAmount?: BN;      // Amount to deposit
  withdrawAmount?: BN;     // Amount to withdraw
  vault: PublicKey;        // Vault address
  strategy: PublicKey;     // Strategy address
}

Remaining Accounts Structure

interface RemainingAccount {
  pubkey: string;         // Account public key
  isSigner: boolean;      // Is signer flag
  isWritable: boolean;    // Is writable flag
}

LangChain Integration

Solana Agent Kit provides several LangChain tools for Voltr operations:

Get Position Values Tool

import { SolanaVoltrGetPositionValues } from 'solana-agent-kit';

const getPositionTool = new SolanaVoltrGetPositionValues(agent);

// Tool input: vault address as string
const input = "vault_address";

// Tool returns JSON string with position values

Deposit Strategy Tool

import { SolanaVoltrDepositStrategy } from 'solana-agent-kit';

const depositTool = new SolanaVoltrDepositStrategy(agent);

// Tool input format (JSON string):
const input = JSON.stringify({
  depositAmount: "1000000",
  vault: "vault_address",
  strategy: "strategy_address"
});

// Tool returns JSON response:
{
  status: "success",
  message: "Deposited 1000000 into strategy successfully",
  transaction: "transaction_signature"
}

Withdraw Strategy Tool

import { SolanaVoltrWithdrawStrategy } from 'solana-agent-kit';

const withdrawTool = new SolanaVoltrWithdrawStrategy(agent);

// Tool input format (JSON string):
const input = JSON.stringify({
  withdrawAmount: "1000000",
  vault: "vault_address",
  strategy: "strategy_address"
});

// Tool returns JSON response:
{
  status: "success",
  message: "Withdrew 1000000 from strategy successfully",
  transaction: "transaction_signature"
}

Example Prompts

For LangChain AI tools, here are example prompts:

Position Management

"Get current position values for vault [address]"
"Deposit 1000 USDC into strategy [address]"
"Withdraw 500 SOL from vault strategy"

Important Notes

1. Token Programs

   • Supports both Token Program and Token-2022
   • Automatically detects token program type
   • Validates program compatibility

2. Amount Handling

   • All amounts must be in base units (lamports)
   • Use BN.js for precise number handling
   • Consider token decimals when calculating amounts

3. Remaining Accounts

   • Fetched automatically from Voltr API
   • Required for strategy operations
   • Includes instruction discriminators

Best Practices

1. Error Handling

   try {
     const signature = await agent.methods.voltrDepositStrategy(
       amount,
       vault,
       strategy
     );
   } catch (error) {
     if (error.message.includes("Invalid asset")) {
       // Handle invalid token program
     } else if (error.message.includes("insufficient")) {
       // Handle insufficient funds
     }
   }
   

2. Amount Calculation

   // Convert from human readable to base units
   function toBaseUnits(amount: number, decimals: number): BN {
     return new BN(amount * Math.pow(10, decimals));
   }
   

3. Transaction Monitoring

   // Monitor transaction status
   const signature = await agent.methods.voltrDepositStrategy(...);
   await agent.methods.connection.confirmTransaction(signature);
   

Technical Details

Constants

const TOKEN_PROGRAMS = {
  LEGACY: TOKEN_PROGRAM_ID,
  TOKEN_2022: TOKEN_2022_PROGRAM_ID
};

Voltr Client Configuration

const client = new VoltrClient(connection, wallet);

API Endpoints

const VOLTR_API = {
  REMAINING_ACCOUNTS: "https://voltr.xyz/api/remaining-accounts"
};

Transaction Options

const TX_OPTIONS = {
  skipPreflight: false,
  preflightCommitment: "confirmed"
};

Implementation Examples

1. Full Deposit Flow

   // 1. Get vault account
   const vaultAccount = await client.fetchVaultAccount(vault);
   
   // 2. Verify token program
   const assetTokenProgram = await getTokenProgram(vaultAccount.asset.mint);
   
   // 3. Get remaining accounts
   const { remainingAccounts } = await fetchRemainingAccounts(vault, strategy);
   
   // 4. Create and send transaction
   const ix = await client.createDepositStrategyIx({...});
   const signature = await sendAndConfirmTransaction(tx, [wallet]);
   

2. Position Value Check

   // Get position and total values
   const values = await client.getPositionAndTotalValuesForVault(vault);
   console.log(`Total Value: ${values.totalValue}`);
   values.positions.forEach(pos => {
     console.log(`Strategy ${pos.strategy}: ${pos.value}`);
   });
   

3. Withdrawal with Amount Validation

   // Check available balance before withdrawal
   const position = await client.getPositionValue(vault, strategy);
   if (withdrawAmount.gt(position)) {
     throw new Error("Insufficient balance in strategy");
   }
   const signature = await agent.methods.voltrWithdrawStrategy(...);