@elmntl/jlpd-sdk 0.1.11 → 0.13.4

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,
+    });
+}