@elmntl/jlpd-sdk 0.2.0 → 0.13.4

package/dist/elemental-lend/accounts.js

@@ -0,0 +1,354 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deserializeLendStrategyState = deserializeLendStrategyState;
+exports.deserializeLendStvPosition = deserializeLendStvPosition;
+exports.deserializeManagerRole = deserializeManagerRole;
+exports.fetchLendStrategyState = fetchLendStrategyState;
+exports.fetchLendStrategyStateByAddress = fetchLendStrategyStateByAddress;
+exports.fetchLendStvPosition = fetchLendStvPosition;
+exports.fetchManagerRole = fetchManagerRole;
+exports.fetchAllLendStrategyStates = fetchAllLendStrategyStates;
+exports.fetchManagersForStrategy = fetchManagersForStrategy;
+exports.buildProtocolAccountsForAum = buildProtocolAccountsForAum;
+const web3_js_1 = require("@solana/web3.js");
+const buffer_1 = require("../common/buffer");
+const strategy_interface_1 = require("../common/strategy-interface");
+const constants_1 = require("./constants");
+const pda_1 = require("./pda");
+// ---------------------------------------------------------------------------
+// Deserialization
+//
+// All offsets below INCLUDE the 8-byte Anchor account discriminator. Layout
+// blocks above each parser show the field map; the helpers in
+// `common/buffer.ts` validate that `offset + width <= data.length` so a
+// drift between this file and the on-chain layout fails loudly with a
+// `RangeError` rather than returning garbage.
+// ---------------------------------------------------------------------------
+/**
+ * LendStrategyState — Elemental Lend's per-base-mint strategy account. Total 536 bytes.
+ *
+ * Layout (offsets include the 8-byte discriminator):
+ *   [  0..  8]  discriminator                    (sha256("account:StrategyState")[..8] —
+ *                                                  shared with jlpd-strategy)
+ *   --- StrategyStateHeader (104 bytes, identical across all strategy programs) ---
+ *   [  8.. 40]  baseMint                          Pubkey
+ *   [ 40.. 72]  authority                         Pubkey   (p-stv-core program)
+ *   [ 72.. 80]  pps                               u64      (scaled by PPS_DECIMALS = 10^9)
+ *   [ 80.. 88]  totalAum                          u64
+ *   [ 88.. 96]  totalShares                       u64
+ *   [ 96..104]  lastUpdated                       u64      (unix seconds)
+ *   [104..106]  flags                             u16      (FLAG_PAUSED, …)
+ *   [106..107]  version                           u8
+ *   [107..108]  bump                              u8
+ *   [108..112]  _headerPadding                    [u8; 4]
+ *   --- Custom Elemental Lend fields (424 bytes) ---
+ *   [112..144]  admin                             Pubkey
+ *   [144..464]  protocols[10]                     [Pubkey; 10]   (registered protocol accounts)
+ *   [464..465]  protocolCount                     u8
+ *   [465..466]  managerCount                      u8
+ *   [466..472]  _padding                          [u8; 6]
+ *   [472..536]  _reserved                         [u8; 64]
+ */
+function deserializeLendStrategyState(data) {
+    if (data.length < constants_1.STRATEGY_STATE_SIZE) {
+        throw new Error(`LendStrategyState data too short: ${data.length} < ${constants_1.STRATEGY_STATE_SIZE}`);
+    }
+    const disc = data.subarray(0, 8);
+    if (!disc.equals(constants_1.DISC_STRATEGY_STATE)) {
+        throw new Error(`Invalid LendStrategyState discriminator`);
+    }
+    const protocolCount = (0, buffer_1.readU8)(data, 464);
+    const managerCount = (0, buffer_1.readU8)(data, 465);
+    const protocols = [];
+    for (let i = 0; i < protocolCount; i++) {
+        protocols.push((0, buffer_1.readPubkey)(data, 144 + i * 32));
+    }
+    return {
+        // Header
+        baseMint: (0, buffer_1.readPubkey)(data, 8),
+        authority: (0, buffer_1.readPubkey)(data, 40),
+        pps: (0, buffer_1.readU64)(data, 72),
+        totalAum: (0, buffer_1.readU64)(data, 80),
+        totalShares: (0, buffer_1.readU64)(data, 88),
+        lastUpdated: (0, buffer_1.readU64)(data, 96),
+        flags: (0, buffer_1.readU16)(data, 104),
+        version: (0, buffer_1.readU8)(data, 106),
+        bump: (0, buffer_1.readU8)(data, 107),
+        // Custom
+        admin: (0, buffer_1.readPubkey)(data, 112),
+        protocols,
+        protocolCount,
+        managerCount,
+    };
+}
+/**
+ * StvPosition — per-STV virtual share record. Total 120 bytes.
+ *
+ * The on-disk layout is identical across elemental-lend and jlpd-strategy
+ * (`StvPosition` from `common/strategy-interface.ts`). The 8-byte
+ * discriminator validation here distinguishes the two so a `JlpdStvPosition`
+ * can't be parsed as a lend position by mistake. See
+ * `common/strategy-interface.ts` for the field-by-field layout.
+ */
+function deserializeLendStvPosition(data) {
+    if (data.length < constants_1.STV_POSITION_SIZE) {
+        throw new Error(`StvPosition data too short: ${data.length} < ${constants_1.STV_POSITION_SIZE}`);
+    }
+    const disc = data.subarray(0, 8);
+    if (!disc.equals(constants_1.DISC_STV_POSITION)) {
+        throw new Error(`Invalid StvPosition discriminator`);
+    }
+    return (0, strategy_interface_1.deserializeStvPosition)(data);
+}
+/**
+ * ManagerRole — per-(strategy_state, manager) authorization. Total 80 bytes.
+ *
+ * Layout (offsets include the 8-byte discriminator):
+ *   [  0..  8]  discriminator       (sha256("account:ManagerRole")[..8] —
+ *                                     shared with p-stv-core + jlpd-strategy)
+ *   [  8.. 40]  strategyState        Pubkey
+ *   [ 40.. 72]  manager              Pubkey
+ *   [ 72.. 73]  bump                 u8
+ *   [ 73.. 80]  _padding             [u8; 7]
+ */
+function deserializeManagerRole(data) {
+    if (data.length < constants_1.MANAGER_ROLE_SIZE) {
+        throw new Error(`ManagerRole data too short: ${data.length} < ${constants_1.MANAGER_ROLE_SIZE}`);
+    }
+    const disc = data.subarray(0, 8);
+    if (!disc.equals(constants_1.DISC_MANAGER_ROLE)) {
+        throw new Error(`Invalid ManagerRole discriminator`);
+    }
+    return {
+        strategyState: (0, buffer_1.readPubkey)(data, 8),
+        manager: (0, buffer_1.readPubkey)(data, 40),
+        bump: (0, buffer_1.readU8)(data, 72),
+    };
+}
+// ---------------------------------------------------------------------------
+// Fetch Helpers
+// ---------------------------------------------------------------------------
+async function fetchLendStrategyState(connection, baseMint, programId = constants_1.PROGRAM_ID) {
+    const [pda] = (0, pda_1.findStrategyStatePda)(baseMint, programId);
+    const info = await connection.getAccountInfo(pda);
+    if (!info)
+        throw new Error(`LendStrategyState not found for mint ${baseMint.toBase58()}`);
+    return deserializeLendStrategyState(info.data);
+}
+async function fetchLendStrategyStateByAddress(connection, address) {
+    const info = await connection.getAccountInfo(address);
+    if (!info)
+        throw new Error(`LendStrategyState not found at ${address.toBase58()}`);
+    return deserializeLendStrategyState(info.data);
+}
+async function fetchLendStvPosition(connection, stv, programId = constants_1.PROGRAM_ID) {
+    const [pda] = (0, pda_1.findStvPositionPda)(stv, programId);
+    const info = await connection.getAccountInfo(pda);
+    if (!info)
+        throw new Error(`StvPosition not found for stv ${stv.toBase58()}`);
+    return deserializeLendStvPosition(info.data);
+}
+async function fetchManagerRole(connection, strategyState, manager, programId = constants_1.PROGRAM_ID) {
+    const [pda] = (0, pda_1.findLendManagerRolePda)(strategyState, manager, programId);
+    const info = await connection.getAccountInfo(pda);
+    if (!info)
+        return null;
+    return deserializeManagerRole(info.data);
+}
+// ---------------------------------------------------------------------------
+// GPA Helpers
+// ---------------------------------------------------------------------------
+async function fetchAllLendStrategyStates(connection, programId = constants_1.PROGRAM_ID) {
+    const accounts = await connection.getProgramAccounts(programId, {
+        filters: [
+            { dataSize: constants_1.STRATEGY_STATE_SIZE },
+            { memcmp: { offset: 0, bytes: constants_1.DISC_STRATEGY_STATE.toString("base64"), encoding: "base64" } },
+        ],
+    });
+    return accounts.map((a) => [a.pubkey, deserializeLendStrategyState(a.account.data)]);
+}
+async function fetchManagersForStrategy(connection, strategyState, programId = constants_1.PROGRAM_ID) {
+    const accounts = await connection.getProgramAccounts(programId, {
+        filters: [
+            { dataSize: constants_1.MANAGER_ROLE_SIZE },
+            { memcmp: { offset: 0, bytes: constants_1.DISC_MANAGER_ROLE.toString("base64"), encoding: "base64" } },
+            { memcmp: { offset: 8, bytes: strategyState.toBuffer().toString("base64"), encoding: "base64" } },
+        ],
+    });
+    return accounts.map((a) => [a.pubkey, deserializeManagerRole(a.account.data)]);
+}
+// ---------------------------------------------------------------------------
+// Protocol Account Builders
+// ---------------------------------------------------------------------------
+/**
+ * Build remaining_accounts for the update_aum CPI on elemental-lend.
+ *
+ * COMPLETENESS REQUIREMENT: Every registered protocol MUST be present in the
+ * returned array. The on-chain update_aum.rs validates a completeness bitmap
+ * (seen == expected) and rejects with `IncompleteProtocolAccounts` if any
+ * registered protocol is missing (update_aum.rs:265). An uninitialized share
+ * ATA is NOT an error — the on-chain `read_protocol_share_ata` checks the
+ * canonical ATA key and returns 0 for uninitialised accounts (update_aum.rs:314).
+ *
+ * Canonical ATA addresses are DERIVED (not fetched from token account lists) so
+ * that uninitialized ATAs are included. The on-chain `is_canonical_ata`
+ * (update_aum.rs:30-37) pins the SINGLE SPL-Token ATA derivation — all Elemental
+ * Lend receipt mints (Kamino kvTokens, Jupiter fTokens) are SPL-Token mints. Share
+ * ATAs are ALWAYS derived under the SPL Token program id regardless of the caller's
+ * `tokenProgramId`; passing a Token-2022 id would yield a different ATA address that
+ * the on-chain handler rejects.
+ *
+ *   - kVault (KvauG...): [kvtoken_ata, vault_state] (2 accounts)
+ *   - Jupiter Lend (jup3Y...): [ftoken_ata, lending_account, rewards_rate_model] (3 accounts)
+ *
+ * @param connection - Solana connection (needed to fetch protocol account data)
+ * @param strategy - Deserialized LendStrategyState (with protocols list)
+ * @param strategyStatePda - The strategy state PDA (owns the share-token ATAs)
+ * @param tokenProgramId - Token program for the BASE mint ATA derivation. Share-mint ATAs
+ *   (kvToken, fToken) are always derived under SPL Token regardless of this value.
+ * @param protocolCache - Optional pre-resolved cache of protocol specs keyed by protocol
+ *   pubkey base-58. On a cache hit the `getMultipleAccountsInfo` fetch is skipped for
+ *   that protocol. On a miss the protocol is fetched and the result is stored in the
+ *   cache for future calls. Pass a shared `Map` across repeated calls (e.g. in a keeper
+ *   loop) to avoid refetching mostly-static protocol metadata every iteration.
+ *
+ *   **Cache contract (FIX 4 — staleness):** The cache is caller-owned and intentionally
+ *   short-lived / slot-scoped. Callers are responsible for invalidation. For Jupiter Lend
+ *   protocols the cached `data` includes the `fTokenMint` and `rewardsRateModel` fields;
+ *   if a Jupiter Lend pool's `rewardsRateModel` account changes (rare, governance-gated)
+ *   the cache entry becomes stale. Always construct a fresh `Map` (or clear the existing
+ *   one) at the start of each slot/epoch boundary or after any on-chain governance change
+ *   to the protocol accounts. Do NOT hold the same cache instance across multiple slots in
+ *   latency-sensitive paths — create a new `Map()` per transaction-building pass instead.
+ */
+async function buildProtocolAccountsForAum(connection, strategy, strategyStatePda, 
+// Retained for signature stability + positional `protocolCache`; share-mint ATAs are
+// pinned to SPL Token (the program's is_canonical_ata is SPL-only), so the caller's
+// token program is no longer used for any derivation in this builder.
+_tokenProgramId, protocolCache) {
+    const accounts = [];
+    if (strategy.protocolCount === 0)
+        return accounts;
+    // Only fetch the active slice — strategy.protocols is a fixed-size array but only
+    // the first protocolCount entries are registered; the rest are default pubkeys.
+    const activeProtocols = strategy.protocols.slice(0, strategy.protocolCount);
+    // Determine which protocols need an RPC fetch (cache miss or no cache).
+    const needFetch = [];
+    const needFetchIdx = [];
+    for (let i = 0; i < activeProtocols.length; i++) {
+        const key = activeProtocols[i].toBase58();
+        if (!protocolCache || !protocolCache.has(key)) {
+            needFetch.push(activeProtocols[i]);
+            needFetchIdx.push(i);
+        }
+    }
+    // Batch-fetch all cache-miss protocols in one RPC call.
+    let fetchedInfos = [];
+    if (needFetch.length > 0) {
+        fetchedInfos = await connection.getMultipleAccountsInfo(needFetch);
+    }
+    // FIX 3: Build a direct map from active-protocol index → resolved {owner, data}.
+    // Resolve each protocol's result BEFORE writing anything into the cache, so the
+    // build loop selects fetch results by the protocol's position in needFetchIdx
+    // rather than by post-mutation cache.has() — which would desync fetchIdx when
+    // some fetched protocols return null (null results are not written to the cache,
+    // so a later null-result protocol would have its cache.has() == false in the build
+    // loop, but fetchIdx would be pointing to the wrong slot because prior successful
+    // fetches were already consumed from fetchedInfos via cache hits).
+    const resolved = new Array(activeProtocols.length);
+    for (let j = 0; j < needFetchIdx.length; j++) {
+        const i = needFetchIdx[j];
+        const info = fetchedInfos[j];
+        const keyStr = activeProtocols[i].toBase58();
+        if (!info) {
+            throw new Error(`buildProtocolAccountsForAum: protocol account not found: ${keyStr} (index ${i})`);
+        }
+        resolved[i] = { owner: info.owner, data: info.data };
+    }
+    // Fill cached protocols into resolved[], then populate the cache from fresh fetches.
+    // Separating these two steps ensures the cache is only written AFTER all results are
+    // resolved — so the build loop below always drives selection from `resolved[]` (index-
+    // based), never from a post-mutation cache.has() check.
+    for (let i = 0; i < activeProtocols.length; i++) {
+        if (resolved[i] === undefined) {
+            // Must be a cache hit (was excluded from needFetch).
+            const cached = protocolCache.get(activeProtocols[i].toBase58());
+            resolved[i] = cached;
+        }
+    }
+    // Populate cache for future calls (only for successfully fetched entries).
+    if (protocolCache) {
+        for (let j = 0; j < needFetchIdx.length; j++) {
+            const i = needFetchIdx[j];
+            protocolCache.set(activeProtocols[i].toBase58(), resolved[i]);
+        }
+    }
+    // Build protocol account groups — drive selection from resolved[] by index.
+    // The emitted AccountMeta[] order and flags are identical whether the protocol
+    // was cached or freshly fetched (both paths produce the same resolved[i]).
+    for (let i = 0; i < activeProtocols.length; i++) {
+        const protocolKey = activeProtocols[i];
+        const keyStr = protocolKey.toBase58();
+        const { owner, data } = resolved[i];
+        if (owner.equals(constants_1.KAMINO_VAULT_PROGRAM)) {
+            // kVault: AUM accounts = [kvtoken_ata, vault_state]
+            //
+            // Derive the shares_mint PDA: ["shares", vault_state] under KAMINO_VAULT_PROGRAM.
+            // Derive the canonical kvToken ATA for strategyStatePda — even if uninitialized,
+            // the on-chain handler accepts it (returns 0 for data.len() < 72).
+            // Share ATAs are always SPL-Token (is_canonical_ata pins spl_token derivation).
+            const [sharesMint] = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("shares"), protocolKey.toBuffer()], constants_1.KAMINO_VAULT_PROGRAM);
+            const kvTokenAta = findAtaAddress(sharesMint, strategyStatePda, SPL_TOKEN_PROGRAM_ID);
+            accounts.push({ pubkey: kvTokenAta, isSigner: false, isWritable: false }, { pubkey: protocolKey, isSigner: false, isWritable: false });
+        }
+        else if (owner.equals(constants_1.JUP_LEND_EARN_PROGRAM)) {
+            // Jupiter Lend Earn: AUM accounts = [ftoken_ata, lending_account, rewards_rate_model]
+            //
+            // Lending account layout (Jupiter Lend Earn — Anchor 8-byte disc):
+            //   [  0..  8]  discriminator
+            //   [  8.. 40]  authority             Pubkey
+            //   [ 40.. 72]  fTokenMint            Pubkey
+            //   [ 72.. 75]  _padding              [u8; 3]
+            //   [ 75..107]  rewardsRateModel      Pubkey
+            //   [107..]     remaining fields      …
+            if (data.length < 107) {
+                throw new Error(`buildProtocolAccountsForAum: Jupiter Lend account data too short at ${keyStr}`);
+            }
+            const fTokenMint = new web3_js_1.PublicKey(data.subarray(40, 72));
+            const rewardsRateModel = new web3_js_1.PublicKey(data.subarray(75, 107));
+            // Share ATAs are always SPL-Token — is_canonical_ata (update_aum.rs:30-37) pins
+            // the spl_token derivation. Jupiter fTokens are SPL-Token mints; a Token-2022
+            // derivation would produce a different key the on-chain handler rejects.
+            const fTokenAta = findAtaAddress(fTokenMint, strategyStatePda, SPL_TOKEN_PROGRAM_ID);
+            accounts.push({ pubkey: fTokenAta, isSigner: false, isWritable: false }, { pubkey: protocolKey, isSigner: false, isWritable: false }, { pubkey: rewardsRateModel, isSigner: false, isWritable: false });
+        }
+        else {
+            // Unknown protocol owner — reject loudly rather than silently skipping.
+            // An unknown protocol would make the on-chain completeness check fail anyway.
+            throw new Error(`buildProtocolAccountsForAum: unknown protocol owner ${owner.toBase58()} at ${keyStr}`);
+        }
+    }
+    return accounts;
+}
+/** Associated Token Program ID (constant; same across SPL Token and Token-2022 namespaces). */
+const ASSOCIATED_TOKEN_PROGRAM_ID_KEY = new web3_js_1.PublicKey("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL");
+/**
+ * SPL Token program ID. Used to pin ATA derivations for lend receipt/share mints.
+ *
+ * The on-chain `is_canonical_ata` (update_aum.rs:30-37) pins the SINGLE SPL-Token ATA
+ * derivation — all Elemental Lend receipt mints (Kamino kvTokens, Jupiter fTokens) are
+ * SPL-Token mints, verified on-chain 2026-06-13. Deriving under Token-2022 would yield
+ * a different address that the on-chain handler rejects.
+ */
+const SPL_TOKEN_PROGRAM_ID = new web3_js_1.PublicKey("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
+/**
+ * Derive an Associated Token Account address.
+ *
+ * PDA([owner, tokenProgram, mint], ASSOCIATED_TOKEN_PROGRAM_ID).
+ * Inline helper scoped to this module so elemental-lend/accounts.ts has no
+ * cross-module dependency on common/ata.ts.
+ */
+function findAtaAddress(mint, owner, tokenProgram) {
+    const [ata] = web3_js_1.PublicKey.findProgramAddressSync([owner.toBuffer(), tokenProgram.toBuffer(), mint.toBuffer()], ASSOCIATED_TOKEN_PROGRAM_ID_KEY);
+    return ata;
+}

package/dist/elemental-lend/constants.d.ts

@@ -0,0 +1,25 @@
+import { PublicKey } from "@solana/web3.js";
+export declare const PROGRAM_ID: PublicKey;
+export declare const STRATEGY_STATE_SEED: Buffer<ArrayBuffer>;
+export declare const POSITION_SEED: Buffer<ArrayBuffer>;
+export declare const MANAGER_SEED: Buffer<ArrayBuffer>;
+export { DISC_STRATEGY_STATE, DISC_STV_POSITION, DISC_MANAGER_ROLE, } from "../common/constants";
+export declare const IX_INIT_OR_UPDATE_STRATEGY: Buffer<ArrayBuffer>;
+export declare const IX_CLOSE_STRATEGY: Buffer<ArrayBuffer>;
+export declare const IX_RESET_STRATEGY: Buffer<ArrayBuffer>;
+export declare const IX_ADD_MANAGER: Buffer<ArrayBuffer>;
+export declare const IX_REMOVE_MANAGER: Buffer<ArrayBuffer>;
+export declare const IX_KVAULT_DEPOSIT: Buffer<ArrayBuffer>;
+export declare const IX_KVAULT_WITHDRAW: Buffer<ArrayBuffer>;
+export declare const IX_JUP_LEND_DEPOSIT: Buffer<ArrayBuffer>;
+export declare const IX_JUP_LEND_WITHDRAW: Buffer<ArrayBuffer>;
+export declare const STRATEGY_STATE_SIZE = 536;
+export declare const STV_POSITION_SIZE = 120;
+export declare const MANAGER_ROLE_SIZE = 80;
+export declare const FLAG_PAUSED = 1;
+export declare const MAX_PROTOCOLS = 10;
+export declare const KAMINO_VAULT_PROGRAM: PublicKey;
+export declare const KLEND_PROGRAM: PublicKey;
+/** Jupiter Lend Earn program (the supply-side product). */
+export declare const JUP_LEND_EARN_PROGRAM: PublicKey;
+export { PPS_DECIMALS } from "../common/constants";

package/dist/elemental-lend/constants.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PPS_DECIMALS = exports.JUP_LEND_EARN_PROGRAM = exports.KLEND_PROGRAM = exports.KAMINO_VAULT_PROGRAM = exports.MAX_PROTOCOLS = exports.FLAG_PAUSED = exports.MANAGER_ROLE_SIZE = exports.STV_POSITION_SIZE = exports.STRATEGY_STATE_SIZE = exports.IX_JUP_LEND_WITHDRAW = exports.IX_JUP_LEND_DEPOSIT = exports.IX_KVAULT_WITHDRAW = exports.IX_KVAULT_DEPOSIT = exports.IX_REMOVE_MANAGER = exports.IX_ADD_MANAGER = exports.IX_RESET_STRATEGY = exports.IX_CLOSE_STRATEGY = exports.IX_INIT_OR_UPDATE_STRATEGY = exports.DISC_MANAGER_ROLE = exports.DISC_STV_POSITION = exports.DISC_STRATEGY_STATE = exports.MANAGER_SEED = exports.POSITION_SEED = exports.STRATEGY_STATE_SEED = exports.PROGRAM_ID = void 0;
+const web3_js_1 = require("@solana/web3.js");
+exports.PROGRAM_ID = new web3_js_1.PublicKey("EHaGVh7p6xSxZsq4CcEEZhnV5adDvWg1gS1Rc5rLiBpC");
+// PDA Seeds
+exports.STRATEGY_STATE_SEED = Buffer.from("strategy_state");
+exports.POSITION_SEED = Buffer.from("position");
+exports.MANAGER_SEED = Buffer.from("manager");
+// Account discriminators (Anchor 8-byte) — defined once in common/, re-exported here
+var constants_1 = require("../common/constants");
+Object.defineProperty(exports, "DISC_STRATEGY_STATE", { enumerable: true, get: function () { return constants_1.DISC_STRATEGY_STATE; } });
+Object.defineProperty(exports, "DISC_STV_POSITION", { enumerable: true, get: function () { return constants_1.DISC_STV_POSITION; } });
+Object.defineProperty(exports, "DISC_MANAGER_ROLE", { enumerable: true, get: function () { return constants_1.DISC_MANAGER_ROLE; } });
+// Instruction discriminators (Anchor 8-byte)
+// --- Admin instructions ---
+exports.IX_INIT_OR_UPDATE_STRATEGY = Buffer.from([221, 4, 60, 139, 83, 148, 116, 247]);
+// sha256("global:close_strategy")[..8] — verified against elemental_lend.json IDL
+exports.IX_CLOSE_STRATEGY = Buffer.from([56, 247, 170, 246, 89, 221, 134, 200]);
+// sha256("global:reset_strategy")[..8] — verified against elemental_lend.json IDL
+exports.IX_RESET_STRATEGY = Buffer.from([127, 28, 155, 41, 137, 170, 16, 39]);
+// sha256("global:add_manager")[..8]
+exports.IX_ADD_MANAGER = Buffer.from([0x7d, 0x26, 0xc0, 0xd4, 0x65, 0x5b, 0xb3, 0x10]);
+// sha256("global:remove_manager")[..8]
+exports.IX_REMOVE_MANAGER = Buffer.from([0x96, 0x37, 0x9d, 0x4d, 0x80, 0x94, 0x07, 0x0f]);
+// --- Protocol instructions (manager-only via ManagerRole PDA) ---
+exports.IX_KVAULT_DEPOSIT = Buffer.from([240, 233, 97, 12, 52, 70, 230, 243]);
+exports.IX_KVAULT_WITHDRAW = Buffer.from([186, 254, 50, 47, 123, 146, 242, 216]);
+exports.IX_JUP_LEND_DEPOSIT = Buffer.from([87, 129, 182, 64, 170, 11, 223, 59]);
+exports.IX_JUP_LEND_WITHDRAW = Buffer.from([46, 152, 191, 164, 24, 135, 89, 64]);
+// NOTE: The CPI-facing discriminators (init_position, deposit, withdraw, update_aum)
+// are invoked by p-stv-core directly via remaining_accounts; clients do not call them
+// standalone and they are not exported from this SDK module.
+// Account sizes
+exports.STRATEGY_STATE_SIZE = 536;
+exports.STV_POSITION_SIZE = 120;
+exports.MANAGER_ROLE_SIZE = 80;
+// Flags
+exports.FLAG_PAUSED = 0x0001;
+// Limits
+exports.MAX_PROTOCOLS = 10;
+// External protocol programs
+exports.KAMINO_VAULT_PROGRAM = new web3_js_1.PublicKey("KvauGMspG5k6rtzrqqn7WNn3oZdyKqLKwK2XWQ8FLjd");
+exports.KLEND_PROGRAM = new web3_js_1.PublicKey("KLend2g3cP87fffoy8q1mQqGKjrxjC8boSyAYavgmjD");
+/** Jupiter Lend Earn program (the supply-side product). */
+exports.JUP_LEND_EARN_PROGRAM = new web3_js_1.PublicKey("jup3YeL8QhtSx1e253b2FDvsMNC87fDrgQZivbrndc9");
+var constants_2 = require("../common/constants");
+Object.defineProperty(exports, "PPS_DECIMALS", { enumerable: true, get: function () { return constants_2.PPS_DECIMALS; } });

package/dist/elemental-lend/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./constants";
+export * from "./types";
+export * from "./pda";
+export * from "./accounts";
+export * from "./instructions";
+export * from "./jupiter-lend";
+export * from "./kamino-vault";
+export * from "./protocol-actions";

package/dist/elemental-lend/index.js

@@ -0,0 +1,24 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./constants"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./pda"), exports);
+__exportStar(require("./accounts"), exports);
+__exportStar(require("./instructions"), exports);
+__exportStar(require("./jupiter-lend"), exports);
+__exportStar(require("./kamino-vault"), exports);
+__exportStar(require("./protocol-actions"), exports);

package/dist/elemental-lend/instructions.d.ts

@@ -0,0 +1,104 @@
+import { PublicKey, TransactionInstruction, AccountMeta } from "@solana/web3.js";
+import BN from "bn.js";
+export interface InitOrUpdateStrategyArgs {
+    admin: PublicKey;
+    strategyState: PublicKey;
+    baseMint: PublicKey;
+    strategyBaseAta: PublicKey;
+    tokenProgram: PublicKey;
+    systemProgram?: PublicKey;
+    associatedTokenProgram?: PublicKey;
+    authority?: PublicKey | null;
+    flags?: number | null;
+    addProtocol?: PublicKey | null;
+    removeProtocol?: PublicKey | null;
+    newAdmin?: PublicKey | null;
+    /**
+     * One-shot legacy backfill of `manager_count` (update path only) — set to the true
+     * live ManagerRole count on a strategy that predates the counter, so the
+     * close_strategy `manager_count == 0` gate is effective. Omit on normal calls.
+     */
+    managerCount?: number | null;
+    remainingAccounts?: AccountMeta[];
+}
+export declare function createInitOrUpdateStrategyIx(args: InitOrUpdateStrategyArgs, programId?: PublicKey): TransactionInstruction;
+export interface CloseStrategyArgs {
+    admin: PublicKey;
+    payer: PublicKey;
+    strategyState: PublicKey;
+    strategyBaseAta: PublicKey;
+    baseMint: PublicKey;
+    tokenProgram: PublicKey;
+    /** Optional: required when strategy_base_ata has residual balance to drain. */
+    remainingAccounts?: AccountMeta[];
+}
+export declare function createCloseStrategyIx(args: CloseStrategyArgs, programId?: PublicKey): TransactionInstruction;
+export interface ResetStrategyArgs {
+    admin: PublicKey;
+    strategyState: PublicKey;
+}
+export declare function createResetStrategyIx(args: ResetStrategyArgs, programId?: PublicKey): TransactionInstruction;
+export interface KvaultDepositArgs {
+    manager: PublicKey;
+    strategyState: PublicKey;
+    managerRole: PublicKey;
+    depositorBaseAta: PublicKey;
+    depositorSharesAta: PublicKey;
+    amount: BN | number;
+    /** Minimum protocol-receipt out (deposit: shares/fTokens; withdraw: base). 0 = non-zero only. */
+    minOut?: BN | number;
+    remainingAccounts: AccountMeta[];
+}
+export declare function createKvaultDepositIx(args: KvaultDepositArgs, programId?: PublicKey): TransactionInstruction;
+export interface KvaultWithdrawArgs {
+    manager: PublicKey;
+    strategyState: PublicKey;
+    managerRole: PublicKey;
+    depositorBaseAta: PublicKey;
+    depositorSharesAta: PublicKey;
+    shares: BN | number;
+    /** Minimum protocol-receipt out (deposit: shares/fTokens; withdraw: base). 0 = non-zero only. */
+    minOut?: BN | number;
+    remainingAccounts: AccountMeta[];
+}
+export declare function createKvaultWithdrawIx(args: KvaultWithdrawArgs, programId?: PublicKey): TransactionInstruction;
+export interface JupLendDepositArgs {
+    manager: PublicKey;
+    strategyState: PublicKey;
+    managerRole: PublicKey;
+    depositorBaseAta: PublicKey;
+    depositorFtokenAta: PublicKey;
+    amount: BN | number;
+    /** Minimum protocol-receipt out (deposit: shares/fTokens; withdraw: base). 0 = non-zero only. */
+    minOut?: BN | number;
+    remainingAccounts: AccountMeta[];
+}
+export declare function createJupLendDepositIx(args: JupLendDepositArgs, programId?: PublicKey): TransactionInstruction;
+export interface JupLendWithdrawArgs {
+    manager: PublicKey;
+    strategyState: PublicKey;
+    managerRole: PublicKey;
+    depositorBaseAta: PublicKey;
+    depositorFtokenAta: PublicKey;
+    amount: BN | number;
+    /** Minimum protocol-receipt out (deposit: shares/fTokens; withdraw: base). 0 = non-zero only. */
+    minOut?: BN | number;
+    remainingAccounts: AccountMeta[];
+}
+export declare function createJupLendWithdrawIx(args: JupLendWithdrawArgs, programId?: PublicKey): TransactionInstruction;
+export interface AddManagerArgs {
+    admin: PublicKey;
+    payer: PublicKey;
+    strategyState: PublicKey;
+    managerRole: PublicKey;
+    manager: PublicKey;
+    systemProgram?: PublicKey;
+}
+export declare function createAddManagerIx(args: AddManagerArgs, programId?: PublicKey): TransactionInstruction;
+export interface RemoveManagerArgs {
+    admin: PublicKey;
+    payer: PublicKey;
+    strategyState: PublicKey;
+    managerRole: PublicKey;
+}
+export declare function createRemoveManagerIx(args: RemoveManagerArgs, programId?: PublicKey): TransactionInstruction;