upshift-finance 1.0.0

package/lib/adapters/solana/utils.js

@@ -0,0 +1,595 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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");
+const constants_1 = require("./constants");
+const core_1 = require("../../core");
+// ============================================================================
+// SOLANA UTILITIES
+// ============================================================================
+function getExplorerLink({ signature, type = 'tx', network = constants_1.fallbackNetwork, }) {
+    const baseUrl = 'https://solscan.io';
+    return `${baseUrl}/${type}/${signature}?cluster=${network}`;
+}
+// Re-exported from the core leaf so consumers in the core layer can import it
+// without taking a dependency on the Solana adapter.
+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;
+    // Check if it's an Ethereum address first
+    if ((0, ethers_1.isAddress)(signature))
+        return false;
+    // Check if it's a valid Solana address (including PDAs) — addresses are not signatures
+    if ((0, chain_address_1.isSolanaAddress)(signature))
+        return false;
+    // Check if it's a valid base58 string with correct length for Solana signatures
+    // Solana signatures are base58 encoded and typically 88 characters long
+    const base58Chars = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+    const isValidBase58 = signature
+        .split('')
+        .every((char) => base58Chars.includes(char));
+    if (!isValidBase58)
+        return false;
+    // Check length - Solana signatures are typically 88 characters
+    return (signature.length >= 80 && signature.length <= 100);
+}
+function getProgram({ provider, idl, programId, network, }) {
+    const baseIdl = idl ?? constants_1.vaultIdl;
+    // Precedence: explicit `programId` → a custom IDL's `address` → the network
+    // default → the bundled IDL's embedded `address`.
+    //
+    // The custom-address check compares by VALUE, not reference. Keying off
+    // `idl === vaultIdl` broke for a structurally-identical-but-not-reference-equal
+    // copy (second bundle instance, or JSON round-tripped), silently retargeting
+    // devnet callers at mainnet. Every copy carries the same build stamp, so it
+    // still defers to the network default — but a genuinely custom IDL is honoured.
+    const suppliedAddress = typeof baseIdl?.address === 'string' && baseIdl.address !== constants_1.vaultIdl.address
+        ? baseIdl.address
+        : undefined;
+    const explicitId = programId ?? suppliedAddress;
+    if (explicitId) {
+        return new anchor_1.Program({ ...baseIdl, address: explicitId }, provider);
+    }
+    if (network) {
+        const networkDefault = (0, constants_1.getDeployedProgramIds)(network)?.vault;
+        if (!networkDefault) {
+            throw new core_1.AugustValidationError('INVALID_INPUT', `No canonical august_vault deployment for Solana network '${network}'. ` +
+                `Deployed networks: ${Object.keys(constants_1.programIds).join(', ')}. ` +
+                `Pass an explicit \`programId\` (or an IDL carrying the target \`address\`) to target a program on this network.`);
+        }
+        return new anchor_1.Program({ ...baseIdl, address: networkDefault }, provider);
+    }
+    return new anchor_1.Program(baseIdl, provider);
+}
+// ============================================================================
+// SOLANA PROVIDERS
+// ============================================================================
+async function testRpcEndpoint({ connection }) {
+    try {
+        const blockHeight = await connection.getBlockHeight();
+        return { success: true, blockHeight };
+    }
+    catch (error) {
+        return { success: false, error };
+    }
+}
+// Function to get the best available RPC endpoint
+async function getBestRpcEndpoint({ endpoint, network = constants_1.fallbackNetwork, connection, }) {
+    const primaryEndpoint = endpoint;
+    const fallbackEndpoint = constants_1.fallbackRpcEndpoints[network];
+    // Test primary endpoint first
+    const primaryTest = await testRpcEndpoint({ connection });
+    if (primaryTest.success) {
+        return primaryEndpoint;
+    }
+    // Fall back to public endpoint
+    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 core_1.AugustValidationError('INVALID_INPUT', 'Wallet not connected: publicKey and signTransaction are required for write operations');
+    }
+    return new anchor_1.AnchorProvider(connection, {
+        publicKey,
+        signTransaction,
+        signAllTransactions: async (txs) => {
+            // Use Promise.all instead of await in loop
+            const signedTransactions = await Promise.all(txs.map(async (tx) => signTransaction(tx)));
+            return signedTransactions;
+        },
+    }, { commitment: 'confirmed' });
+}
+// Read-only provider for data fetching without wallet connection
+function getReadOnlyProvider({ connection }) {
+    // Create a dummy wallet object for read-only operations
+    const dummyWallet = {
+        publicKey: web3_js_1.PublicKey.default, // Use default public key
+        signTransaction: async (_tx) => {
+            throw new core_1.AugustValidationError('INVALID_INPUT', 'Cannot sign transactions with read-only provider');
+        },
+        signAllTransactions: async (_txs) => {
+            throw new core_1.AugustValidationError('INVALID_INPUT', 'Cannot sign transactions with read-only provider');
+        },
+    };
+    return new anchor_1.AnchorProvider(connection, dummyWallet, {
+        commitment: 'confirmed',
+    });
+}
+// ============================================================================
+// SOLANA DERIVATIONS
+// ============================================================================
+function deriveVaultStatePda(vaultProgramId) {
+    if (!vaultProgramId)
+        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 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 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'),
+        depositMint.toBuffer(),
+    ];
+    if (vaultVersion !== undefined) {
+        if (!Number.isInteger(vaultVersion) ||
+            vaultVersion < 0 ||
+            vaultVersion > 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]));
+    }
+    const [pda] = web3_js_1.PublicKey.findProgramAddressSync(seeds, _vaultProgramId);
+    return pda;
+}
+// ============================================================================
+// SOLANA VAULTS
+// ============================================================================
+async function getVaultState({ provider, connection, vaultProgramId, vaultAddress, idl, }) {
+    const returnObj = {
+        vaultState: null,
+        depositMintDecimals: null,
+    };
+    try {
+        const cacheKey = `vaultState-${vaultAddress || vaultProgramId}`;
+        const cachedData = await (0, core_1.getSafeCache)(cacheKey);
+        if (cachedData)
+            return cachedData;
+        if (!vaultProgramId) {
+            throw new core_1.AugustValidationError('INVALID_INPUT', 'Please enter a vault program ID');
+        }
+        const vaultStatePda = vaultAddress
+            ? new web3_js_1.PublicKey(vaultAddress)
+            : deriveVaultStatePda(vaultProgramId);
+        const _vaultProgramId = new web3_js_1.PublicKey(vaultProgramId);
+        const program = getProgram({
+            provider,
+            idl,
+            programId: _vaultProgramId.toBase58(),
+        });
+        const state = await program.account.vaultState.fetch(vaultStatePda);
+        returnObj.vaultState = state;
+        if (state.depositMint) {
+            try {
+                const mintInfo = await connection.getParsedAccountInfo(state.depositMint);
+                if (mintInfo.value) {
+                    const parsedData = mintInfo.value.data;
+                    returnObj.depositMintDecimals = parsedData.parsed.info.decimals;
+                }
+            }
+            catch (mintError) {
+                core_1.Logger.log.error('getVaultState', mintError, {
+                    message: 'Error fetching deposit mint decimals',
+                });
+            }
+        }
+        await (0, core_1.setSafeCache)(cacheKey, returnObj);
+        return returnObj;
+    }
+    catch (e) {
+        const error = e;
+        core_1.Logger.log.error('getVaultState', error, {
+            message: 'Error reading vault state',
+        });
+        return returnObj;
+    }
+}
+// Read-only version of getVaultState that works without wallet connection
+async function getVaultStateReadOnly({ vaultProgramId, vaultAddress, connection, idl, }) {
+    const returnObj = {
+        vaultState: null,
+        depositMintDecimals: null,
+    };
+    try {
+        const cacheKey = `vaultState-${vaultAddress || vaultProgramId}`;
+        const cachedData = await (0, core_1.getSafeCache)(cacheKey);
+        if (cachedData)
+            return cachedData;
+        if (!vaultProgramId) {
+            throw new core_1.AugustValidationError('INVALID_INPUT', 'Please enter a vault program ID');
+        }
+        const _vaultProgramId = new web3_js_1.PublicKey(vaultProgramId);
+        const vaultStatePda = vaultAddress
+            ? new web3_js_1.PublicKey(vaultAddress)
+            : deriveVaultStatePda(_vaultProgramId);
+        // Use connection directly to fetch account data
+        const accountInfo = await connection.getAccountInfo(vaultStatePda);
+        if (!accountInfo) {
+            core_1.Logger.log.warn('getVaultStateReadOnly', 'Vault state account not found');
+            return returnObj;
+        }
+        // Try to create a program with read-only provider for parsing
+        try {
+            const readOnlyProvider = getReadOnlyProvider({ connection });
+            const program = getProgram({
+                provider: readOnlyProvider,
+                idl,
+                programId: _vaultProgramId.toBase58(),
+            });
+            const state = await program.account.vaultState.fetch(vaultStatePda);
+            returnObj.vaultState = state;
+            if (state.depositMint) {
+                try {
+                    const mintInfo = await connection.getParsedAccountInfo(state.depositMint);
+                    if (mintInfo.value) {
+                        const parsedData = mintInfo.value.data;
+                        returnObj.depositMintDecimals = parsedData.parsed.info.decimals;
+                    }
+                }
+                catch (mintError) {
+                    core_1.Logger.log.error('getVaultStateReadOnly', mintError, {
+                        message: 'Error fetching deposit mint decimals',
+                    });
+                }
+            }
+        }
+        catch (programError) {
+            core_1.Logger.log.error('getVaultStateReadOnly', programError, {
+                message: 'Error creating program with read-only provider',
+            });
+            // Fallback: program parsing failed, vault state is unavailable
+            returnObj.vaultState = null;
+        }
+        await (0, core_1.setSafeCache)(cacheKey, returnObj);
+        return returnObj;
+    }
+    catch (e) {
+        const error = e;
+        core_1.Logger.log.error('getVaultStateReadOnly', error, {
+            message: 'Error reading vault state',
+        });
+        return returnObj;
+    }
+}
+// Fetch deposit and share mint addresses from on-chain vault state (read-only, no wallet required)
+async function getVaultMints({ vaultProgramId, vaultAddress, connection, idl, }) {
+    try {
+        const cacheKey = `vaultMints-${vaultAddress || vaultProgramId}`;
+        const cachedData = await (0, core_1.getSafeCache)(cacheKey);
+        if (cachedData)
+            return cachedData;
+        if (!vaultProgramId) {
+            throw new core_1.AugustValidationError('INVALID_INPUT', 'Please enter a vault program ID');
+        }
+        const _vaultProgramId = new web3_js_1.PublicKey(vaultProgramId);
+        const vaultStatePda = vaultAddress
+            ? new web3_js_1.PublicKey(vaultAddress)
+            : deriveVaultStatePda(_vaultProgramId);
+        const readOnlyProvider = getReadOnlyProvider({ connection });
+        const program = getProgram({
+            provider: readOnlyProvider,
+            idl,
+            programId: _vaultProgramId.toBase58(),
+        });
+        const state = await program.account.vaultState.fetch(vaultStatePda);
+        const returnObj = {
+            depositMint: state.depositMint.toString(),
+            shareMint: state.shareMint.toString(),
+            // Empty arrays yield undefined, falling back to legacy PDA seeds (no version byte)
+            vaultVersion: Array.isArray(state.vaultVersion)
+                ? state.vaultVersion[0]
+                : undefined,
+        };
+        await (0, core_1.setSafeCache)(cacheKey, returnObj);
+        return returnObj;
+    }
+    catch (e) {
+        const error = e;
+        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, }) {
+    try {
+        const cacheKey = `solana_token-${mintAddress}`;
+        const cachedData = await (0, core_1.getSafeCache)(cacheKey);
+        if (cachedData)
+            return cachedData;
+        // First, try to get token metadata via Metaplex DAS API
+        const response = await fetch(endpoint, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                jsonrpc: '2.0',
+                id: 'text',
+                method: 'getAsset',
+                params: { id: mintAddress.toString() },
+            }),
+        });
+        const data = (await response.json()); // @todo: add interface
+        // If we got valid token metadata, return it
+        if (data.result?.token_info?.decimals !== undefined) {
+            return {
+                address: data?.result?.id,
+                symbol: data.result?.content?.metadata?.symbol || 'N/A',
+                decimals: data.result?.token_info?.decimals,
+                name: data.result?.content?.metadata?.name || 'Unknown',
+                image: data.result?.content.metadata?.image,
+                program: data.result?.token_info?.token_program,
+                mintAuthority: data.result?.token_info?.mint_authority,
+                freezeAuthority: data.result?.token_info?.freeze_authority,
+                supply: data.result?.token_info?.supply,
+            };
+        }
+        // If Metaplex metadata didn't work, check if this is a vault program address
+        // In that case, we should query the share mint PDA instead
+        if (connection) {
+            try {
+                const vaultProgramId = new web3_js_1.PublicKey(mintAddress);
+                // Try to get vault state to see if this is a vault
+                const vaultState = await getVaultStateReadOnly({
+                    vaultProgramId,
+                    connection,
+                    idl: constants_1.vaultIdl,
+                });
+                // If we successfully got vault state, derive the share mint and query that
+                if (vaultState.vaultState) {
+                    const shareMintPda = deriveShareMintPda(vaultProgramId);
+                    // Get share mint metadata from blockchain
+                    const shareMintInfo = await connection.getParsedAccountInfo(shareMintPda);
+                    if (shareMintInfo.value) {
+                        const parsedData = shareMintInfo.value.data;
+                        // Try to get Metaplex metadata for the share mint
+                        const shareMintMetadata = await fetch(endpoint, {
+                            method: 'POST',
+                            headers: {
+                                'Content-Type': 'application/json',
+                            },
+                            body: JSON.stringify({
+                                jsonrpc: '2.0',
+                                id: 'text',
+                                method: 'getAsset',
+                                params: { id: shareMintPda.toString() },
+                            }),
+                        });
+                        const shareMintData = (await shareMintMetadata.json());
+                        const returnObj = {
+                            address: mintAddress.toString(), // Return original vault address
+                            symbol: shareMintData.result?.content?.metadata?.symbol || 'N/A',
+                            decimals: parsedData.parsed.info.decimals,
+                            name: shareMintData.result?.content?.metadata?.name ||
+                                'Vault Share Token',
+                            image: shareMintData.result?.content?.metadata?.image,
+                            program: shareMintData.result?.token_info?.token_program,
+                            mintAuthority: shareMintData.result?.token_info?.mint_authority,
+                            freezeAuthority: shareMintData.result?.token_info?.freeze_authority,
+                            supply: parsedData.parsed.info.supply,
+                            shareMintAddress: shareMintPda.toString(), // Include share mint address
+                        };
+                        await (0, core_1.setSafeCache)(cacheKey, returnObj);
+                        return returnObj;
+                    }
+                }
+            }
+            catch (vaultError) {
+                // Not a vault or error checking vault state, continue to return null
+                core_1.Logger.log.info('getToken', 'Not a vault program or error querying vault:', vaultError);
+            }
+        }
+        // If all attempts failed, return null
+        return null;
+    }
+    catch (error) {
+        core_1.Logger.log.error('getToken', error, {
+            message: 'Error fetching token metadata',
+        });
+        return null;
+    }
+}
+// Helper function to get just the token symbol
+async function getTokenSymbol({ endpoint, mintAddress, }) {
+    try {
+        const tokenMetadata = await getToken({ endpoint, mintAddress });
+        if (tokenMetadata) {
+            return tokenMetadata.symbol;
+        }
+        return null;
+    }
+    catch (error) {
+        core_1.Logger.log.error('getTokenSymbol', error, {
+            message: 'Error fetching token symbol',
+        });
+        return null;
+    }
+}
+async function fetchUserTokenBalance({ connection, publicKey, depositMint, }) {
+    if (!publicKey || !depositMint)
+        return '0';
+    try {
+        const _publicKey = new web3_js_1.PublicKey(publicKey);
+        const _depositMint = new web3_js_1.PublicKey(depositMint);
+        const tokenAccounts = await connection.getParsedTokenAccountsByOwner(_publicKey, {
+            mint: _depositMint,
+        });
+        if (tokenAccounts.value.length > 0) {
+            const balance = tokenAccounts?.value?.[0]?.account.data.parsed.info.tokenAmount
+                .uiAmount;
+            return balance?.toString() || '0';
+        }
+        return '0';
+    }
+    catch (e) {
+        const error = e;
+        core_1.Logger.log.error('fetchUserTokenBalance', error, {
+            message: 'Error fetching user token balance',
+        });
+        return '0';
+    }
+}
+async function fetchUserShareBalance({ connection, publicKey, shareMint, }) {
+    if (!publicKey || !shareMint)
+        return 0;
+    try {
+        const _publicKey = new web3_js_1.PublicKey(publicKey);
+        const _shareMint = new web3_js_1.PublicKey(shareMint);
+        const shareAccounts = await connection.getParsedTokenAccountsByOwner(_publicKey, {
+            mint: _shareMint,
+        });
+        if (shareAccounts.value.length > 0) {
+            const balance = shareAccounts?.value?.[0]?.account.data.parsed.info.tokenAmount
+                .uiAmount;
+            return balance ?? 0;
+        }
+        return 0;
+    }
+    catch (e) {
+        const error = e;
+        core_1.Logger.log.error('fetchUserShareBalance', error, {
+            message: 'Error fetching user share balance',
+        });
+        return 0;
+    }
+}
+/**
+ * Same on-chain lookup as `fetchUserShareBalance`, but returns the raw u64
+ * `amount` string and the mint's `decimals` — or `null` when the scale can't
+ * be determined (see Return shape) — instead of the floating-point `uiAmount`.
+ * Callers that feed the result into BigInt math (positions, redemptions,
+ * allowances) must use this — `uiAmount` is lossy and silently encodes with
+ * the wrong scale when passed back through `toNormalizedBn` without an
+ * explicit decimals argument.
+ *
+ * Return shape:
+ *   `{ amount: '<u64>', decimals: number }` — token account exists.
+ *   `{ amount: '0',     decimals: null   }` — no token account, missing
+ *      tokenAmount in the parsed response, missing args, or the RPC threw.
+ *
+ * `decimals === null` is the "scale unknown" signal — callers that need a
+ * normalized `INormalizedNumber` must substitute a known decimals value
+ * (typically the deposit mint's decimals from backend metadata) before
+ * normalizing. Never throws.
+ *
+ * RPC cost: 1 × `getParsedTokenAccountsByOwner`. Independent of how many
+ * other accounts the wallet owns (filter is mint-scoped).
+ */
+async function fetchUserShareBalanceRaw({ connection, publicKey, shareMint, }) {
+    if (!publicKey || !shareMint)
+        return { amount: '0', decimals: null };
+    try {
+        const _publicKey = new web3_js_1.PublicKey(publicKey);
+        const _shareMint = new web3_js_1.PublicKey(shareMint);
+        const shareAccounts = await connection.getParsedTokenAccountsByOwner(_publicKey, {
+            mint: _shareMint,
+        });
+        const tokenAmount = shareAccounts?.value?.[0]?.account?.data?.parsed?.info?.tokenAmount;
+        if (!tokenAmount)
+            return { amount: '0', decimals: null };
+        return {
+            amount: String(tokenAmount.amount ?? '0'),
+            decimals: typeof tokenAmount.decimals === 'number' ? tokenAmount.decimals : null,
+        };
+    }
+    catch (e) {
+        const error = e;
+        core_1.Logger.log.error('fetchUserShareBalanceRaw', error, {
+            message: 'Error fetching raw user share balance',
+        });
+        return { amount: '0', decimals: null };
+    }
+}
+/**
+ * Resolve the on-chain program ID for a Solana vault.
+ * Prefers the explicit `program_id` from metadata; falls back to the vault address
+ * (for legacy vaults where address == program ID).
+ */
+function resolveProgramId(vaultAddress, solanaMetadata) {
+    return solanaMetadata?.program_id || vaultAddress;
+}
+// String-arithmetic UI→raw conversion. Truncates past `decimals` like
+// ethers.parseUnits; safe past Number.MAX_SAFE_INTEGER.
+/** @internal */
+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}`);
+    }
+    // Build the fixed-decimal string manually — `.toFixed(decimals)` rounds
+    // the last digit, but parseUnits semantics require truncation.
+    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: chain_address_1.isSolanaAddress,
+    isSolana,
+    getProgram,
+    getProvider,
+    getReadOnlyProvider,
+    deriveShareMintPda,
+    deriveVaultStatePda,
+    deriveVaultTokenAtaPda,
+    getVaultState,
+    getVaultStateReadOnly,
+    getToken,
+    getTokenSymbol,
+    fetchUserTokenBalance,
+    fetchUserShareBalance,
+    fetchUserShareBalanceRaw,
+    getBestRpcEndpoint,
+    fallbackDecimals: constants_1.fallbackDecimals,
+    fallbackNetwork: constants_1.fallbackNetwork,
+    programIds: constants_1.programIds,
+    getVaultMints,
+    resolveProgramId,
+};
+//# sourceMappingURL=utils.js.map

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

@@ -0,0 +1,57 @@
+import { type web3 } from '@coral-xyz/anchor';
+import { type Connection, PublicKey, Transaction } from '@solana/web3.js';
+import type { ISolanaConnectionOptions } from './types';
+import type { SendTransactionOptions } from '@solana/wallet-adapter-base';
+/**
+ * Extract a human- and machine-readable reason from a thrown Solana/Anchor
+ * error.
+ *
+ * Anchor's {@link https://github.com/coral-xyz/anchor `ProgramError`} calls
+ * `super()` with no argument, so its `.message` is the empty string by
+ * construction — the real reason lives on `.msg`/`.code` (and `.toString()`).
+ * `AnchorError` puts it on `.error.errorMessage` / `.error.errorCode.number`.
+ * Reading `.message` directly (as this file used to) therefore rendered
+ * `"Solana deposit failed: "` for every recognized on-chain revert — dropping
+ * the numeric code the team needs to tell "Vault is paused" from
+ * "Insufficient amount" from an account-constraint violation.
+ *
+ * When no reason can be extracted, returns an actionable, user-facing fallback
+ * rather than an "unknown error" admission — the raw throwable is still
+ * preserved on the wrapped error's `cause` and in telemetry for diagnosis.
+ */
+export declare function describeSolanaError(e: unknown): string;
+/**
+ * Deposit funds into a Solana August vault and mint share tokens.
+ *
+ * @param depositAmount  `bigint` is treated as raw on-chain units (preferred
+ *   — no JS-float round-trip). `number` is treated as a UI amount and
+ *   scaled by the deposit mint's decimals via {@link uiAmountToRawBn}.
+ * @throws AugustValidationError on missing wallet/programId or invalid amount.
+ * @remarks The on-chain `deposit` instruction has no `min_shares_out`
+ *   parameter; slippage cannot be enforced on-chain until the program ships
+ *   that argument.
+ */
+export declare function handleSolanaDeposit({ provider, connection, network, vaultProgramId, vaultAddress, depositAmount, publicKey, sendTransaction, idl, }: {
+    vaultProgramId: PublicKey | string;
+    vaultAddress?: PublicKey | string;
+    idl: any;
+    publicKey: PublicKey | string;
+    depositAmount: number | bigint;
+    sendTransaction: (transaction: Transaction | web3.VersionedTransaction, connection: Connection, options?: SendTransactionOptions) => Promise<web3.TransactionSignature>;
+} & ISolanaConnectionOptions): Promise<any>;
+/**
+ * Redeem vault shares back into the underlying mint on a Solana August vault.
+ *
+ * @param redeemShares  `bigint` is treated as raw share-token units;
+ *   `number` is treated as a UI amount. See {@link handleSolanaDeposit} for
+ *   the same caveat about the missing on-chain slippage guard.
+ * @throws AugustValidationError on missing wallet/programId or invalid amount.
+ */
+export declare function handleSolanaRedeem({ provider, connection, vaultProgramId, vaultAddress, publicKey, redeemShares, sendTransaction, idl, }: {
+    idl: any;
+    vaultProgramId: PublicKey | string;
+    vaultAddress?: PublicKey | string;
+    publicKey: PublicKey | string;
+    redeemShares: number | bigint;
+    sendTransaction: (transaction: Transaction | web3.VersionedTransaction, connection: Connection, options?: SendTransactionOptions) => Promise<web3.TransactionSignature>;
+} & ISolanaConnectionOptions): Promise<any>;