@elemental-stv-core/sdk 0.8.0 → 0.9.1

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

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInitStrategyIx = createInitStrategyIx;
+exports.createUpdateStrategyIx = createUpdateStrategyIx;
+exports.createRegisterAdapterIx = createRegisterAdapterIx;
+exports.createDeregisterAdapterIx = createDeregisterAdapterIx;
+exports.createAddManagerIx = createAddManagerIx;
+exports.createRemoveManagerIx = createRemoveManagerIx;
+exports.createInitPositionIx = createInitPositionIx;
+exports.createClosePositionIx = createClosePositionIx;
+exports.createDepositIx = createDepositIx;
+exports.createWithdrawIx = createWithdrawIx;
+exports.createRouteDepositIx = createRouteDepositIx;
+exports.createRouteWithdrawIx = createRouteWithdrawIx;
+const web3_js_1 = require("@solana/web3.js");
+const buffer_1 = require("../common/buffer");
+const constants_1 = require("./constants");
+function createInitStrategyIx(args, programId = constants_1.PROGRAM_ID) {
+    const { admin, baseMint, strategyState, authority, systemProgram = web3_js_1.SystemProgram.programId, } = args;
+    return new web3_js_1.TransactionInstruction({
+        keys: [
+            { pubkey: admin, isSigner: true, isWritable: true },
+            { pubkey: baseMint, isSigner: false, isWritable: false },
+            { pubkey: strategyState, isSigner: false, isWritable: true },
+            { pubkey: authority, isSigner: false, isWritable: false },
+            { pubkey: systemProgram, isSigner: false, isWritable: false },
+        ],
+        programId,
+        data: constants_1.IX_INIT_STRATEGY,
+    });
+}
+function createUpdateStrategyIx(args, programId = constants_1.PROGRAM_ID) {
+    const parts = [];
+    (0, buffer_1.writeOptionalPubkey)(parts, args.newAdmin ?? null);
+    (0, buffer_1.writeOptionalU16)(parts, args.newFlags ?? null);
+    return new web3_js_1.TransactionInstruction({
+        keys: [
+            { pubkey: args.admin, isSigner: true, isWritable: false },
+            { pubkey: args.strategyState, isSigner: false, isWritable: true },
+        ],
+        programId,
+        data: Buffer.concat([constants_1.IX_UPDATE_STRATEGY, Buffer.from(parts)]),
+    });
+}
+function createRegisterAdapterIx(args, programId = constants_1.PROGRAM_ID) {
+    const { admin, strategyState, protocolVault, adapterProgram, index, params, systemProgram = web3_js_1.SystemProgram.programId, } = args;
+    if (index < 0 || index > 0xff) {
+        throw new RangeError(`index out of range: ${index}`);
+    }
+    if (params.readAumAccountCount < 0 || params.readAumAccountCount > 0xff) {
+        throw new RangeError(`readAumAccountCount out of range: ${params.readAumAccountCount}`);
+    }
+    const data = Buffer.concat([
+        constants_1.IX_REGISTER_ADAPTER,
+        Buffer.from([index]),
+        params.protocolState.toBuffer(),
+        Buffer.from([params.readAumAccountCount]),
+    ]);
+    return new web3_js_1.TransactionInstruction({
+        keys: [
+            { pubkey: admin, isSigner: true, isWritable: true },
+            { pubkey: strategyState, isSigner: false, isWritable: true },
+            { pubkey: protocolVault, isSigner: false, isWritable: true },
+            { pubkey: adapterProgram, isSigner: false, isWritable: false },
+            { pubkey: systemProgram, isSigner: false, isWritable: false },
+        ],
+        programId,
+        data,
+    });
+}
+function createDeregisterAdapterIx(args, programId = constants_1.PROGRAM_ID) {
+    const { admin, strategyState, protocolVault, systemProgram = web3_js_1.SystemProgram.programId, } = args;
+    return new web3_js_1.TransactionInstruction({
+        keys: [
+            { pubkey: admin, isSigner: true, isWritable: true },
+            { pubkey: strategyState, isSigner: false, isWritable: true },
+            { pubkey: protocolVault, isSigner: false, isWritable: true },
+            { pubkey: systemProgram, isSigner: false, isWritable: false },
+        ],
+        programId,
+        data: constants_1.IX_DEREGISTER_ADAPTER,
+    });
+}
+function createAddManagerIx(args, programId = constants_1.PROGRAM_ID) {
+    const { admin, strategyState, managerRole, manager, systemProgram = web3_js_1.SystemProgram.programId, } = args;
+    return new web3_js_1.TransactionInstruction({
+        keys: [
+            { pubkey: admin, isSigner: true, isWritable: true },
+            { pubkey: strategyState, isSigner: false, isWritable: false },
+            { pubkey: managerRole, isSigner: false, isWritable: true },
+            { pubkey: manager, isSigner: false, isWritable: false },
+            { pubkey: systemProgram, isSigner: false, isWritable: false },
+        ],
+        programId,
+        data: constants_1.IX_ADD_MANAGER,
+    });
+}
+function createRemoveManagerIx(args, programId = constants_1.PROGRAM_ID) {
+    const { admin, strategyState, managerRole, systemProgram = web3_js_1.SystemProgram.programId, } = args;
+    return new web3_js_1.TransactionInstruction({
+        keys: [
+            { pubkey: admin, isSigner: true, isWritable: true },
+            { pubkey: strategyState, isSigner: false, isWritable: false },
+            { pubkey: managerRole, isSigner: false, isWritable: true },
+            { pubkey: systemProgram, isSigner: false, isWritable: false },
+        ],
+        programId,
+        data: constants_1.IX_REMOVE_MANAGER,
+    });
+}
+function createInitPositionIx(args, programId = constants_1.PROGRAM_ID) {
+    const { strategyState, position, stv, payer, systemProgram = web3_js_1.SystemProgram.programId, } = args;
+    return new web3_js_1.TransactionInstruction({
+        keys: [
+            { pubkey: strategyState, isSigner: false, isWritable: false },
+            { pubkey: position, isSigner: false, isWritable: true },
+            { pubkey: stv, isSigner: true, isWritable: false },
+            { pubkey: payer, isSigner: true, isWritable: true },
+            { pubkey: systemProgram, isSigner: false, isWritable: false },
+        ],
+        programId,
+        data: constants_1.IX_INIT_POSITION,
+    });
+}
+function createClosePositionIx(args, programId = constants_1.PROGRAM_ID) {
+    return new web3_js_1.TransactionInstruction({
+        keys: [
+            { pubkey: args.strategyState, isSigner: false, isWritable: false },
+            { pubkey: args.position, isSigner: false, isWritable: true },
+            { pubkey: args.stv, isSigner: true, isWritable: true },
+        ],
+        programId,
+        data: constants_1.IX_CLOSE_POSITION,
+    });
+}
+function createDepositIx(args, programId = constants_1.PROGRAM_ID) {
+    const data = [...constants_1.IX_DEPOSIT];
+    (0, buffer_1.writeU64)(data, args.amount);
+    return new web3_js_1.TransactionInstruction({
+        keys: [
+            { pubkey: args.strategyState, isSigner: false, isWritable: true },
+            { pubkey: args.position, isSigner: false, isWritable: true },
+            { pubkey: args.stv, isSigner: true, isWritable: false },
+        ],
+        programId,
+        data: Buffer.from(data),
+    });
+}
+function createWithdrawIx(args, programId = constants_1.PROGRAM_ID) {
+    const data = [...constants_1.IX_WITHDRAW];
+    (0, buffer_1.writeU64)(data, args.shares);
+    return new web3_js_1.TransactionInstruction({
+        keys: [
+            { pubkey: args.strategyState, isSigner: false, isWritable: true },
+            { pubkey: args.position, isSigner: false, isWritable: true },
+            { pubkey: args.stv, isSigner: true, isWritable: false },
+            { pubkey: args.strategyBaseAta, isSigner: false, isWritable: true },
+            { pubkey: args.destAta, isSigner: false, isWritable: true },
+            { pubkey: args.baseMint, isSigner: false, isWritable: false },
+            { pubkey: args.tokenProgram, isSigner: false, isWritable: false },
+        ],
+        programId,
+        data: Buffer.from(data),
+    });
+}
+function buildRouteIx(disc, args, programId) {
+    const data = [...disc];
+    (0, buffer_1.writeU64)(data, args.amount);
+    return new web3_js_1.TransactionInstruction({
+        keys: [
+            { pubkey: args.manager, isSigner: true, isWritable: false },
+            { pubkey: args.managerRole, isSigner: false, isWritable: false },
+            { pubkey: args.strategyState, isSigner: false, isWritable: false },
+            { pubkey: args.protocolVault, isSigner: false, isWritable: false },
+            { pubkey: args.strategyBaseAta, isSigner: false, isWritable: true },
+            { pubkey: args.baseMint, isSigner: false, isWritable: false },
+            { pubkey: args.tokenProgram, isSigner: false, isWritable: false },
+            { pubkey: args.adapterProgram, isSigner: false, isWritable: false },
+            ...args.remainingAccounts,
+        ],
+        programId,
+        data: Buffer.from(data),
+    });
+}
+function createRouteDepositIx(args, programId = constants_1.PROGRAM_ID) {
+    return buildRouteIx(constants_1.IX_ROUTE_DEPOSIT, args, programId);
+}
+function createRouteWithdrawIx(args, programId = constants_1.PROGRAM_ID) {
+    return buildRouteIx(constants_1.IX_ROUTE_WITHDRAW, args, programId);
+}

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

@@ -0,0 +1,20 @@
+import { PublicKey, TransactionInstruction, AddressLookupTableAccount } from "@solana/web3.js";
+import type { SolanaConnection } from "../common/connection";
+import type { LendStrategyState } from "./types";
+import type { PerProtocolReadAumAccounts } from "./update-aum";
+/**
+ * Build `extendLookupTable` instructions for every account touched by
+ * update_aum / route_* flows on a given strategy:
+ *   - lend program ID
+ *   - each unique adapter program (from ProtocolVault + extras)
+ *   - each ProtocolVault PDA
+ *   - each protocol_state
+ *   - per-protocol adapter-specific accounts (caller-supplied — not stored on-chain in v2)
+ *
+ * Batched at ≤30 addresses per ix.
+ */
+export declare function buildElementalLendLutExtendIxs(connection: SolanaConnection, payer: PublicKey, lutAddress: PublicKey, strategy: LendStrategyState, strategyStatePda: PublicKey, perProtocolReadAumAccounts: PerProtocolReadAumAccounts, extraAdapterPrograms?: PublicKey[], programId?: PublicKey): Promise<TransactionInstruction[]>;
+/**
+ * Fetch an existing ALT for use in VersionedTransaction compilation.
+ */
+export declare function resolveElementalLendLut(connection: Pick<import("@solana/web3.js").Connection, "getAddressLookupTable">, lutAddress: PublicKey): Promise<AddressLookupTableAccount>;

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

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildElementalLendLutExtendIxs = buildElementalLendLutExtendIxs;
+exports.resolveElementalLendLut = resolveElementalLendLut;
+const web3_js_1 = require("@solana/web3.js");
+const constants_1 = require("./constants");
+const accounts_1 = require("./accounts");
+const MAX_LUT_EXTEND_PER_IX = 30;
+/**
+ * Build `extendLookupTable` instructions for every account touched by
+ * update_aum / route_* flows on a given strategy:
+ *   - lend program ID
+ *   - each unique adapter program (from ProtocolVault + extras)
+ *   - each ProtocolVault PDA
+ *   - each protocol_state
+ *   - per-protocol adapter-specific accounts (caller-supplied — not stored on-chain in v2)
+ *
+ * Batched at ≤30 addresses per ix.
+ */
+async function buildElementalLendLutExtendIxs(connection, payer, lutAddress, strategy, strategyStatePda, perProtocolReadAumAccounts, extraAdapterPrograms = [], programId = constants_1.PROGRAM_ID) {
+    const keys = [programId];
+    if (strategy.protocolCount > 0) {
+        const pvs = await (0, accounts_1.fetchAllProtocolVaults)(connection, strategyStatePda, strategy.protocolCount, programId);
+        for (let i = 0; i < pvs.length; i++) {
+            const [pvPda, pv] = pvs[i];
+            keys.push(pvPda);
+            keys.push(pv.adapterProgram);
+            keys.push(pv.protocolState);
+            const reads = perProtocolReadAumAccounts[i];
+            if (reads)
+                for (const k of reads)
+                    keys.push(k);
+        }
+    }
+    for (const p of extraAdapterPrograms)
+        keys.push(p);
+    const seen = new Set();
+    const unique = keys.filter((k) => {
+        const s = k.toBase58();
+        if (seen.has(s))
+            return false;
+        seen.add(s);
+        return true;
+    });
+    const ixs = [];
+    for (let i = 0; i < unique.length; i += MAX_LUT_EXTEND_PER_IX) {
+        ixs.push(web3_js_1.AddressLookupTableProgram.extendLookupTable({
+            payer,
+            authority: payer,
+            lookupTable: lutAddress,
+            addresses: unique.slice(i, i + MAX_LUT_EXTEND_PER_IX),
+        }));
+    }
+    return ixs;
+}
+/**
+ * Fetch an existing ALT for use in VersionedTransaction compilation.
+ */
+async function resolveElementalLendLut(connection, lutAddress) {
+    const { value } = await connection.getAddressLookupTable(lutAddress);
+    if (!value) {
+        throw new Error(`LUT not found: ${lutAddress.toBase58()}`);
+    }
+    return value;
+}

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

@@ -0,0 +1,9 @@
+import { PublicKey } from "@solana/web3.js";
+/** StrategyState PDA: ["strategy_state", base_mint]. */
+export declare function deriveStrategyState(baseMint: PublicKey, programId?: PublicKey): [PublicKey, number];
+/** ProtocolVault PDA: ["protocol", strategy_state, [index]]. */
+export declare function deriveProtocolVault(strategyState: PublicKey, index: number, programId?: PublicKey): [PublicKey, number];
+/** ManagerRole PDA: ["manager", strategy_state, manager]. */
+export declare function deriveManagerRole(strategyState: PublicKey, manager: PublicKey, programId?: PublicKey): [PublicKey, number];
+/** StvPosition PDA: ["position", stv]. */
+export declare function deriveStvPosition(stv: PublicKey, programId?: PublicKey): [PublicKey, number];

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveStrategyState = deriveStrategyState;
+exports.deriveProtocolVault = deriveProtocolVault;
+exports.deriveManagerRole = deriveManagerRole;
+exports.deriveStvPosition = deriveStvPosition;
+const web3_js_1 = require("@solana/web3.js");
+const constants_1 = require("./constants");
+/** StrategyState PDA: ["strategy_state", base_mint]. */
+function deriveStrategyState(baseMint, programId = constants_1.PROGRAM_ID) {
+    return web3_js_1.PublicKey.findProgramAddressSync([constants_1.STRATEGY_STATE_SEED, baseMint.toBuffer()], programId);
+}
+/** ProtocolVault PDA: ["protocol", strategy_state, [index]]. */
+function deriveProtocolVault(strategyState, index, programId = constants_1.PROGRAM_ID) {
+    if (index < 0 || index > 0xff) {
+        throw new RangeError(`ProtocolVault index out of range: ${index}`);
+    }
+    return web3_js_1.PublicKey.findProgramAddressSync([constants_1.PROTOCOL_VAULT_SEED, strategyState.toBuffer(), Buffer.from([index])], programId);
+}
+/** ManagerRole PDA: ["manager", strategy_state, manager]. */
+function deriveManagerRole(strategyState, manager, programId = constants_1.PROGRAM_ID) {
+    return web3_js_1.PublicKey.findProgramAddressSync([constants_1.MANAGER_SEED, strategyState.toBuffer(), manager.toBuffer()], programId);
+}
+/** StvPosition PDA: ["position", stv]. */
+function deriveStvPosition(stv, programId = constants_1.PROGRAM_ID) {
+    return web3_js_1.PublicKey.findProgramAddressSync([constants_1.POSITION_SEED, stv.toBuffer()], programId);
+}

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

@@ -0,0 +1,105 @@
+import { PublicKey } from "@solana/web3.js";
+import BN from "bn.js";
+import type { StrategyStateHeader } from "../common/strategy-interface";
+/** LendStrategyState v2 (280 bytes). */
+export interface LendStrategyState extends StrategyStateHeader {
+    admin: PublicKey;
+    protocolCount: number;
+}
+/**
+ * ProtocolVault (224 bytes). Per-protocol adapter registration.
+ * Core pins only `protocolState`; everything else is validated adapter-side.
+ */
+export interface ProtocolVault {
+    strategyState: PublicKey;
+    adapterProgram: PublicKey;
+    protocolState: PublicKey;
+    index: number;
+    bump: number;
+    readAumAccountCount: number;
+}
+export interface ManagerRole {
+    strategyState: PublicKey;
+    manager: PublicKey;
+    bump: number;
+}
+export type { StvPosition } from "../common/strategy-interface";
+export interface StrategyInitializedEvent {
+    name: "StrategyInitialized";
+    baseMint: PublicKey;
+    authority: PublicKey;
+    admin: PublicKey;
+}
+export interface StrategyUpdatedEvent {
+    name: "StrategyUpdated";
+    baseMint: PublicKey;
+    newAdmin: PublicKey | null;
+    newFlags: number | null;
+}
+export interface AdapterRegisteredEvent {
+    name: "AdapterRegistered";
+    baseMint: PublicKey;
+    index: number;
+    adapterProgram: PublicKey;
+    protocolState: PublicKey;
+}
+export interface AdapterDeregisteredEvent {
+    name: "AdapterDeregistered";
+    baseMint: PublicKey;
+    index: number;
+    adapterProgram: PublicKey;
+}
+export interface RouteDepositedEvent {
+    name: "RouteDeposited";
+    baseMint: PublicKey;
+    protocolIndex: number;
+    amount: BN;
+    actualDeposited: BN;
+}
+export interface RouteWithdrawnEvent {
+    name: "RouteWithdrawn";
+    baseMint: PublicKey;
+    protocolIndex: number;
+    amount: BN;
+    actualWithdrawn: BN;
+}
+export interface AumUpdatedEvent {
+    name: "AumUpdated";
+    baseMint: PublicKey;
+    totalAum: BN;
+    pps: BN;
+    baseBalance: BN;
+    /** Sum of protocol AUM values computed this CPI (not a cached value). */
+    protocolAumSum: BN;
+}
+export interface DepositedEvent {
+    name: "Deposited";
+    stv: PublicKey;
+    amount: BN;
+    sharesMinted: BN;
+}
+export interface WithdrawnEvent {
+    name: "Withdrawn";
+    stv: PublicKey;
+    shares: BN;
+    baseAmount: BN;
+}
+export interface PositionInitializedEvent {
+    name: "PositionInitialized";
+    stv: PublicKey;
+}
+export interface PositionClosedEvent {
+    name: "PositionClosed";
+    stv: PublicKey;
+}
+export interface ManagerAddedEvent {
+    name: "ManagerAdded";
+    strategyState: PublicKey;
+    manager: PublicKey;
+}
+export interface ManagerRemovedEvent {
+    name: "ManagerRemoved";
+    strategyState: PublicKey;
+    manager: PublicKey;
+}
+export type LendV2Event = StrategyInitializedEvent | StrategyUpdatedEvent | AdapterRegisteredEvent | AdapterDeregisteredEvent | RouteDepositedEvent | RouteWithdrawnEvent | AumUpdatedEvent | DepositedEvent | WithdrawnEvent | PositionInitializedEvent | PositionClosedEvent | ManagerAddedEvent | ManagerRemovedEvent;

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

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

package/dist/elemental-lend-v2/update-aum.d.ts

@@ -0,0 +1,29 @@
+import { PublicKey, TransactionInstruction, AccountMeta } from "@solana/web3.js";
+import type { SolanaConnection } from "../common/connection";
+import type { LendStrategyState, ProtocolVault } from "./types";
+/**
+ * Per-protocol map of adapter-specific accounts appended after
+ * `[protocol_vault, adapter_program]` in update_aum's remaining_accounts.
+ *
+ * Keyed by protocol index. First account MUST equal the registered
+ * protocol_state (enforced by core). Subsequent accounts adapter-validated.
+ * Length must equal `ProtocolVault.readAumAccountCount`.
+ */
+export type PerProtocolReadAumAccounts = Record<number, PublicKey[]>;
+/**
+ * Build the update_aum remaining_accounts tail.
+ *
+ * Layout per protocol i in 0..protocol_count:
+ *   [protocol_vault_i, adapter_program_i, ...perProtocolReadAumAccounts[i]]
+ */
+export declare function buildUpdateAumRemainingAccounts(connection: SolanaConnection, strategy: LendStrategyState, strategyStatePda: PublicKey, perProtocolReadAumAccounts: PerProtocolReadAumAccounts, programId?: PublicKey): Promise<AccountMeta[]>;
+/** Sync variant when the caller already has ProtocolVault data cached. */
+export declare function buildUpdateAumRemainingAccountsSync(strategy: LendStrategyState, strategyStatePda: PublicKey, protocolVaults: ProtocolVault[], perProtocolReadAumAccounts: PerProtocolReadAumAccounts, programId?: PublicKey): AccountMeta[];
+export interface UpdateAumArgs {
+    strategyState: PublicKey;
+    stv: PublicKey;
+    strategyBaseAta: PublicKey;
+    baseMint: PublicKey;
+    remainingAccounts: AccountMeta[];
+}
+export declare function createUpdateAumIx(args: UpdateAumArgs, programId?: PublicKey): TransactionInstruction;

package/dist/elemental-lend-v2/update-aum.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildUpdateAumRemainingAccounts = buildUpdateAumRemainingAccounts;
+exports.buildUpdateAumRemainingAccountsSync = buildUpdateAumRemainingAccountsSync;
+exports.createUpdateAumIx = createUpdateAumIx;
+const web3_js_1 = require("@solana/web3.js");
+const constants_1 = require("./constants");
+const accounts_1 = require("./accounts");
+const pda_1 = require("./pda");
+/**
+ * Build the update_aum remaining_accounts tail.
+ *
+ * Layout per protocol i in 0..protocol_count:
+ *   [protocol_vault_i, adapter_program_i, ...perProtocolReadAumAccounts[i]]
+ */
+async function buildUpdateAumRemainingAccounts(connection, strategy, strategyStatePda, perProtocolReadAumAccounts, programId = constants_1.PROGRAM_ID) {
+    const out = [];
+    if (strategy.protocolCount === 0)
+        return out;
+    const pvs = await (0, accounts_1.fetchAllProtocolVaults)(connection, strategyStatePda, strategy.protocolCount, programId);
+    for (let i = 0; i < pvs.length; i++) {
+        const [pvPda, pv] = pvs[i];
+        const reads = perProtocolReadAumAccounts[i];
+        if (!reads) {
+            throw new Error(`buildUpdateAumRemainingAccounts: missing read_aum accounts for protocol ${i}`);
+        }
+        if (reads.length !== pv.readAumAccountCount) {
+            throw new Error(`buildUpdateAumRemainingAccounts: protocol ${i} expects ` +
+                `${pv.readAumAccountCount} read_aum accounts, got ${reads.length}`);
+        }
+        if (!reads[0].equals(pv.protocolState)) {
+            throw new Error(`buildUpdateAumRemainingAccounts: protocol ${i} first read_aum account must equal ` +
+                `protocol_state ${pv.protocolState.toBase58()}, got ${reads[0].toBase58()}`);
+        }
+        out.push({ pubkey: pvPda, isSigner: false, isWritable: false });
+        out.push({ pubkey: pv.adapterProgram, isSigner: false, isWritable: false });
+        for (const k of reads) {
+            out.push({ pubkey: k, isSigner: false, isWritable: false });
+        }
+    }
+    return out;
+}
+/** Sync variant when the caller already has ProtocolVault data cached. */
+function buildUpdateAumRemainingAccountsSync(strategy, strategyStatePda, protocolVaults, perProtocolReadAumAccounts, programId = constants_1.PROGRAM_ID) {
+    if (protocolVaults.length !== strategy.protocolCount) {
+        throw new Error(`protocolVaults length ${protocolVaults.length} does not match strategy.protocolCount ${strategy.protocolCount}`);
+    }
+    const out = [];
+    for (let i = 0; i < protocolVaults.length; i++) {
+        const pv = protocolVaults[i];
+        const [pvPda] = (0, pda_1.deriveProtocolVault)(strategyStatePda, i, programId);
+        const reads = perProtocolReadAumAccounts[i];
+        if (!reads) {
+            throw new Error(`missing read_aum accounts for protocol ${i}`);
+        }
+        if (reads.length !== pv.readAumAccountCount) {
+            throw new Error(`protocol ${i} expects ${pv.readAumAccountCount} read_aum accounts, got ${reads.length}`);
+        }
+        if (!reads[0].equals(pv.protocolState)) {
+            throw new Error(`protocol ${i} first read_aum account must equal protocol_state`);
+        }
+        out.push({ pubkey: pvPda, isSigner: false, isWritable: false });
+        out.push({ pubkey: pv.adapterProgram, isSigner: false, isWritable: false });
+        for (const k of reads) {
+            out.push({ pubkey: k, isSigner: false, isWritable: false });
+        }
+    }
+    return out;
+}
+function createUpdateAumIx(args, programId = constants_1.PROGRAM_ID) {
+    return new web3_js_1.TransactionInstruction({
+        keys: [
+            { pubkey: args.strategyState, isSigner: false, isWritable: true },
+            { pubkey: args.stv, isSigner: true, isWritable: false },
+            { pubkey: args.strategyBaseAta, isSigner: false, isWritable: false },
+            { pubkey: args.baseMint, isSigner: false, isWritable: false },
+            ...args.remainingAccounts,
+        ],
+        programId,
+        data: constants_1.IX_UPDATE_AUM,
+    });
+}

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export * as common from "./common";
 export * as pStvCore from "./p-stv-core";
 export * as elementalLend from "./elemental-lend";
+export * as elementalLendV2 from "./elemental-lend-v2";
 export * as jlpdStrategy from "./jlpd-strategy";

package/dist/index.js

@@ -33,8 +33,9 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.jlpdStrategy = exports.elementalLend = exports.pStvCore = exports.common = void 0;
+exports.jlpdStrategy = exports.elementalLendV2 = exports.elementalLend = exports.pStvCore = exports.common = void 0;
 exports.common = __importStar(require("./common"));
 exports.pStvCore = __importStar(require("./p-stv-core"));
 exports.elementalLend = __importStar(require("./elemental-lend"));
+exports.elementalLendV2 = __importStar(require("./elemental-lend-v2"));
 exports.jlpdStrategy = __importStar(require("./jlpd-strategy"));

package/dist/jlpd-strategy/jlp-data.d.ts

@@ -71,3 +71,85 @@ export declare function computeAddLiquidityFee(args: {
     isDiscount: boolean;
 };
 export declare function fetchJlpCustodyData(connection: SolanaConnection): Promise<JlpData>;
+/** Public symbol used by the effective-weights API.
+ *
+ * Note: JLP custody is internally named "WBTC" but represents BTC exposure
+ * for sensitivity purposes — surfaced as `'BTC'` here per spec. */
+export type EffectiveWeightSymbol = "BTC" | "ETH" | "SOL" | "USDC" | "USDT";
+export interface AssetEffectiveWeight {
+    mint: PublicKey;
+    symbol: EffectiveWeightSymbol;
+    /** Effective USD contribution, normalized to 8 decimals. */
+    effUsd: bigint;
+    /** Share of total effective USD, in basis points (0–10000). */
+    effShareBps: number;
+    /** True if `(owned − locked) < 0`. Spot term clamped to 0 in `effUsd`. */
+    spotClamped: boolean;
+}
+export interface JlpEffectiveWeights {
+    assets: AssetEffectiveWeight[];
+    /** Sum of all `effUsd` values, 8 decimals. */
+    totalEffUsd: bigint;
+    /** Total pool aumUsd (including `guaranteed_usd`), 8 decimals — context only. */
+    totalAumUsd: bigint;
+}
+/** Inputs needed to compute effective USD for one custody.
+ *
+ * Decoupled from on-chain fetching so unit tests can drive the math directly. */
+export interface EffectiveWeightInput {
+    owned: bigint;
+    locked: bigint;
+    /** Raw debt u128 (DEBT_MULTIPLIER-scaled by 1e9 internally, then by 10^decimals). */
+    debt: bigint;
+    /** Raw borrow-lend interests accrued u128 (same scale as `debt`). */
+    borrowLendInterestsAccrued: bigint;
+    shortSizeUsd: bigint;
+    avgShortPriceUsd: bigint;
+    guaranteedUsd: bigint;
+    decimals: number;
+    /** Price scaled to 8 decimals (float price × 10^8, as bigint). */
+    priceScaled8: bigint;
+}
+export interface EffectiveWeightOutput {
+    /** (owned + netDebt − locked) × price, normalized to 8-decimal USD. Clamped to 0 if negative. */
+    spotEffUsd: bigint;
+    /** shortSize × price / avgShortPrice, normalized to 8-decimal USD. 0 if no shorts. */
+    shortEffUsd: bigint;
+    /** spotEffUsd + shortEffUsd. */
+    effUsd: bigint;
+    /** True if (owned + netDebt − locked) < 0 — spot term was clamped. */
+    spotClamped: boolean;
+    /** netDebt tokens applied to spot term (already converted to token-base units). */
+    netDebtTokens: bigint;
+}
+/** Compute effective USD (price-sensitivity-weighted) for a single custody.
+ *
+ * Formula (in 8-decimal USD):
+ *   netDebtTokens = max(debt − borrowLendInterestsAccrued, 0) / DEBT_MULTIPLIER
+ *   spot          = (owned + netDebtTokens − locked) × price_8dec / 10^decimals
+ *   short         = shortSize_6dec × price_8dec / avgShortPrice_6dec  (zeroed if either operand is 0)
+ *   effUsd        = max(spot, 0) + short
+ *
+ * Algebra for unit normalization:
+ *   - owned/locked/netDebt is in 10^decimals base units; price is 10^8 USD.
+ *     spot = (owned + netDebt − locked) × price_8dec / 10^decimals → 10^8 USD ✓
+ *   - debt is stored as u128 scaled by DEBT_MULTIPLIER (1e9) on top of 10^decimals.
+ *     netDebtTokens = (debt − borrowLendInterestsAccrued) / DEBT_MULTIPLIER
+ *     (integer division — small rounding under one base unit, acceptable).
+ *   - shortSize and avgShortPrice are both 10^6; ratio is dimensionless.
+ *     short = shortSize × price_8dec / avgShortPrice → 10^8 USD ✓
+ */
+export declare function computeEffectiveUsd(input: EffectiveWeightInput): EffectiveWeightOutput;
+/**
+ * Fetch JLP pool effective-weight composition.
+ *
+ * Returns price-sensitivity-weighted shares per asset, dropping `guaranteed_usd`
+ * from the per-asset weight calculation. Suitable for rebalance planners that
+ * want to track the pool's true delta-1 composition rather than reported aumUsd.
+ *
+ * Reuses the same on-chain custody parser and Jupiter Price API source as
+ * `fetchJlpCustodyData` to keep numbers consistent across callers.
+ *
+ * @returns assets in fixed order: BTC, ETH, SOL, USDC, USDT.
+ */
+export declare function fetchJlpEffectiveWeights(connection: SolanaConnection): Promise<JlpEffectiveWeights>;