Class VoltrClient

Main client for interacting with the Voltr protocol

Remarks

The VoltrClient provides methods for initializing and managing vaults, handling strategies, and performing deposits/withdrawals. It requires a Solana connection and optionally accepts a wallet for signing transactions.

Example

import { VoltrClient } from '@voltr/sdk';
import { Connection } from '@solana/web3.js';

const connection = new Connection('https://api.mainnet-beta.solana.com');
const client = new VoltrClient(connection);

Hierarchy

AccountUtils
- VoltrClient

Constructors

constructor

new VoltrClient(conn: Connection, wallet?: Keypair): VoltrClient
Creates a new VoltrClient instance
Parameters
- conn: Connection
  Solana connection instance
- Optionalwallet: Keypair
  Optional keypair for signing transactions
Returns VoltrClient
Overrides AccountUtils.constructor
- Defined in src/client.ts:89

Properties

adaptorIdl

adaptorIdl: Idl

adaptorProgram

adaptorProgram: Program<VoltrAdaptor>

conn

conn: Connection

provider

provider: AnchorProvider

vaultIdl

vaultIdl: Idl

vaultProgram

vaultProgram: Program<VoltrVault>

Methods

addStrategyToVaultIx

addStrategyToVaultIx(
params: { payer: PublicKey; strategy: PublicKey; vault: PublicKey },
): Promise<TransactionInstruction>
Creates an instruction to add a strategy to a vault
Parameters
- params: { payer: PublicKey; strategy: PublicKey; vault: PublicKey }
  Parameters for adding strategy to vault
Returns Promise<TransactionInstruction>
Promise resolving to a TransactionInstruction
Throws
If the instruction creation fails
Example
```
const ix = await client.addStrategyToVaultIx({
  payer: payerPubkey,
  vault: vaultPubkey,
  strategy: strategyPubkey
});
```
- Defined in src/client.ts:504

calculateAssetsForWithdraw

calculateAssetsForWithdraw(vaultPk: PublicKey, lpAmount: BN): Promise<BN>
Calculates the amount of assets that would be received for a given LP token amount
Parameters
- vaultPk: PublicKey
  Public key of the vault
- lpAmount: BN
  Amount of LP tokens to calculate for
Returns Promise<BN>
Promise resolving to the amount of assets that would be received
Throws
If LP supply or total assets are invalid

Throws
If math overflow occurs during calculation
Example
```
const assetsToReceive = await client.calculateAssetsForWithdraw(
  vaultPubkey,
  new BN('1000000000')
);
```
- Defined in src/client.ts:803

calculateLpTokensForDeposit

calculateLpTokensForDeposit(depositAmount: BN, vaultPk: PublicKey): Promise<BN>
Calculates the amount of LP tokens that would be received for a given asset deposit
Parameters
- depositAmount: BN
  Amount of assets to deposit
- vaultPk: PublicKey
  Public key of the vault
Returns Promise<BN>
Promise resolving to the amount of LP tokens that would be received
Throws
If math overflow occurs during calculation
Example
```
const lpTokens = await client.calculateLpTokensForDeposit(
  new BN('1000000000'),
  vaultPubkey
);
```
- Defined in src/client.ts:843

createDepositIx

createDepositIx(
    amount: BN,
    params: {
        userAuthority: PublicKey;
        vault: PublicKey;
        vaultAssetMint: PublicKey;
    },
): Promise<TransactionInstruction>
Creates a deposit instruction
Parameters
- amount: BN
  Amount of tokens to deposit
- params: { userAuthority: PublicKey; vault: PublicKey; vaultAssetMint: PublicKey }
  Deposit parameters
Returns Promise<TransactionInstruction>
Promise resolving to a TransactionInstruction
Example
```
const ix = await client.createDepositIx(
  new BN('1000000000'),
  {
    userAuthority: userPubkey,
    vault: vaultPubkey,
    vaultAssetMint: mintPubkey
  }
);
```
- Defined in src/client.ts:362

createDepositStrategyIx

createDepositStrategyIx(
    amount: BN,
    params: {
        counterpartyAssetTa: PublicKey;
        protocolProgram: PublicKey;
        remainingAccounts: {
            isSigner: boolean;
            isWritable: boolean;
            pubkey: PublicKey;
        }[];
        strategy: PublicKey;
        vault: PublicKey;
        vaultAssetMint: PublicKey;
        vaultStrategy: PublicKey;
    },
): Promise<TransactionInstruction>
Creates an instruction to deposit assets into a strategy
Parameters
- amount: BN
  Amount of assets to deposit
- params: {
      counterpartyAssetTa: PublicKey;
      protocolProgram: PublicKey;
      remainingAccounts: {
          isSigner: boolean;
          isWritable: boolean;
          pubkey: PublicKey;
      }[];
      strategy: PublicKey;
      vault: PublicKey;
      vaultAssetMint: PublicKey;
      vaultStrategy: PublicKey;
  }
  Strategy deposit parameters
Returns Promise<TransactionInstruction>
Promise resolving to a TransactionInstruction
Throws
If the instruction creation fails
Example
```
const ix = await client.createDepositStrategyIx(
  new BN('1000000000'),
  {
    vault: vaultPubkey,
    vaultAssetMint: mintPubkey,
    strategy: strategyPubkey,
    vaultStrategy: vaultStrategyPubkey,
    counterpartyAssetTa: taPubkey,
    remainingAccounts: []
  }
);
```
- Defined in src/client.ts:548

createInitializeVaultIx

createInitializeVaultIx(
    params: {
        admin: PublicKey;
        manager: PublicKey;
        payer: PublicKey;
        vault: Keypair;
        vaultAssetMint: PublicKey;
        vaultParams: VaultParams;
    },
): Promise<TransactionInstruction>

Creates an instruction to initialize a new vault

Parameters

params: {
    admin: PublicKey;
    manager: PublicKey;
    payer: PublicKey;
    vault: Keypair;
    vaultAssetMint: PublicKey;
    vaultParams: VaultParams;
}
Parameters for initializing the vault

Returns Promise<TransactionInstruction>

Promise resolving to a TransactionInstruction

Example

const ix = await client.createInitializeVaultIx({
  vault: vaultKeypair,
  vaultAssetMint: new PublicKey('...'),
  admin: adminPubkey,
  manager: managerPubkey,
  payer: payerPubkey,
  vaultParams: {
    config: {
      managementFee: 50, // 0.5%
      performanceFee: 1000, // 10%
      maxCap: new BN('1000000000')
    },
    name: "My Vault",
    description: "Example vault"
  }
});

createRemoveStrategyIx

createRemoveStrategyIx(
params: { admin: PublicKey; strategy: PublicKey; vault: PublicKey },
): Promise<TransactionInstruction>
Creates an instruction to remove a strategy from a vault
Parameters
- params: { admin: PublicKey; strategy: PublicKey; vault: PublicKey }
  Parameters for removing strategy
Returns Promise<TransactionInstruction>
Promise resolving to a TransactionInstruction
Throws
If the instruction creation fails
Example
```
const ix = await client.createRemoveStrategyIx({
  admin: adminPubkey,
  vault: vaultPubkey,
  strategy: strategyPubkey
});
```
- Defined in src/client.ts:675

createStrategyIx

createStrategyIx(
    strategyType:
        | { marginfi: Record<string, never> }
        | { kamino: Record<string, never> }
        | { solend: Record<string, never> }
        | { driftx: Record<string, never> },
    params: {
        admin: PublicKey;
        counterpartyAssetTa: PublicKey;
        payer: PublicKey;
        protocolProgram: PublicKey;
    },
): Promise<TransactionInstruction>
Creates an instruction to initialize a new strategy
Parameters
- strategyType:
      | { marginfi: Record<string, never> }
      | { kamino: Record<string, never> }
      | { solend: Record<string, never> }
      | { driftx: Record<string, never> }
  Type of strategy to create (marginfi or kamino or drift or solend)
- params: {
      admin: PublicKey;
      counterpartyAssetTa: PublicKey;
      payer: PublicKey;
      protocolProgram: PublicKey;
  }
  Strategy initialization parameters
Returns Promise<TransactionInstruction>
Promise resolving to a TransactionInstruction
Throws
If the instruction creation fails
Example
```
const ix = await client.createStrategyIx(
  { marginfi: {} },
  {
    payer: payerPubkey,
    admin: adminPubkey,
    counterpartyAssetTa: taPubkey,
    protocolProgram: programPubkey
  }
);
```
- Defined in src/client.ts:458

createWithdrawIx

createWithdrawIx(
    amount: BN,
    params: {
        userAuthority: PublicKey;
        vault: PublicKey;
        vaultAssetMint: PublicKey;
    },
): Promise<TransactionInstruction>
Creates a withdraw instruction
Parameters
- amount: BN
  Amount of LP tokens to withdraw
- params: { userAuthority: PublicKey; vault: PublicKey; vaultAssetMint: PublicKey }
  Withdraw parameters
Returns Promise<TransactionInstruction>
Promise resolving to a TransactionInstruction
Throws
If the instruction creation fails
Example
```
const ix = await client.createWithdrawIx(
  new BN('1000000000'),
  {
    userAuthority: userPubkey,
    vault: vaultPubkey,
    vaultAssetMint: mintPubkey
  }
);
```
- Defined in src/client.ts:409

createWithdrawStrategyIx

createWithdrawStrategyIx(
    amount: BN,
    params: {
        counterpartyAssetTa: PublicKey;
        counterpartyAssetTaAuth: PublicKey;
        protocolProgram: PublicKey;
        remainingAccounts: {
            isSigner: boolean;
            isWritable: boolean;
            pubkey: PublicKey;
        }[];
        strategy: PublicKey;
        vault: PublicKey;
        vaultAssetMint: PublicKey;
        vaultStrategy: PublicKey;
    },
): Promise<TransactionInstruction>
Creates an instruction to withdraw assets from a strategy
Parameters
- amount: BN
  Amount of assets to withdraw
- params: {
      counterpartyAssetTa: PublicKey;
      counterpartyAssetTaAuth: PublicKey;
      protocolProgram: PublicKey;
      remainingAccounts: {
          isSigner: boolean;
          isWritable: boolean;
          pubkey: PublicKey;
      }[];
      strategy: PublicKey;
      vault: PublicKey;
      vaultAssetMint: PublicKey;
      vaultStrategy: PublicKey;
  }
  Strategy withdrawal parameters
Returns Promise<TransactionInstruction>
Promise resolving to a TransactionInstruction
Throws
If the instruction creation fails
Example
```
const ix = await client.createWithdrawStrategyIx(
  new BN('1000000000'),
  {
    vault: vaultPubkey,
    vaultAssetMint: mintPubkey,
    strategy: strategyPubkey,
    vaultStrategy: vaultStrategyPubkey,
    counterpartyAssetTa: taPubkey,
    counterpartyAssetTaAuth: taAuthPubkey,
    remainingAccounts: []
  }
);
```
- Defined in src/client.ts:614

fetchAdaptorStrategyAccount

fetchAdaptorStrategyAccount(
adaptorStrategy: PublicKey,
): Promise<
{ adaptorProgram: PublicKey; strategy: PublicKey; vault: PublicKey },
>
Fetches an adaptor strategy account's data
Parameters
- adaptorStrategy: PublicKey
  Public key of the adaptor strategy account
Returns Promise<{ adaptorProgram: PublicKey; strategy: PublicKey; vault: PublicKey }>
Promise resolving to the adaptor strategy account data
Example
```
const adaptorStrategyAccount = await client.fetchAdaptorStrategyAccount(adaptorStrategyPubkey);
```
- Defined in src/client.ts:777

fetchAllStrategyAccounts

fetchAllStrategyAccounts(): Promise<
    ProgramAccount<
        {
            counterpartyAssetTa: PublicKey;
            protocolProgram: PublicKey;
            strategyType: any;
        },
    >[],
>
Fetches all strategy accounts

Returns Promise<
    ProgramAccount<
        {
            counterpartyAssetTa: PublicKey;
            protocolProgram: PublicKey;
            strategyType: any;
        },
    >[],
>
Promise resolving to an array of strategy accounts
Example
```
const strategyAccounts = await client.fetchAllStrategyAccounts();
```
- Defined in src/client.ts:703

fetchStrategyAccount

fetchStrategyAccount(
    strategy: PublicKey,
): Promise<
    {
        counterpartyAssetTa: PublicKey;
        protocolProgram: PublicKey;
        strategyType: any;
    },
>
Fetches a strategy account's data
Parameters
- strategy: PublicKey
  Public key of the strategy
Returns Promise<
    {
        counterpartyAssetTa: PublicKey;
        protocolProgram: PublicKey;
        strategyType: any;
    },
>
Promise resolving to the strategy account data
Example
```
const strategyAccount = await client.fetchStrategyAccount(strategyPubkey);
```
- Defined in src/client.ts:749

fetchVaultAccount

fetchVaultAccount(
    vault: PublicKey,
): Promise<
    {
        admin: PublicKey;
        asset: any;
        configuration: any;
        description: number[];
        lastUpdateSlot: BN;
        lp: any;
        manager: PublicKey;
        name: number[];
    },
>
Fetches a vault account's data
Parameters
- vault: PublicKey
  Public key of the vault
Returns Promise<
    {
        admin: PublicKey;
        asset: any;
        configuration: any;
        description: number[];
        lastUpdateSlot: BN;
        lp: any;
        manager: PublicKey;
        name: number[];
    },
>
Promise resolving to the vault account data
- Defined in src/client.ts:735

fetchVaultStrategyAccount

fetchVaultStrategyAccount(
    vaultStrategy: PublicKey,
): Promise<
    {
        currentAmount: BN;
        strategy: PublicKey;
        vaultAssetIdleAuth: PublicKey;
    },
>
Fetches a vault strategy account's data
Parameters
- vaultStrategy: PublicKey
  Public key of the vault strategy account
Returns Promise<
    {
        currentAmount: BN;
        strategy: PublicKey;
        vaultAssetIdleAuth: PublicKey;
    },
>
Promise resolving to the vault strategy account data
Example
```
const vaultStrategyAccount = await client.fetchVaultStrategyAccount(vaultStrategyPubkey);
```
- Defined in src/client.ts:763

fetchVaultStrategyAccounts

fetchVaultStrategyAccounts(
    vaultAssetIdleAuth: PublicKey,
): Promise<
    ProgramAccount<
        {
            currentAmount: BN;
            strategy: PublicKey;
            vaultAssetIdleAuth: PublicKey;
        },
    >[],
>
Fetches all vault strategy accounts
Parameters
- vaultAssetIdleAuth: PublicKey
  Public key of the vault asset idle auth
Returns Promise<
    ProgramAccount<
        {
            currentAmount: BN;
            strategy: PublicKey;
            vaultAssetIdleAuth: PublicKey;
        },
    >[],
>
Promise resolving to an array of vault strategy accounts
Example
```
const vaultStrategyAccounts = await client.fetchVaultStrategyAccounts(vaultAssetIdleAuthPubkey);
```
- Defined in src/client.ts:717

findAdaptorStrategy

findAdaptorStrategy(vault: PublicKey, strategy: PublicKey): PublicKey
Finds the adaptor strategy PDA for a given vault and strategy
Parameters
- vault: PublicKey
  Public key of the vault
- strategy: PublicKey
  Public key of the strategy
Returns PublicKey
The PDA for the adaptor strategy account
Example
```
const adaptorStrategy = client.findAdaptorStrategy(vaultPubkey, strategyPubkey);
```
- Defined in src/client.ts:223

findStrategy

findStrategy(counterpartyAssetTa: PublicKey): PublicKey
Finds the strategy PDA for a given counterparty asset token account
Parameters
- counterpartyAssetTa: PublicKey
  Public key of the counterparty asset token account
Returns PublicKey
The PDA for the strategy account
Example
```
const strategy = client.findStrategy(counterpartyAssetTaPubkey);
```
- Defined in src/client.ts:204

findStrategyAddresses

findStrategyAddresses(
    vault: PublicKey,
    vaultAssetIdleAuth: PublicKey,
    counterpartyAssetTa: PublicKey,
): {
    adaptorStrategy: PublicKey;
    strategy: PublicKey;
    vaultStrategy: PublicKey;
}
Finds all strategy-related addresses
Parameters
- vault: PublicKey
  Public key of the vault
- vaultAssetIdleAuth: PublicKey
  Public key of the vault's asset idle authority
- counterpartyAssetTa: PublicKey
  Public key of the counterparty asset token account
Returns { adaptorStrategy: PublicKey; strategy: PublicKey; vaultStrategy: PublicKey }
Object containing all strategy-related PDAs
- Defined in src/client.ts:256

findVaultAddresses

findVaultAddresses(
    vault: PublicKey,
): {
    vaultAssetIdleAuth: PublicKey;
    vaultLpFeeAuth: PublicKey;
    vaultLpMint: PublicKey;
}
Finds all vault-related addresses
Parameters
- vault: PublicKey
  Public key of the vault
Returns {
    vaultAssetIdleAuth: PublicKey;
    vaultLpFeeAuth: PublicKey;
    vaultLpMint: PublicKey;
}
Object containing all vault-related PDAs
- Defined in src/client.ts:182

findVaultAssetIdleAuth

findVaultAssetIdleAuth(vault: PublicKey): PublicKey
Finds the vault's asset idle authority address
Parameters
- vault: PublicKey
  Public key of the vault
Returns PublicKey
The PDA for the vault's asset idle authority
- Defined in src/client.ts:151

findVaultLpFeeAuth

findVaultLpFeeAuth(vault: PublicKey): PublicKey
Finds the vault's LP fee authority address
Parameters
- vault: PublicKey
  Public key of the vault
Returns PublicKey
The PDA for the vault's LP fee authority
Example
```
const feeAuth = client.findVaultLpFeeAuth(vaultPubkey);
```
- Defined in src/client.ts:169

findVaultLpMint

findVaultLpMint(vault: PublicKey): PublicKey
Finds the vault LP mint address for a given vault
Parameters
- vault: PublicKey
  Public key of the vault
Returns PublicKey
The PDA for the vault's LP mint
- Defined in src/client.ts:138

findVaultStrategy

findVaultStrategy(vaultAssetIdleAuth: PublicKey, strategy: PublicKey): PublicKey
Finds the vault strategy PDA for a given vault and strategy
Parameters
- vaultAssetIdleAuth: PublicKey
  Public key of the vault's asset idle authority
- strategy: PublicKey
  Public key of the strategy
Returns PublicKey
The PDA for the vault strategy account
- Defined in src/client.ts:237

getBalance

getBalance(publicKey: PublicKey): Promise<number>
Parameters
- publicKey: PublicKey
Returns Promise<number>
Inherited from AccountUtils.getBalance
- Defined in src/client.ts:55

Class VoltrClient

Remarks

Example

Hierarchy

Index

Constructors

Properties

Methods

Constructors

constructor

Parameters

Returns VoltrClient

Properties

adaptorIdl

adaptorProgram

conn

provider

vaultIdl

vaultProgram

Methods

addStrategyToVaultIx

Parameters

Returns Promise<TransactionInstruction>

Throws

Example

calculateAssetsForWithdraw

Parameters

Returns Promise<BN>

Throws

Throws

Example

calculateLpTokensForDeposit

Parameters

Returns Promise<BN>

Throws

Example

createDepositIx

Parameters

Returns Promise<TransactionInstruction>

Example

createDepositStrategyIx

Parameters

Returns Promise<TransactionInstruction>

Throws

Example

createInitializeVaultIx

Parameters

Returns Promise<TransactionInstruction>

Example

createRemoveStrategyIx

Parameters

Returns Promise<TransactionInstruction>

Throws

Example

createStrategyIx

Parameters

Returns Promise<TransactionInstruction>

Throws

Example

createWithdrawIx

Parameters

Returns Promise<TransactionInstruction>

Throws

Example

createWithdrawStrategyIx

Parameters

Returns Promise<TransactionInstruction>

Throws

Example

fetchAdaptorStrategyAccount

Parameters

Returns Promise<{ adaptorProgram: PublicKey; strategy: PublicKey; vault: PublicKey }>

Example

fetchAllStrategyAccounts

Returns Promise< ProgramAccount< { counterpartyAssetTa: PublicKey; protocolProgram: PublicKey; strategyType: any; }, >[],>

Example

fetchStrategyAccount

Parameters

Returns Promise< { counterpartyAssetTa: PublicKey; protocolProgram: PublicKey; strategyType: any; },>

Example

Returns Promise<
ProgramAccount<
{
counterpartyAssetTa: PublicKey;
protocolProgram: PublicKey;
strategyType: any;
},
>[],
>

Returns Promise<
{
counterpartyAssetTa: PublicKey;
protocolProgram: PublicKey;
strategyType: any;
},
>

Returns Promise<
{
admin: PublicKey;
asset: any;
configuration: any;
description: number[];
lastUpdateSlot: BN;
lp: any;
manager: PublicKey;
name: number[];
},
>

Returns Promise<
{
currentAmount: BN;
strategy: PublicKey;
vaultAssetIdleAuth: PublicKey;
},
>

Returns Promise<
ProgramAccount<
{
currentAmount: BN;
strategy: PublicKey;
vaultAssetIdleAuth: PublicKey;
},
>[],
>

Returns {
vaultAssetIdleAuth: PublicKey;
vaultLpFeeAuth: PublicKey;
vaultLpMint: PublicKey;
}