@elmntl/jlpd-sdk 0.1.11 → 0.13.4

package/dist/common/ata.d.ts

@@ -0,0 +1,26 @@
+import { PublicKey, TransactionInstruction } from "@solana/web3.js";
+/**
+ * Derive an Associated Token Account (ATA) address.
+ *
+ * Equivalent to `@solana/spl-token`'s `getAssociatedTokenAddressSync` but
+ * inlined to avoid pulling the runtime helpers into hot paths and to give a
+ * single source of truth across all SDK sub-packages (p-stv-core,
+ * elemental-lend, jlpd-strategy).
+ *
+ * @param mint - Token mint
+ * @param owner - Owner of the ATA (typically a PDA or wallet)
+ * @param tokenProgram - Token program ID (SPL Token or Token-2022)
+ */
+export declare function findAta(mint: PublicKey, owner: PublicKey, tokenProgram: PublicKey): PublicKey;
+/**
+ * Build an Associated Token Account `CreateIdempotent` instruction.
+ *
+ * Idempotent — safe to include on every tx; the ATA program no-ops if the
+ * account already exists. Works for both SPL Token and Token-2022.
+ *
+ * @param payer - Wallet paying rent + signing the tx
+ * @param mint - Token mint the ATA will hold
+ * @param owner - ATA owner (wallet or PDA)
+ * @param tokenProgram - SPL Token or Token-2022 program id
+ */
+export declare function createIdempotentAtaIx(payer: PublicKey, mint: PublicKey, owner: PublicKey, tokenProgram: PublicKey): TransactionInstruction;

package/dist/common/ata.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findAta = findAta;
+exports.createIdempotentAtaIx = createIdempotentAtaIx;
+const web3_js_1 = require("@solana/web3.js");
+const spl_token_1 = require("@solana/spl-token");
+/**
+ * Derive an Associated Token Account (ATA) address.
+ *
+ * Equivalent to `@solana/spl-token`'s `getAssociatedTokenAddressSync` but
+ * inlined to avoid pulling the runtime helpers into hot paths and to give a
+ * single source of truth across all SDK sub-packages (p-stv-core,
+ * elemental-lend, jlpd-strategy).
+ *
+ * @param mint - Token mint
+ * @param owner - Owner of the ATA (typically a PDA or wallet)
+ * @param tokenProgram - Token program ID (SPL Token or Token-2022)
+ */
+function findAta(mint, owner, tokenProgram) {
+    const [ata] = web3_js_1.PublicKey.findProgramAddressSync([owner.toBuffer(), tokenProgram.toBuffer(), mint.toBuffer()], spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID);
+    return ata;
+}
+/**
+ * Build an Associated Token Account `CreateIdempotent` instruction.
+ *
+ * Idempotent — safe to include on every tx; the ATA program no-ops if the
+ * account already exists. Works for both SPL Token and Token-2022.
+ *
+ * @param payer - Wallet paying rent + signing the tx
+ * @param mint - Token mint the ATA will hold
+ * @param owner - ATA owner (wallet or PDA)
+ * @param tokenProgram - SPL Token or Token-2022 program id
+ */
+function createIdempotentAtaIx(payer, mint, owner, tokenProgram) {
+    const ata = findAta(mint, owner, tokenProgram);
+    return new web3_js_1.TransactionInstruction({
+        keys: [
+            { pubkey: payer, isSigner: true, isWritable: true },
+            { pubkey: ata, isSigner: false, isWritable: true },
+            { pubkey: owner, isSigner: false, isWritable: false },
+            { pubkey: mint, isSigner: false, isWritable: false },
+            { pubkey: web3_js_1.SystemProgram.programId, isSigner: false, isWritable: false },
+            { pubkey: tokenProgram, isSigner: false, isWritable: false },
+        ],
+        programId: spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID,
+        data: Buffer.from([1]), // CreateIdempotent
+    });
+}

package/dist/common/buffer.d.ts

@@ -0,0 +1,15 @@
+import { PublicKey } from "@solana/web3.js";
+import BN from "bn.js";
+export declare function readPubkey(data: Buffer, offset: number): PublicKey;
+export declare function readU64(data: Buffer, offset: number): BN;
+/** Read a signed little-endian i64 as a BN (two's-complement aware). */
+export declare function readI64(data: Buffer, offset: number): BN;
+export declare function readU32(data: Buffer, offset: number): number;
+export declare function readU16(data: Buffer, offset: number): number;
+export declare function readU8(data: Buffer, offset: number): number;
+export declare function writeU64(parts: number[], value: BN | number): void;
+export declare function writeOptionalPubkey(parts: number[], value: PublicKey | undefined | null): void;
+export declare function writeOptionalU64(parts: number[], value: BN | number | undefined | null): void;
+export declare function writeOptionalU32(parts: number[], value: number | undefined | null): void;
+export declare function writeOptionalU16(parts: number[], value: number | undefined | null): void;
+export declare function writeOptionalU8(parts: number[], value: number | undefined | null): void;

package/dist/common/buffer.js

@@ -0,0 +1,118 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readPubkey = readPubkey;
+exports.readU64 = readU64;
+exports.readI64 = readI64;
+exports.readU32 = readU32;
+exports.readU16 = readU16;
+exports.readU8 = readU8;
+exports.writeU64 = writeU64;
+exports.writeOptionalPubkey = writeOptionalPubkey;
+exports.writeOptionalU64 = writeOptionalU64;
+exports.writeOptionalU32 = writeOptionalU32;
+exports.writeOptionalU16 = writeOptionalU16;
+exports.writeOptionalU8 = writeOptionalU8;
+const web3_js_1 = require("@solana/web3.js");
+const bn_js_1 = __importDefault(require("bn.js"));
+// ---------------------------------------------------------------------------
+// Read Helpers (account deserialization)
+//
+// Each helper validates that `offset + width <= data.length` and throws a
+// descriptive error if the slice would run past the buffer end. Catching
+// these at the call site (a malformed account, a layout drift, an incorrect
+// offset constant) is much cheaper than chasing the resulting garbage data
+// through downstream parsing.
+// ---------------------------------------------------------------------------
+function checkBounds(data, offset, width, label) {
+    if (offset < 0 || offset + width > data.length) {
+        throw new RangeError(`${label}: cannot read ${width} bytes at offset ${offset} (buffer length=${data.length})`);
+    }
+}
+function readPubkey(data, offset) {
+    checkBounds(data, offset, 32, "readPubkey");
+    return new web3_js_1.PublicKey(data.subarray(offset, offset + 32));
+}
+function readU64(data, offset) {
+    checkBounds(data, offset, 8, "readU64");
+    return new bn_js_1.default(data.subarray(offset, offset + 8), "le");
+}
+/** Read a signed little-endian i64 as a BN (two's-complement aware). */
+function readI64(data, offset) {
+    checkBounds(data, offset, 8, "readI64");
+    return new bn_js_1.default(data.readBigInt64LE(offset).toString());
+}
+function readU32(data, offset) {
+    checkBounds(data, offset, 4, "readU32");
+    return data.readUInt32LE(offset);
+}
+function readU16(data, offset) {
+    checkBounds(data, offset, 2, "readU16");
+    return data.readUInt16LE(offset);
+}
+function readU8(data, offset) {
+    checkBounds(data, offset, 1, "readU8");
+    return data[offset];
+}
+// ---------------------------------------------------------------------------
+// Write Helpers (instruction serialization)
+// ---------------------------------------------------------------------------
+function writeU64(parts, value) {
+    const bn = new bn_js_1.default(value);
+    parts.push(...bn.toArrayLike(Buffer, "le", 8));
+}
+function writeOptionalPubkey(parts, value) {
+    if (value != null) {
+        parts.push(0x01);
+        parts.push(...value.toBuffer());
+    }
+    else {
+        parts.push(0x00);
+    }
+}
+function writeOptionalU64(parts, value) {
+    if (value != null) {
+        parts.push(0x01);
+        const bn = new bn_js_1.default(value);
+        parts.push(...bn.toArrayLike(Buffer, "le", 8));
+    }
+    else {
+        parts.push(0x00);
+    }
+}
+function writeOptionalU32(parts, value) {
+    if (value != null) {
+        parts.push(0x01);
+        const buf = Buffer.alloc(4);
+        buf.writeUInt32LE(value, 0);
+        parts.push(...buf);
+    }
+    else {
+        parts.push(0x00);
+    }
+}
+function writeOptionalU16(parts, value) {
+    if (value != null) {
+        parts.push(0x01);
+        const buf = Buffer.alloc(2);
+        buf.writeUInt16LE(value, 0);
+        parts.push(...buf);
+    }
+    else {
+        parts.push(0x00);
+    }
+}
+function writeOptionalU8(parts, value) {
+    if (value != null) {
+        if (!Number.isInteger(value) || value < 0 || value > 0xff) {
+            throw new Error(`writeOptionalU8: value out of range (0..255): ${value}`);
+        }
+        parts.push(0x01);
+        parts.push(value);
+    }
+    else {
+        parts.push(0x00);
+    }
+}

package/dist/common/connection.d.ts

@@ -0,0 +1,13 @@
+import { Connection } from "@solana/web3.js";
+/**
+ * Canonical structural connection type used by every Elemental SDK module
+ * that needs to read on-chain state.
+ *
+ * Using a `Pick<Connection, ...>` here lets callers pass any version of
+ * `@solana/web3.js` without nominal type mismatches across module versions.
+ *
+ * If a builder needs only a subset of these methods, prefer aliasing further
+ * (`type ProtocolActionConnection = Pick<SolanaConnection, "getAccountInfo" | "getMultipleAccountsInfo">`)
+ * rather than defining a competing top-level type.
+ */
+export type SolanaConnection = Pick<Connection, "getAccountInfo" | "getMultipleAccountsInfo" | "getProgramAccounts" | "getTokenAccountsByOwner" | "getSlot" | "getBlockTime">;

package/dist/common/connection.js

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

package/dist/common/constants.d.ts

@@ -0,0 +1,14 @@
+/** Price per share scale factor (10^9) */
+export declare const PPS_DECIMALS = 1000000000;
+/** Basis points denominator */
+export declare const BPS_DENOMINATOR = 10000;
+/** Seconds in a year (365 days) */
+export declare const SECONDS_PER_YEAR = 31536000;
+/** Default staleness threshold in seconds */
+export declare const STALENESS_THRESHOLD = 120;
+/** sha256("account:StrategyState")[..8] — used by elemental-lend, jlpd-strategy */
+export declare const DISC_STRATEGY_STATE: Buffer<ArrayBuffer>;
+/** sha256("account:StvPosition")[..8] — used by elemental-lend, jlpd-strategy */
+export declare const DISC_STV_POSITION: Buffer<ArrayBuffer>;
+/** sha256("account:ManagerRole")[..8] — used by p-stv-core, elemental-lend, jlpd-strategy */
+export declare const DISC_MANAGER_ROLE: Buffer<ArrayBuffer>;

package/dist/common/constants.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DISC_MANAGER_ROLE = exports.DISC_STV_POSITION = exports.DISC_STRATEGY_STATE = exports.STALENESS_THRESHOLD = exports.SECONDS_PER_YEAR = exports.BPS_DENOMINATOR = exports.PPS_DECIMALS = void 0;
+/** Price per share scale factor (10^9) */
+exports.PPS_DECIMALS = 1000000000;
+/** Basis points denominator */
+exports.BPS_DENOMINATOR = 10000;
+/** Seconds in a year (365 days) */
+exports.SECONDS_PER_YEAR = 31536000;
+/** Default staleness threshold in seconds */
+exports.STALENESS_THRESHOLD = 120;
+// ---------------------------------------------------------------------------
+// Shared Anchor account discriminators
+//
+// All three Elemental programs use Anchor's `sha256("account:<Type>")[..8]`
+// discriminator format. The following types share the same on-chain layout
+// across programs and therefore the same discriminator bytes — defining them
+// once in `common` keeps them in lock-step.
+// ---------------------------------------------------------------------------
+/** sha256("account:StrategyState")[..8] — used by elemental-lend, jlpd-strategy */
+exports.DISC_STRATEGY_STATE = Buffer.from([
+    0x53, 0x12, 0xe0, 0x6d, 0xae, 0x64, 0x27, 0x8b,
+]);
+/** sha256("account:StvPosition")[..8] — used by elemental-lend, jlpd-strategy */
+exports.DISC_STV_POSITION = Buffer.from([
+    0x2f, 0xd4, 0xfb, 0xb0, 0x8a, 0xa0, 0x1e, 0x57,
+]);
+/** sha256("account:ManagerRole")[..8] — used by p-stv-core, elemental-lend, jlpd-strategy */
+exports.DISC_MANAGER_ROLE = Buffer.from([
+    0x25, 0xe8, 0x64, 0xe9, 0xaa, 0xe9, 0xdb, 0xb9,
+]);

package/dist/common/index.d.ts

@@ -0,0 +1,6 @@
+export { readPubkey, readU64, readU32, readU16, readU8, writeU64, writeOptionalPubkey, writeOptionalU64, writeOptionalU32, writeOptionalU16, } from "./buffer";
+export { PPS_DECIMALS, BPS_DENOMINATOR, SECONDS_PER_YEAR, STALENESS_THRESHOLD, DISC_STRATEGY_STATE, DISC_STV_POSITION, DISC_MANAGER_ROLE, } from "./constants";
+export type { SolanaConnection } from "./connection";
+export type { StrategyStateHeader, StvPosition, } from "./strategy-interface";
+export { deserializeStrategyStateHeader, deserializeStvPosition, } from "./strategy-interface";
+export { findAta, createIdempotentAtaIx } from "./ata";

package/dist/common/index.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createIdempotentAtaIx = exports.findAta = exports.deserializeStvPosition = exports.deserializeStrategyStateHeader = exports.DISC_MANAGER_ROLE = exports.DISC_STV_POSITION = exports.DISC_STRATEGY_STATE = exports.STALENESS_THRESHOLD = exports.SECONDS_PER_YEAR = exports.BPS_DENOMINATOR = exports.PPS_DECIMALS = exports.writeOptionalU16 = exports.writeOptionalU32 = exports.writeOptionalU64 = exports.writeOptionalPubkey = exports.writeU64 = exports.readU8 = exports.readU16 = exports.readU32 = exports.readU64 = exports.readPubkey = void 0;
+var buffer_1 = require("./buffer");
+Object.defineProperty(exports, "readPubkey", { enumerable: true, get: function () { return buffer_1.readPubkey; } });
+Object.defineProperty(exports, "readU64", { enumerable: true, get: function () { return buffer_1.readU64; } });
+Object.defineProperty(exports, "readU32", { enumerable: true, get: function () { return buffer_1.readU32; } });
+Object.defineProperty(exports, "readU16", { enumerable: true, get: function () { return buffer_1.readU16; } });
+Object.defineProperty(exports, "readU8", { enumerable: true, get: function () { return buffer_1.readU8; } });
+Object.defineProperty(exports, "writeU64", { enumerable: true, get: function () { return buffer_1.writeU64; } });
+Object.defineProperty(exports, "writeOptionalPubkey", { enumerable: true, get: function () { return buffer_1.writeOptionalPubkey; } });
+Object.defineProperty(exports, "writeOptionalU64", { enumerable: true, get: function () { return buffer_1.writeOptionalU64; } });
+Object.defineProperty(exports, "writeOptionalU32", { enumerable: true, get: function () { return buffer_1.writeOptionalU32; } });
+Object.defineProperty(exports, "writeOptionalU16", { enumerable: true, get: function () { return buffer_1.writeOptionalU16; } });
+var constants_1 = require("./constants");
+Object.defineProperty(exports, "PPS_DECIMALS", { enumerable: true, get: function () { return constants_1.PPS_DECIMALS; } });
+Object.defineProperty(exports, "BPS_DENOMINATOR", { enumerable: true, get: function () { return constants_1.BPS_DENOMINATOR; } });
+Object.defineProperty(exports, "SECONDS_PER_YEAR", { enumerable: true, get: function () { return constants_1.SECONDS_PER_YEAR; } });
+Object.defineProperty(exports, "STALENESS_THRESHOLD", { enumerable: true, get: function () { return constants_1.STALENESS_THRESHOLD; } });
+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; } });
+var strategy_interface_1 = require("./strategy-interface");
+Object.defineProperty(exports, "deserializeStrategyStateHeader", { enumerable: true, get: function () { return strategy_interface_1.deserializeStrategyStateHeader; } });
+Object.defineProperty(exports, "deserializeStvPosition", { enumerable: true, get: function () { return strategy_interface_1.deserializeStvPosition; } });
+var ata_1 = require("./ata");
+Object.defineProperty(exports, "findAta", { enumerable: true, get: function () { return ata_1.findAta; } });
+Object.defineProperty(exports, "createIdempotentAtaIx", { enumerable: true, get: function () { return ata_1.createIdempotentAtaIx; } });

package/dist/common/strategy-interface.d.ts

@@ -0,0 +1,59 @@
+import { PublicKey } from "@solana/web3.js";
+import BN from "bn.js";
+/**
+ * StrategyStateHeader — 104-byte prefix shared by every strategy program.
+ *
+ * Layout (offsets include the 8-byte discriminator):
+ *   [  0..  8]  discriminator      (set by the wrapping account)
+ *   [  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
+ *   [106..107]  version             u8
+ *   [107..108]  bump                u8
+ *   [108..112]  _headerPadding      [u8; 4]
+ */
+export interface StrategyStateHeader {
+    baseMint: PublicKey;
+    authority: PublicKey;
+    pps: BN;
+    totalAum: BN;
+    totalShares: BN;
+    lastUpdated: BN;
+    flags: number;
+    version: number;
+    bump: number;
+}
+/**
+ * Deserialize the standard 104-byte StrategyState header from any strategy
+ * account. `data` must include the 8-byte discriminator prefix; the caller
+ * is responsible for validating that the discriminator matches the expected
+ * type before invoking this helper.
+ */
+export declare function deserializeStrategyStateHeader(data: Buffer): StrategyStateHeader;
+/**
+ * StvPosition — per-STV virtual share record. 48 bytes of meaningful data
+ * (full account is 120 bytes including the 8-byte discriminator and trailing
+ * reserved padding).
+ *
+ * Layout (offsets include the 8-byte discriminator):
+ *   [  0..  8]  discriminator       (set by the wrapping account)
+ *   [  8.. 40]  stv                  Pubkey
+ *   [ 40.. 48]  shares               u64
+ *   [ 48.. 49]  bump                 u8
+ *   [ 49..120]  _reserved            [u8; 71]
+ */
+export interface StvPosition {
+    stv: PublicKey;
+    shares: BN;
+    bump: number;
+}
+/**
+ * Deserialize the standard StvPosition from any strategy account. `data`
+ * must include the 8-byte discriminator prefix; the caller validates the
+ * discriminator before invoking this helper.
+ */
+export declare function deserializeStvPosition(data: Buffer): StvPosition;

package/dist/common/strategy-interface.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deserializeStrategyStateHeader = deserializeStrategyStateHeader;
+exports.deserializeStvPosition = deserializeStvPosition;
+const buffer_1 = require("./buffer");
+/**
+ * Deserialize the standard 104-byte StrategyState header from any strategy
+ * account. `data` must include the 8-byte discriminator prefix; the caller
+ * is responsible for validating that the discriminator matches the expected
+ * type before invoking this helper.
+ */
+function deserializeStrategyStateHeader(data) {
+    if (data.length < 112) {
+        throw new Error(`StrategyState header data too short: ${data.length} < 112`);
+    }
+    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),
+    };
+}
+/**
+ * Deserialize the standard StvPosition from any strategy account. `data`
+ * must include the 8-byte discriminator prefix; the caller validates the
+ * discriminator before invoking this helper.
+ */
+function deserializeStvPosition(data) {
+    if (data.length < 56) {
+        throw new Error(`StvPosition data too short: ${data.length} < 56`);
+    }
+    return {
+        stv: (0, buffer_1.readPubkey)(data, 8),
+        shares: (0, buffer_1.readU64)(data, 40),
+        bump: (0, buffer_1.readU8)(data, 48),
+    };
+}

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

@@ -0,0 +1,103 @@
+import { AccountMeta, PublicKey } from "@solana/web3.js";
+import type { StvPosition } from "../common/strategy-interface";
+import type { SolanaConnection } from "../common/connection";
+import { LendStrategyState, ManagerRole } from "./types";
+/**
+ * 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]
+ */
+export declare function deserializeLendStrategyState(data: Buffer): LendStrategyState;
+/**
+ * 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.
+ */
+export declare function deserializeLendStvPosition(data: Buffer): StvPosition;
+/**
+ * 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]
+ */
+export declare function deserializeManagerRole(data: Buffer): ManagerRole;
+export declare function fetchLendStrategyState(connection: SolanaConnection, baseMint: PublicKey, programId?: PublicKey): Promise<LendStrategyState>;
+export declare function fetchLendStrategyStateByAddress(connection: SolanaConnection, address: PublicKey): Promise<LendStrategyState>;
+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>;
+export declare function fetchAllLendStrategyStates(connection: SolanaConnection, programId?: PublicKey): Promise<[PublicKey, LendStrategyState][]>;
+export declare function fetchManagersForStrategy(connection: SolanaConnection, strategyState: PublicKey, programId?: PublicKey): Promise<[PublicKey, ManagerRole][]>;
+/**
+ * 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.
+ */
+export declare function buildProtocolAccountsForAum(connection: SolanaConnection, strategy: LendStrategyState, strategyStatePda: PublicKey, _tokenProgramId: PublicKey, protocolCache?: Map<string, {
+    owner: PublicKey;
+    data: Buffer;
+}>): Promise<AccountMeta[]>;