@elmntl/jlpd-sdk 0.1.11 → 0.13.4

package/dist/elemental-lend/pda.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findStrategyStatePda = findStrategyStatePda;
+exports.findStvPositionPda = findStvPositionPda;
+exports.findLendManagerRolePda = findLendManagerRolePda;
+const web3_js_1 = require("@solana/web3.js");
+const constants_1 = require("./constants");
+function findStrategyStatePda(baseMint, programId = constants_1.PROGRAM_ID) {
+    return web3_js_1.PublicKey.findProgramAddressSync([constants_1.STRATEGY_STATE_SEED, baseMint.toBuffer()], programId);
+}
+function findStvPositionPda(stv, programId = constants_1.PROGRAM_ID) {
+    return web3_js_1.PublicKey.findProgramAddressSync([constants_1.POSITION_SEED, stv.toBuffer()], programId);
+}
+/**
+ * Derive the per-strategy_state `ManagerRole` PDA for Elemental Lend.
+ * Seeds: `["manager", strategy_state, manager]`.
+ *
+ * Note the per-program prefix on the name: each Elemental program has its
+ * own `ManagerRole` PDA scoped to a different anchor account (`p-stv-core`
+ * → STV, `jlpd-strategy` → JlpdConfig).
+ */
+function findLendManagerRolePda(strategyState, manager, programId = constants_1.PROGRAM_ID) {
+    return web3_js_1.PublicKey.findProgramAddressSync([constants_1.MANAGER_SEED, strategyState.toBuffer(), manager.toBuffer()], programId);
+}

package/dist/elemental-lend/protocol-actions.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Protocol action transaction builders for Elemental Lend.
+ *
+ * Builds complete instruction arrays for deposit/withdraw to/from
+ * Kamino kVault and Jupiter Lend protocols. Ready to pass to sendSmartTx.
+ */
+import { PublicKey, TransactionInstruction } from "@solana/web3.js";
+/**
+ * Connection interface required by the protocol-action builders. This is a
+ * narrower subset of the canonical `SolanaConnection` defined in
+ * `common/connection.ts` — protocol actions only ever need to read accounts.
+ */
+import type { SolanaConnection } from "../common/connection";
+export type ProtocolActionConnection = Pick<SolanaConnection, "getAccountInfo" | "getMultipleAccountsInfo">;
+import type { JupiterLendPool } from "./jupiter-lend";
+export type ProtocolType = "Kamino kVault" | "Jupiter Lend";
+export type ProtocolAction = "deposit" | "withdraw";
+export interface ProtocolActionArgs {
+    connection: ProtocolActionConnection;
+    /** Manager wallet (signer) */
+    manager: PublicKey;
+    /** Lend strategy state PDA (derived from baseMint if not provided) */
+    strategyState?: PublicKey;
+    /** Protocol address (Kamino vault_state or Jupiter Lend lending account) */
+    protocol: PublicKey;
+    protocolType: ProtocolType;
+    action: ProtocolAction;
+    /** Amount in base token units (e.g. USDC lamports) */
+    amount: bigint;
+    /**
+     * Minimum protocol-receipt out (deposit: min shares/fTokens; withdraw: min base).
+     * On-chain the handler reverts if the CPI yields less (and always requires > 0).
+     * Defaults to 0n (non-zero still enforced; 0 opts out of slippage protection).
+     */
+    minOut?: bigint;
+    baseMint: PublicKey;
+    /** Token program for the base mint (defaults to SPL Token) */
+    tokenProgram?: PublicKey;
+    /** Jupiter Lend pool config (defaults to USDC_POOL) */
+    jupLendPool?: JupiterLendPool;
+    /** Elemental Lend program ID (defaults to PROGRAM_ID) */
+    programId?: PublicKey;
+}
+/**
+ * Build complete instruction array for a protocol deposit or withdraw.
+ *
+ * Returns instructions including a compute budget instruction (400k CU)
+ * and the protocol-specific instruction with all accounts resolved.
+ *
+ * For Kamino kVault withdraw: reads vault_state on-chain to convert
+ * base amount to kvToken shares, and reads KLend reserves for the
+ * withdraw accounts.
+ *
+ * @returns TransactionInstruction[] ready for sendSmartTx
+ */
+export declare function buildProtocolActionIxs(args: ProtocolActionArgs): Promise<TransactionInstruction[]>;

package/dist/elemental-lend/protocol-actions.js

@@ -0,0 +1,244 @@
+"use strict";
+/**
+ * Protocol action transaction builders for Elemental Lend.
+ *
+ * Builds complete instruction arrays for deposit/withdraw to/from
+ * Kamino kVault and Jupiter Lend protocols. Ready to pass to sendSmartTx.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildProtocolActionIxs = buildProtocolActionIxs;
+const web3_js_1 = require("@solana/web3.js");
+const spl_token_1 = require("@solana/spl-token");
+const ata_1 = require("../common/ata");
+const constants_1 = require("./constants");
+const pda_1 = require("./pda");
+const kamino_vault_1 = require("./kamino-vault");
+const jupiter_lend_1 = require("./jupiter-lend");
+// ---------------------------------------------------------------------------
+// Main Builder
+// ---------------------------------------------------------------------------
+/**
+ * Build complete instruction array for a protocol deposit or withdraw.
+ *
+ * Returns instructions including a compute budget instruction (400k CU)
+ * and the protocol-specific instruction with all accounts resolved.
+ *
+ * For Kamino kVault withdraw: reads vault_state on-chain to convert
+ * base amount to kvToken shares, and reads KLend reserves for the
+ * withdraw accounts.
+ *
+ * @returns TransactionInstruction[] ready for sendSmartTx
+ */
+async function buildProtocolActionIxs(args) {
+    const { connection, manager, protocol, protocolType, action, amount, minOut = 0n, baseMint, tokenProgram = spl_token_1.TOKEN_PROGRAM_ID, jupLendPool, programId = constants_1.PROGRAM_ID, } = args;
+    const [strategyStatePda] = args.strategyState
+        ? [args.strategyState]
+        : (0, pda_1.findStrategyStatePda)(baseMint, programId);
+    const strategyBaseAta = (0, ata_1.findAta)(baseMint, strategyStatePda, tokenProgram);
+    const [managerRolePda] = (0, pda_1.findLendManagerRolePda)(strategyStatePda, manager, programId);
+    if (protocolType === "Jupiter Lend") {
+        return buildJupLendActionIxs({
+            connection,
+            manager,
+            strategyStatePda,
+            strategyBaseAta,
+            managerRolePda,
+            protocol,
+            action,
+            amount,
+            minOut,
+            baseMint,
+            tokenProgram,
+            pool: jupLendPool ?? jupiter_lend_1.JUP_LEND_POOLS[baseMint.toBase58()] ?? jupiter_lend_1.USDC_POOL,
+            programId,
+        });
+    }
+    else {
+        return buildKvaultActionIxs({
+            connection,
+            manager,
+            strategyStatePda,
+            strategyBaseAta,
+            managerRolePda,
+            vaultState: protocol,
+            action,
+            amount,
+            minOut,
+            baseMint,
+            tokenProgram,
+            programId,
+        });
+    }
+}
+function buildJupLendActionIxs(params) {
+    const { manager, strategyStatePda, strategyBaseAta, managerRolePda, action, amount, minOut, tokenProgram, pool, programId, } = params;
+    const strategyFtokenAta = (0, ata_1.findAta)(pool.fTokenMint, strategyStatePda, tokenProgram);
+    const JUP_LEND_PROG = new web3_js_1.PublicKey("jup3YeL8QhtSx1e253b2FDvsMNC87fDrgQZivbrndc9");
+    // Fixed accounts for the Anchor instruction
+    const fixedAccounts = [
+        { pubkey: manager, isSigner: true, isWritable: true },
+        { pubkey: strategyStatePda, isSigner: false, isWritable: false },
+        { pubkey: managerRolePda, isSigner: false, isWritable: false },
+        { pubkey: strategyBaseAta, isSigner: false, isWritable: true },
+        { pubkey: strategyFtokenAta, isSigner: false, isWritable: true },
+    ];
+    let disc;
+    let remainingAccounts;
+    if (action === "deposit") {
+        disc = Buffer.from(constants_1.IX_JUP_LEND_DEPOSIT);
+        remainingAccounts = [
+            ...(0, jupiter_lend_1.buildJupLendDepositAccounts)(pool, strategyStatePda, strategyBaseAta, strategyFtokenAta).map((a) => ({ ...a, isSigner: false })),
+            { pubkey: JUP_LEND_PROG, isSigner: false, isWritable: false },
+        ];
+    }
+    else {
+        disc = Buffer.from(constants_1.IX_JUP_LEND_WITHDRAW);
+        remainingAccounts = [
+            ...(0, jupiter_lend_1.buildJupLendWithdrawAccounts)(pool, strategyStatePda, strategyFtokenAta, strategyBaseAta).map((a) => ({ ...a, isSigner: false })),
+            { pubkey: JUP_LEND_PROG, isSigner: false, isWritable: false },
+        ];
+    }
+    // Data: disc(8) + amount(8) + min_out(8) [deposit: min_ftokens_out, withdraw: min_base_out].
+    const amountBuf = Buffer.alloc(8);
+    amountBuf.writeBigUInt64LE(amount, 0);
+    const minOutBuf = Buffer.alloc(8);
+    minOutBuf.writeBigUInt64LE(minOut, 0);
+    const ixData = Buffer.concat([disc, amountBuf, minOutBuf]);
+    const ix = new web3_js_1.TransactionInstruction({
+        keys: [...fixedAccounts, ...remainingAccounts],
+        programId,
+        data: ixData,
+    });
+    return Promise.resolve([ix]);
+}
+async function buildKvaultActionIxs(params) {
+    const { connection, manager, strategyStatePda, strategyBaseAta, managerRolePda, vaultState, action, amount, minOut, baseMint, tokenProgram, programId, } = params;
+    // Read vault state for reserve data (needed for both deposit and withdraw)
+    const vaultStateInfo = await connection.getAccountInfo(vaultState);
+    if (!vaultStateInfo)
+        throw new Error("Kamino vault state not found");
+    const vaultData = vaultStateInfo.data;
+    // Read ALL KLend reserves from vault state for batch refresh
+    const reserveKeys = [];
+    for (let i = 0; i < 10; i++) {
+        try {
+            const { reserve } = (0, kamino_vault_1.readVaultAllocation)(vaultData, i);
+            if (!reserve.equals(web3_js_1.PublicKey.default)) {
+                reserveKeys.push(reserve);
+            }
+        }
+        catch {
+            break;
+        }
+    }
+    // Fetch all reserves to read their lending_market field. `readReserveAccounts`
+    // (from kamino-vault.ts) is the canonical parser — keeps the KLend Reserve
+    // layout constants in one place.
+    const reserveInfos = await connection.getMultipleAccountsInfo(reserveKeys);
+    const klendReserves = [];
+    for (let i = 0; i < reserveKeys.length; i++) {
+        const rInfo = reserveInfos[i];
+        if (!rInfo)
+            continue;
+        try {
+            const { lendingMarket } = (0, kamino_vault_1.readReserveAccounts)(rInfo.data);
+            klendReserves.push({ reserve: reserveKeys[i], lendingMarket });
+        }
+        catch {
+            // Skip reserves whose data isn't long enough for a full parse
+        }
+    }
+    const [sharesMint] = (0, kamino_vault_1.findKvaultSharesMint)(vaultState);
+    const strategySharesAta = (0, ata_1.findAta)(sharesMint, strategyStatePda, tokenProgram);
+    // Fixed accounts for the Anchor instruction
+    const fixedAccounts = [
+        { pubkey: manager, isSigner: true, isWritable: true },
+        { pubkey: strategyStatePda, isSigner: false, isWritable: false },
+        { pubkey: managerRolePda, isSigner: false, isWritable: false },
+        { pubkey: strategyBaseAta, isSigner: false, isWritable: true },
+        { pubkey: strategySharesAta, isSigner: false, isWritable: true },
+    ];
+    if (action === "deposit") {
+        return buildKvaultDepositIxs(fixedAccounts, vaultState, strategyStatePda, strategyBaseAta, strategySharesAta, baseMint, klendReserves, amount, minOut, programId);
+    }
+    else {
+        return buildKvaultWithdrawIxs(connection, fixedAccounts, vaultState, vaultData, strategyStatePda, strategyBaseAta, strategySharesAta, baseMint, klendReserves, amount, minOut, programId);
+    }
+}
+function buildKvaultDepositIxs(fixedAccounts, vaultState, strategyStatePda, strategyBaseAta, strategySharesAta, baseMint, klendReserves, amount, minOut, programId) {
+    const disc = Buffer.from(constants_1.IX_KVAULT_DEPOSIT);
+    const remainingAccounts = (0, kamino_vault_1.buildKvaultDepositAccounts)(vaultState, strategyStatePda, strategyBaseAta, strategySharesAta, baseMint, klendReserves).map((a) => ({ ...a, isSigner: false }));
+    // Data: disc(8) + amount(8) + min_shares_out(8).
+    const amountBuf = Buffer.alloc(8);
+    amountBuf.writeBigUInt64LE(amount, 0);
+    const minOutBuf = Buffer.alloc(8);
+    minOutBuf.writeBigUInt64LE(minOut, 0);
+    const ixData = Buffer.concat([disc, amountBuf, minOutBuf]);
+    const ix = new web3_js_1.TransactionInstruction({
+        keys: [...fixedAccounts, ...remainingAccounts],
+        programId,
+        data: ixData,
+    });
+    return Promise.resolve([ix]);
+}
+async function buildKvaultWithdrawIxs(connection, fixedAccounts, vaultState, vaultData, strategyStatePda, strategyBaseAta, strategySharesAta, baseMint, klendReserves, amount, minOut, programId) {
+    const disc = Buffer.from(constants_1.IX_KVAULT_WITHDRAW);
+    // Convert base amount to kvToken shares
+    const sharesIssued = vaultData.readBigUInt64LE(232);
+    const prevAumSfLo = vaultData.readBigUInt64LE(280);
+    const prevAumSfHi = vaultData.readBigUInt64LE(288);
+    const prevAumSf = prevAumSfLo + (prevAumSfHi << BigInt(64));
+    const FRACTION_ONE = BigInt(1) << BigInt(60);
+    let withdrawShares;
+    if (prevAumSf > BigInt(0) && sharesIssued > BigInt(0)) {
+        // Round up to ensure enough shares are redeemed
+        withdrawShares = (amount * sharesIssued * FRACTION_ONE + prevAumSf - BigInt(1)) / prevAumSf;
+    }
+    else {
+        withdrawShares = amount; // fallback: 1:1
+    }
+    // Cap to actual kvToken balance.
+    // SPL Token Account layout: [mint(0..32)][owner(32..64)][amount(64..72)]…
+    const sharesAtaInfo = await connection.getAccountInfo(strategySharesAta);
+    if (sharesAtaInfo) {
+        const actualBalance = sharesAtaInfo.data.readBigUInt64LE(64);
+        if (withdrawShares > actualBalance) {
+            withdrawShares = actualBalance;
+        }
+    }
+    // Read reserve data for withdraw accounts.
+    // Kamino VaultState — first allocation slot starts at offset 312:
+    //   [312..344]  reserve       Pubkey
+    //   [344..376]  ctokenVault   Pubkey
+    // (See `kamino-vault.ts:VAULT_ALLOCATION_OFFSET` for the full table.)
+    const reserveKey = new web3_js_1.PublicKey(vaultData.subarray(312, 344));
+    const reserveInfo = await connection.getAccountInfo(reserveKey);
+    if (!reserveInfo)
+        throw new Error("KLend reserve not found");
+    const reserveConfig = (0, kamino_vault_1.buildKvaultWithdrawReserveConfig)(vaultData, reserveInfo.data, 0);
+    const remainingAccounts = (0, kamino_vault_1.buildKvaultWithdrawAccounts)(vaultState, strategyStatePda, strategyBaseAta, strategySharesAta, baseMint, reserveConfig).map((a) => ({ ...a, isSigner: false }));
+    // Append ALL reserves first, then unique lending markets
+    for (const r of klendReserves) {
+        remainingAccounts.push({ pubkey: r.reserve, isSigner: false, isWritable: true });
+    }
+    const seenMarkets = new Set();
+    for (const r of klendReserves) {
+        const key = r.lendingMarket.toBase58();
+        if (!seenMarkets.has(key)) {
+            seenMarkets.add(key);
+            remainingAccounts.push({ pubkey: r.lendingMarket, isSigner: false, isWritable: false });
+        }
+    }
+    // Data: disc(8) + shares(8) + min_base_out(8). minOut is the base-out floor.
+    const sharesBuf = Buffer.alloc(8);
+    sharesBuf.writeBigUInt64LE(withdrawShares, 0);
+    const minOutBuf = Buffer.alloc(8);
+    minOutBuf.writeBigUInt64LE(minOut, 0);
+    const ixData = Buffer.concat([disc, sharesBuf, minOutBuf]);
+    const ix = new web3_js_1.TransactionInstruction({
+        keys: [...fixedAccounts, ...remainingAccounts],
+        programId,
+        data: ixData,
+    });
+    return [ix];
+}

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

@@ -0,0 +1,113 @@
+import { PublicKey } from "@solana/web3.js";
+import BN from "bn.js";
+import type { StrategyStateHeader } from "../common/strategy-interface";
+/** Full StrategyState for Elemental Lend (536 bytes) */
+export interface LendStrategyState extends StrategyStateHeader {
+    admin: PublicKey;
+    protocols: PublicKey[];
+    protocolCount: number;
+    managerCount: number;
+}
+/** ManagerRole account — authorizes a manager for protocol instructions */
+export interface ManagerRole {
+    strategyState: PublicKey;
+    manager: PublicKey;
+    bump: number;
+}
+export type { StvPosition } from "../common/strategy-interface";
+export interface StrategyInitializedEvent {
+    name: "StrategyInitialized";
+    strategyState: PublicKey;
+    admin: PublicKey;
+    baseMint: PublicKey;
+    authority: PublicKey;
+}
+export interface StrategyUpdatedEvent {
+    name: "StrategyUpdated";
+    strategyState: PublicKey;
+    oldAdmin: PublicKey;
+    newAdmin: PublicKey;
+    oldAuthority: PublicKey;
+    newAuthority: PublicKey;
+    oldFlags: number;
+    newFlags: number;
+}
+export interface PositionInitializedEvent {
+    name: "PositionInitialized";
+    strategyState: PublicKey;
+    stv: PublicKey;
+}
+export interface LendDepositEvent {
+    name: "DepositEvent";
+    strategyState: PublicKey;
+    stv: PublicKey;
+    amount: BN;
+    shares: BN;
+    pps: BN;
+}
+export interface LendWithdrawEvent {
+    name: "WithdrawEvent";
+    strategyState: PublicKey;
+    stv: PublicKey;
+    shares: BN;
+    amount: BN;
+    pps: BN;
+}
+export interface AumUpdatedEvent {
+    name: "AumUpdated";
+    strategyState: PublicKey;
+    totalAum: BN;
+    pps: BN;
+    lastUpdated: BN;
+}
+export interface KvaultDepositEvent {
+    name: "KvaultDepositEvent";
+    strategyState: PublicKey;
+    amount: BN;
+    sharesReceived: BN;
+    timestamp: BN;
+}
+export interface KvaultWithdrawEvent {
+    name: "KvaultWithdrawEvent";
+    strategyState: PublicKey;
+    shares: BN;
+    baseReceived: BN;
+    timestamp: BN;
+}
+export interface JupLendDepositEvent {
+    name: "JupLendDepositEvent";
+    strategyState: PublicKey;
+    amount: BN;
+    ftokensReceived: BN;
+    timestamp: BN;
+}
+export interface JupLendWithdrawEvent {
+    name: "JupLendWithdrawEvent";
+    strategyState: PublicKey;
+    amount: BN;
+    ftokensBurned: BN;
+    timestamp: BN;
+}
+export interface ProtocolAddedEvent {
+    name: "ProtocolAdded";
+    strategyState: PublicKey;
+    protocolAccount: PublicKey;
+    protocolCount: number;
+}
+export interface ProtocolRemovedEvent {
+    name: "ProtocolRemoved";
+    strategyState: PublicKey;
+    protocolAccount: PublicKey;
+    protocolCount: number;
+}
+export interface ManagerAddedEvent {
+    name: "ManagerAdded";
+    strategyState: PublicKey;
+    manager: PublicKey;
+}
+export interface ManagerRemovedEvent {
+    name: "ManagerRemoved";
+    strategyState: PublicKey;
+    manager: PublicKey;
+}
+export type LendEvent = StrategyInitializedEvent | StrategyUpdatedEvent | PositionInitializedEvent | LendDepositEvent | LendWithdrawEvent | AumUpdatedEvent | KvaultDepositEvent | KvaultWithdrawEvent | JupLendDepositEvent | JupLendWithdrawEvent | ProtocolAddedEvent | ProtocolRemovedEvent | ManagerAddedEvent | ManagerRemovedEvent;

package/dist/elemental-lend/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/elemental-lend-v2/accounts.d.ts

@@ -0,0 +1,14 @@
+import { PublicKey } from "@solana/web3.js";
+import type { StvPosition } from "../common/strategy-interface";
+import type { SolanaConnection } from "../common/connection";
+import type { LendStrategyState, ProtocolVault, ManagerRole } from "./types";
+export declare function deserializeStrategyState(data: Buffer): LendStrategyState;
+export declare function deserializeProtocolVault(data: Buffer): ProtocolVault;
+export declare function deserializeLendStvPosition(data: Buffer): StvPosition;
+export declare function deserializeManagerRole(data: Buffer): ManagerRole;
+export declare function fetchStrategyState(connection: SolanaConnection, baseMint: PublicKey, programId?: PublicKey): Promise<LendStrategyState>;
+export declare function fetchStrategyStateByAddress(connection: SolanaConnection, address: PublicKey): Promise<LendStrategyState>;
+export declare function fetchProtocolVault(connection: SolanaConnection, strategyState: PublicKey, index: number, programId?: PublicKey): Promise<ProtocolVault>;
+export declare function fetchAllProtocolVaults(connection: SolanaConnection, strategyState: PublicKey, protocolCount: number, programId?: PublicKey): Promise<[PublicKey, ProtocolVault][]>;
+export declare function fetchLendStvPosition(connection: SolanaConnection, stv: PublicKey, programId?: PublicKey): Promise<StvPosition>;
+export declare function fetchManagerRole(connection: SolanaConnection, strategyState: PublicKey, manager: PublicKey, programId?: PublicKey): Promise<ManagerRole | null>;

package/dist/elemental-lend-v2/accounts.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deserializeStrategyState = deserializeStrategyState;
+exports.deserializeProtocolVault = deserializeProtocolVault;
+exports.deserializeLendStvPosition = deserializeLendStvPosition;
+exports.deserializeManagerRole = deserializeManagerRole;
+exports.fetchStrategyState = fetchStrategyState;
+exports.fetchStrategyStateByAddress = fetchStrategyStateByAddress;
+exports.fetchProtocolVault = fetchProtocolVault;
+exports.fetchAllProtocolVaults = fetchAllProtocolVaults;
+exports.fetchLendStvPosition = fetchLendStvPosition;
+exports.fetchManagerRole = fetchManagerRole;
+const buffer_1 = require("../common/buffer");
+const strategy_interface_1 = require("../common/strategy-interface");
+const constants_1 = require("./constants");
+const pda_1 = require("./pda");
+// ---------------------------------------------------------------------------
+// Deserializers
+// ---------------------------------------------------------------------------
+function deserializeStrategyState(data) {
+    if (data.length < constants_1.STRATEGY_STATE_SIZE) {
+        throw new Error(`StrategyState data too short: ${data.length} < ${constants_1.STRATEGY_STATE_SIZE}`);
+    }
+    if (!data.subarray(0, 8).equals(constants_1.DISC_STRATEGY_STATE)) {
+        throw new Error(`Invalid StrategyState discriminator`);
+    }
+    return {
+        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),
+        admin: (0, buffer_1.readPubkey)(data, 112),
+        protocolCount: (0, buffer_1.readU8)(data, 144),
+    };
+}
+function deserializeProtocolVault(data) {
+    if (data.length < constants_1.PROTOCOL_VAULT_SIZE) {
+        throw new Error(`ProtocolVault data too short: ${data.length} < ${constants_1.PROTOCOL_VAULT_SIZE}`);
+    }
+    if (!data.subarray(0, 8).equals(constants_1.DISC_PROTOCOL_VAULT)) {
+        throw new Error(`Invalid ProtocolVault discriminator`);
+    }
+    return {
+        strategyState: (0, buffer_1.readPubkey)(data, 8),
+        adapterProgram: (0, buffer_1.readPubkey)(data, 40),
+        protocolState: (0, buffer_1.readPubkey)(data, 72),
+        index: (0, buffer_1.readU8)(data, 104),
+        bump: (0, buffer_1.readU8)(data, 105),
+        readAumAccountCount: (0, buffer_1.readU8)(data, 106),
+    };
+}
+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}`);
+    }
+    if (!data.subarray(0, 8).equals(constants_1.DISC_STV_POSITION)) {
+        throw new Error(`Invalid StvPosition discriminator`);
+    }
+    return (0, strategy_interface_1.deserializeStvPosition)(data);
+}
+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}`);
+    }
+    if (!data.subarray(0, 8).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 fetchStrategyState(connection, baseMint, programId = constants_1.PROGRAM_ID) {
+    const [pda] = (0, pda_1.deriveStrategyState)(baseMint, programId);
+    const info = await connection.getAccountInfo(pda);
+    if (!info) {
+        throw new Error(`StrategyState not found for mint ${baseMint.toBase58()}`);
+    }
+    return deserializeStrategyState(info.data);
+}
+async function fetchStrategyStateByAddress(connection, address) {
+    const info = await connection.getAccountInfo(address);
+    if (!info)
+        throw new Error(`StrategyState not found at ${address.toBase58()}`);
+    return deserializeStrategyState(info.data);
+}
+async function fetchProtocolVault(connection, strategyState, index, programId = constants_1.PROGRAM_ID) {
+    const [pda] = (0, pda_1.deriveProtocolVault)(strategyState, index, programId);
+    const info = await connection.getAccountInfo(pda);
+    if (!info) {
+        throw new Error(`ProtocolVault not found at index ${index} for ${strategyState.toBase58()}`);
+    }
+    return deserializeProtocolVault(info.data);
+}
+async function fetchAllProtocolVaults(connection, strategyState, protocolCount, programId = constants_1.PROGRAM_ID) {
+    if (protocolCount === 0)
+        return [];
+    const pdas = [];
+    for (let i = 0; i < protocolCount; i++) {
+        const [pda] = (0, pda_1.deriveProtocolVault)(strategyState, i, programId);
+        pdas.push(pda);
+    }
+    const infos = await connection.getMultipleAccountsInfo(pdas);
+    const out = [];
+    for (let i = 0; i < pdas.length; i++) {
+        const info = infos[i];
+        if (!info) {
+            throw new Error(`ProtocolVault ${i} missing at ${pdas[i].toBase58()}`);
+        }
+        out.push([pdas[i], deserializeProtocolVault(info.data)]);
+    }
+    return out;
+}
+async function fetchLendStvPosition(connection, stv, programId = constants_1.PROGRAM_ID) {
+    const [pda] = (0, pda_1.deriveStvPosition)(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.deriveManagerRole)(strategyState, manager, programId);
+    const info = await connection.getAccountInfo(pda);
+    if (!info)
+        return null;
+    return deserializeManagerRole(info.data);
+}

package/dist/elemental-lend-v2/adapters.d.ts

@@ -0,0 +1,22 @@
+import { PublicKey } from "@solana/web3.js";
+export type AdapterKind = "kamino" | "jupiter-lend";
+export interface AdapterMeta {
+    kind: AdapterKind;
+    programId: PublicKey;
+    readAumAccountCount: number;
+}
+export declare const KAMINO_ADAPTER: AdapterMeta;
+export declare const JUPITER_LEND_ADAPTER: AdapterMeta;
+export declare const ADAPTERS: Record<AdapterKind, AdapterMeta>;
+export interface RegisterAdapterParams {
+    protocolState: PublicKey;
+    readAumAccountCount: number;
+}
+/** Kamino: protocol_state = vault_state, count = 2. */
+export declare function buildRegisterKaminoParams(vaultState: PublicKey): RegisterAdapterParams;
+/** Jupiter Lend: protocol_state = lending, count = 4. */
+export declare function buildRegisterJupLendParams(lending: PublicKey): RegisterAdapterParams;
+/** Kamino: [vault_state, kv_token_ata]. */
+export declare function resolveKaminoReadAumAccounts(vaultState: PublicKey, kvTokenAta: PublicKey): PublicKey[];
+/** Jupiter Lend: [lending, rewards_rate_model, fToken_ata, fToken_mint]. */
+export declare function resolveJupLendReadAumAccounts(lending: PublicKey, rewardsRateModel: PublicKey, ftokenAta: PublicKey, ftokenMint: PublicKey): PublicKey[];

package/dist/elemental-lend-v2/adapters.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ADAPTERS = exports.JUPITER_LEND_ADAPTER = exports.KAMINO_ADAPTER = void 0;
+exports.buildRegisterKaminoParams = buildRegisterKaminoParams;
+exports.buildRegisterJupLendParams = buildRegisterJupLendParams;
+exports.resolveKaminoReadAumAccounts = resolveKaminoReadAumAccounts;
+exports.resolveJupLendReadAumAccounts = resolveJupLendReadAumAccounts;
+const constants_1 = require("./constants");
+exports.KAMINO_ADAPTER = {
+    kind: "kamino",
+    programId: constants_1.KAMINO_ADAPTER_PROGRAM_ID,
+    readAumAccountCount: constants_1.KAMINO_READ_AUM_ACCOUNT_COUNT,
+};
+exports.JUPITER_LEND_ADAPTER = {
+    kind: "jupiter-lend",
+    programId: constants_1.JUPITER_LEND_ADAPTER_PROGRAM_ID,
+    readAumAccountCount: constants_1.JUPITER_LEND_READ_AUM_ACCOUNT_COUNT,
+};
+exports.ADAPTERS = {
+    kamino: exports.KAMINO_ADAPTER,
+    "jupiter-lend": exports.JUPITER_LEND_ADAPTER,
+};
+/** Kamino: protocol_state = vault_state, count = 2. */
+function buildRegisterKaminoParams(vaultState) {
+    return {
+        protocolState: vaultState,
+        readAumAccountCount: constants_1.KAMINO_READ_AUM_ACCOUNT_COUNT,
+    };
+}
+/** Jupiter Lend: protocol_state = lending, count = 4. */
+function buildRegisterJupLendParams(lending) {
+    return {
+        protocolState: lending,
+        readAumAccountCount: constants_1.JUPITER_LEND_READ_AUM_ACCOUNT_COUNT,
+    };
+}
+// ---------------------------------------------------------------------------
+// read_aum account resolvers
+//
+// Order MUST match the adapter's read_aum layout. First slot = protocol_state
+// (core-pinned). Adapter validates remaining slots from on-chain data.
+// ---------------------------------------------------------------------------
+/** Kamino: [vault_state, kv_token_ata]. */
+function resolveKaminoReadAumAccounts(vaultState, kvTokenAta) {
+    return [vaultState, kvTokenAta];
+}
+/** Jupiter Lend: [lending, rewards_rate_model, fToken_ata, fToken_mint]. */
+function resolveJupLendReadAumAccounts(lending, rewardsRateModel, ftokenAta, ftokenMint) {
+    return [lending, rewardsRateModel, ftokenAta, ftokenMint];
+}