@elmntl/jlpd-sdk 0.2.0 → 0.13.4

package/dist/p-stv-core/lut.d.ts

@@ -0,0 +1,41 @@
+/**
+ * p-STV Core Address Lookup Table helpers.
+ *
+ * Packages the STATIC (per-program, not per-tx) p-stv-core accounts into a LUT
+ * so versioned transactions can compress them into a single 1-byte index.
+ *
+ * Usage:
+ *   // Owner flow (one-time):
+ *   const [createIx, lutAddress] = AddressLookupTableProgram.createLookupTable({...});
+ *   const extendIxs = buildPstvCoreLutExtendIxs(payer, lutAddress);
+ *   // send createIx + extendIxs
+ *
+ *   // Consumer flow (every tx):
+ *   const lutAccount = await resolvePstvCoreLut(connection, lutAddress);
+ *   const msg = new TransactionMessage({...}).compileToV0Message([lutAccount]);
+ *
+ * NOTE: Only program IDs, the GlobalConfig PDA, and token/ATA/compute-budget
+ * program IDs. Per-vault PDAs (stv, evMint, vaultAta, withdrawRequest,
+ * managerRole) and strategy/lend state live in separate LUTs.
+ */
+import { AddressLookupTableAccount, Connection, PublicKey, TransactionInstruction } from "@solana/web3.js";
+/**
+ * Static p-stv-core accounts for the shared LUT. Order is deterministic so
+ * callers can cross-check against an on-chain LUT.
+ */
+export declare function getPstvCoreLutAddresses(programId?: PublicKey): PublicKey[];
+/**
+ * Build `extendLookupTable` ixs pushing every static p-stv-core account
+ * into `lutAddress`. Chunks at `MAX_ADDRS_PER_EXTEND` for safety.
+ *
+ * @param payer    Wallet funding + authority of the LUT.
+ * @param lutAddress LUT to extend (must be created via
+ *                   `AddressLookupTableProgram.createLookupTable` first).
+ * @param programId Override for p-stv-core program ID (defaults to mainnet).
+ */
+export declare function buildPstvCoreLutExtendIxs(payer: PublicKey, lutAddress: PublicKey, programId?: PublicKey): TransactionInstruction[];
+/**
+ * Fetch an `AddressLookupTableAccount` by address for use in
+ * `TransactionMessage.compileToV0Message([lutAccount])`.
+ */
+export declare function resolvePstvCoreLut(connection: Pick<Connection, "getAddressLookupTable">, lutAddress: PublicKey): Promise<AddressLookupTableAccount>;

package/dist/p-stv-core/lut.js

@@ -0,0 +1,81 @@
+"use strict";
+/**
+ * p-STV Core Address Lookup Table helpers.
+ *
+ * Packages the STATIC (per-program, not per-tx) p-stv-core accounts into a LUT
+ * so versioned transactions can compress them into a single 1-byte index.
+ *
+ * Usage:
+ *   // Owner flow (one-time):
+ *   const [createIx, lutAddress] = AddressLookupTableProgram.createLookupTable({...});
+ *   const extendIxs = buildPstvCoreLutExtendIxs(payer, lutAddress);
+ *   // send createIx + extendIxs
+ *
+ *   // Consumer flow (every tx):
+ *   const lutAccount = await resolvePstvCoreLut(connection, lutAddress);
+ *   const msg = new TransactionMessage({...}).compileToV0Message([lutAccount]);
+ *
+ * NOTE: Only program IDs, the GlobalConfig PDA, and token/ATA/compute-budget
+ * program IDs. Per-vault PDAs (stv, evMint, vaultAta, withdrawRequest,
+ * managerRole) and strategy/lend state live in separate LUTs.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPstvCoreLutAddresses = getPstvCoreLutAddresses;
+exports.buildPstvCoreLutExtendIxs = buildPstvCoreLutExtendIxs;
+exports.resolvePstvCoreLut = resolvePstvCoreLut;
+const web3_js_1 = require("@solana/web3.js");
+const spl_token_1 = require("@solana/spl-token");
+const constants_1 = require("./constants");
+const pda_1 = require("./pda");
+/** Max addresses per `extendLookupTable` ix (Solana runtime limit). */
+const MAX_ADDRS_PER_EXTEND = 20;
+/**
+ * Static p-stv-core accounts for the shared LUT. Order is deterministic so
+ * callers can cross-check against an on-chain LUT.
+ */
+function getPstvCoreLutAddresses(programId = constants_1.PROGRAM_ID) {
+    const [configPda] = (0, pda_1.findConfigPda)(programId);
+    return [
+        programId,
+        web3_js_1.SystemProgram.programId,
+        spl_token_1.TOKEN_PROGRAM_ID,
+        spl_token_1.TOKEN_2022_PROGRAM_ID,
+        spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID,
+        web3_js_1.ComputeBudgetProgram.programId,
+        configPda,
+    ];
+}
+/**
+ * Build `extendLookupTable` ixs pushing every static p-stv-core account
+ * into `lutAddress`. Chunks at `MAX_ADDRS_PER_EXTEND` for safety.
+ *
+ * @param payer    Wallet funding + authority of the LUT.
+ * @param lutAddress LUT to extend (must be created via
+ *                   `AddressLookupTableProgram.createLookupTable` first).
+ * @param programId Override for p-stv-core program ID (defaults to mainnet).
+ */
+function buildPstvCoreLutExtendIxs(payer, lutAddress, programId = constants_1.PROGRAM_ID) {
+    const addresses = getPstvCoreLutAddresses(programId);
+    const ixs = [];
+    for (let i = 0; i < addresses.length; i += MAX_ADDRS_PER_EXTEND) {
+        const chunk = addresses.slice(i, i + MAX_ADDRS_PER_EXTEND);
+        ixs.push(web3_js_1.AddressLookupTableProgram.extendLookupTable({
+            payer,
+            authority: payer,
+            lookupTable: lutAddress,
+            addresses: chunk,
+        }));
+    }
+    return ixs;
+}
+/**
+ * Fetch an `AddressLookupTableAccount` by address for use in
+ * `TransactionMessage.compileToV0Message([lutAccount])`.
+ */
+async function resolvePstvCoreLut(connection, lutAddress) {
+    const { value } = await connection.getAddressLookupTable(lutAddress);
+    if (!value) {
+        throw new Error(`p-stv-core LUT not found at ${lutAddress.toBase58()} — create it first with buildPstvCoreLutExtendIxs`);
+    }
+    return value;
+}

package/dist/p-stv-core/pda.d.ts

@@ -0,0 +1,30 @@
+import { PublicKey } from "@solana/web3.js";
+import BN from "bn.js";
+export declare function findConfigPda(programId?: PublicKey): [PublicKey, number];
+export declare function findStvPda(vaultId: number | BN, programId?: PublicKey): [PublicKey, number];
+export declare function findEvMintPda(vaultId: number | BN, programId?: PublicKey): [PublicKey, number];
+export declare function findWithdrawRequestPda(stv: PublicKey, user: PublicKey, epochId: number, programId?: PublicKey): [PublicKey, number];
+/**
+ * Derive the migrate-kind WithdrawRequest PDA.
+ * Seeds: `["migrate_request", stv, user, epoch_id_le4]`.
+ *
+ * Distinct prefix from `findWithdrawRequestPda` so a user can hold both a
+ * withdraw and a migrate request for the same (stv, user, epoch) without
+ * a PDA collision. `stv` is the SOURCE STV; `epochId` is the source STV's
+ * `currentEpochId` at request time.
+ */
+export declare function findMigrateRequestPda(stv: PublicKey, user: PublicKey, epochId: number, programId?: PublicKey): [PublicKey, number];
+/**
+ * Derive the per-user delayed deposit request PDA.
+ * Seeds: `["delayed_deposit", stv, user, epoch_id_le4]`.
+ */
+export declare function findDelayedDepositRequestPda(stv: PublicKey, user: PublicKey, epochId: number, programId?: PublicKey): [PublicKey, number];
+/**
+ * Derive the per-STV `ManagerRole` PDA for p-STV Core.
+ * Seeds: `["manager", stv, manager]`.
+ *
+ * Note the per-program prefix on the name: each Elemental program has its
+ * own `ManagerRole` PDA scoped to a different anchor account
+ * (`elemental-lend` → strategy_state, `jlpd-strategy` → config).
+ */
+export declare function findStvManagerRolePda(stv: PublicKey, manager: PublicKey, programId?: PublicKey): [PublicKey, number];

package/dist/p-stv-core/pda.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findConfigPda = findConfigPda;
+exports.findStvPda = findStvPda;
+exports.findEvMintPda = findEvMintPda;
+exports.findWithdrawRequestPda = findWithdrawRequestPda;
+exports.findMigrateRequestPda = findMigrateRequestPda;
+exports.findDelayedDepositRequestPda = findDelayedDepositRequestPda;
+exports.findStvManagerRolePda = findStvManagerRolePda;
+const web3_js_1 = require("@solana/web3.js");
+const bn_js_1 = __importDefault(require("bn.js"));
+const constants_1 = require("./constants");
+function findConfigPda(programId = constants_1.PROGRAM_ID) {
+    return web3_js_1.PublicKey.findProgramAddressSync([constants_1.CONFIG_SEED], programId);
+}
+function findStvPda(vaultId, programId = constants_1.PROGRAM_ID) {
+    const id = new bn_js_1.default(vaultId);
+    return web3_js_1.PublicKey.findProgramAddressSync([constants_1.STV_SEED, id.toArrayLike(Buffer, "le", 8)], programId);
+}
+function findEvMintPda(vaultId, programId = constants_1.PROGRAM_ID) {
+    const id = new bn_js_1.default(vaultId);
+    return web3_js_1.PublicKey.findProgramAddressSync([constants_1.EV_MINT_SEED, id.toArrayLike(Buffer, "le", 8)], programId);
+}
+function findWithdrawRequestPda(stv, user, epochId, programId = constants_1.PROGRAM_ID) {
+    const epochBuf = Buffer.alloc(4);
+    epochBuf.writeUInt32LE(epochId, 0);
+    return web3_js_1.PublicKey.findProgramAddressSync([constants_1.WITHDRAW_REQUEST_SEED, stv.toBuffer(), user.toBuffer(), epochBuf], programId);
+}
+/**
+ * Derive the migrate-kind WithdrawRequest PDA.
+ * Seeds: `["migrate_request", stv, user, epoch_id_le4]`.
+ *
+ * Distinct prefix from `findWithdrawRequestPda` so a user can hold both a
+ * withdraw and a migrate request for the same (stv, user, epoch) without
+ * a PDA collision. `stv` is the SOURCE STV; `epochId` is the source STV's
+ * `currentEpochId` at request time.
+ */
+function findMigrateRequestPda(stv, user, epochId, programId = constants_1.PROGRAM_ID) {
+    const epochBuf = Buffer.alloc(4);
+    epochBuf.writeUInt32LE(epochId, 0);
+    return web3_js_1.PublicKey.findProgramAddressSync([constants_1.MIGRATE_REQUEST_SEED, stv.toBuffer(), user.toBuffer(), epochBuf], programId);
+}
+/**
+ * Derive the per-user delayed deposit request PDA.
+ * Seeds: `["delayed_deposit", stv, user, epoch_id_le4]`.
+ */
+function findDelayedDepositRequestPda(stv, user, epochId, programId = constants_1.PROGRAM_ID) {
+    const epochBuf = Buffer.alloc(4);
+    epochBuf.writeUInt32LE(epochId, 0);
+    return web3_js_1.PublicKey.findProgramAddressSync([constants_1.DELAYED_DEPOSIT_SEED, stv.toBuffer(), user.toBuffer(), epochBuf], programId);
+}
+/**
+ * Derive the per-STV `ManagerRole` PDA for p-STV Core.
+ * Seeds: `["manager", stv, manager]`.
+ *
+ * Note the per-program prefix on the name: each Elemental program has its
+ * own `ManagerRole` PDA scoped to a different anchor account
+ * (`elemental-lend` → strategy_state, `jlpd-strategy` → config).
+ */
+function findStvManagerRolePda(stv, manager, programId = constants_1.PROGRAM_ID) {
+    return web3_js_1.PublicKey.findProgramAddressSync([constants_1.MANAGER_SEED, stv.toBuffer(), manager.toBuffer()], programId);
+}

package/dist/p-stv-core/prices.d.ts

@@ -0,0 +1,20 @@
+/**
+ * USD price fetcher for display purposes.
+ *
+ * Stablecoins (USDC, JupUSD) are hardcoded to $1.00.
+ * Other tokens use Jupiter swap quote API (1 unit → USDC) to derive price.
+ */
+export interface TokenPrice {
+    mint: string;
+    price: number;
+}
+/**
+ * Fetch USD prices for a list of token mint addresses.
+ *
+ * Stablecoins (USDC, JupUSD) are hardcoded to $1.00.
+ * Other tokens: fetches a Jupiter swap quote (1 unit → USDC) to derive price.
+ *
+ * @param mints - Array of mint address strings (base58)
+ * @returns Record<mint, usdPrice>
+ */
+export declare function fetchUsdPrices(mints: string[]): Promise<Record<string, number>>;

package/dist/p-stv-core/prices.js

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * USD price fetcher for display purposes.
+ *
+ * Stablecoins (USDC, JupUSD) are hardcoded to $1.00.
+ * Other tokens use Jupiter swap quote API (1 unit → USDC) to derive price.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchUsdPrices = fetchUsdPrices;
+const USDC_MINT = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
+const JUPUSD_MINT = "JuprjznTrTSp2UFa3ZBUFgwdAmtZCq4MQCwysN55USD";
+/** Mints pegged 1:1 to USD */
+const STABLE_MINTS = new Set([USDC_MINT, JUPUSD_MINT]);
+/** Decimals per mint (for computing 1 unit in base units) */
+const MINT_DECIMALS = {
+    "So11111111111111111111111111111111111111112": 9, // SOL
+    "3NZ9JMVBmGAqocybic2c7LQCJScmgsAZ6vQqTDzcqmJh": 8, // wBTC
+    "7vfCXTUXx5WJV5JADk17DUJ4ksgau7utNKj4b963voxs": 8, // wETH
+};
+const USDC_DECIMALS = 6;
+const JUPITER_QUOTE_API = "https://api.jup.ag/swap/v1/quote";
+function getJupiterApiKey() {
+    if (typeof process !== "undefined" && process.env) {
+        return process.env.NEXT_PUBLIC_JUPITER_API_KEY || process.env.JUPITER_API_KEY;
+    }
+    return undefined;
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Fetch USD prices for a list of token mint addresses.
+ *
+ * Stablecoins (USDC, JupUSD) are hardcoded to $1.00.
+ * Other tokens: fetches a Jupiter swap quote (1 unit → USDC) to derive price.
+ *
+ * @param mints - Array of mint address strings (base58)
+ * @returns Record<mint, usdPrice>
+ */
+async function fetchUsdPrices(mints) {
+    const prices = {};
+    const toFetch = [];
+    for (const mint of mints) {
+        if (STABLE_MINTS.has(mint)) {
+            prices[mint] = 1.0;
+        }
+        else if (MINT_DECIMALS[mint] !== undefined) {
+            toFetch.push(mint);
+        }
+    }
+    if (toFetch.length === 0)
+        return prices;
+    const apiKey = getJupiterApiKey();
+    const headers = {};
+    if (apiKey)
+        headers["x-api-key"] = apiKey;
+    // Fetch prices in parallel (1 unit of each → USDC)
+    const results = await Promise.allSettled(toFetch.map(async (mint) => {
+        const decimals = MINT_DECIMALS[mint];
+        const oneUnit = Math.pow(10, decimals).toString();
+        const url = `${JUPITER_QUOTE_API}?inputMint=${mint}&outputMint=${USDC_MINT}&amount=${oneUnit}&slippageBps=50`;
+        const resp = await fetch(url, { headers });
+        if (!resp.ok)
+            return null;
+        const data = (await resp.json());
+        const outAmount = data?.outAmount;
+        if (!outAmount)
+            return null;
+        return { mint, price: Number(outAmount) / Math.pow(10, USDC_DECIMALS) };
+    }));
+    for (const result of results) {
+        if (result.status === "fulfilled" && result.value) {
+            prices[result.value.mint] = result.value.price;
+        }
+    }
+    return prices;
+}

package/dist/p-stv-core/remaining-accounts.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Remaining accounts builders for p-STV Core instructions.
+ *
+ * These functions build the complete `remainingAccounts` arrays needed for
+ * deposit, claim_withdraw, and process_epoch instructions, pulling all the
+ * lend + protocol AUM + strategy pair + auto-route/unroute account building
+ * logic out of the frontend and into the SDK.
+ */
+import { AccountMeta, PublicKey, TransactionInstruction } from "@solana/web3.js";
+import type { SolanaConnection } from "../common/connection";
+export type { SolanaConnection };
+/** Minimal vault shape required by the context builders. */
+export interface VaultInfo {
+    /** STV account address */
+    address: PublicKey;
+    /** Base token mint */
+    baseMint: PublicKey;
+    /** Lend program (PublicKey.default if not active) */
+    lendProgram: PublicKey;
+    /** Immutable strategy program (PublicKey.default if none) */
+    strategy: PublicKey;
+    /**
+     * Token program for the base mint (SPL Token or Token-2022).
+     *
+     * This MUST match the token_program passed as a fixed account to the p-stv-core
+     * instruction. The on-chain handler derives lend_base_ata using
+     * [strategy_state, token_program, base_mint] (check_lend_base_ata, lend.rs:61)
+     * and rejects a mismatch. Defaults to SPL Token when omitted for back-compat,
+     * but callers MUST supply the correct value for Token-2022 mints.
+     */
+    tokenProgram?: PublicKey;
+}
+export interface DepositContext {
+    remainingAccounts: AccountMeta[];
+    protocolAumCount: number;
+    autoRouteCount: number;
+    preInstructions: TransactionInstruction[];
+}
+export interface ClaimWithdrawContext {
+    remainingAccounts: AccountMeta[];
+    autoUnrouteCount: number;
+    /** Protocol-AUM accounts placed between the 4 fixed lend accounts and auto-unroute,
+     *  feeding the pre-unsweep update_aum refresh. Pass to createClaimWithdrawIx.protocolAumCount. */
+    protocolAumCount: number;
+    /**
+     * Pre-instructions to add before the claim_withdraw ix.
+     * Currently always empty — see DepositContext.preInstructions.
+     */
+    preInstructions: TransactionInstruction[];
+}
+export interface DepositToStrategyContext {
+    remainingAccounts: AccountMeta[];
+    /** Number of protocol AUM accounts (after the 4 fixed lend accounts). */
+    protocolAumCount: number;
+    autoUnrouteCount: number;
+    preInstructions: TransactionInstruction[];
+}
+export interface ProcessEpochContext {
+    remainingAccounts: AccountMeta[];
+    protocolAumCount: number;
+    /**
+     * Pre-instructions to add before the process_epoch ix.
+     * Currently always empty — see DepositContext.preInstructions.
+     */
+    preInstructions: TransactionInstruction[];
+}
+/**
+ * Build the complete remaining_accounts for a deposit instruction.
+ *
+ * Layout: [4 lend, N protocol_aum, M*2+P strategy_pairs, K auto_route]
+ *
+ * - If lend is active, derives lend PDAs and fetches protocol AUM accounts
+ * - Builds strategy pair accounts for each active strategy
+ * - If USDC + Jupiter Lend registered, appends auto-route accounts
+ * - Checks for stale kVaults (returned in preInstructions once invest ix is available)
+ */
+export declare function buildDepositContext(connection: SolanaConnection, vault: VaultInfo, payer?: PublicKey): Promise<DepositContext>;
+/**
+ * Build the complete remaining_accounts for a claim_withdraw instruction.
+ *
+ * Layout: [4 lend, K auto_unroute]
+ *
+ * - If lend is active, derives lend PDAs
+ * - If USDC + Jupiter Lend, appends auto-unroute accounts
+ */
+export declare function buildClaimWithdrawContext(connection: SolanaConnection, vault: VaultInfo): Promise<ClaimWithdrawContext>;
+/**
+ * Build the complete remaining_accounts for a deposit_to_strategy instruction.
+ *
+ * Layout: [4 fixed lend, N protocol_aum, K auto_unroute]
+ *
+ * - Fixed lend accounts (if lend is active)
+ * - Protocol AUM accounts: required by the on-chain handler to refresh lend
+ *   valuation via update_lend_aum before the reserved_base liquidity lock check
+ * - Auto-unroute accounts: forwarded to the lend withdraw CPI for unsweep
+ *
+ * The `connection` parameter is required to fetch LendStrategyState and
+ * resolve protocol AUM accounts.
+ */
+export declare function buildDepositToStrategyContext(connection: SolanaConnection, vault: VaultInfo): Promise<DepositToStrategyContext>;
+/**
+ * Build the complete remaining_accounts for a process_epoch instruction.
+ *
+ * @param phase - 'lockPps': needs lend + protocol AUM + strategy pairs for NAV.
+ *                'advance': empty remaining_accounts.
+ */
+export declare function buildProcessEpochContext(connection: SolanaConnection, vault: VaultInfo, phase: "lockPps" | "advance"): Promise<ProcessEpochContext>;