@elemental-stv-core/sdk 0.5.0 → 0.6.0

package/dist/p-stv-core/index.d.ts

@@ -8,4 +8,3 @@ export * from "./remaining-accounts";
 export * from "./send-tx";
 export * from "./sol-wrap";
 export * from "./prices";
-//# sourceMappingURL=index.d.ts.map

package/dist/p-stv-core/index.js

@@ -24,4 +24,3 @@ __exportStar(require("./remaining-accounts"), exports);
 __exportStar(require("./send-tx"), exports);
 __exportStar(require("./sol-wrap"), exports);
 __exportStar(require("./prices"), exports);
-//# sourceMappingURL=index.js.map

package/dist/p-stv-core/instructions.d.ts

@@ -42,6 +42,8 @@ export interface InitOrUpdateStvArgs {
 export declare function createInitOrUpdateStvIx(args: InitOrUpdateStvArgs, programId?: PublicKey): TransactionInstruction;
 export interface DepositArgs {
     user: PublicKey;
+    /** GlobalConfig PDA — checked for CFG_FLAG_GLOBAL_PAUSED */
+    config: PublicKey;
     stv: PublicKey;
     vaultAta: PublicKey;
     userBaseAta: PublicKey;
@@ -61,6 +63,8 @@ export interface DepositArgs {
 export declare function createDepositIx(args: DepositArgs, programId?: PublicKey): TransactionInstruction;
 export interface RequestWithdrawArgs {
     user: PublicKey;
+    /** GlobalConfig PDA — checked for CFG_FLAG_GLOBAL_PAUSED */
+    config: PublicKey;
     stv: PublicKey;
     withdrawRequest: PublicKey;
     userEvAta: PublicKey;
@@ -74,6 +78,8 @@ export interface RequestWithdrawArgs {
 export declare function createRequestWithdrawIx(args: RequestWithdrawArgs, programId?: PublicKey): TransactionInstruction;
 export interface ClaimWithdrawArgs {
     user: PublicKey;
+    /** GlobalConfig PDA — checked for CFG_FLAG_GLOBAL_PAUSED */
+    config: PublicKey;
     stv: PublicKey;
     withdrawRequest: PublicKey;
     vaultAta: PublicKey;
@@ -88,6 +94,8 @@ export declare function createClaimWithdrawIx(args: ClaimWithdrawArgs, programId
 export interface OverrideClaimWithdrawArgs {
     manager: PublicKey;
     managerRole: PublicKey;
+    /** GlobalConfig PDA — checked for CFG_FLAG_GLOBAL_PAUSED */
+    config: PublicKey;
     user: PublicKey;
     stv: PublicKey;
     withdrawRequest: PublicKey;
@@ -101,6 +109,8 @@ export interface OverrideClaimWithdrawArgs {
 export declare function createOverrideClaimWithdrawIx(args: OverrideClaimWithdrawArgs, programId?: PublicKey): TransactionInstruction;
 export interface ProcessEpochArgs {
     payer: PublicKey;
+    /** GlobalConfig PDA — checked for CFG_FLAG_GLOBAL_PAUSED */
+    config: PublicKey;
     stv: PublicKey;
     evMint: PublicKey;
     feeReceiverEvAta: PublicKey;
@@ -116,6 +126,8 @@ export declare function createProcessEpochIx(args: ProcessEpochArgs, programId?:
 export interface DepositToStrategyArgs {
     manager: PublicKey;
     managerRole: PublicKey;
+    /** GlobalConfig PDA — checked for CFG_FLAG_GLOBAL_PAUSED */
+    config: PublicKey;
     stv: PublicKey;
     vaultAta: PublicKey;
     baseMint: PublicKey;
@@ -126,7 +138,13 @@ export interface DepositToStrategyArgs {
     tokenProgram: PublicKey;
     amount: BN | number;
     minShares: BN | number;
-    /** Number of auto-unroute accounts appended after lend accounts (0 = no auto-unroute) */
+    /**
+     * Number of protocol AUM accounts (kVault: 2/protocol, Jupiter Lend: 3/protocol)
+     * used by update_lend_aum for fresh lend valuation before the reserved_base
+     * liquidity lock check. Always required (0 if lend has no active protocols).
+     */
+    protocolAumCount: number;
+    /** Number of auto-unroute accounts appended after protocol accounts (0 = no auto-unroute) */
     autoUnrouteCount?: number;
     remainingAccounts?: AccountMeta[];
 }
@@ -134,6 +152,8 @@ export declare function createDepositToStrategyIx(args: DepositToStrategyArgs, p
 export interface WithdrawFromStrategyArgs {
     manager: PublicKey;
     managerRole: PublicKey;
+    /** GlobalConfig PDA — checked for CFG_FLAG_GLOBAL_PAUSED */
+    config: PublicKey;
     stv: PublicKey;
     vaultAta: PublicKey;
     baseMint: PublicKey;
@@ -153,9 +173,7 @@ export interface CloseStvArgs {
     stv: PublicKey;
     evMint: PublicKey;
     vaultAta: PublicKey;
-    baseMint: PublicKey;
     tokenProgram: PublicKey;
-    remainingAccounts?: AccountMeta[];
 }
 export declare function createCloseStvIx(args: CloseStvArgs, programId?: PublicKey): TransactionInstruction;
 export interface AddManagerArgs {
@@ -176,6 +194,34 @@ export interface RemoveManagerArgs {
     managerRole: PublicKey;
 }
 export declare function createRemoveManagerIx(args: RemoveManagerArgs, programId?: PublicKey): TransactionInstruction;
+export interface MigrateLendArgs {
+    admin: PublicKey;
+    payer: PublicKey;
+    config: PublicKey;
+    stv: PublicKey;
+    vaultAta: PublicKey;
+    baseMint: PublicKey;
+    tokenProgram: PublicKey;
+    systemProgram?: PublicKey;
+    /** Current lend program — must match stv.lend_program on-chain. */
+    oldLendProgram: PublicKey;
+    /** New lend program (PublicKey.default to deactivate lend entirely). */
+    newLendProgram: PublicKey;
+    /** Protocol AUM accounts for old lend update_aum. */
+    protocolAumCount: number;
+    /** Auto-unroute accounts for old lend withdraw. */
+    autoUnrouteCount: number;
+    /**
+     * remaining_accounts layout:
+     *   Old section (4 + protocolAumCount + autoUnrouteCount):
+     *     [oldLendProgram, oldStrategyState, oldStvPosition, oldBaseAta,
+     *      ...protocolAumAccounts, ...autoUnrouteAccounts]
+     *   New section (if newLendProgram != default, 4 accounts):
+     *     [newLendProgram, newStrategyState, newPositionPda, newBaseAta]
+     */
+    remainingAccounts?: AccountMeta[];
+}
+export declare function createMigrateLendIx(args: MigrateLendArgs, programId?: PublicKey): TransactionInstruction;
 export declare function buildLendRemainingAccounts(lend: {
     lendProgram: PublicKey;
     lendStrategyState: PublicKey;
@@ -186,4 +232,3 @@ export declare function buildStrategyRemainingAccounts(strategies: {
     strategyState: PublicKey;
     stvPosition: PublicKey;
 }[]): AccountMeta[];
-//# sourceMappingURL=instructions.d.ts.map

package/dist/p-stv-core/instructions.js

@@ -12,6 +12,7 @@ exports.createWithdrawFromStrategyIx = createWithdrawFromStrategyIx;
 exports.createCloseStvIx = createCloseStvIx;
 exports.createAddManagerIx = createAddManagerIx;
 exports.createRemoveManagerIx = createRemoveManagerIx;
+exports.createMigrateLendIx = createMigrateLendIx;
 exports.buildLendRemainingAccounts = buildLendRemainingAccounts;
 exports.buildStrategyRemainingAccounts = buildStrategyRemainingAccounts;
 const web3_js_1 = require("@solana/web3.js");
@@ -71,7 +72,7 @@ function createInitOrUpdateStvIx(args, programId = constants_1.PROGRAM_ID) {
     });
 }
 function createDepositIx(args, programId = constants_1.PROGRAM_ID) {
-    const { user, stv, vaultAta, userBaseAta, userEvAta, evMint, feeReceiverEvAta, baseMint, tokenProgram, amount, minShares, protocolAumCount = 0, autoRouteCount = 0, remainingAccounts = [], } = args;
+    const { user, config, stv, vaultAta, userBaseAta, userEvAta, evMint, feeReceiverEvAta, baseMint, tokenProgram, amount, minShares, protocolAumCount = 0, autoRouteCount = 0, remainingAccounts = [], } = args;
     const data = [constants_1.IX_DEPOSIT];
     (0, buffer_1.writeU64)(data, amount);
     (0, buffer_1.writeU64)(data, minShares);
@@ -80,6 +81,7 @@ function createDepositIx(args, programId = constants_1.PROGRAM_ID) {
     return new web3_js_1.TransactionInstruction({
         keys: [
             { pubkey: user, isSigner: true, isWritable: true },
+            { pubkey: config, isSigner: false, isWritable: false },
             { pubkey: stv, isSigner: false, isWritable: true },
             { pubkey: vaultAta, isSigner: false, isWritable: true },
             { pubkey: userBaseAta, isSigner: false, isWritable: true },
@@ -95,13 +97,14 @@ function createDepositIx(args, programId = constants_1.PROGRAM_ID) {
     });
 }
 function createRequestWithdrawIx(args, programId = constants_1.PROGRAM_ID) {
-    const { user, stv, withdrawRequest, userEvAta, escrowEvAta, evMint, tokenProgram, systemProgram = web3_js_1.SystemProgram.programId, shares, wrBump, } = args;
+    const { user, config, stv, withdrawRequest, userEvAta, escrowEvAta, evMint, tokenProgram, systemProgram = web3_js_1.SystemProgram.programId, shares, wrBump, } = args;
     const data = [constants_1.IX_REQUEST_WITHDRAW];
     (0, buffer_1.writeU64)(data, shares);
     data.push(wrBump & 0xff);
     return new web3_js_1.TransactionInstruction({
         keys: [
             { pubkey: user, isSigner: true, isWritable: true },
+            { pubkey: config, isSigner: false, isWritable: false },
             { pubkey: stv, isSigner: false, isWritable: true },
             { pubkey: withdrawRequest, isSigner: false, isWritable: true },
             { pubkey: userEvAta, isSigner: false, isWritable: true },
@@ -115,13 +118,15 @@ function createRequestWithdrawIx(args, programId = constants_1.PROGRAM_ID) {
     });
 }
 function createClaimWithdrawIx(args, programId = constants_1.PROGRAM_ID) {
-    const { user, stv, withdrawRequest, vaultAta, userBaseAta, baseMint, tokenProgram, remainingAccounts = [], autoUnrouteCount = 0, } = args;
-    const data = autoUnrouteCount > 0
-        ? Buffer.from([constants_1.IX_CLAIM_WITHDRAW, autoUnrouteCount & 0xff])
-        : Buffer.from([constants_1.IX_CLAIM_WITHDRAW]);
+    const { user, config, stv, withdrawRequest, vaultAta, userBaseAta, baseMint, tokenProgram, remainingAccounts = [], autoUnrouteCount = 0, } = args;
+    // Always serialize the auto_unroute_count byte (write 0 when there's no
+    // auto-unroute). The on-chain handler always reads this byte from
+    // instruction data.
+    const data = Buffer.from([constants_1.IX_CLAIM_WITHDRAW, autoUnrouteCount & 0xff]);
     return new web3_js_1.TransactionInstruction({
         keys: [
             { pubkey: user, isSigner: true, isWritable: true },
+            { pubkey: config, isSigner: false, isWritable: false },
             { pubkey: stv, isSigner: false, isWritable: true },
             { pubkey: withdrawRequest, isSigner: false, isWritable: true },
             { pubkey: vaultAta, isSigner: false, isWritable: true },
@@ -135,7 +140,7 @@ function createClaimWithdrawIx(args, programId = constants_1.PROGRAM_ID) {
     });
 }
 function createOverrideClaimWithdrawIx(args, programId = constants_1.PROGRAM_ID) {
-    const { manager, managerRole, user, stv, withdrawRequest, vaultAta, userBaseAta, baseMint, tokenProgram, remainingAccounts = [], autoUnrouteCount = 0, } = args;
+    const { manager, managerRole, config, user, stv, withdrawRequest, vaultAta, userBaseAta, baseMint, tokenProgram, remainingAccounts = [], autoUnrouteCount = 0, } = args;
     const data = autoUnrouteCount > 0
         ? Buffer.from([constants_1.IX_OVERRIDE_CLAIM_WITHDRAW, autoUnrouteCount & 0xff])
         : Buffer.from([constants_1.IX_OVERRIDE_CLAIM_WITHDRAW]);
@@ -143,6 +148,7 @@ function createOverrideClaimWithdrawIx(args, programId = constants_1.PROGRAM_ID)
         keys: [
             { pubkey: manager, isSigner: true, isWritable: false },
             { pubkey: managerRole, isSigner: false, isWritable: false },
+            { pubkey: config, isSigner: false, isWritable: false },
             { pubkey: user, isSigner: false, isWritable: true },
             { pubkey: stv, isSigner: false, isWritable: true },
             { pubkey: withdrawRequest, isSigner: false, isWritable: true },
@@ -157,10 +163,11 @@ function createOverrideClaimWithdrawIx(args, programId = constants_1.PROGRAM_ID)
     });
 }
 function createProcessEpochIx(args, programId = constants_1.PROGRAM_ID) {
-    const { payer, stv, evMint, feeReceiverEvAta, escrowEvAta, vaultAta, tokenProgram, advanceEpoch, protocolAumCount = 0, remainingAccounts = [], } = args;
+    const { payer, config, stv, evMint, feeReceiverEvAta, escrowEvAta, vaultAta, tokenProgram, advanceEpoch, protocolAumCount = 0, remainingAccounts = [], } = args;
     return new web3_js_1.TransactionInstruction({
         keys: [
             { pubkey: payer, isSigner: true, isWritable: true },
+            { pubkey: config, isSigner: false, isWritable: false },
             { pubkey: stv, isSigner: false, isWritable: true },
             { pubkey: evMint, isSigner: false, isWritable: true },
             { pubkey: feeReceiverEvAta, isSigner: false, isWritable: true },
@@ -174,10 +181,13 @@ function createProcessEpochIx(args, programId = constants_1.PROGRAM_ID) {
     });
 }
 function createDepositToStrategyIx(args, programId = constants_1.PROGRAM_ID) {
-    const { manager, managerRole, stv, vaultAta, baseMint, strategyProgram, strategyState, stvPosition, strategyBaseAta, tokenProgram, amount, minShares, autoUnrouteCount = 0, remainingAccounts = [], } = args;
+    const { manager, managerRole, config, stv, vaultAta, baseMint, strategyProgram, strategyState, stvPosition, strategyBaseAta, tokenProgram, amount, minShares, protocolAumCount, autoUnrouteCount = 0, remainingAccounts = [], } = args;
     const data = [constants_1.IX_DEPOSIT_TO_STRATEGY];
     (0, buffer_1.writeU64)(data, amount);
     (0, buffer_1.writeU64)(data, minShares);
+    // Always emit protocol_aum_count at offset 16 (even if 0); auto_unroute_count
+    // remains optional and is appended only when > 0.
+    data.push(protocolAumCount & 0xff);
     if (autoUnrouteCount > 0) {
         data.push(autoUnrouteCount & 0xff);
     }
@@ -185,6 +195,7 @@ function createDepositToStrategyIx(args, programId = constants_1.PROGRAM_ID) {
         keys: [
             { pubkey: manager, isSigner: true, isWritable: true },
             { pubkey: managerRole, isSigner: false, isWritable: false },
+            { pubkey: config, isSigner: false, isWritable: false },
             { pubkey: stv, isSigner: false, isWritable: true },
             { pubkey: vaultAta, isSigner: false, isWritable: true },
             { pubkey: baseMint, isSigner: false, isWritable: false },
@@ -200,13 +211,14 @@ function createDepositToStrategyIx(args, programId = constants_1.PROGRAM_ID) {
     });
 }
 function createWithdrawFromStrategyIx(args, programId = constants_1.PROGRAM_ID) {
-    const { manager, managerRole, stv, vaultAta, baseMint, strategyProgram, strategyState, stvPosition, strategyBaseAta, tokenProgram, shares, remainingAccounts = [], } = args;
+    const { manager, managerRole, config, stv, vaultAta, baseMint, strategyProgram, strategyState, stvPosition, strategyBaseAta, tokenProgram, shares, remainingAccounts = [], } = args;
     const data = [constants_1.IX_WITHDRAW_FROM_STRATEGY];
     (0, buffer_1.writeU64)(data, shares);
     return new web3_js_1.TransactionInstruction({
         keys: [
             { pubkey: manager, isSigner: true, isWritable: true },
             { pubkey: managerRole, isSigner: false, isWritable: false },
+            { pubkey: config, isSigner: false, isWritable: false },
             { pubkey: stv, isSigner: false, isWritable: true },
             { pubkey: vaultAta, isSigner: false, isWritable: true },
             { pubkey: baseMint, isSigner: false, isWritable: false },
@@ -222,7 +234,7 @@ function createWithdrawFromStrategyIx(args, programId = constants_1.PROGRAM_ID)
     });
 }
 function createCloseStvIx(args, programId = constants_1.PROGRAM_ID) {
-    const { admin, payer, config, stv, evMint, vaultAta, baseMint, tokenProgram, remainingAccounts = [] } = args;
+    const { admin, payer, config, stv, evMint, vaultAta, tokenProgram } = args;
     return new web3_js_1.TransactionInstruction({
         keys: [
             { pubkey: admin, isSigner: true, isWritable: false },
@@ -231,9 +243,7 @@ function createCloseStvIx(args, programId = constants_1.PROGRAM_ID) {
             { pubkey: stv, isSigner: false, isWritable: true },
             { pubkey: evMint, isSigner: false, isWritable: true },
             { pubkey: vaultAta, isSigner: false, isWritable: true },
-            { pubkey: baseMint, isSigner: false, isWritable: false },
             { pubkey: tokenProgram, isSigner: false, isWritable: false },
-            ...remainingAccounts,
         ],
         programId,
         data: Buffer.from([constants_1.IX_CLOSE_STV]),
@@ -269,6 +279,29 @@ function createRemoveManagerIx(args, programId = constants_1.PROGRAM_ID) {
         data: Buffer.from([constants_1.IX_REMOVE_MANAGER]),
     });
 }
+function createMigrateLendIx(args, programId = constants_1.PROGRAM_ID) {
+    const { admin, payer, config, stv, vaultAta, baseMint, tokenProgram, systemProgram = web3_js_1.SystemProgram.programId, oldLendProgram, newLendProgram, protocolAumCount, autoUnrouteCount, remainingAccounts = [], } = args;
+    const data = [constants_1.IX_MIGRATE_LEND];
+    data.push(...oldLendProgram.toBuffer());
+    data.push(...newLendProgram.toBuffer());
+    data.push(protocolAumCount & 0xff);
+    data.push(autoUnrouteCount & 0xff);
+    return new web3_js_1.TransactionInstruction({
+        keys: [
+            { pubkey: admin, isSigner: true, isWritable: false },
+            { pubkey: payer, isSigner: true, isWritable: true },
+            { pubkey: config, isSigner: false, isWritable: false },
+            { pubkey: stv, isSigner: false, isWritable: true },
+            { pubkey: vaultAta, isSigner: false, isWritable: true },
+            { pubkey: baseMint, isSigner: false, isWritable: false },
+            { pubkey: tokenProgram, isSigner: false, isWritable: false },
+            { pubkey: systemProgram, isSigner: false, isWritable: false },
+            ...remainingAccounts,
+        ],
+        programId,
+        data: Buffer.from(data),
+    });
+}
 // ---------------------------------------------------------------------------
 // Remaining Accounts Helpers
 // ---------------------------------------------------------------------------
@@ -287,4 +320,3 @@ function buildStrategyRemainingAccounts(strategies) {
     }
     return accounts;
 }
-//# sourceMappingURL=instructions.js.map

package/dist/p-stv-core/pda.d.ts

@@ -4,5 +4,12 @@ export declare function findConfigPda(programId?: PublicKey): [PublicKey, number
 export declare function findStvPda(vaultId: number | BN, programId?: PublicKey): [PublicKey, number];
 export declare function findEvMintPda(vaultId: number | BN, programId?: PublicKey): [PublicKey, number];
 export declare function findWithdrawRequestPda(stv: PublicKey, user: PublicKey, epochId: number, programId?: PublicKey): [PublicKey, number];
-export declare function findManagerRolePda(stv: PublicKey, manager: PublicKey, programId?: PublicKey): [PublicKey, number];
-//# sourceMappingURL=pda.d.ts.map
+/**
+ * Derive the per-STV `ManagerRole` PDA for p-STV Core.
+ * Seeds: `["manager", stv, manager]`.
+ *
+ * Note the per-program prefix on the name: each Elemental program has its
+ * own `ManagerRole` PDA scoped to a different anchor account
+ * (`elemental-lend` → strategy_state, `jlpd-strategy` → config).
+ */
+export declare function findStvManagerRolePda(stv: PublicKey, manager: PublicKey, programId?: PublicKey): [PublicKey, number];

package/dist/p-stv-core/pda.js

@@ -7,7 +7,7 @@ exports.findConfigPda = findConfigPda;
 exports.findStvPda = findStvPda;
 exports.findEvMintPda = findEvMintPda;
 exports.findWithdrawRequestPda = findWithdrawRequestPda;
-exports.findManagerRolePda = findManagerRolePda;
+exports.findStvManagerRolePda = findStvManagerRolePda;
 const web3_js_1 = require("@solana/web3.js");
 const bn_js_1 = __importDefault(require("bn.js"));
 const constants_1 = require("./constants");
@@ -27,7 +27,14 @@ function findWithdrawRequestPda(stv, user, epochId, programId = constants_1.PROG
     epochBuf.writeUInt32LE(epochId, 0);
     return web3_js_1.PublicKey.findProgramAddressSync([constants_1.WITHDRAW_REQUEST_SEED, stv.toBuffer(), user.toBuffer(), epochBuf], programId);
 }
-function findManagerRolePda(stv, manager, programId = constants_1.PROGRAM_ID) {
+/**
+ * Derive the per-STV `ManagerRole` PDA for p-STV Core.
+ * Seeds: `["manager", stv, manager]`.
+ *
+ * Note the per-program prefix on the name: each Elemental program has its
+ * own `ManagerRole` PDA scoped to a different anchor account
+ * (`elemental-lend` → strategy_state, `jlpd-strategy` → config).
+ */
+function findStvManagerRolePda(stv, manager, programId = constants_1.PROGRAM_ID) {
     return web3_js_1.PublicKey.findProgramAddressSync([constants_1.MANAGER_SEED, stv.toBuffer(), manager.toBuffer()], programId);
 }
-//# sourceMappingURL=pda.js.map

package/dist/p-stv-core/prices.d.ts

@@ -18,4 +18,3 @@ export interface TokenPrice {
  * @returns Record<mint, usdPrice>
  */
 export declare function fetchUsdPrices(mints: string[]): Promise<Record<string, number>>;
-//# sourceMappingURL=prices.d.ts.map

package/dist/p-stv-core/prices.js

@@ -75,4 +75,3 @@ async function fetchUsdPrices(mints) {
     }
     return prices;
 }
-//# sourceMappingURL=prices.js.map

package/dist/p-stv-core/remaining-accounts.d.ts

@@ -6,13 +6,9 @@
  * lend + protocol AUM + strategy pair + auto-route/unroute account building
  * logic out of the frontend and into the SDK.
  */
-import { AccountMeta, Connection, PublicKey, TransactionInstruction } from "@solana/web3.js";
-/**
- * Minimal connection interface accepted by the context builders.
- * Using a structural type avoids nominal type mismatches when the
- * consumer has a different version of @solana/web3.js installed.
- */
-export type SolanaConnection = Pick<Connection, "getAccountInfo" | "getMultipleAccountsInfo" | "getTokenAccountsByOwner" | "getSlot" | "getEpochInfo" | "getBlockTime">;
+import { AccountMeta, PublicKey, TransactionInstruction } from "@solana/web3.js";
+import type { SolanaConnection } from "../common/connection";
+export type { SolanaConnection };
 /** Minimal vault shape required by the context builders. */
 export interface VaultInfo {
     /** STV account address */
@@ -43,6 +39,8 @@ export interface ClaimWithdrawContext {
 }
 export interface DepositToStrategyContext {
     remainingAccounts: AccountMeta[];
+    /** Number of protocol AUM accounts (after the 4 fixed lend accounts). */
+    protocolAumCount: number;
     autoUnrouteCount: number;
     preInstructions: TransactionInstruction[];
 }
@@ -76,17 +74,19 @@ export declare function buildDepositContext(connection: SolanaConnection, vault:
  * - If lend is active, derives lend PDAs
  * - If USDC + Jupiter Lend, appends auto-unroute accounts
  */
-export declare function buildClaimWithdrawContext(connection: SolanaConnection, vault: VaultInfo): Promise<ClaimWithdrawContext>;
+export declare function buildClaimWithdrawContext(vault: VaultInfo): Promise<ClaimWithdrawContext>;
 /**
  * Build the complete remaining_accounts for a deposit_to_strategy instruction.
  *
- * Layout: [4 lend, K auto_unroute]
+ * Layout: [4 fixed lend, N protocol_aum, K auto_unroute]
  *
- * Same as claim_withdraw: if lend is active, derives lend PDAs.
- * If USDC + Jupiter Lend, appends auto-unroute accounts for unsweep.
+ * - Fixed lend accounts (if lend is active)
+ * - Protocol AUM accounts: required by the on-chain handler to refresh lend
+ *   valuation via update_lend_aum before the reserved_base liquidity lock check
+ * - Auto-unroute accounts: forwarded to the lend withdraw CPI for unsweep
  *
- * Note: no Kamino invest pre-instructions here — deposit_to_strategy unsweeps
- * from the active protocol (Jupiter Lend for USDC), not Kamino.
+ * The `connection` parameter is required to fetch LendStrategyState and
+ * resolve protocol AUM accounts.
  */
 export declare function buildDepositToStrategyContext(connection: SolanaConnection, vault: VaultInfo): Promise<DepositToStrategyContext>;
 /**
@@ -96,4 +96,3 @@ export declare function buildDepositToStrategyContext(connection: SolanaConnecti
  *                'advance': empty remaining_accounts.
  */
 export declare function buildProcessEpochContext(connection: SolanaConnection, vault: VaultInfo, phase: "lockPps" | "advance"): Promise<ProcessEpochContext>;
-//# sourceMappingURL=remaining-accounts.d.ts.map

package/dist/p-stv-core/remaining-accounts.js

@@ -17,30 +17,24 @@ const pda_1 = require("../elemental-lend/pda");
 const accounts_1 = require("../elemental-lend/accounts");
 const jupiter_lend_1 = require("../elemental-lend/jupiter-lend");
 const kamino_vault_1 = require("../elemental-lend/kamino-vault");
-const spl_token_1 = require("@solana/spl-token");
+const ata_1 = require("../common/ata");
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
 const DEFAULT_PUBKEY = web3_js_1.PublicKey.default;
 const TOKEN_PROGRAM = new web3_js_1.PublicKey("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
-const USDC_MINT = new web3_js_1.PublicKey("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
 const STRATEGY_STATE_SEED = Buffer.from("strategy_state");
 const POSITION_SEED = Buffer.from("position");
 function isDefault(pubkey) {
     return pubkey.equals(DEFAULT_PUBKEY);
 }
-/** Derive the ATA address (same logic as @solana/spl-token getAssociatedTokenAddressSync) */
-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 the 4 fixed lend accounts: [lendProgram, lendStrategyState, lendPosition, lendBaseAta]
  */
 function buildFixedLendAccounts(lendProgram, baseMint, stvAddress) {
     const [lendStrategyState] = (0, pda_1.findStrategyStatePda)(baseMint, lendProgram);
     const [lendPosition] = (0, pda_1.findStvPositionPda)(stvAddress, lendProgram);
-    const lendBaseAta = findAta(baseMint, lendStrategyState, TOKEN_PROGRAM);
+    const lendBaseAta = (0, ata_1.findAta)(baseMint, lendStrategyState, TOKEN_PROGRAM);
     return {
         lendStrategyState,
         accounts: [
@@ -95,32 +89,30 @@ async function buildDepositContext(connection, vault, payer) {
     if (!isDefault(vault.lendProgram)) {
         const { accounts: lendAccounts, lendStrategyState } = buildFixedLendAccounts(vault.lendProgram, vault.baseMint, vault.address);
         remainingAccounts.push(...lendAccounts);
-        // Protocol AUM accounts
-        const conn = connection;
-        try {
-            const lendState = await (0, accounts_1.fetchLendStrategyState)(conn, vault.baseMint, vault.lendProgram);
-            const protocolAccounts = await (0, accounts_1.buildProtocolAccountsForAum)(conn, lendState, lendStrategyState, TOKEN_PROGRAM);
-            protocolAumCount = protocolAccounts.length;
-            remainingAccounts.push(...protocolAccounts);
-        }
-        catch {
-            // If strategy state not found, skip protocol accounts
-        }
-        // Check kVault staleness — prepend invest ix if stale
-        try {
-            const conn = connection;
-            const lendState = await (0, accounts_1.fetchLendStrategyState)(conn, vault.baseMint, vault.lendProgram).catch(() => null);
-            if (lendState) {
+        // Single fetch of LendStrategyState — used for both protocol AUM
+        // accounts and kVault staleness check.
+        const lendState = await (0, accounts_1.fetchLendStrategyState)(connection, vault.baseMint, vault.lendProgram).catch(() => null);
+        if (lendState) {
+            // Protocol AUM accounts
+            try {
+                const protocolAccounts = await (0, accounts_1.buildProtocolAccountsForAum)(connection, lendState, lendStrategyState, TOKEN_PROGRAM);
+                protocolAumCount = protocolAccounts.length;
+                remainingAccounts.push(...protocolAccounts);
+            }
+            catch {
+                // If protocol resolution fails, skip protocol accounts
+            }
+            // Check kVault staleness — prepend invest ix if stale
+            try {
                 const protocolKeys = lendState.protocols
                     .filter((p) => !isDefault(p));
                 // Need a payer for the invest ix — will be set by the caller
-                // Use PublicKey.default as placeholder; the caller replaces it
-                const investIxs = payer ? await (0, kamino_vault_1.buildKaminoInvestIxsIfStale)(conn, payer, vault.baseMint, protocolKeys) : [];
+                const investIxs = payer ? await (0, kamino_vault_1.buildKaminoInvestIxsIfStale)(connection, payer, vault.baseMint, protocolKeys) : [];
                 preInstructions.push(...investIxs);
             }
-        }
-        catch {
-            // Skip if staleness check fails
+            catch {
+                // Skip if staleness check fails
+            }
         }
     }
     // 2. Strategy pair accounts (2 per strategy: state + position)
@@ -132,8 +124,8 @@ async function buildDepositContext(connection, vault, payer) {
     if (!isDefault(vault.lendProgram) && jupPool) {
         try {
             const [lendSS] = (0, pda_1.findStrategyStatePda)(vault.baseMint, vault.lendProgram);
-            const strategyBaseAta = findAta(vault.baseMint, lendSS, TOKEN_PROGRAM);
-            const strategyFtokenAta = findAta(jupPool.fTokenMint, lendSS, TOKEN_PROGRAM);
+            const strategyBaseAta = (0, ata_1.findAta)(vault.baseMint, lendSS, TOKEN_PROGRAM);
+            const strategyFtokenAta = (0, ata_1.findAta)(jupPool.fTokenMint, lendSS, TOKEN_PROGRAM);
             const autoRouteAccounts = (0, jupiter_lend_1.buildJupLendAutoRouteAccounts)(jupPool, lendSS, strategyBaseAta, strategyFtokenAta);
             autoRouteCount = autoRouteAccounts.length;
             for (const acc of autoRouteAccounts) {
@@ -168,7 +160,7 @@ async function buildDepositContext(connection, vault, payer) {
  * - If lend is active, derives lend PDAs
  * - If USDC + Jupiter Lend, appends auto-unroute accounts
  */
-async function buildClaimWithdrawContext(connection, vault) {
+async function buildClaimWithdrawContext(vault) {
     const remainingAccounts = [];
     const preInstructions = [];
     let autoUnrouteCount = 0;
@@ -179,8 +171,8 @@ async function buildClaimWithdrawContext(connection, vault) {
         const jupPoolForUnroute = jupiter_lend_1.JUP_LEND_POOLS[vault.baseMint.toBase58()];
         if (jupPoolForUnroute) {
             try {
-                const lendBaseAta = findAta(vault.baseMint, lendStrategyState, TOKEN_PROGRAM);
-                const strategyFtokenAta = findAta(jupPoolForUnroute.fTokenMint, lendStrategyState, TOKEN_PROGRAM);
+                const lendBaseAta = (0, ata_1.findAta)(vault.baseMint, lendStrategyState, TOKEN_PROGRAM);
+                const strategyFtokenAta = (0, ata_1.findAta)(jupPoolForUnroute.fTokenMint, lendStrategyState, TOKEN_PROGRAM);
                 const autoUnrouteAccounts = (0, jupiter_lend_1.buildJupLendAutoUnrouteAccounts)(jupPoolForUnroute, lendStrategyState, strategyFtokenAta, lendBaseAta);
                 autoUnrouteCount = autoUnrouteAccounts.length;
                 remainingAccounts.push(...autoUnrouteAccounts.map(a => ({ ...a, isSigner: false })));
@@ -195,26 +187,43 @@ async function buildClaimWithdrawContext(connection, vault) {
 /**
  * Build the complete remaining_accounts for a deposit_to_strategy instruction.
  *
- * Layout: [4 lend, K auto_unroute]
+ * Layout: [4 fixed lend, N protocol_aum, K auto_unroute]
  *
- * Same as claim_withdraw: if lend is active, derives lend PDAs.
- * If USDC + Jupiter Lend, appends auto-unroute accounts for unsweep.
+ * - Fixed lend accounts (if lend is active)
+ * - Protocol AUM accounts: required by the on-chain handler to refresh lend
+ *   valuation via update_lend_aum before the reserved_base liquidity lock check
+ * - Auto-unroute accounts: forwarded to the lend withdraw CPI for unsweep
  *
- * Note: no Kamino invest pre-instructions here — deposit_to_strategy unsweeps
- * from the active protocol (Jupiter Lend for USDC), not Kamino.
+ * The `connection` parameter is required to fetch LendStrategyState and
+ * resolve protocol AUM accounts.
  */
 async function buildDepositToStrategyContext(connection, vault) {
     const remainingAccounts = [];
+    let protocolAumCount = 0;
     let autoUnrouteCount = 0;
     if (!isDefault(vault.lendProgram)) {
         const { accounts: lendAccounts, lendStrategyState } = buildFixedLendAccounts(vault.lendProgram, vault.baseMint, vault.address);
         remainingAccounts.push(...lendAccounts);
+        // Fetch LendStrategyState once — used for protocol AUM resolution.
+        const lendState = await (0, accounts_1.fetchLendStrategyState)(connection, vault.baseMint, vault.lendProgram).catch(() => null);
+        if (lendState) {
+            // Protocol AUM accounts (kVault: 2/protocol, Jupiter Lend: 3/protocol)
+            try {
+                const protocolAccounts = await (0, accounts_1.buildProtocolAccountsForAum)(connection, lendState, lendStrategyState, TOKEN_PROGRAM);
+                protocolAumCount = protocolAccounts.length;
+                remainingAccounts.push(...protocolAccounts);
+            }
+            catch {
+                // Skip protocol accounts if resolution fails — on-chain update_lend_aum
+                // will then reject if protocols are active.
+            }
+        }
         // Auto-unroute from Jupiter Lend (for any asset with a configured pool)
         const jupPoolForUnroute = jupiter_lend_1.JUP_LEND_POOLS[vault.baseMint.toBase58()];
         if (jupPoolForUnroute) {
             try {
-                const lendBaseAta = findAta(vault.baseMint, lendStrategyState, TOKEN_PROGRAM);
-                const strategyFtokenAta = findAta(jupPoolForUnroute.fTokenMint, lendStrategyState, TOKEN_PROGRAM);
+                const lendBaseAta = (0, ata_1.findAta)(vault.baseMint, lendStrategyState, TOKEN_PROGRAM);
+                const strategyFtokenAta = (0, ata_1.findAta)(jupPoolForUnroute.fTokenMint, lendStrategyState, TOKEN_PROGRAM);
                 const autoUnrouteAccounts = (0, jupiter_lend_1.buildJupLendAutoUnrouteAccounts)(jupPoolForUnroute, lendStrategyState, strategyFtokenAta, lendBaseAta);
                 autoUnrouteCount = autoUnrouteAccounts.length;
                 remainingAccounts.push(...autoUnrouteAccounts.map(a => ({ ...a, isSigner: false })));
@@ -224,7 +233,7 @@ async function buildDepositToStrategyContext(connection, vault) {
             }
         }
     }
-    return { remainingAccounts, autoUnrouteCount, preInstructions: [] };
+    return { remainingAccounts, protocolAumCount, autoUnrouteCount, preInstructions: [] };
 }
 /**
  * Build the complete remaining_accounts for a process_epoch instruction.
@@ -243,10 +252,9 @@ async function buildProcessEpochContext(connection, vault, phase) {
     if (!isDefault(vault.lendProgram)) {
         const { accounts: lendAccounts, lendStrategyState } = buildFixedLendAccounts(vault.lendProgram, vault.baseMint, vault.address);
         remainingAccounts.push(...lendAccounts);
-        const conn = connection;
         try {
-            const lendState = await (0, accounts_1.fetchLendStrategyState)(conn, vault.baseMint, vault.lendProgram);
-            const protocolAccounts = await (0, accounts_1.buildProtocolAccountsForAum)(conn, lendState, lendStrategyState, TOKEN_PROGRAM);
+            const lendState = await (0, accounts_1.fetchLendStrategyState)(connection, vault.baseMint, vault.lendProgram);
+            const protocolAccounts = await (0, accounts_1.buildProtocolAccountsForAum)(connection, lendState, lendStrategyState, TOKEN_PROGRAM);
             protocolAumCount = protocolAccounts.length;
             remainingAccounts.push(...protocolAccounts);
         }
@@ -259,4 +267,3 @@ async function buildProcessEpochContext(connection, vault, phase) {
     remainingAccounts.push(...strategyAccounts);
     return { remainingAccounts, protocolAumCount, preInstructions };
 }
-//# sourceMappingURL=remaining-accounts.js.map