upshift-config 0.5.14

package/lib/adapters/solana/getters.js

@@ -0,0 +1,165 @@
+"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;
+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");
+/**
+ * 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.
+ * @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) => {
+    const solanaRpcUrl = options.rpcUrl;
+    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,
+        });
+        onChainAvailable = true;
+        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);
+    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);
+            }
+        }
+        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;
+    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);
+    }
+    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,
+        });
+    }
+    // Build unified vault object combining on-chain and backend data
+    return (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,
+    });
+};
+exports.getSolanaVault = getSolanaVault;
+//# sourceMappingURL=getters.js.map

package/lib/adapters/solana/idl/vault-idl.d.ts

@@ -0,0 +1,272 @@
+/**
+ * august_vault program IDL (Anchor).
+ *
+ * GENERATED — do not edit by hand. The versioned multi-vault interface the SDK
+ * targets, generated from the devnet on-chain IDL of `C8B1…` — the only
+ * deployment that publishes one matching this file. Refresh with
+ * `anchor idl fetch C8B1… -u devnet`.
+ *
+ * At runtime the SDK targets the canonical `up12…` instead, whose own published
+ * IDL is STALE (an Anchor IDL upload is not refreshed by a program upgrade), so
+ * it can't be used as the generation source. The solana-idl-drift check (CI)
+ * therefore validates `up12…` by pinning its deployed binary and by decoding
+ * live VaultState accounts against this file — see
+ * tests/vaults/solana-idl-drift.test.ts.
+ *
+ * `address` is a build stamp (the mainnet id), NOT network-aware. Never rely on
+ * it: SolanaAdapter/getProgram resolve the real program id per network from
+ * programIds, or from an explicit `programId` override.
+ */
+export declare const vaultIdl: {
+    accounts: {
+        discriminator: number[];
+        name: string;
+    }[];
+    address: string;
+    errors: {
+        code: number;
+        msg: string;
+        name: string;
+    }[];
+    events: {
+        discriminator: number[];
+        name: string;
+    }[];
+    instructions: ({
+        accounts: ({
+            name: string;
+            signer: boolean;
+            writable: boolean;
+            docs?: undefined;
+            pda?: undefined;
+            address?: undefined;
+        } | {
+            docs: string[];
+            name: string;
+            signer: boolean;
+            writable: boolean;
+            pda?: undefined;
+            address?: undefined;
+        } | {
+            docs: string[];
+            name: string;
+            writable: boolean;
+            signer?: undefined;
+            pda?: undefined;
+            address?: undefined;
+        } | {
+            docs: string[];
+            name: string;
+            signer?: undefined;
+            writable?: undefined;
+            pda?: undefined;
+            address?: undefined;
+        } | {
+            name: string;
+            pda: {
+                program: {
+                    kind: string;
+                    value: number[];
+                };
+                seeds: ({
+                    kind: string;
+                    value: number[];
+                    path?: undefined;
+                } | {
+                    kind: string;
+                    path: string;
+                    value?: undefined;
+                })[];
+            };
+            writable: boolean;
+            signer?: undefined;
+            docs?: undefined;
+            address?: undefined;
+        } | {
+            address: string;
+            name: string;
+            signer?: undefined;
+            writable?: undefined;
+            docs?: undefined;
+            pda?: undefined;
+        })[];
+        args: {
+            name: string;
+            type: string;
+        }[];
+        discriminator: number[];
+        docs: string[];
+        name: string;
+    } | {
+        accounts: ({
+            name: string;
+            writable: boolean;
+            signer?: undefined;
+            address?: undefined;
+        } | {
+            name: string;
+            writable?: undefined;
+            signer?: undefined;
+            address?: undefined;
+        } | {
+            name: string;
+            signer: boolean;
+            writable?: undefined;
+            address?: undefined;
+        } | {
+            name: string;
+            signer: boolean;
+            writable: boolean;
+            address?: undefined;
+        } | {
+            address: string;
+            name: string;
+            writable?: undefined;
+            signer?: undefined;
+        })[];
+        args: {
+            name: string;
+            type: string;
+        }[];
+        discriminator: number[];
+        docs: string[];
+        name: string;
+    } | {
+        accounts: ({
+            name: string;
+            writable: boolean;
+            pda?: undefined;
+            signer?: undefined;
+        } | {
+            name: string;
+            pda: {
+                program: {
+                    kind: string;
+                    value: number[];
+                };
+                seeds: ({
+                    kind: string;
+                    path: string;
+                    value?: undefined;
+                } | {
+                    kind: string;
+                    value: number[];
+                    path?: undefined;
+                })[];
+            };
+            writable: boolean;
+            signer?: undefined;
+        } | {
+            name: string;
+            signer: boolean;
+            writable?: undefined;
+            pda?: undefined;
+        } | {
+            name: string;
+            writable?: undefined;
+            pda?: undefined;
+            signer?: undefined;
+        })[];
+        args: {
+            name: string;
+            type: string;
+        }[];
+        discriminator: number[];
+        docs: string[];
+        name: string;
+    } | {
+        accounts: ({
+            docs: string[];
+            name: string;
+            signer: boolean;
+            writable?: undefined;
+            pda?: undefined;
+            address?: undefined;
+        } | {
+            docs: string[];
+            name: string;
+            writable: boolean;
+            signer?: undefined;
+            pda?: undefined;
+            address?: undefined;
+        } | {
+            docs: string[];
+            name: string;
+            signer?: undefined;
+            writable?: undefined;
+            pda?: undefined;
+            address?: undefined;
+        } | {
+            name: string;
+            pda: {
+                program: {
+                    kind: string;
+                    value: number[];
+                };
+                seeds: ({
+                    kind: string;
+                    value: number[];
+                    path?: undefined;
+                } | {
+                    kind: string;
+                    path: string;
+                    value?: undefined;
+                })[];
+            };
+            writable: boolean;
+            docs?: undefined;
+            signer?: undefined;
+            address?: undefined;
+        } | {
+            address: string;
+            name: string;
+            docs?: undefined;
+            signer?: undefined;
+            writable?: undefined;
+            pda?: undefined;
+        })[];
+        args: {
+            name: string;
+            type: string;
+        }[];
+        discriminator: number[];
+        docs: string[];
+        name: string;
+    })[];
+    metadata: {
+        description: string;
+        name: string;
+        spec: string;
+        version: string;
+    };
+    types: ({
+        name: string;
+        repr: {
+            kind: string;
+        };
+        serialization: string;
+        type: {
+            fields: {
+                name: string;
+                type: string;
+            }[];
+            kind: string;
+        };
+    } | {
+        name: string;
+        type: {
+            fields: ({
+                name: string;
+                type: string;
+            } | {
+                name: string;
+                type: {
+                    array: (string | number)[];
+                };
+            })[];
+            kind: string;
+        };
+        repr?: undefined;
+        serialization?: undefined;
+    })[];
+};