@voltr/vault-sdk 0.1.1

package/dist/client.d.ts

@@ -0,0 +1,563 @@
+import { Program, AnchorProvider, Idl, BN } from "@coral-xyz/anchor";
+import { Connection, Keypair, PublicKey, TransactionInstruction } from "@solana/web3.js";
+import { VaultParams, VoltrVault, InitializeStrategyArgs, DepositStrategyArgs, WithdrawStrategyArgs } from "./types";
+declare class AccountUtils {
+    conn: Connection;
+    constructor(conn: Connection);
+    /**
+     * Gets the balance of a Solana account
+     * @param publicKey - Public key to check balance for
+     * @returns Promise resolving to the account balance in lamports
+     * @throws {Error} If fetching balance fails
+     */
+    getBalance(publicKey: PublicKey): Promise<number>;
+}
+/**
+ * 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
+ * ```typescript
+ * 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);
+ * ```
+ */
+export declare class VoltrClient extends AccountUtils {
+    provider: AnchorProvider;
+    vaultProgram: Program<VoltrVault>;
+    vaultIdl: Idl;
+    /**
+     * Creates a new VoltrClient instance
+     * @param conn - Solana connection instance
+     * @param wallet - Optional keypair for signing transactions
+     */
+    constructor(conn: Connection, wallet?: Keypair);
+    private setProvider;
+    private setPrograms;
+    /**
+     * Finds the vault LP mint address for a given vault
+     * @param vault - Public key of the vault
+     * @returns The PDA for the vault's LP mint
+     */
+    findVaultLpMint(vault: PublicKey): PublicKey;
+    /**
+     * Finds the vault's asset idle authority address
+     * @param vault - Public key of the vault
+     * @returns The PDA for the vault's asset idle authority
+     */
+    findVaultAssetIdleAuth(vault: PublicKey): PublicKey;
+    /**
+     * Finds the vault's LP fee authority address
+     * @param vault - Public key of the vault
+     * @returns The PDA for the vault's LP fee authority
+     *
+     * @example
+     * ```typescript
+     * const feeAuth = client.findVaultLpFeeAuth(vaultPubkey);
+     * ```
+     */
+    findVaultLpFeeAuth(vault: PublicKey): PublicKey;
+    /**
+     * Finds all vault-related addresses
+     * @param vault - Public key of the vault
+     * @returns Object containing all vault-related PDAs
+     *
+     * @example
+     * ```typescript
+     * const addresses = client.findVaultAddresses(vaultPubkey);
+     * console.log(addresses.vaultLpMint.toBase58());
+     * console.log(addresses.vaultAssetIdleAuth.toBase58());
+     * console.log(addresses.vaultLpFeeAuth.toBase58());
+     * ```
+     */
+    findVaultAddresses(vault: PublicKey): {
+        vaultLpMint: PublicKey;
+        vaultAssetIdleAuth: PublicKey;
+        vaultLpFeeAuth: PublicKey;
+    };
+    /**
+     * Finds the vault strategy auth address
+     * @param vault - Public key of the vault
+     * @param strategy - Public key of the strategy
+     * @returns The PDA for the vault strategy auth
+     *
+     * @example
+     * ```typescript
+     * const vaultStrategyAuth = client.findVaultStrategyAuth(vaultPubkey, strategyPubkey);
+     * ```
+     */
+    findVaultStrategyAuth(vault: PublicKey, strategy: PublicKey): PublicKey;
+    /**
+     * Finds the strategy init receipt address
+     * @param vault - Public key of the vault
+     * @param strategy - Public key of the strategy
+     * @returns The PDA for the strategy init receipt
+     *
+     * @example
+     * ```typescript
+     * const strategyInitReceipt = client.findStrategyInitReceipt(vaultPubkey, strategyPubkey);
+     * ```
+     */
+    findStrategyInitReceipt(vault: PublicKey, strategy: PublicKey): PublicKey;
+    /**
+     * Creates an instruction to initialize a new vault
+     *
+     * @param {VaultParams} vaultParams - Configuration parameters for the vault
+     * @param {VaultConfig} vaultParams.config - Vault configuration settings
+     * @param {BN} vaultParams.config.maxCap - Maximum capacity of the vault
+     * @param {BN} vaultParams.config.startAtTs - Vault start timestamp in seconds
+     * @param {number} vaultParams.config.managerManagementFee - Manager's management fee in basis points (e.g., 50 = 0.5%)
+     * @param {number} vaultParams.config.managerPerformanceFee - Manager's performance fee in basis points (e.g., 1000 = 10%)
+     * @param {number} vaultParams.config.adminManagementFee - Admin's management fee in basis points (e.g., 50 = 0.5%)
+     * @param {number} vaultParams.config.adminPerformanceFee - Admin's performance fee in basis points (e.g., 1000 = 10%)
+     * @param {string} vaultParams.name - Name of the vault
+     * @param {string} vaultParams.description - Description of the vault
+     * @param {Object} params - Additional parameters for initializing the vault
+     * @param {Keypair} params.vault - Keypair for the new vault
+     * @param {PublicKey} params.vaultAssetMint - Public key of the vault's asset mint
+     * @param {PublicKey} params.admin - Public key of the vault admin
+     * @param {PublicKey} params.manager - Public key of the vault manager
+     * @param {PublicKey} params.payer - Public key of the fee payer
+     * @returns {Promise<TransactionInstruction>} Transaction instruction for initializing the vault
+     *
+     * @example
+     * ```typescript
+     * const ix = await client.createInitializeVaultIx(
+     *   {
+     *     config: {
+     *       maxCap: new BN('1000000000'),
+     *       startAtTs: new BN(Math.floor(Date.now() / 1000)),
+     *       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
+     *   }
+     * );
+     * ```
+     */
+    createInitializeVaultIx(vaultParams: VaultParams, { vault, vaultAssetMint, admin, manager, payer, }: {
+        vault: Keypair;
+        vaultAssetMint: PublicKey;
+        admin: PublicKey;
+        manager: PublicKey;
+        payer: PublicKey;
+    }): Promise<TransactionInstruction>;
+    /**
+     * Creates a deposit instruction
+     *
+     * @param {BN} amount - Amount of tokens to deposit
+     * @param {Object} params - Deposit parameters
+     * @param {PublicKey} params.userAuthority - Public key of the user's transfer authority
+     * @param {PublicKey} params.vault - Public key of the vault
+     * @param {PublicKey} params.vaultAssetMint - Public key of the vault asset mint
+     * @param {PublicKey} params.assetTokenProgram - Public key of the asset token program
+     * @returns {Promise<TransactionInstruction>} Transaction instruction for depositing tokens
+     * @throws {Error} If instruction creation fails
+     *
+     * @example
+     * ```typescript
+     * const ix = await client.createDepositIx(
+     *   new BN('1000000000'),
+     *   {
+     *     userAuthority: userPubkey,
+     *     vault: vaultPubkey,
+     *     vaultAssetMint: mintPubkey,
+     *     assetTokenProgram: tokenProgramPubkey
+     *   }
+     * );
+     * ```
+     */
+    createDepositIx(amount: BN, { userAuthority, vault, vaultAssetMint, assetTokenProgram, }: {
+        userAuthority: PublicKey;
+        vault: PublicKey;
+        vaultAssetMint: PublicKey;
+        assetTokenProgram: PublicKey;
+    }): Promise<TransactionInstruction>;
+    /**
+     * Creates a withdraw instruction
+     *
+     * @param amount - Amount of LP tokens to withdraw
+     * @param {Object} params - Withdraw parameters
+     * @param {PublicKey} params.userAuthority - Public key of the user authority
+     * @param {PublicKey} params.vault - Public key of the vault
+     * @param {PublicKey} params.vaultAssetMint - Public key of the vault asset mint
+     * @param {PublicKey} params.assetTokenProgram - Public key of the asset token program
+     * @returns {Promise<TransactionInstruction>} Transaction instruction for withdrawal
+     *
+     * @throws {Error} If the instruction creation fails
+     *
+     * @example
+     * const ix = await client.createWithdrawIx(
+     *   new BN('1000000000'),
+     *   {
+     *     userAuthority: userPubkey,
+     *     vault: vaultPubkey,
+     *     vaultAssetMint: mintPubkey,
+     *     assetTokenProgram: tokenProgramPubkey
+     *   }
+     * );
+     */
+    createWithdrawIx(amount: BN, { userAuthority, vault, vaultAssetMint, assetTokenProgram, }: {
+        userAuthority: PublicKey;
+        vault: PublicKey;
+        vaultAssetMint: PublicKey;
+        assetTokenProgram: PublicKey;
+    }): Promise<TransactionInstruction>;
+    /**
+     * Creates an instruction to add an adaptor to a vault
+     * @param {Object} params - Parameters for adding adaptor to vault
+     * @param {PublicKey} params.vault - Public key of the vault
+     * @param {PublicKey} params.payer - Public key of the payer
+     * @param {PublicKey} params.adaptorProgram - Public key of the adaptor program
+     * @returns {Promise<TransactionInstruction>} Transaction instruction for adding adaptor to vault
+     *
+     * @throws {Error} If the instruction creation fails
+     *
+     * @example
+     * ```typescript
+     * const ix = await client.createAddAdaptorIx({
+     *   vault: vaultPubkey,
+     *   payer: payerPubkey,
+     *   adaptorProgram: adaptorProgramPubkey
+     * });
+     * ```
+     */
+    createAddAdaptorIx({ vault, payer, adaptorProgram, }: {
+        vault: PublicKey;
+        payer: PublicKey;
+        adaptorProgram?: PublicKey;
+    }): Promise<TransactionInstruction>;
+    /**
+     * Creates an instruction to initialize a strategy to a vault
+     * @param {InitializeStrategyArgs} initArgs - Arguments for strategy initialization
+     * @param {Buffer | null} [initArgs.instructionDiscriminator] - Optional discriminator for the instruction
+     * @param {Buffer | null} [initArgs.additionalArgs] - Optional additional arguments for the instruction
+     * @param {Object} params - Parameters for initializing strategy to vault
+     * @param {PublicKey} params.payer - Public key of the payer
+     * @param {PublicKey} params.vault - Public key of the vault
+     * @param {PublicKey} params.manager - Public key of the manager
+     * @param {PublicKey} params.strategy - Public key of the strategy
+     * @param {PublicKey} params.adaptorProgram - Public key of the adaptor program
+     * @returns {Promise<TransactionInstruction>} Transaction instruction for initializing strategy to vault
+     * @throws {Error} If the instruction creation fails
+     *
+     * @example
+     * ```typescript
+     * const ix = await client.createInitializeStrategyIx(
+     *   {
+     *     instructionDiscriminator: Buffer.from('...'), // optional
+     *     additionalArgs: Buffer.from('...')           // optional
+     *   },
+     *   {
+     *     payer: payerPubkey,
+     *     vault: vaultPubkey,
+     *     manager: managerPubkey,
+     *     strategy: strategyPubkey,
+     *     adaptorProgram: adaptorProgramPubkey
+     *   }
+     * );
+     * ```
+     */
+    createInitializeStrategyIx({ instructionDiscriminator, additionalArgs, }: InitializeStrategyArgs, { payer, vault, manager, strategy, adaptorProgram, }: {
+        payer: PublicKey;
+        vault: PublicKey;
+        manager: PublicKey;
+        strategy: PublicKey;
+        adaptorProgram?: PublicKey;
+    }): Promise<TransactionInstruction>;
+    /**
+     * Creates an instruction to deposit assets into a strategy
+     *
+     * @param {Object} depositArgs - Deposit arguments
+     * @param {BN} depositArgs.depositAmount - Amount of assets to deposit
+     * @param {Buffer | null} [depositArgs.instructionDiscriminator] - Optional discriminator for the instruction
+     * @param {Buffer | null} [depositArgs.additionalArgs] - Optional additional arguments for the instruction
+     * @param {Object} params - Strategy deposit parameters
+     * @param {PublicKey} params.vault - Public key of the vault
+     * @param {PublicKey} params.vaultAssetMint - Public key of the vault asset mint
+     * @param {PublicKey} params.strategy - Public key of the strategy
+     * @param {PublicKey} params.assetTokenProgram - Public key of the asset token program
+     * @param {PublicKey} params.adaptorProgram - Public key of the adaptor program
+     * @param {Array<{ pubkey: PublicKey, isSigner: boolean, isWritable: boolean }>} params.remainingAccounts - Remaining accounts for the instruction
+     * @returns {Promise<TransactionInstruction>} Transaction instruction for depositing assets into strategy
+     * @throws {Error} If the instruction creation fails
+     *
+     * @example
+     * ```typescript
+     * const ix = await client.createDepositStrategyIx(
+     *   {
+     *     depositAmount: new BN('1000000000'),
+     *     instructionDiscriminator: Buffer.from('...'),
+     *     additionalArgs: Buffer.from('...')
+     *   },
+     *   {
+     *     vault: vaultPubkey,
+     *     vaultAssetMint: mintPubkey,
+     *     strategy: strategyPubkey,
+     *     assetTokenProgram: tokenProgramPubkey,
+     *     adaptorProgram: adaptorProgramPubkey,
+     *     remainingAccounts: []
+     *   }
+     * );
+     * ```
+     */
+    createDepositStrategyIx({ depositAmount, instructionDiscriminator, additionalArgs, }: DepositStrategyArgs, { vault, vaultAssetMint, strategy, assetTokenProgram, adaptorProgram, remainingAccounts, }: {
+        vault: PublicKey;
+        vaultAssetMint: PublicKey;
+        strategy: PublicKey;
+        assetTokenProgram: PublicKey;
+        adaptorProgram?: PublicKey;
+        remainingAccounts: Array<{
+            pubkey: PublicKey;
+            isSigner: boolean;
+            isWritable: boolean;
+        }>;
+    }): Promise<TransactionInstruction>;
+    /**
+     * Creates an instruction to withdraw assets from a strategy
+     *
+     * @param {Object} withdrawArgs - Withdrawal arguments
+     * @param {BN} withdrawArgs.withdrawAmount - Amount of assets to withdraw
+     * @param {Buffer | null} [withdrawArgs.instructionDiscriminator] - Optional discriminator for the instruction
+     * @param {Buffer | null} [withdrawArgs.additionalArgs] - Optional additional arguments for the instruction
+     * @param {Object} params - Strategy withdrawal parameters
+     * @param {PublicKey} params.vault - Public key of the vault
+     * @param {PublicKey} params.vaultAssetMint - Public key of the vault asset mint
+     * @param {PublicKey} params.strategy - Public key of the strategy
+     * @param {PublicKey} params.assetTokenProgram - Public key of the asset token program
+     * @param {PublicKey} params.adaptorProgram - Public key of the adaptor program
+     * @param {Array<{ pubkey: PublicKey, isSigner: boolean, isWritable: boolean }>} params.remainingAccounts - Remaining accounts for the instruction
+     * @returns {Promise<TransactionInstruction>} Transaction instruction for withdrawing assets from strategy
+     * @throws {Error} If the instruction creation fails
+     *
+     * @example
+     * ```typescript
+     * 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: []
+     *   }
+     * );
+     * ```
+     */
+    createWithdrawStrategyIx({ withdrawAmount, instructionDiscriminator, additionalArgs, }: WithdrawStrategyArgs, { vault, vaultAssetMint, strategy, assetTokenProgram, adaptorProgram, remainingAccounts, }: {
+        vault: PublicKey;
+        vaultAssetMint: PublicKey;
+        strategy: PublicKey;
+        assetTokenProgram: PublicKey;
+        adaptorProgram?: PublicKey;
+        remainingAccounts: Array<{
+            pubkey: PublicKey;
+            isSigner: boolean;
+            isWritable: boolean;
+        }>;
+    }): Promise<TransactionInstruction>;
+    /**
+     * Creates an instruction to remove a strategy from a vault
+     * @param {Object} params - Parameters for removing strategy
+     * @param {PublicKey} params.vault - Public key of the vault
+     * @param {PublicKey} params.adaptorProgram - Public key of the adaptor program
+     * @returns {Promise<TransactionInstruction>} Transaction instruction for removing strategy from vault
+     * @throws {Error} If instruction creation fails
+     *
+     * @example
+     * ```typescript
+     * const ix = await client.createRemoveStrategyIx({
+     *   vault: vaultPubkey,
+     *   adaptorProgram: adaptorProgramPubkey
+     * });
+     * ```
+     */
+    createRemoveStrategyIx({ vault, adaptorProgram, }: {
+        vault: PublicKey;
+        adaptorProgram?: PublicKey;
+    }): Promise<TransactionInstruction>;
+    /**
+     * Fetches all strategy init receipt accounts
+     * @returns Promise resolving to an array of strategy init receipt accounts
+     *
+     * @example
+     * ```typescript
+     * const strategyInitReceiptAccounts = await client.fetchAllStrategyInitReceiptAccounts();
+     * ```
+     */
+    fetchAllStrategyInitReceiptAccounts(): Promise<import("@coral-xyz/anchor").ProgramAccount<{
+        vault: PublicKey;
+        strategy: PublicKey;
+        positionValue: BN;
+        lastUpdatedTs: BN;
+        version: number;
+        bump: number;
+        vaultStrategyAuthBump: number;
+        padding0: number[];
+        reserved: number[];
+    }>[]>;
+    /**
+     * Fetches all strategy init receipt accounts of a vault
+     * @param vault - Public key of the vault
+     * @returns Promise resolving to an array of strategy init receipt accounts
+     *
+     * @example
+     * ```typescript
+     * const strategyInitReceiptAccounts = await client.fetchAllStrategyInitReceiptAccountsOfVault(vaultPubkey);
+     * ```
+     */
+    fetchAllStrategyInitReceiptAccountsOfVault(vault: PublicKey): Promise<import("@coral-xyz/anchor").ProgramAccount<{
+        vault: PublicKey;
+        strategy: PublicKey;
+        positionValue: BN;
+        lastUpdatedTs: BN;
+        version: number;
+        bump: number;
+        vaultStrategyAuthBump: number;
+        padding0: number[];
+        reserved: number[];
+    }>[]>;
+    /**
+     * Fetches all adaptor add receipt accounts of a vault
+     * @param vault - Public key of the vault
+     * @returns Promise resolving to an array of adaptor add receipt accounts
+     *
+     * @example
+     * ```typescript
+     * const adaptorAddReceiptAccounts = await client.fetchAllAdaptorAddReceiptAccountsOfVault(vaultPubkey);
+     * ```
+     */
+    fetchAllAdaptorAddReceiptAccountsOfVault(vault: PublicKey): Promise<import("@coral-xyz/anchor").ProgramAccount<{
+        vault: PublicKey;
+        adaptorProgram: PublicKey;
+        version: number;
+        bump: number;
+        padding0: number[];
+        reserved: number[];
+    }>[]>;
+    getPositionAndTotalValuesForVault(vault: PublicKey): Promise<{
+        totalValue: any;
+        strategies: {
+            strategyId: string;
+            amount: any;
+        }[];
+    }>;
+    /**
+     * Fetches a vault account's data
+     * @param vault - Public key of the vault
+     * @returns Promise resolving to the vault account data
+     */
+    fetchVaultAccount(vault: PublicKey): Promise<{
+        name: number[];
+        description: number[];
+        asset: any;
+        lp: any;
+        manager: PublicKey;
+        admin: PublicKey;
+        vaultConfiguration: any;
+        feeConfiguration: any;
+        lastUpdatedTs: BN;
+        version: number;
+        padding0: number[];
+        reserved: number[];
+    }>;
+    /**
+     * Fetches a strategy init receipt account's data
+     * @param strategyInitReceipt - Public key of the strategy init receipt account
+     * @returns Promise resolving to the strategy init receipt account data
+     *
+     * @example
+     * ```typescript
+     * const strategyInitReceiptAccount = await client.fetchStrategyInitReceiptAccount(strategyInitReceiptPubkey);
+     * ```
+     */
+    fetchStrategyInitReceiptAccount(strategyInitReceipt: PublicKey): Promise<{
+        vault: PublicKey;
+        strategy: PublicKey;
+        positionValue: BN;
+        lastUpdatedTs: BN;
+        version: number;
+        bump: number;
+        vaultStrategyAuthBump: number;
+        padding0: number[];
+        reserved: number[];
+    }>;
+    /**
+     * Fetches an adaptor add receipt account's data
+     * @param adaptorAddReceipt - Public key of the adaptor add receipt account
+     * @returns Promise resolving to the adaptor add receipt account data
+     *
+     * @example
+     * ```typescript
+     * const adaptorAddReceiptAccount = await client.fetchAdaptorAddReceiptAccount(adaptorAddReceiptPubkey);
+     * ```
+     */
+    fetchAdaptorAddReceiptAccount(adaptorAddReceipt: PublicKey): Promise<{
+        vault: PublicKey;
+        adaptorProgram: PublicKey;
+        version: number;
+        bump: number;
+        padding0: number[];
+        reserved: number[];
+    }>;
+    /**
+     * Calculates the amount of assets that would be received for a given LP token amount
+     *
+     * @param vaultPk - Public key of the vault
+     * @param lpAmount - Amount of LP tokens to calculate for
+     * @returns Promise resolving to the amount of assets that would be received
+     *
+     * @throws {Error} If LP supply or total assets are invalid
+     * @throws {Error} If math overflow occurs during calculation
+     *
+     * @example
+     * ```typescript
+     * const assetsToReceive = await client.calculateAssetsForWithdraw(
+     *   vaultPubkey,
+     *   new BN('1000000000')
+     * );
+     * ```
+     */
+    calculateAssetsForWithdraw(vaultPk: PublicKey, lpAmount: BN): Promise<BN>;
+    /**
+     * Calculates the amount of LP tokens that would be received for a given asset deposit
+     *
+     * @param depositAmount - Amount of assets to deposit
+     * @param vaultPk - Public key of the vault
+     * @returns Promise resolving to the amount of LP tokens that would be received
+     *
+     * @throws {Error} If math overflow occurs during calculation
+     *
+     * @example
+     * ```typescript
+     * const lpTokens = await client.calculateLpTokensForDeposit(
+     *   new BN('1000000000'),
+     *   vaultPubkey
+     * );
+     * ```
+     */
+    calculateLpTokensForDeposit(depositAmount: BN, vaultPk: PublicKey): Promise<BN>;
+}
+export {};