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/vault-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

Index

Constructors

constructor

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

Properties

conn

conn: Connection

provider

provider: AnchorProvider

vaultIdl

vaultIdl: Idl

vaultProgram

vaultProgram: Program<VoltrVault>

Methods

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:1727

calculateAssetsForWithdrawHelper

calculateAssetsForWithdrawHelper(
    vaultTotalValue: BN,
    vaultLastUpdatedLockedProfit: BN,
    vaultLockedProfitDegradationDuration: BN,
    vaultAccumulatedLpAdminFees: BN,
    vaultAccumulatedLpManagerFees: BN,
    vaultAccumulatedLpProtocolFees: BN,
    vaultRedemptionFee: number,
    lpSupply: BN,
    lpAmount: BN,
): BN
Parameters
- vaultTotalValue: BN
- vaultLastUpdatedLockedProfit: BN
- vaultLockedProfitDegradationDuration: BN
- vaultAccumulatedLpAdminFees: BN
- vaultAccumulatedLpManagerFees: BN
- vaultAccumulatedLpProtocolFees: BN
- vaultRedemptionFee: number
- lpSupply: BN
- lpAmount: BN
Returns BN
- Defined in src/client.ts:1669

calculateLockedProfit

calculateLockedProfit(
    lastUpdatedLockedProfit: BN,
    lockedProfitDegradationDuration: BN,
    currentTime: BN,
): BN
Parameters
- lastUpdatedLockedProfit: BN
- lockedProfitDegradationDuration: BN
- currentTime: BN
Returns BN
- Defined in src/client.ts:1653

calculateLpForDeposit

calculateLpForDeposit(vaultPk: PublicKey, assetAmount: BN): Promise<BN>
Calculates the amount of LP tokens that would be received for a given asset deposit
Parameters
- vaultPk: PublicKey
  Public key of the vault
- assetAmount: BN
  Amount of assets to deposit
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(
  vaultPubkey
  new BN('1000000000'),
);
```
- Defined in src/client.ts:1841

calculateLpForWithdraw

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

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

createAddAdaptorIx

createAddAdaptorIx(
    params: {
        adaptorProgram?: PublicKey;
        admin: PublicKey;
        payer: PublicKey;
        vault: PublicKey;
    },
): Promise<TransactionInstruction>
Creates an instruction to add an adaptor to a vault
Parameters
- params: {
      adaptorProgram?: PublicKey;
      admin: PublicKey;
      payer: PublicKey;
      vault: PublicKey;
  }
  Parameters for adding adaptor to vault
  - OptionaladaptorProgram?: PublicKey
    Public key of the adaptor program
  - admin: PublicKey
    Public key of the admin
  - payer: PublicKey
    Public key of the payer
  - vault: PublicKey
    Public key of the vault
Returns Promise<TransactionInstruction>
Transaction instruction for adding adaptor to vault
Throws
If the instruction creation fails
Example
```
const ix = await client.createAddAdaptorIx({
  vault: vaultPubkey,
  payer: payerPubkey,
  admin: adminPubkey,
  adaptorProgram: adaptorProgramPubkey
});
```
- Defined in src/client.ts:671

createCalibrateHighWaterMarkIx

createCalibrateHighWaterMarkIx(
params: { admin: PublicKey; vault: PublicKey },
): Promise<TransactionInstruction>
Creates an instruction to calibrate the high water mark
Parameters
- params: { admin: PublicKey; vault: PublicKey }
  Parameters for calibrating the high water mark
  - admin: PublicKey
    Public key of the admin
  - vault: PublicKey
    Public key of the vault
Returns Promise<TransactionInstruction>
Transaction instruction for calibrating the high water mark
Throws
If instruction creation fails
Example
```
const ix = await client.createCalibrateHighWaterMarkIx({
  vault: vaultPubkey,
  admin: adminPubkey,
});
```
- Defined in src/client.ts:1211

createCancelRequestWithdrawVaultIx

createCancelRequestWithdrawVaultIx(
params: { userTransferAuthority: PublicKey; vault: PublicKey },
): Promise<TransactionInstruction>
Creates a cancel withdraw instruction for a vault
Parameters
- params: { userTransferAuthority: PublicKey; vault: PublicKey }
  Cancel withdraw request parameters
  - userTransferAuthority: PublicKey
    Public key of the user authority
  - vault: PublicKey
    Public key of the vault
Returns Promise<TransactionInstruction>
Transaction instruction for withdrawal
Throws
If the instruction creation fails
Example
```
const ix = await client.createCancelRequestWithdrawVaultIx(
  {
    userTransferAuthority: userPubkey,
    vault: vaultPubkey,
  }
);
```
- Defined in src/client.ts:588

createCloseStrategyIx

createCloseStrategyIx(
    params: {
        manager: PublicKey;
        payer: PublicKey;
        strategy: PublicKey;
        vault: PublicKey;
    },
): Promise<TransactionInstruction>
Creates an instruction to close a strategy
Parameters
- params: { manager: PublicKey; payer: PublicKey; strategy: PublicKey; vault: PublicKey }
  Parameters for closing strategy
  - manager: PublicKey
    Public key of the manager
  - payer: PublicKey
    Public key of the payer
  - strategy: PublicKey
    Public key of the strategy
  - vault: PublicKey
    Public key of the vault
Returns Promise<TransactionInstruction>
Transaction instruction for closing strategy
Throws
If instruction creation fails
Example
```
const ix = await client.createCloseStrategyIx({
  payer: payerPubkey,
  manager: managerPubkey,
  vault: vaultPubkey,
  strategy: strategyPubkey,
});
```
- Defined in src/client.ts:1173

createCreateLpMetadataIx

createCreateLpMetadataIx(
createLpMetadataArgs: { name: string; symbol: string; uri: string },
params: { admin: PublicKey; payer: PublicKey; vault: PublicKey },
): Promise<TransactionInstruction>
Creates an instruction to create LP metadata
Parameters
- createLpMetadataArgs: { name: string; symbol: string; uri: string }
  Parameters for creating LP metadata
  - name: string
    Name of the LP
  - symbol: string
    Symbol of the LP
  - uri: string
    URI of the LP metadata
- params: { admin: PublicKey; payer: PublicKey; vault: PublicKey }
  Parameters for creating LP metadata
  - admin: PublicKey
    Public key of the admin
  - payer: PublicKey
    Public key of the payer
  - vault: PublicKey
    Public key of the vault
Returns Promise<TransactionInstruction>
Transaction instruction for creating LP metadata
Throws
If instruction creation fails
Example
```
const ix = await client.createCreateLpMetadataIx({
  name: "My LP",
  symbol: "MYLP",
  uri: "https://mylp.com/metadata",
});
```
- Defined in src/client.ts:1249

createDepositStrategyIx

createDepositStrategyIx(
    depositArgs: DepositStrategyArgs,
    params: {
        adaptorProgram?: PublicKey;
        assetTokenProgram: PublicKey;
        manager: PublicKey;
        remainingAccounts: {
            isSigner: boolean;
            isWritable: boolean;
            pubkey: PublicKey;
        }[];
        strategy: PublicKey;
        vault: PublicKey;
        vaultAssetMint: PublicKey;
    },
): Promise<TransactionInstruction>
Creates an instruction to deposit assets into a strategy
Parameters
- depositArgs: DepositStrategyArgs
  Deposit arguments
  - OptionaladditionalArgs?: null | Buffer<ArrayBufferLike>
  - depositAmount: BN
  - OptionalinstructionDiscriminator?: null | Buffer<ArrayBufferLike>
- params: {
      adaptorProgram?: PublicKey;
      assetTokenProgram: PublicKey;
      manager: PublicKey;
      remainingAccounts: {
          isSigner: boolean;
          isWritable: boolean;
          pubkey: PublicKey;
      }[];
      strategy: PublicKey;
      vault: PublicKey;
      vaultAssetMint: PublicKey;
  }
  Strategy deposit parameters
  - OptionaladaptorProgram?: PublicKey
    Public key of the adaptor program
  - assetTokenProgram: PublicKey
    Public key of the asset token program
  - manager: PublicKey
    Public key of the manager
  - remainingAccounts: { isSigner: boolean; isWritable: boolean; pubkey: PublicKey }[]
    Remaining accounts for the instruction
  - strategy: PublicKey
    Public key of the strategy
  - vault: PublicKey
    Public key of the vault
  - vaultAssetMint: PublicKey
    Public key of the vault asset mint
Returns Promise<TransactionInstruction>
Transaction instruction for depositing assets into strategy
Throws
If the instruction creation fails
Example
```
const ix = await client.createDepositStrategyIx(
  {
    depositAmount: new BN('1000000000'),
    instructionDiscriminator: Buffer.from('...'),
    additionalArgs: Buffer.from('...')
  },
  {
    manager: managerPubkey,
    vault: vaultPubkey,
    vaultAssetMint: mintPubkey,
    strategy: strategyPubkey,
    assetTokenProgram: tokenProgramPubkey,
    adaptorProgram: adaptorProgramPubkey,
    remainingAccounts: []
  }
);
```
- Defined in src/client.ts:805

createDepositVaultIx

createDepositVaultIx(
    amount: BN,
    params: {
        assetTokenProgram: PublicKey;
        userTransferAuthority: PublicKey;
        vault: PublicKey;
        vaultAssetMint: PublicKey;
    },
): Promise<TransactionInstruction>
Creates a deposit instruction for a vault
Parameters
- amount: BN
  Amount of tokens to deposit
- params: {
      assetTokenProgram: PublicKey;
      userTransferAuthority: PublicKey;
      vault: PublicKey;
      vaultAssetMint: PublicKey;
  }
  Deposit parameters
  - assetTokenProgram: PublicKey
    Public key of the asset token program
  - userTransferAuthority: PublicKey
    Public key of the user's transfer authority
  - vault: PublicKey
    Public key of the vault
  - vaultAssetMint: PublicKey
    Public key of the vault asset mint
Returns Promise<TransactionInstruction>
Transaction instruction for depositing tokens
Throws
If instruction creation fails
Example
```
const ix = await client.createDepositVaultIx(
  new BN('1000000000'),
  {
    userTransferAuthority: userPubkey,
    vault: vaultPubkey,
    vaultAssetMint: mintPubkey,
    assetTokenProgram: tokenProgramPubkey
  }
);
```
- Defined in src/client.ts:494

createDirectWithdrawStrategyIx

createDirectWithdrawStrategyIx(
    directWithdrawArgs: { userArgs?: null | Buffer<ArrayBufferLike> },
    params: {
        adaptorProgram?: PublicKey;
        assetTokenProgram: PublicKey;
        remainingAccounts: {
            isSigner: boolean;
            isWritable: boolean;
            pubkey: PublicKey;
        }[];
        strategy: PublicKey;
        user: PublicKey;
        vault: PublicKey;
        vaultAssetMint: PublicKey;
    },
): Promise<TransactionInstruction>
Creates an instruction to withdraw assets from a direct withdraw strategy
Parameters
- directWithdrawArgs: { userArgs?: null | Buffer<ArrayBufferLike> }
  Withdrawal arguments
  - OptionaluserArgs?: null | Buffer<ArrayBufferLike>
    Optional user arguments for the instruction
- params: {
      adaptorProgram?: PublicKey;
      assetTokenProgram: PublicKey;
      remainingAccounts: {
          isSigner: boolean;
          isWritable: boolean;
          pubkey: PublicKey;
      }[];
      strategy: PublicKey;
      user: PublicKey;
      vault: PublicKey;
      vaultAssetMint: PublicKey;
  }
  Parameters for withdrawing assets from direct withdraw strategy
  - OptionaladaptorProgram?: PublicKey
    Public key of the adaptor program
  - assetTokenProgram: PublicKey
    Public key of the asset token program
  - remainingAccounts: { isSigner: boolean; isWritable: boolean; pubkey: PublicKey }[]
    Remaining accounts for the instruction
  - strategy: PublicKey
    Public key of the strategy
  - user: PublicKey
    Public key of the user
  - vault: PublicKey
    Public key of the vault
  - vaultAssetMint: PublicKey
    Public key of the vault asset mint
Returns Promise<TransactionInstruction>
Transaction instruction for withdrawing assets from direct withdraw strategy
Throws
If instruction creation fails
Example
```
const ix = await client.createDirectWithdrawStrategyIx(
  {
    userArgs: Buffer.from('...')
  },
  {
    user: userPubkey,
    vault: vaultPubkey,
    strategy: strategyPubkey,
    vaultAssetMint: mintPubkey,
    assetTokenProgram: tokenProgramPubkey,
    adaptorProgram: adaptorProgramPubkey,
    remainingAccounts: []
  }
);
```
- Defined in src/client.ts:1068

createHarvestFeeIx

createHarvestFeeIx(
    params: {
        harvester: PublicKey;
        protocolAdmin: PublicKey;
        vault: PublicKey;
        vaultAdmin: PublicKey;
        vaultManager: PublicKey;
    },
): Promise<TransactionInstruction>
Creates an instruction to harvest fees from a vault
Parameters
- params: {
      harvester: PublicKey;
      protocolAdmin: PublicKey;
      vault: PublicKey;
      vaultAdmin: PublicKey;
      vaultManager: PublicKey;
  }
  Parameters for harvesting fees
  - harvester: PublicKey
    Public key of the harvester
  - protocolAdmin: PublicKey
    Public key of the protocol admin
  - vault: PublicKey
    Public key of the vault
  - vaultAdmin: PublicKey
    Public key of the vault admin
  - vaultManager: PublicKey
    Public key of the vault manager
Returns Promise<TransactionInstruction>
Transaction instruction for harvesting fees
Throws
If instruction creation fails
Example
```
const ix = await client.createHarvestFeeIx({
  harvester: harvesterPubkey,
  vaultManager: vaultManagerPubkey,
  vaultAdmin: vaultAdminPubkey,
  protocolAdmin: protocolAdminPubkey,
  vault: vaultPubkey,
});
```
- Defined in src/client.ts:1128

createInitializeDirectWithdrawStrategyIx

createInitializeDirectWithdrawStrategyIx(
    initArgs: InitializeDirectWithdrawStrategyArgs,
    params: {
        adaptorProgram?: PublicKey;
        admin: PublicKey;
        payer: PublicKey;
        strategy: PublicKey;
        vault: PublicKey;
    },
): Promise<TransactionInstruction>
Creates an instruction to initialize a direct withdraw strategy
Parameters
- initArgs: InitializeDirectWithdrawStrategyArgs
  Arguments for initializing direct withdraw strategy
  - OptionaladditionalArgs?: null | Buffer<ArrayBufferLike>
  - OptionalallowUserArgs?: boolean
  - OptionalinstructionDiscriminator?: null | Buffer<ArrayBufferLike>
- params: {
      adaptorProgram?: PublicKey;
      admin: PublicKey;
      payer: PublicKey;
      strategy: PublicKey;
      vault: PublicKey;
  }
  Parameters for initializing direct withdraw strategy
  - OptionaladaptorProgram?: PublicKey
    Public key of the adaptor program
  - admin: PublicKey
    Public key of the admin
  - payer: PublicKey
    Public key of the payer
  - strategy: PublicKey
    Public key of the strategy
  - vault: PublicKey
    Public key of the vault
Returns Promise<TransactionInstruction>
Transaction instruction for initializing direct withdraw strategy
Throws
If instruction creation fails
Example
```
const ix = await client.createInitializeDirectWithdrawStrategyIx(
  {
    instructionDiscriminator: Buffer.from('...'),
    additionalArgs: Buffer.from('...'),
    allowUserArgs: true
  },
  {
    payer: payerPubkey,
    admin: adminPubkey,
    vault: vaultPubkey,
    strategy: strategyPubkey,
    adaptorProgram: adaptorProgramPubkey
  }
);
```
- Defined in src/client.ts:999

createInitializeStrategyIx

createInitializeStrategyIx(
    initArgs: InitializeStrategyArgs,
    params?: {
        adaptorProgram?: PublicKey;
        manager: PublicKey;
        payer: PublicKey;
        remainingAccounts: {
            isSigner: boolean;
            isWritable: boolean;
            pubkey: PublicKey;
        }[];
        strategy: PublicKey;
        vault: PublicKey;
    },
): Promise<TransactionInstruction>
Creates an instruction to initialize a strategy to a vault
Parameters
- initArgs: InitializeStrategyArgs
  Arguments for strategy initialization
  - OptionaladditionalArgs?: null | Buffer<ArrayBufferLike>
  - OptionalinstructionDiscriminator?: null | Buffer<ArrayBufferLike>
- Optionalparams: {
      adaptorProgram?: PublicKey;
      manager: PublicKey;
      payer: PublicKey;
      remainingAccounts: {
          isSigner: boolean;
          isWritable: boolean;
          pubkey: PublicKey;
      }[];
      strategy: PublicKey;
      vault: PublicKey;
  }
  Parameters for initializing strategy to vault
  - OptionaladaptorProgram?: PublicKey
    Public key of the adaptor program
  - manager: PublicKey
    Public key of the manager
  - payer: PublicKey
    Public key of the payer
  - remainingAccounts: { isSigner: boolean; isWritable: boolean; pubkey: PublicKey }[]
    Remaining accounts for the instruction
  - strategy: PublicKey
    Public key of the strategy
  - vault: PublicKey
    Public key of the vault
Returns Promise<TransactionInstruction>
Transaction instruction for initializing strategy to vault
Throws
If the instruction creation fails
Example
```
const ix = await client.createInitializeStrategyIx(
  {
    instructionDiscriminator: Buffer.from('...'), // optional
    additionalArgs: Buffer.from('...')           // optional
  },
  {
    payer: payerPubkey,
    vault: vaultPubkey,
    manager: managerPubkey,
    strategy: strategyPubkey,
    adaptorProgram: adaptorProgramPubkey,
    remainingAccounts: []
  }
);
```
- Defined in src/client.ts:726

createInitializeVaultIx

createInitializeVaultIx(
    vaultParams: VaultParams,
    params: {
        admin: PublicKey;
        manager: PublicKey;
        payer: PublicKey;
        vault: PublicKey;
        vaultAssetMint: PublicKey;
    },
): Promise<TransactionInstruction>
Creates an instruction to initialize a new vault
Parameters
- vaultParams: VaultParams
  Configuration parameters for the vault
  - config: VaultConfig
  - description: string
  - name: string
- params: {
      admin: PublicKey;
      manager: PublicKey;
      payer: PublicKey;
      vault: PublicKey;
      vaultAssetMint: PublicKey;
  }
  Additional parameters for initializing the vault
  - admin: PublicKey
    Public key of the vault admin
  - manager: PublicKey
    Public key of the vault manager
  - payer: PublicKey
    Public key of the fee payer
  - vault: PublicKey
    Keypair for the new vault
  - vaultAssetMint: PublicKey
    Public key of the vault's asset mint
Returns Promise<TransactionInstruction>
Transaction instruction for initializing the vault
Example
```
const ix = await client.createInitializeVaultIx(
  {
    config: {
      maxCap: new BN('1000000000'),
      startAtTs: new BN(Math.floor(Date.now() / 1000)),
      lockedProfitDegradationDuration: new BN(3600), // 1 hour
      redemptionFee: 10,
      issuanceFee: 10,
      withdrawalWaitingPeriod: new BN(3600), // 1 hour
      managerManagementFee: 50,  // 0.5%
      managerPerformanceFee: 1000,  // 10%
      adminManagementFee: 50,  // 0.5%
      adminPerformanceFee: 1000,  // 10%
    },
    name: "My Vault",
    description: "Example vault"
  },
  {
    vault: vaultKeypair,
    vaultAssetMint: new PublicKey('...'),
    admin: adminPubkey,
    manager: managerPubkey,
    payer: payerPubkey
  }
);
```
- Defined in src/client.ts:366

createRemoveAdaptorIx

createRemoveAdaptorIx(
    params: {
        adaptorProgram?: PublicKey;
        admin: PublicKey;
        vault: PublicKey;
    },
): Promise<TransactionInstruction>
Creates an instruction to remove a strategy from a vault
Parameters
- params: { adaptorProgram?: PublicKey; admin: PublicKey; vault: PublicKey }
  Parameters for removing strategy
  - OptionaladaptorProgram?: PublicKey
    Public key of the adaptor program
  - admin: PublicKey
    Public key of the admin
  - vault: PublicKey
    Public key of the vault
Returns Promise<TransactionInstruction>
Transaction instruction for removing adaptor from vault
Throws
If instruction creation fails
Example
```
const ix = await client.createRemoveAdaptorIx({
  vault: vaultPubkey,
  admin: adminPubkey,
  adaptorProgram: adaptorProgramPubkey
});
```
- Defined in src/client.ts:947

createRequestWithdrawVaultIx

createRequestWithdrawVaultIx(
    requestWithdrawArgs: RequestWithdrawVaultArgs,
    params: {
        payer: PublicKey;
        userTransferAuthority: PublicKey;
        vault: PublicKey;
    },
): Promise<TransactionInstruction>
Creates a request withdraw instruction for a vault
Parameters
- requestWithdrawArgs: RequestWithdrawVaultArgs
  Arguments for withdrawing from the vault
  - amount: BN
  - isAmountInLp: boolean
  - isWithdrawAll: boolean
- params: { payer: PublicKey; userTransferAuthority: PublicKey; vault: PublicKey }
  Request withdraw parameters
  - payer: PublicKey
    Public key of the payer
  - userTransferAuthority: PublicKey
    Public key of the user authority
  - vault: PublicKey
    Public key of the vault
Returns Promise<TransactionInstruction>
Transaction instruction for withdrawal
Throws
If the instruction creation fails
Example
```
const ix = await client.createRequestWithdrawVaultIx(
  {
    amount: new BN('1000000000'),
    isAmountInLp: true,
    isWithdrawAll: false,
  },
  {
    payer: payerPubkey,
    userTransferAuthority: userPubkey,
    vault: vaultPubkey,
  }
);
```
- Defined in src/client.ts:548

createUpdateVaultIx

createUpdateVaultIx(
vaultConfig: VaultConfig,
params: { admin: PublicKey; vault: PublicKey },
): Promise<TransactionInstruction>
Creates an instruction to update a vault
Parameters
- vaultConfig: VaultConfig
  Configuration parameters for the vault
  - adminManagementFee: number
  - adminPerformanceFee: number
  - issuanceFee: number
  - lockedProfitDegradationDuration: BN
  - managerManagementFee: number
  - managerPerformanceFee: number
  - maxCap: BN
  - redemptionFee: number
  - startAtTs: BN
  - withdrawalWaitingPeriod: BN
- params: { admin: PublicKey; vault: PublicKey }
  Parameters for updating the vault
  - admin: PublicKey
    Public key of the vault admin
  - vault: PublicKey
    Public key of the vault
Returns Promise<TransactionInstruction>
Transaction instruction for updating the vault
Example
```
const ix = await client.createUpdateVaultIx(
  {
    maxCap: new BN('1000000000'),
    startAtTs: new BN(Math.floor(Date.now() / 1000)),
    managerManagementFee: 50,
    managerPerformanceFee: 1000,
    adminManagementFee: 50,
    adminPerformanceFee: 1000,
  },
  { vault: vaultPubkey, admin: adminPubkey }
);
```
- Defined in src/client.ts:446

createWithdrawStrategyIx

createWithdrawStrategyIx(
    withdrawArgs: WithdrawStrategyArgs,
    params: {
        adaptorProgram?: PublicKey;
        assetTokenProgram: PublicKey;
        manager: PublicKey;
        remainingAccounts: {
            isSigner: boolean;
            isWritable: boolean;
            pubkey: PublicKey;
        }[];
        strategy: PublicKey;
        vault: PublicKey;
        vaultAssetMint: PublicKey;
    },
): Promise<TransactionInstruction>
Creates an instruction to withdraw assets from a strategy
Parameters
- withdrawArgs: WithdrawStrategyArgs
  Withdrawal arguments
  - OptionaladditionalArgs?: null | Buffer<ArrayBufferLike>
  - OptionalinstructionDiscriminator?: null | Buffer<ArrayBufferLike>
  - withdrawAmount: BN
- params: {
      adaptorProgram?: PublicKey;
      assetTokenProgram: PublicKey;
      manager: PublicKey;
      remainingAccounts: {
          isSigner: boolean;
          isWritable: boolean;
          pubkey: PublicKey;
      }[];
      strategy: PublicKey;
      vault: PublicKey;
      vaultAssetMint: PublicKey;
  }
  Strategy withdrawal parameters
  - OptionaladaptorProgram?: PublicKey
    Public key of the adaptor program
  - assetTokenProgram: PublicKey
    Public key of the asset token program
  - manager: PublicKey
  - remainingAccounts: { isSigner: boolean; isWritable: boolean; pubkey: PublicKey }[]
    Remaining accounts for the instruction
  - strategy: PublicKey
    Public key of the strategy
  - vault: PublicKey
    Public key of the vault
  - vaultAssetMint: PublicKey
    Public key of the vault asset mint
Returns Promise<TransactionInstruction>
Transaction instruction for withdrawing assets from strategy
Throws
If the instruction creation fails
Example
```
const ix = await client.createWithdrawStrategyIx(
  {
    withdrawAmount: new BN('1000000000'),
    instructionDiscriminator: Buffer.from('...'),
    additionalArgs: Buffer.from('...')
  },
  {
    vault: vaultPubkey,
    vaultAssetMint: mintPubkey,
    strategy: strategyPubkey,
    assetTokenProgram: tokenProgramPubkey,
    adaptorProgram: adaptorProgramPubkey,
    remainingAccounts: []
  }
);
```
- Defined in src/client.ts:883

createWithdrawVaultIx

createWithdrawVaultIx(
    params: {
        assetTokenProgram: PublicKey;
        userTransferAuthority: PublicKey;
        vault: PublicKey;
        vaultAssetMint: PublicKey;
    },
): Promise<TransactionInstruction>
Creates a withdraw instruction for a vault
Parameters
- params: {
      assetTokenProgram: PublicKey;
      userTransferAuthority: PublicKey;
      vault: PublicKey;
      vaultAssetMint: PublicKey;
  }
  Withdraw parameters
  - assetTokenProgram: PublicKey
    Public key of the asset token program
  - userTransferAuthority: PublicKey
    Public key of the user authority
  - vault: PublicKey
    Public key of the vault
  - vaultAssetMint: PublicKey
    Public key of the vault asset mint
Returns Promise<TransactionInstruction>
Transaction instruction for withdrawal
Throws
If the instruction creation fails
Example
```
const ix = await client.createWithdrawVaultIx(
  {
    userTransferAuthority: userPubkey,
    vault: vaultPubkey,
    vaultAssetMint: mintPubkey,
    assetTokenProgram: tokenProgramPubkey
  }
);
```
- Defined in src/client.ts:626

fetchAdaptorAddReceiptAccount

fetchAdaptorAddReceiptAccount(
    adaptorAddReceipt: PublicKey,
): Promise<
    {
        adaptorProgram: PublicKey;
        bump: number;
        lastUpdatedEpoch: BN;
        padding0: number[];
        reserved: number[];
        vault: PublicKey;
        version: number;
    },
>
Fetches an adaptor add receipt account's data
Parameters
- adaptorAddReceipt: PublicKey
  Public key of the adaptor add receipt account
Returns Promise<
    {
        adaptorProgram: PublicKey;
        bump: number;
        lastUpdatedEpoch: BN;
        padding0: number[];
        reserved: number[];
        vault: PublicKey;
        version: number;
    },
>
Promise resolving to the adaptor add receipt account data
Example
```
const adaptorAddReceiptAccount = await client.fetchAdaptorAddReceiptAccount(adaptorAddReceiptPubkey);
```
- Defined in src/client.ts:1399

fetchAllAdaptorAddReceiptAccountsOfVault

fetchAllAdaptorAddReceiptAccountsOfVault(
    vault: PublicKey,
): Promise<
    ProgramAccount<
        {
            adaptorProgram: PublicKey;
            bump: number;
            lastUpdatedEpoch: BN;
            padding0: number[];
            reserved: number[];
            vault: PublicKey;
            version: number;
        },
    >[],
>
Fetches all adaptor add receipt accounts of a vault
Parameters
- vault: PublicKey
  Public key of the vault
Returns Promise<
    ProgramAccount<
        {
            adaptorProgram: PublicKey;
            bump: number;
            lastUpdatedEpoch: BN;
            padding0: number[];
            reserved: number[];
            vault: PublicKey;
            version: number;
        },
    >[],
>
Promise resolving to an array of adaptor add receipt accounts
Example
```
const adaptorAddReceiptAccounts = await client.fetchAllAdaptorAddReceiptAccountsOfVault(vaultPubkey);
```
- Defined in src/client.ts:1347

fetchAllRequestWithdrawVaultReceiptsOfVault

fetchAllRequestWithdrawVaultReceiptsOfVault(
    vault: PublicKey,
): Promise<
    ProgramAccount<
        {
            amountAssetToWithdrawDecimalBits: BN;
            amountLpEscrowed: BN;
            bump: number;
            user: PublicKey;
            vault: PublicKey;
            version: number;
            withdrawableFromTs: BN;
        },
    >[],
>
Fetches all request withdraw vault receipt accounts of a vault
Parameters
- vault: PublicKey
  Public key of the vault
Returns Promise<
    ProgramAccount<
        {
            amountAssetToWithdrawDecimalBits: BN;
            amountLpEscrowed: BN;
            bump: number;
            user: PublicKey;
            vault: PublicKey;
            version: number;
            withdrawableFromTs: BN;
        },
    >[],
>
Promise resolving to an array of request withdraw vault receipt accounts
Example
```
const requestWithdrawVaultReceiptAccounts = await client.fetchAllRequestWithdrawVaultReceiptsOfVault(vaultPubkey);
```
- Defined in src/client.ts:1326

fetchAllStrategyInitReceiptAccounts

fetchAllStrategyInitReceiptAccounts(): Promise<
    ProgramAccount<
        {
            adaptorProgram: PublicKey;
            bump: number;
            lastUpdatedTs: BN;
            padding0: number[];
            positionValue: BN;
            reserved: number[];
            strategy: PublicKey;
            vault: PublicKey;
            vaultStrategyAuthBump: number;
            version: number;
        },
    >[],
>
Fetches all strategy init receipt accounts

Returns Promise<
    ProgramAccount<
        {
            adaptorProgram: PublicKey;
            bump: number;
            lastUpdatedTs: BN;
            padding0: number[];
            positionValue: BN;
            reserved: number[];
            strategy: PublicKey;
            vault: PublicKey;
            vaultStrategyAuthBump: number;
            version: number;
        },
    >[],
>
Promise resolving to an array of strategy init receipt accounts
Example
```
const strategyInitReceiptAccounts = await client.fetchAllStrategyInitReceiptAccounts();
```
- Defined in src/client.ts:1291

fetchAllStrategyInitReceiptAccountsOfVault

fetchAllStrategyInitReceiptAccountsOfVault(
    vault: PublicKey,
): Promise<
    ProgramAccount<
        {
            adaptorProgram: PublicKey;
            bump: number;
            lastUpdatedTs: BN;
            padding0: number[];
            positionValue: BN;
            reserved: number[];
            strategy: PublicKey;
            vault: PublicKey;
            vaultStrategyAuthBump: number;
            version: number;
        },
    >[],
>
Fetches all strategy init receipt accounts of a vault
Parameters
- vault: PublicKey
  Public key of the vault
Returns Promise<
    ProgramAccount<
        {
            adaptorProgram: PublicKey;
            bump: number;
            lastUpdatedTs: BN;
            padding0: number[];
            positionValue: BN;
            reserved: number[];
            strategy: PublicKey;
            vault: PublicKey;
            vaultStrategyAuthBump: number;
            version: number;
        },
    >[],
>
Promise resolving to an array of strategy init receipt accounts
Example
```
const strategyInitReceiptAccounts = await client.fetchAllStrategyInitReceiptAccountsOfVault(vaultPubkey);
```
- Defined in src/client.ts:1305

fetchRequestWithdrawVaultReceiptAccount

fetchRequestWithdrawVaultReceiptAccount(
    requestWithdrawVaultReceipt: PublicKey,
): Promise<
    {
        amountAssetToWithdrawDecimalBits: BN;
        amountLpEscrowed: BN;
        bump: number;
        user: PublicKey;
        vault: PublicKey;
        version: number;
        withdrawableFromTs: BN;
    },
>
Fetches a request withdraw vault receipt account's data
Parameters
- requestWithdrawVaultReceipt: PublicKey
  Public key of the request withdraw vault receipt account
Returns Promise<
    {
        amountAssetToWithdrawDecimalBits: BN;
        amountLpEscrowed: BN;
        bump: number;
        user: PublicKey;
        vault: PublicKey;
        version: number;
        withdrawableFromTs: BN;
    },
>
Promise resolving to the request withdraw vault receipt account data
Example
```
const requestWithdrawVaultReceiptAccount = await client.fetchRequestWithdrawVaultReceiptAccount(requestWithdrawVaultReceiptPubkey);
```
- Defined in src/client.ts:1416

fetchStrategyInitReceiptAccount

fetchStrategyInitReceiptAccount(
    strategyInitReceipt: PublicKey,
): Promise<
    {
        adaptorProgram: PublicKey;
        bump: number;
        lastUpdatedTs: BN;
        padding0: number[];
        positionValue: BN;
        reserved: number[];
        strategy: PublicKey;
        vault: PublicKey;
        vaultStrategyAuthBump: number;
        version: number;
    },
>
Fetches a strategy init receipt account's data
Parameters
- strategyInitReceipt: PublicKey
  Public key of the strategy init receipt account
Returns Promise<
    {
        adaptorProgram: PublicKey;
        bump: number;
        lastUpdatedTs: BN;
        padding0: number[];
        positionValue: BN;
        reserved: number[];
        strategy: PublicKey;
        vault: PublicKey;
        vaultStrategyAuthBump: number;
        version: number;
    },
>
Promise resolving to the strategy init receipt account data
Example
```
const strategyInitReceiptAccount = await client.fetchStrategyInitReceiptAccount(strategyInitReceiptPubkey);
```
- Defined in src/client.ts:1382

fetchVaultAccount

fetchVaultAccount(
    vault: PublicKey,
): Promise<
    {
        admin: PublicKey;
        asset: {
            idleAta: PublicKey;
            idleAtaAuthBump: number;
            mint: PublicKey;
            reserved: number[];
            totalValue: BN;
        };
        description: number[];
        feeConfiguration: {
            adminManagementFee: number;
            adminPerformanceFee: number;
            issuanceFee: number;
            managerManagementFee: number;
            managerPerformanceFee: number;
            redemptionFee: number;
            reserved: number[];
        };
        feeState: {
            accumulatedLpAdminFees: BN;
            accumulatedLpManagerFees: BN;
            accumulatedLpProtocolFees: BN;
            reserved: number[];
        };
        feeUpdate: {
            lastManagementFeeUpdateTs: BN;
            lastPerformanceFeeUpdateTs: BN;
        };
        highWaterMark: {
            highestAssetPerLpDecimalBits: BN;
            lastUpdatedTs: BN;
            reserved: number[];
        };
        lastUpdatedTs: BN;
        lockedProfitState: { lastReport: BN; lastUpdatedLockedProfit: BN };
        lp: {
            mint: PublicKey;
            mintAuthBump: number;
            mintBump: number;
            reserved: number[];
        };
        manager: PublicKey;
        name: number[];
        padding0: number[];
        reserved: number[];
        vaultConfiguration: {
            lockedProfitDegradationDuration: BN;
            maxCap: BN;
            reserved: number[];
            startAtTs: BN;
            withdrawalWaitingPeriod: BN;
        };
        version: number;
    },
>
Fetches a vault account's data
Parameters
- vault: PublicKey
  Public key of the vault
Returns Promise<
    {
        admin: PublicKey;
        asset: {
            idleAta: PublicKey;
            idleAtaAuthBump: number;
            mint: PublicKey;
            reserved: number[];
            totalValue: BN;
        };
        description: number[];
        feeConfiguration: {
            adminManagementFee: number;
            adminPerformanceFee: number;
            issuanceFee: number;
            managerManagementFee: number;
            managerPerformanceFee: number;
            redemptionFee: number;
            reserved: number[];
        };
        feeState: {
            accumulatedLpAdminFees: BN;
            accumulatedLpManagerFees: BN;
            accumulatedLpProtocolFees: BN;
            reserved: number[];
        };
        feeUpdate: {
            lastManagementFeeUpdateTs: BN;
            lastPerformanceFeeUpdateTs: BN;
        };
        highWaterMark: {
            highestAssetPerLpDecimalBits: BN;
            lastUpdatedTs: BN;
            reserved: number[];
        };
        lastUpdatedTs: BN;
        lockedProfitState: { lastReport: BN; lastUpdatedLockedProfit: BN };
        lp: {
            mint: PublicKey;
            mintAuthBump: number;
            mintBump: number;
            reserved: number[];
        };
        manager: PublicKey;
        name: number[];
        padding0: number[];
        reserved: number[];
        vaultConfiguration: {
            lockedProfitDegradationDuration: BN;
            maxCap: BN;
            reserved: number[];
            startAtTs: BN;
            withdrawalWaitingPeriod: BN;
        };
        version: number;
    },
>
Promise resolving to the vault account data
- Defined in src/client.ts:1365

findDirectWithdrawInitReceipt

findDirectWithdrawInitReceipt(vault: PublicKey, strategy: PublicKey): PublicKey
Finds the direct withdraw init receipt address
Parameters
- vault: PublicKey
  Public key of the vault
- strategy: PublicKey
  Public key of the strategy
Returns PublicKey
The PDA for the direct withdraw init receipt
Example
```
const directWithdrawInitReceipt = client.findDirectWithdrawInitReceipt(vaultPubkey, strategyPubkey);
```
- Defined in src/client.ts:245

findLpMetadataAccount

findLpMetadataAccount(vault: PublicKey): PublicKey
Finds the LP metadata account for a given vault
Parameters
- vault: PublicKey
  Public key of the vault
Returns PublicKey
The PDA for the LP metadata account
Example
```
const lpMetadataAccount = client.findLpMetadataAccount(vaultPubkey);
```
- Defined in src/client.ts:302

findRequestWithdrawVaultReceipt

findRequestWithdrawVaultReceipt(vault: PublicKey, user: PublicKey): PublicKey
Finds the request withdraw vault receipt address
Parameters
- vault: PublicKey
  Public key of the vault
- user: PublicKey
  Public key of the user
Returns PublicKey
The PDA for the request withdraw vault receipt
Example
```
const requestWithdrawVaultReceipt = client.findRequestWithdrawVaultReceipt(vaultPubkey, userPubkey);
```
- Defined in src/client.ts:283

findStrategyInitReceipt

findStrategyInitReceipt(vault: PublicKey, strategy: PublicKey): PublicKey
Finds the strategy init receipt address
Parameters
- vault: PublicKey
  Public key of the vault
- strategy: PublicKey
  Public key of the strategy
Returns PublicKey
The PDA for the strategy init receipt
Example
```
const strategyInitReceipt = client.findStrategyInitReceipt(vaultPubkey, strategyPubkey);
```
- Defined in src/client.ts:226

findVaultAddresses

findVaultAddresses(
vault: PublicKey,
): { vaultAssetIdleAuth: PublicKey; vaultLpMint: PublicKey }
Finds all vault-related addresses
Parameters
- vault: PublicKey
  Public key of the vault
Returns { vaultAssetIdleAuth: PublicKey; vaultLpMint: PublicKey }
Object containing all vault-related PDAs
Example
```
const addresses = client.findVaultAddresses(vaultPubkey);
console.log(addresses.vaultLpMint.toBase58());
console.log(addresses.vaultAssetIdleAuth.toBase58());
console.log(addresses.vaultLpFeeAuth.toBase58());
```
- Defined in src/client.ts:186

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:165

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:152

findVaultStrategyAddresses

findVaultStrategyAddresses(
    vault: PublicKey,
    strategy: PublicKey,
): {
    directWithdrawInitReceipt: PublicKey;
    strategyInitReceipt: PublicKey;
    vaultStrategyAuth: PublicKey;
}
Parameters
- vault: PublicKey
- strategy: PublicKey
Returns {
    directWithdrawInitReceipt: PublicKey;
    strategyInitReceipt: PublicKey;
    vaultStrategyAuth: PublicKey;
}
- Defined in src/client.ts:257

findVaultStrategyAuth

findVaultStrategyAuth(vault: PublicKey, strategy: PublicKey): PublicKey
Finds the vault strategy auth address
Parameters
- vault: PublicKey
  Public key of the vault
- strategy: PublicKey
  Public key of the strategy
Returns PublicKey
The PDA for the vault strategy auth
Example
```
const vaultStrategyAuth = client.findVaultStrategyAuth(vaultPubkey, strategyPubkey);
```
- Defined in src/client.ts:207

getAccumulatedAdminFeesForVault

getAccumulatedAdminFeesForVault(vault: PublicKey): Promise<BN>
Fetches the accumulated admin fees for a vault
Parameters
- vault: PublicKey
  Public key of the vault
Returns Promise<BN>
Promise resolving to the accumulated admin fees
Example
```
const accumulatedAdminFees = await client.getAccumulatedAdminFeesForVault(vaultPubkey);
```
- Defined in src/client.ts:1465

getAccumulatedManagerFeesForVault

getAccumulatedManagerFeesForVault(vault: PublicKey): Promise<BN>
Fetches the accumulated manager fees for a vault
Parameters
- vault: PublicKey
  Public key of the vault
Returns Promise<BN>
Promise resolving to the accumulated manager fees
Example
```
const accumulatedManagerFees = await client.getAccumulatedManagerFeesForVault(vaultPubkey);
```
- Defined in src/client.ts:1480

getAllPendingWithdrawalsForVault

getAllPendingWithdrawalsForVault(
    vault: PublicKey,
): Promise<
    {
        amountAssetToWithdrawAtPresent: number;
        amountAssetToWithdrawAtRequest: number;
        amountAssetToWithdrawEffective: number;
        amountLpEscrowed: number;
        user: PublicKey;
        withdrawableFromTs: number;
    }[],
>
Fetches all pending withdrawals for a vault
Parameters
- vault: PublicKey
  Public key of the vault
Returns Promise<
    {
        amountAssetToWithdrawAtPresent: number;
        amountAssetToWithdrawAtRequest: number;
        amountAssetToWithdrawEffective: number;
        amountLpEscrowed: number;
        user: PublicKey;
        withdrawableFromTs: number;
    }[],
>
Promise resolving to an array of pending withdrawals
Example
```
const pendingWithdrawals = await client.getAllPendingWithdrawalsForVault(vaultPubkey);
```
- Defined in src/client.ts:1633

getBalance

getBalance(publicKey: PublicKey): Promise<number>
Gets the balance of a Solana account
Parameters
- publicKey: PublicKey
  Public key to check balance for
Returns Promise<number>
Promise resolving to the account balance in lamports

Throws
If fetching balance fails
Inherited from AccountUtils.getBalance
- Defined in src/client.ts:71

getCurrentAssetPerLpForVault

getCurrentAssetPerLpForVault(vault: PublicKey): Promise<number>
Fetches the current asset per LP for a vault
Parameters
- vault: PublicKey
  Public key of the vault
Returns Promise<number>
Promise resolving to the current asset per LP
Example
```
const currentAssetPerLp = await client.getCurrentAssetPerLpForVault(vaultPubkey);
```
- Defined in src/client.ts:1495

getHighWaterMarkForVault

getHighWaterMarkForVault(
vault: PublicKey,
): Promise<{ highestAssetPerLp: number; lastUpdatedTs: number }>
Fetches the high water mark for a vault
Parameters
- vault: PublicKey
  Public key of the vault
Returns Promise<{ highestAssetPerLp: number; lastUpdatedTs: number }>
Promise resolving to the high water mark
Example
```
const highWaterMark = await client.getHighWaterMarkForVault(vaultPubkey);
```
- Defined in src/client.ts:1525

getPendingWithdrawalForUser

getPendingWithdrawalForUser(
    vault: PublicKey,
    user: PublicKey,
): Promise<
    {
        amountAssetToWithdrawAtPresent: number;
        amountAssetToWithdrawAtRequest: number;
        amountAssetToWithdrawEffective: number;
        amountLpEscrowed: number;
        user: PublicKey;
        withdrawableFromTs: number;
    },
>
Fetches the pending withdrawal for a user
Parameters
- vault: PublicKey
  Public key of the vault
- user: PublicKey
  Public key of the user
Returns Promise<
    {
        amountAssetToWithdrawAtPresent: number;
        amountAssetToWithdrawAtRequest: number;
        amountAssetToWithdrawEffective: number;
        amountLpEscrowed: number;
        user: PublicKey;
        withdrawableFromTs: number;
    },
>
Promise resolving to the pending withdrawal
Example
```
const pendingWithdrawal = await client.getPendingWithdrawalForUser(vaultPubkey, userPubkey);
```
- Defined in src/client.ts:1600

getPositionAndTotalValuesForVault

getPositionAndTotalValuesForVault(
    vault: PublicKey,
): Promise<
    {
        strategies: { amount: number; strategyId: string }[];
        totalValue: number;
    },
>
Fetches the position and total values for a vault
Parameters
- vault: PublicKey
  Public key of the vault
Returns Promise<
    {
        strategies: { amount: number; strategyId: string }[];
        totalValue: number;
    },
>
Promise resolving to the position and total values
Example
```
const positionAndTotalValues = await client.getPositionAndTotalValuesForVault(vaultPubkey);
```
- Defined in src/client.ts:1437

Class VoltrClient

Remarks

Example

Hierarchy

Index

Constructors

Properties

Methods

Constructors

constructor

Parameters

Returns VoltrClient

Properties

conn

provider

vaultIdl

vaultProgram

Methods

calculateAssetsForWithdraw

Parameters

Returns Promise<BN>

Throws

Throws

Example

calculateAssetsForWithdrawHelper

Parameters

Returns BN

calculateLockedProfit

Parameters

Returns BN

calculateLpForDeposit

Parameters

Returns Promise<BN>

Throws

Example

calculateLpForWithdraw

Parameters

Returns Promise<BN>

Throws

Throws

Example

createAddAdaptorIx

Parameters

OptionaladaptorProgram?: PublicKey

admin: PublicKey

payer: PublicKey

vault: PublicKey

Returns Promise<TransactionInstruction>

Throws

Example

createCalibrateHighWaterMarkIx

Parameters

admin: PublicKey

vault: PublicKey

Returns Promise<TransactionInstruction>

Throws

Example

createCancelRequestWithdrawVaultIx

Parameters

userTransferAuthority: PublicKey

vault: PublicKey

Returns Promise<TransactionInstruction>

Throws

Example

createCloseStrategyIx

Parameters

manager: PublicKey

payer: PublicKey

strategy: PublicKey

vault: PublicKey

Returns Promise<TransactionInstruction>

Throws

Example

createCreateLpMetadataIx

Parameters

name: string

symbol: string

uri: string

admin: PublicKey

payer: PublicKey

`Optional`adaptorProgram?: PublicKey

`Optional`additionalArgs?: null | Buffer<ArrayBufferLike>

`Optional`instructionDiscriminator?: null | Buffer<ArrayBufferLike>

`Optional`adaptorProgram?: PublicKey

`Optional`userArgs?: null | Buffer<ArrayBufferLike>

`Optional`adaptorProgram?: PublicKey

`Optional`additionalArgs?: null | Buffer<ArrayBufferLike>

`Optional`allowUserArgs?: boolean

`Optional`instructionDiscriminator?: null | Buffer<ArrayBufferLike>

`Optional`adaptorProgram?: PublicKey

`Optional`additionalArgs?: null | Buffer<ArrayBufferLike>

`Optional`instructionDiscriminator?: null | Buffer<ArrayBufferLike>

`Optional`adaptorProgram?: PublicKey