@upshiftfinance/sdk 0.0.0-stage → 0.1.0

package/lib/adapters/solana/getters.js

@@ -0,0 +1,275 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSolanaVault = void 0;
+exports.getSolanaVaultAumUsd = getSolanaVaultAumUsd;
+const web3_js_1 = require("@solana/web3.js");
+const utils_1 = require("./utils");
+const SolanaConstants = __importStar(require("./constants"));
+const core_1 = require("../../core");
+const utils_2 = require("../../modules/vaults/utils");
+const withdrawal_queue_1 = require("./withdrawal-queue");
+/**
+ * Fetch Solana vault data from on-chain program state.
+ * Falls back to backend-only data when Solana RPC is unavailable,
+ * ensuring vaults always appear in the list even without on-chain access.
+ *
+ * When the vault has a withdrawal queue, `withdrawalQueue` carries its live
+ * summary, at the cost of one extra `getMultipleAccountsInfo` (the queue and a
+ * fresh read of the vault state, for `enabled`). A failed queue read is
+ * logged and leaves the field out rather than failing the vault.
+ * @param tokenizedVault Vault metadata from backend
+ * @param options RPC configuration with Solana service
+ * @returns Formatted vault object with Solana-specific fields
+ */
+const getSolanaVault = async (tokenizedVault, options) => {
+    // `options.rpcUrl` is resolved upstream as `providers[vault.chain]`, and that
+    // map is keyed by EVM chain id — Solana's synthetic id is never in it, so the
+    // field arrives undefined for every Solana vault however well the app has
+    // configured its Solana RPC. The connection built from that RPC *is* passed
+    // (`solanaService`), so take the endpoint off it rather than fetching against
+    // `undefined`.
+    const solanaRpcUrl = (options.rpcUrl ??
+        options.solanaService?.connection?.rpcEndpoint);
+    const solanaMetadata = tokenizedVault.solana_vault_metadata;
+    const programId = utils_1.SolanaUtils.resolveProgramId(tokenizedVault.address, solanaMetadata);
+    // Fallback decimals: prefer backend metadata, then the application default
+    const fallbackDecimals = solanaMetadata?.deposit_token_decimals ?? SolanaConstants.fallbackDecimals;
+    let vaultState = null;
+    let depositMint = null;
+    let onChainAvailable = false;
+    // Attempt to fetch on-chain data; gracefully degrade if RPC is unavailable
+    try {
+        vaultState = await utils_1.SolanaUtils.getVaultStateReadOnly({
+            idl: SolanaConstants.vaultIdl,
+            vaultProgramId: programId,
+            vaultAddress: solanaMetadata?.vault_state_pda ?? undefined,
+            endpoint: solanaRpcUrl,
+            connection: options?.solanaService?.connection,
+        });
+        // `getVaultStateReadOnly` swallows RPC and decode failures and resolves
+        // `{ vaultState: null }` rather than throwing, so a resolved call is not
+        // proof the chain was reachable. Only a decoded state counts; otherwise
+        // `totalAssets` must come from the backend's `latest_reported_tvl`
+        // instead of being computed as 0 from a missing `localAum`/`deployedAum`.
+        onChainAvailable = vaultState?.vaultState != null;
+        if (vaultState?.vaultState?.depositMint) {
+            try {
+                depositMint = await utils_1.SolanaUtils.getToken({
+                    mintAddress: vaultState.vaultState.depositMint,
+                    endpoint: solanaRpcUrl,
+                    connection: options?.solanaService?.connection,
+                });
+            }
+            catch (tokenError) {
+                core_1.Logger.log.warn('getSolanaVault', 'Token fetch failed, using backend metadata', { vault: tokenizedVault.address, error: tokenError });
+            }
+        }
+    }
+    catch (error) {
+        // Only degrade gracefully for network/RPC issues; re-throw everything else
+        const isNetworkError = error instanceof Error &&
+            (/fetch failed|ETIMEDOUT|timeout|ECONNREFUSED|403|503|network/i.test(error.message) ||
+                error.name === 'AbortError');
+        if (!isNetworkError) {
+            throw error;
+        }
+        core_1.Logger.log.warn('getSolanaVault', 'RPC unavailable, using backend-only data', { vault: tokenizedVault.address, error });
+    }
+    const decimals = vaultState?.depositMintDecimals ?? fallbackDecimals;
+    // Fetch share mint supply to get totalSupply.
+    // Prefer vaultState.shareMint (correct for multi-vault programs like jitoSOL);
+    // fall back to deriveShareMintPda(programId) for legacy single-vault programs.
+    let totalSupply = (0, core_1.toNormalizedBn)(0, decimals);
+    let shareDecimals = decimals;
+    if (onChainAvailable) {
+        try {
+            const shareMintFromState = vaultState?.vaultState?.shareMint;
+            const shareMintKey = shareMintFromState
+                ? new web3_js_1.PublicKey(String(shareMintFromState))
+                : utils_1.SolanaUtils.deriveShareMintPda(programId);
+            const shareMintAccountInfo = await options.solanaService?.connection.getParsedAccountInfo(shareMintKey);
+            if (shareMintAccountInfo?.value) {
+                const parsedData = shareMintAccountInfo.value.data;
+                const { supply, decimals: mintDecimals } = parsedData.parsed.info;
+                totalSupply = (0, core_1.toNormalizedBn)(BigInt(supply), mintDecimals);
+                shareDecimals = mintDecimals;
+            }
+        }
+        catch (error) {
+            core_1.Logger.log.warn('getSolanaVault', 'Error fetching share mint info', {
+                vault: tokenizedVault.address,
+                error,
+            });
+        }
+    }
+    // Total assets must mirror the on-chain `VaultState::total_assets()` which
+    // is `local_aum + deployed_aum` (see solana-vaults/programs/august-vault/
+    // src/state/vault.rs). Reading deployed_aum alone makes the displayed share
+    // price drop below 1.0 the instant the operator deploys part of the vault,
+    // even though the vault has had no PnL.
+    let totalAssets;
+    // `local_aum` is what the vault program itself holds — the idle buffer the
+    // operators' portfolios (Octav) never see.
+    let idleAssets;
+    if (onChainAvailable) {
+        const localAumRaw = vaultState?.vaultState?.localAum;
+        const deployedAumRaw = vaultState?.vaultState?.deployedAum;
+        const localAum = localAumRaw !== null && localAumRaw !== undefined
+            ? BigInt(localAumRaw.toString())
+            : BigInt(0);
+        const deployedAum = deployedAumRaw !== null && deployedAumRaw !== undefined
+            ? BigInt(deployedAumRaw.toString())
+            : BigInt(0);
+        totalAssets = (0, core_1.toNormalizedBn)(localAum + deployedAum, decimals);
+        idleAssets = (0, core_1.toNormalizedBn)(localAum, decimals);
+    }
+    else {
+        totalAssets = (0, utils_2.backendTvlToNormalizedBn)(tokenizedVault.latest_reported_tvl, decimals);
+    }
+    // Deposit asset: use on-chain data if available, otherwise backend metadata
+    const depositAsset = {
+        address: depositMint?.address ?? solanaMetadata?.deposit_mint,
+        symbol: depositMint?.symbol ?? solanaMetadata?.deposit_token_symbol,
+        decimals: depositMint?.decimals ?? fallbackDecimals,
+    };
+    if (!depositAsset.address) {
+        core_1.Logger.log.warn('getSolanaVault', 'Missing deposit asset address', {
+            vault: tokenizedVault.address,
+        });
+    }
+    let withdrawalQueue;
+    const solanaService = options.solanaService;
+    if (onChainAvailable && vaultState?.vaultState && solanaService) {
+        try {
+            const queueProgramId = (0, withdrawal_queue_1.resolveQueueProgramId)(solanaService);
+            withdrawalQueue = queueProgramId
+                ? await (0, withdrawal_queue_1.getSolanaWithdrawalQueueSummary)({
+                    connection: solanaService.connection,
+                    queueProgramId,
+                    vaultState: solanaMetadata?.vault_state_pda
+                        ? new web3_js_1.PublicKey(solanaMetadata.vault_state_pda)
+                        : utils_1.SolanaUtils.deriveVaultStatePda(programId),
+                    shareDecimals,
+                })
+                : undefined;
+        }
+        catch (error) {
+            core_1.Logger.log.warn('getSolanaVault', 'Withdrawal queue read failed', {
+                vault: tokenizedVault.address,
+                error,
+            });
+        }
+    }
+    // Build unified vault object combining on-chain and backend data
+    const vault = (0, utils_2.buildBackendVault)(tokenizedVault, {
+        chainId: core_1.SPECIAL_CHAINS.solana.chainId,
+        version: 'sol-0',
+        name: tokenizedVault.vault_name || 'Solana Program',
+        totalAssets,
+        totalSupply,
+        depositAssets: [depositAsset],
+        receipt: {
+            address: tokenizedVault.address,
+            symbol: tokenizedVault.receipt_token_symbol || 'upSOL',
+            decimals: decimals,
+        },
+        programId,
+    });
+    if (idleAssets)
+        vault.idleAssets = idleAssets;
+    if (tokenizedVault.eoa_operators?.length) {
+        vault.eoa_operators = tokenizedVault.eoa_operators;
+    }
+    if (withdrawalQueue)
+        vault.withdrawalQueue = withdrawalQueue;
+    return vault;
+};
+exports.getSolanaVault = getSolanaVault;
+/**
+ * Read a Solana vault's AUM in USD fresh from its state account.
+ *
+ * For comparing the vault with live portfolio data: the state cache behind
+ * {@link getSolanaVault} can be up to 24h old, which would show yield accrued
+ * since as unattributed. Costs one uncached vault-state read (plus the deposit
+ * mint's decimals), then one cached price lookup.
+ *
+ * Never rejects. A failed read, a missing state account or symbol, or a
+ * non-positive price returns `null`, so the caller can drop the comparison
+ * without losing the rest of its result.
+ *
+ * @param tokenizedVault - Backend row of the Solana vault
+ * @param options - Must carry `solanaService` for the RPC connection
+ * @returns The vault's deployed and idle AUM in USD, or `null`
+ */
+async function getSolanaVaultAumUsd(tokenizedVault, options) {
+    const metadata = tokenizedVault.solana_vault_metadata;
+    const symbol = metadata?.deposit_token_symbol;
+    try {
+        if (!symbol)
+            throw new Error('no deposit_token_symbol in vault metadata');
+        const state = await utils_1.SolanaUtils.getVaultStateReadOnly({
+            idl: SolanaConstants.vaultIdl,
+            vaultProgramId: utils_1.SolanaUtils.resolveProgramId(tokenizedVault.address, metadata),
+            vaultAddress: metadata?.vault_state_pda ?? undefined,
+            connection: options?.solanaService?.connection,
+            fresh: true,
+        });
+        const vaultState = state?.vaultState;
+        // Checked before pricing so an unreachable RPC costs no price request.
+        if (!vaultState)
+            throw new Error('vault state unavailable');
+        const price = await (0, core_1.fetchTokenPrice)(symbol, undefined, undefined, options?.headers);
+        if (!(price > 0))
+            throw new Error(`${symbol} priced at ${price}`);
+        const decimals = state.depositMintDecimals ??
+            metadata?.deposit_token_decimals ??
+            SolanaConstants.fallbackDecimals;
+        const toUsd = (raw) => Number((0, core_1.toNormalizedBn)(BigInt(String(raw ?? 0)), decimals).normalized) *
+            price;
+        return {
+            deployedUsd: toUsd(vaultState.deployedAum),
+            idleUsd: toUsd(vaultState.localAum),
+        };
+    }
+    catch (error) {
+        core_1.Logger.log.warn('getSolanaVaultAumUsd', 'AUM read failed', {
+            vault: tokenizedVault.address,
+            error,
+        });
+        return null;
+    }
+}
+//# sourceMappingURL=getters.js.map