@augustdigital/sdk 6.0.1 → 7.0.1

package/lib/adapters/evm/getters.d.ts

@@ -1,4 +1,4 @@
 import { ITokenizedVault } from '../../types';
-import { IVaultBaseOptions } from '../../modules/vaults';
+import { IVaultBaseOptions } from '../../modules/vaults/types';
 export declare const getEvmVaultV1: (tokenizedVault: ITokenizedVault, options: IVaultBaseOptions) => Promise<import("../../types").IVault>;
 export declare const getEvmVaultV2: (tokenizedVault: ITokenizedVault, options: IVaultBaseOptions) => Promise<import("../../types").IVault>;

package/lib/adapters/evm/getters.js

@@ -6,7 +6,6 @@ const core_1 = require("../../core");
 const utils_1 = require("../../modules/vaults/utils");
 const TokenizedVaultV2_1 = require("../../abis/TokenizedVaultV2");
 const TokenizedVaultV2Receipt_1 = require("../../abis/TokenizedVaultV2Receipt");
-const TokenizedVaultV2WhitelistedAssets_1 = require("../../abis/TokenizedVaultV2WhitelistedAssets");
 const getEvmVaultV1 = async (tokenizedVault, options) => {
     const vault = tokenizedVault.address;
     if (!vault) {
@@ -109,29 +108,25 @@ const getEvmVaultV2 = async (tokenizedVault, options) => {
         return vaultContract[f]();
     }));
     const receiptAddress = vaultContractCalls[core_1.VAULT_FUNCTIONS_V2.length - 1];
+    const whitelistedAssetsAddress = vaultContractCalls[0];
     const reciptContract = (0, core_1.createContract)({
         address: receiptAddress,
         abi: TokenizedVaultV2Receipt_1.ABI_TOKENIZED_VAULT_V2_RECEIPT,
         provider,
     });
-    const receiptContractCalls = await Promise.all(core_1.VAULT_FUNCTIONS_V2_RECEIPT.map((f) => {
-        if (f === 'symbol') {
-            return (0, core_1.getSymbol)(provider, receiptAddress, false);
-        }
-        if (f === 'decimals') {
-            return (0, core_1.getDecimals)(provider, receiptAddress, false);
-        }
-        return reciptContract[f]();
-    }));
-    const whitelistedAssetsAddress = vaultContractCalls[0];
-    const whitelistedAssetsContract = (0, core_1.createContract)({
-        address: whitelistedAssetsAddress,
-        abi: TokenizedVaultV2WhitelistedAssets_1.ABI_TOKENIZED_VAULT_V2_WHITELISTED_ASSETS,
-        provider,
-    });
-    const whitelistedAssetsContractCalls = await Promise.all(core_1.VAULT_FUNCTIONS_V2_WHITELISTED_ASSETS.map((f) => {
-        return whitelistedAssetsContract[f]();
-    }));
+    const [receiptContractCalls, whitelistedList] = await Promise.all([
+        Promise.all(core_1.VAULT_FUNCTIONS_V2_RECEIPT.map((f) => {
+            if (f === 'symbol') {
+                return (0, core_1.getSymbol)(provider, receiptAddress, false);
+            }
+            if (f === 'decimals') {
+                return (0, core_1.getDecimals)(provider, receiptAddress, false);
+            }
+            return reciptContract[f]();
+        })),
+        (0, core_1.getWhitelistedAssets)(provider, whitelistedAssetsAddress),
+    ]);
+    const whitelistedAssetsContractCalls = [whitelistedList];
     const combinedCalls = [
         ...vaultContractCalls,
         ...receiptContractCalls,

package/lib/adapters/evm/index.d.ts

@@ -1,4 +1,5 @@
-import { IContractWriteOptions, INativeDepositOptions } from '../../modules/vaults/write.actions';
+import { IContractWriteOptions, INativeDepositOptions, ApproveResult } from '../../modules/vaults/write.actions';
+import { IPreviewDepositOptions, IPreviewRedeemOptions, IAllowanceOptions, IBalanceOfOptions, IMaxDepositOptions } from '../../modules/vaults/read.actions';
 import { CompatibleSigner } from '../../core/helpers/signer';
 import { IAddress } from '../../types';
 export * from './getters';
@@ -9,6 +10,7 @@ declare class EVMAdapter {
     setSigner(signer: CompatibleSigner): void;
     private getSigner;
     vaultApprove(options: IContractWriteOptions): Promise<string>;
+    approve(options: IContractWriteOptions): Promise<ApproveResult>;
     vaultAllowance(options: IContractWriteOptions): Promise<import("../../types").INormalizedNumber>;
     vaultDeposit(options: IContractWriteOptions): Promise<string>;
     vaultRequestRedeem(options: IContractWriteOptions): Promise<string>;
@@ -37,5 +39,10 @@ declare class EVMAdapter {
         vault: IAddress;
         depositCapAmount?: bigint;
     }): Promise<import("../../types").INormalizedNumber>;
+    previewDeposit(options: IPreviewDepositOptions): Promise<bigint>;
+    previewRedeem(options: IPreviewRedeemOptions): Promise<bigint>;
+    allowance(options: IAllowanceOptions): Promise<bigint>;
+    balanceOf(options: IBalanceOfOptions): Promise<bigint>;
+    maxDeposit(options: IMaxDepositOptions): Promise<bigint>;
 }
 export default EVMAdapter;

package/lib/adapters/evm/index.js

@@ -40,6 +40,10 @@ class EVMAdapter {
         const signer = await this.getSigner();
         return (0, write_actions_1.vaultApprove)(signer, options);
     }
+    async approve(options) {
+        const signer = await this.getSigner();
+        return (0, write_actions_1.approve)(signer, options);
+    }
     async vaultAllowance(options) {
         const signer = await this.getSigner();
         return (0, read_actions_1.vaultAllowance)(signer, options);
@@ -76,6 +80,26 @@ class EVMAdapter {
         const signer = await this.getSigner();
         return (0, read_actions_1.getRemainingAllocations)(signer, options);
     }
+    async previewDeposit(options) {
+        const signer = await this.getSigner();
+        return (0, read_actions_1.previewDeposit)(signer, options);
+    }
+    async previewRedeem(options) {
+        const signer = await this.getSigner();
+        return (0, read_actions_1.previewRedeem)(signer, options);
+    }
+    async allowance(options) {
+        const signer = await this.getSigner();
+        return (0, read_actions_1.allowance)(signer, options);
+    }
+    async balanceOf(options) {
+        const signer = await this.getSigner();
+        return (0, read_actions_1.balanceOf)(signer, options);
+    }
+    async maxDeposit(options) {
+        const signer = await this.getSigner();
+        return (0, read_actions_1.maxDeposit)(signer, options);
+    }
 }
 exports.default = EVMAdapter;
 //# sourceMappingURL=index.js.map

package/lib/adapters/solana/index.d.ts

@@ -11,7 +11,7 @@ export declare const Solana: {
             signature: string;
             type: "tx" | "address" | "token";
         } & import("./types").ISolanaConnectionOptions) => string;
-        isSolanaAddress: (address: string) => boolean;
+        isSolanaAddress: typeof import("./utils").isSolanaAddress;
         isSolana: (signature: string) => boolean;
         getProgram: ({ provider, idl, programId, network, }: {
             idl: any;
@@ -68,7 +68,7 @@ export declare const Solana: {
             amount: string;
             decimals: number | null;
         }>;
-        getBestRpcEndpoint: ({ endpoint, network, connection, }: import("./types").ISolanaConnectionOptions) => Promise<`https://${string}` | "http://127.0.0.1:8899">;
+        getBestRpcEndpoint: ({ endpoint, network, connection, }: import("./types").ISolanaConnectionOptions) => Promise<"http://127.0.0.1:8899" | `https://${string}`>;
         fallbackDecimals: number;
         fallbackNetwork: import("../..").ISolanaNetwork;
         programIds: {
@@ -136,8 +136,8 @@ declare class SolanaAdapter {
         amount: string;
         decimals: number | null;
     }>;
-    vaultDeposit(vaultProgramId: PublicKey | string, idl: any, publicKey: PublicKey | string, depositAmount: number, sendTransaction: (transaction: Transaction | web3.VersionedTransaction, connection: Connection, options?: SendTransactionOptions) => Promise<web3.TransactionSignature>, vaultAddress?: PublicKey | string): Promise<any>;
-    vaultRedeem(vaultProgramId: PublicKey | string, idl: any, publicKey: PublicKey | string, redeemShares: number, sendTransaction: (transaction: Transaction | web3.VersionedTransaction, connection: Connection, options?: SendTransactionOptions) => Promise<web3.TransactionSignature>, vaultAddress?: PublicKey | string): Promise<any>;
+    vaultDeposit(vaultProgramId: PublicKey | string, idl: any, publicKey: PublicKey | string, depositAmount: number | bigint, sendTransaction: (transaction: Transaction | web3.VersionedTransaction, connection: Connection, options?: SendTransactionOptions) => Promise<web3.TransactionSignature>, vaultAddress?: PublicKey | string): Promise<any>;
+    vaultRedeem(vaultProgramId: PublicKey | string, idl: any, publicKey: PublicKey | string, redeemShares: number | bigint, sendTransaction: (transaction: Transaction | web3.VersionedTransaction, connection: Connection, options?: SendTransactionOptions) => Promise<web3.TransactionSignature>, vaultAddress?: PublicKey | string): Promise<any>;
     getProgramId(type: 'vault'): string;
 }
 export default SolanaAdapter;

package/lib/adapters/solana/utils.d.ts

@@ -1,17 +1,18 @@
-import { AnchorProvider, Program, web3 } from '@coral-xyz/anchor';
+import { AnchorProvider, BN, Program, web3 } from '@coral-xyz/anchor';
 import { PublicKey, Transaction } from '@solana/web3.js';
 import { ISolanaConnectionOptions, ISolanaVaultState } from './types';
 declare function getExplorerLink({ signature, type, network, }: {
     signature: string;
     type: 'tx' | 'address' | 'token';
 } & ISolanaConnectionOptions): string;
-declare function isSolanaAddress(address: string): boolean;
+import { isSolanaAddress } from '../../core/helpers/chain-address';
+export { isSolanaAddress };
 declare function isSolana(signature: string): boolean;
 declare function getProgram({ provider, idl, programId, network, }: {
     idl: any;
     programId?: string;
 } & ISolanaConnectionOptions): Program<any>;
-declare function getBestRpcEndpoint({ endpoint, network, connection, }: ISolanaConnectionOptions): Promise<`https://${string}` | "http://127.0.0.1:8899">;
+declare function getBestRpcEndpoint({ endpoint, network, connection, }: ISolanaConnectionOptions): Promise<"http://127.0.0.1:8899" | `https://${string}`>;
 declare function getProvider({ connection, publicKey, signTransaction, }: {
     publicKey: PublicKey;
     signTransaction: (<T extends Transaction | web3.VersionedTransaction>(transaction: T) => Promise<T>) | undefined;
@@ -75,6 +76,7 @@ declare function fetchUserShareBalanceRaw({ connection, publicKey, shareMint, }:
 declare function resolveProgramId(vaultAddress: string, solanaMetadata?: {
     program_id?: string;
 } | null): string;
+export declare function uiAmountToRawBn(uiAmount: number, decimals: number): BN;
 export declare const SolanaUtils: {
     getExplorerLink: typeof getExplorerLink;
     isSolanaAddress: typeof isSolanaAddress;
@@ -112,4 +114,3 @@ export declare const SolanaUtils: {
     getVaultMints: typeof getVaultMints;
     resolveProgramId: typeof resolveProgramId;
 };
-export {};

package/lib/adapters/solana/utils.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SolanaUtils = void 0;
+exports.SolanaUtils = exports.isSolanaAddress = void 0;
+exports.uiAmountToRawBn = uiAmountToRawBn;
 const anchor_1 = require("@coral-xyz/anchor");
 const web3_js_1 = require("@solana/web3.js");
 const ethers_1 = require("ethers");
@@ -10,25 +11,14 @@ function getExplorerLink({ signature, type = 'tx', network = constants_1.fallbac
     const baseUrl = 'https://solscan.io';
     return `${baseUrl}/${type}/${signature}?cluster=${network}`;
 }
-function isSolanaAddress(address) {
-    if (!address)
-        return false;
-    if ((0, ethers_1.isAddress)(address))
-        return false;
-    try {
-        new web3_js_1.PublicKey(address);
-        return true;
-    }
-    catch (_e) {
-        return false;
-    }
-}
+const chain_address_1 = require("../../core/helpers/chain-address");
+Object.defineProperty(exports, "isSolanaAddress", { enumerable: true, get: function () { return chain_address_1.isSolanaAddress; } });
 function isSolana(signature) {
     if (!signature || typeof signature !== 'string')
         return false;
     if ((0, ethers_1.isAddress)(signature))
         return false;
-    if (isSolanaAddress(signature))
+    if ((0, chain_address_1.isSolanaAddress)(signature))
         return false;
     const base58Chars = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
     const isValidBase58 = signature
@@ -67,12 +57,12 @@ async function getBestRpcEndpoint({ endpoint, network = constants_1.fallbackNetw
     if (primaryTest.success) {
         return primaryEndpoint;
     }
-    console.warn('⚠️ Primary RPC endpoint failed, using fallback:', fallbackEndpoint);
+    core_1.Logger.log.warn('getBestRpcEndpoint', '⚠️ Primary RPC endpoint failed, using fallback:', fallbackEndpoint);
     return fallbackEndpoint;
 }
 function getProvider({ connection, publicKey, signTransaction, }) {
     if (!publicKey || !signTransaction) {
-        throw new Error('Wallet not connected');
+        throw new core_1.AugustValidationError('INVALID_INPUT', 'Wallet not connected: publicKey and signTransaction are required for write operations');
     }
     return new anchor_1.AnchorProvider(connection, {
         publicKey,
@@ -87,10 +77,10 @@ function getReadOnlyProvider({ connection }) {
     const dummyWallet = {
         publicKey: web3_js_1.PublicKey.default,
         signTransaction: async (_tx) => {
-            throw new Error('Cannot sign transactions with read-only provider');
+            throw new core_1.AugustValidationError('INVALID_INPUT', 'Cannot sign transactions with read-only provider');
         },
         signAllTransactions: async (_txs) => {
-            throw new Error('Cannot sign transactions with read-only provider');
+            throw new core_1.AugustValidationError('INVALID_INPUT', 'Cannot sign transactions with read-only provider');
         },
     };
     return new anchor_1.AnchorProvider(connection, dummyWallet, {
@@ -99,21 +89,21 @@ function getReadOnlyProvider({ connection }) {
 }
 function deriveVaultStatePda(vaultProgramId) {
     if (!vaultProgramId)
-        throw new Error('Vault program ID missing');
+        throw new core_1.AugustValidationError('INVALID_INPUT', 'Vault program ID missing');
     const _vaultProgramId = new web3_js_1.PublicKey(vaultProgramId);
     const [pda] = web3_js_1.PublicKey.findProgramAddressSync([new TextEncoder().encode('VAULT_STATE')], _vaultProgramId);
     return pda;
 }
 function deriveShareMintPda(vaultProgramId) {
     if (!vaultProgramId)
-        throw new Error('Vault program ID missing');
+        throw new core_1.AugustValidationError('INVALID_INPUT', 'Vault program ID missing');
     const _vaultProgramId = new web3_js_1.PublicKey(vaultProgramId);
     const [pda] = web3_js_1.PublicKey.findProgramAddressSync([new TextEncoder().encode('mint')], _vaultProgramId);
     return pda;
 }
 function deriveVaultTokenAtaPda(vaultProgramId, depositMint, vaultVersion) {
     if (!(vaultProgramId && depositMint))
-        throw new Error('Vault program ID or deposit mint missing');
+        throw new core_1.AugustValidationError('INVALID_INPUT', 'Vault program ID or deposit mint missing');
     const _vaultProgramId = new web3_js_1.PublicKey(vaultProgramId);
     const seeds = [
         Buffer.from('token_vault'),
@@ -123,7 +113,7 @@ function deriveVaultTokenAtaPda(vaultProgramId, depositMint, vaultVersion) {
         if (!Number.isInteger(vaultVersion) ||
             vaultVersion < 0 ||
             vaultVersion > 255) {
-            throw new Error(`Invalid vault version ${vaultVersion}: must be an integer between 0 and 255`);
+            throw new core_1.AugustValidationError('INVALID_INPUT', `Invalid vault version ${vaultVersion}: must be an integer between 0 and 255`);
         }
         seeds.push(Buffer.from([vaultVersion]));
     }
@@ -141,7 +131,7 @@ async function getVaultState({ provider, connection, vaultProgramId, vaultAddres
         if (cachedData)
             return cachedData;
         if (!vaultProgramId) {
-            throw new Error('Please enter a vault program ID');
+            throw new core_1.AugustValidationError('INVALID_INPUT', 'Please enter a vault program ID');
         }
         const vaultStatePda = vaultAddress
             ? new web3_js_1.PublicKey(vaultAddress)
@@ -163,7 +153,9 @@ async function getVaultState({ provider, connection, vaultProgramId, vaultAddres
                 }
             }
             catch (mintError) {
-                console.error('Error fetching deposit mint decimals:', mintError);
+                core_1.Logger.log.error('getVaultState', mintError, {
+                    message: 'Error fetching deposit mint decimals',
+                });
             }
         }
         await (0, core_1.setSafeCache)(cacheKey, returnObj);
@@ -171,7 +163,9 @@ async function getVaultState({ provider, connection, vaultProgramId, vaultAddres
     }
     catch (e) {
         const error = e;
-        console.error('Error reading vault state:', error);
+        core_1.Logger.log.error('getVaultState', error, {
+            message: 'Error reading vault state',
+        });
         return returnObj;
     }
 }
@@ -186,7 +180,7 @@ async function getVaultStateReadOnly({ vaultProgramId, vaultAddress, connection,
         if (cachedData)
             return cachedData;
         if (!vaultProgramId) {
-            throw new Error('Please enter a vault program ID');
+            throw new core_1.AugustValidationError('INVALID_INPUT', 'Please enter a vault program ID');
         }
         const _vaultProgramId = new web3_js_1.PublicKey(vaultProgramId);
         const vaultStatePda = vaultAddress
@@ -194,7 +188,7 @@ async function getVaultStateReadOnly({ vaultProgramId, vaultAddress, connection,
             : deriveVaultStatePda(_vaultProgramId);
         const accountInfo = await connection.getAccountInfo(vaultStatePda);
         if (!accountInfo) {
-            console.warn('Vault state account not found');
+            core_1.Logger.log.warn('getVaultStateReadOnly', 'Vault state account not found');
             return returnObj;
         }
         try {
@@ -215,12 +209,16 @@ async function getVaultStateReadOnly({ vaultProgramId, vaultAddress, connection,
                     }
                 }
                 catch (mintError) {
-                    console.error('Error fetching deposit mint decimals:', mintError);
+                    core_1.Logger.log.error('getVaultStateReadOnly', mintError, {
+                        message: 'Error fetching deposit mint decimals',
+                    });
                 }
             }
         }
         catch (programError) {
-            console.error('Error creating program with read-only provider:', programError);
+            core_1.Logger.log.error('getVaultStateReadOnly', programError, {
+                message: 'Error creating program with read-only provider',
+            });
             returnObj.vaultState = null;
         }
         await (0, core_1.setSafeCache)(cacheKey, returnObj);
@@ -228,7 +226,9 @@ async function getVaultStateReadOnly({ vaultProgramId, vaultAddress, connection,
     }
     catch (e) {
         const error = e;
-        console.error('Error reading vault state:', error);
+        core_1.Logger.log.error('getVaultStateReadOnly', error, {
+            message: 'Error reading vault state',
+        });
         return returnObj;
     }
 }
@@ -239,7 +239,7 @@ async function getVaultMints({ vaultProgramId, vaultAddress, connection, idl, })
         if (cachedData)
             return cachedData;
         if (!vaultProgramId) {
-            throw new Error('Please enter a vault program ID');
+            throw new core_1.AugustValidationError('INVALID_INPUT', 'Please enter a vault program ID');
         }
         const _vaultProgramId = new web3_js_1.PublicKey(vaultProgramId);
         const vaultStatePda = vaultAddress
@@ -264,12 +264,19 @@ async function getVaultMints({ vaultProgramId, vaultAddress, connection, idl, })
     }
     catch (e) {
         const error = e;
-        console.error('Error reading vault mints:', error);
-        return {
-            depositMint: '',
-            shareMint: '',
-            vaultVersion: undefined,
-        };
+        const cause = error?.message || String(error);
+        core_1.Logger.log.error('getVaultMints', error, {
+            message: 'Error reading vault mints',
+            vaultProgramId: String(vaultProgramId),
+            vaultAddress: vaultAddress ? String(vaultAddress) : undefined,
+        });
+        throw new core_1.AugustSDKError('UNKNOWN', `Failed to read vault mints from on-chain state: ${cause}`, {
+            cause: error,
+            context: {
+                vaultProgramId: String(vaultProgramId),
+                vaultAddress: vaultAddress ? String(vaultAddress) : undefined,
+            },
+        });
     }
 }
 async function getToken({ mintAddress, endpoint, connection, }) {
@@ -349,13 +356,15 @@ async function getToken({ mintAddress, endpoint, connection, }) {
                 }
             }
             catch (vaultError) {
-                console.log('Not a vault program or error querying vault:', vaultError);
+                core_1.Logger.log.info('getToken', 'Not a vault program or error querying vault:', vaultError);
             }
         }
         return null;
     }
     catch (error) {
-        console.error('Error fetching token metadata:', error);
+        core_1.Logger.log.error('getToken', error, {
+            message: 'Error fetching token metadata',
+        });
         return null;
     }
 }
@@ -368,7 +377,9 @@ async function getTokenSymbol({ endpoint, mintAddress, }) {
         return null;
     }
     catch (error) {
-        console.error('Error fetching token symbol:', error);
+        core_1.Logger.log.error('getTokenSymbol', error, {
+            message: 'Error fetching token symbol',
+        });
         return null;
     }
 }
@@ -390,7 +401,9 @@ async function fetchUserTokenBalance({ connection, publicKey, depositMint, }) {
     }
     catch (e) {
         const error = e;
-        console.error('Error fetching user token balance:', error);
+        core_1.Logger.log.error('fetchUserTokenBalance', error, {
+            message: 'Error fetching user token balance',
+        });
         return '0';
     }
 }
@@ -412,7 +425,9 @@ async function fetchUserShareBalance({ connection, publicKey, shareMint, }) {
     }
     catch (e) {
         const error = e;
-        console.error('Error fetching user share balance:', error);
+        core_1.Logger.log.error('fetchUserShareBalance', error, {
+            message: 'Error fetching user share balance',
+        });
         return 0;
     }
 }
@@ -435,16 +450,38 @@ async function fetchUserShareBalanceRaw({ connection, publicKey, shareMint, }) {
     }
     catch (e) {
         const error = e;
-        console.error('Error fetching raw user share balance:', error);
+        core_1.Logger.log.error('fetchUserShareBalanceRaw', error, {
+            message: 'Error fetching raw user share balance',
+        });
         return { amount: '0', decimals: null };
     }
 }
 function resolveProgramId(vaultAddress, solanaMetadata) {
     return solanaMetadata?.program_id || vaultAddress;
 }
+function uiAmountToRawBn(uiAmount, decimals) {
+    if (!Number.isFinite(uiAmount)) {
+        throw new core_1.AugustValidationError('INVALID_INPUT', `uiAmountToRawBn: amount must be finite, got ${uiAmount}`);
+    }
+    if (uiAmount < 0) {
+        throw new core_1.AugustValidationError('INVALID_INPUT', `uiAmountToRawBn: amount must be non-negative, got ${uiAmount}`);
+    }
+    if (!Number.isInteger(decimals) || decimals < 0) {
+        throw new core_1.AugustValidationError('INVALID_INPUT', `uiAmountToRawBn: decimals must be a non-negative integer, got ${decimals}`);
+    }
+    const uiStr = uiAmount.toString();
+    const expansion = uiStr.includes('e') || uiStr.includes('E')
+        ? uiAmount.toFixed(Math.max(decimals, 20)).replace(/\.?0+$/, '')
+        : uiStr;
+    const [whole, fraction = ''] = expansion.split('.');
+    const truncated = fraction.slice(0, decimals);
+    const paddedFraction = truncated.padEnd(decimals, '0');
+    const raw = (whole + paddedFraction).replace(/^0+/, '') || '0';
+    return new anchor_1.BN(raw);
+}
 exports.SolanaUtils = {
     getExplorerLink,
-    isSolanaAddress,
+    isSolanaAddress: chain_address_1.isSolanaAddress,
     isSolana,
     getProgram,
     getProvider,

package/lib/adapters/solana/vault.actions.d.ts

@@ -7,7 +7,7 @@ export declare function handleSolanaDeposit({ provider, connection, network, vau
     vaultAddress?: PublicKey | string;
     idl: any;
     publicKey: PublicKey | string;
-    depositAmount: number;
+    depositAmount: number | bigint;
     sendTransaction: (transaction: Transaction | web3.VersionedTransaction, connection: Connection, options?: SendTransactionOptions) => Promise<web3.TransactionSignature>;
 } & ISolanaConnectionOptions): Promise<any>;
 export declare function handleSolanaRedeem({ provider, connection, vaultProgramId, vaultAddress, publicKey, redeemShares, sendTransaction, idl, }: {
@@ -15,6 +15,6 @@ export declare function handleSolanaRedeem({ provider, connection, vaultProgramI
     vaultProgramId: PublicKey | string;
     vaultAddress?: PublicKey | string;
     publicKey: PublicKey | string;
-    redeemShares: number;
+    redeemShares: number | bigint;
     sendTransaction: (transaction: Transaction | web3.VersionedTransaction, connection: Connection, options?: SendTransactionOptions) => Promise<web3.TransactionSignature>;
 } & ISolanaConnectionOptions): Promise<any>;