@elmntl/jlpd-sdk 0.2.0 → 0.13.5

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

@@ -0,0 +1,670 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createInitOrUpdateConfigIx = createInitOrUpdateConfigIx;
+exports.createInitOrUpdateStvIx = createInitOrUpdateStvIx;
+exports.createDepositIx = createDepositIx;
+exports.createRequestWithdrawIx = createRequestWithdrawIx;
+exports.createClaimWithdrawIx = createClaimWithdrawIx;
+exports.createOverrideClaimWithdrawIx = createOverrideClaimWithdrawIx;
+exports.createProcessEpochIx = createProcessEpochIx;
+exports.createProcessDelayedDepositIx = createProcessDelayedDepositIx;
+exports.createDepositToStrategyIx = createDepositToStrategyIx;
+exports.createWithdrawFromStrategyIx = createWithdrawFromStrategyIx;
+exports.createCloseStvIx = createCloseStvIx;
+exports.createAddManagerIx = createAddManagerIx;
+exports.createRemoveManagerIx = createRemoveManagerIx;
+exports.createMigrateLendIx = createMigrateLendIx;
+exports.createMigrateRequestIx = createMigrateRequestIx;
+exports.createMigrateExecuteIx = createMigrateExecuteIx;
+exports.createMigrateCancelIx = createMigrateCancelIx;
+exports.buildLendRemainingAccounts = buildLendRemainingAccounts;
+exports.buildMigrateRemainingAccounts = buildMigrateRemainingAccounts;
+exports.buildStrategyRemainingAccounts = buildStrategyRemainingAccounts;
+exports.createInstantWithdrawIx = createInstantWithdrawIx;
+exports.createSeedStvIx = createSeedStvIx;
+exports.createAcceptVaultAdminIx = createAcceptVaultAdminIx;
+exports.createTripCircuitBreakerIx = createTripCircuitBreakerIx;
+const web3_js_1 = require("@solana/web3.js");
+const spl_token_1 = require("@solana/spl-token");
+const buffer_1 = require("../common/buffer");
+const constants_1 = require("./constants");
+function createInitOrUpdateConfigIx(args, programId = constants_1.PROGRAM_ID) {
+    const { admin, payer, config, systemProgram = web3_js_1.SystemProgram.programId, bump, newAdmin, newFlags } = args;
+    const data = [constants_1.IX_INIT_OR_UPDATE_CONFIG, bump & 0xff];
+    (0, buffer_1.writeOptionalPubkey)(data, newAdmin);
+    (0, buffer_1.writeOptionalU16)(data, newFlags);
+    return new web3_js_1.TransactionInstruction({
+        keys: [
+            { pubkey: admin, isSigner: true, isWritable: false },
+            { pubkey: payer, isSigner: true, isWritable: true },
+            { pubkey: config, isSigner: false, isWritable: true },
+            { pubkey: systemProgram, isSigner: false, isWritable: false },
+        ],
+        programId,
+        data: Buffer.from(data),
+    });
+}
+function createInitOrUpdateStvIx(args, programId = constants_1.PROGRAM_ID) {
+    const { admin, payer, config, stv, evMint, baseMint, vaultAta, feeReceiverEvAta, tokenProgram, ataProgram = spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID, systemProgram = web3_js_1.SystemProgram.programId, vaultId, stvBump, evMintBump, feeReceiver, strategy, epochSec, mgmtFeeBps, perfFeeBps, vaultCapacity, minDeposit, flags, addStrategy, removeStrategy, lendProgram, dailyWithdrawLimitBps, depositFeeBps, withdrawalFeeBps, withdrawalMode, vaultAdmin, pendingAdmin, strategyStalenessThreshold, warmAdmin, lendInitAccounts, remainingAccounts = [], } = args;
+    // Reject simultaneous vaultAdmin + pendingAdmin: they share one wire position
+    // but are branch-interpreted (create vs update). Providing both is always wrong.
+    if (vaultAdmin !== undefined && pendingAdmin !== undefined) {
+        throw new Error("createInitOrUpdateStvIx: supply exactly one of vaultAdmin (create) or pendingAdmin (update), not both");
+    }
+    const data = [constants_1.IX_INIT_OR_UPDATE_STV];
+    (0, buffer_1.writeU64)(data, vaultId);
+    data.push(stvBump & 0xff);
+    data.push(evMintBump & 0xff);
+    (0, buffer_1.writeOptionalPubkey)(data, feeReceiver);
+    (0, buffer_1.writeOptionalPubkey)(data, strategy);
+    (0, buffer_1.writeOptionalU32)(data, epochSec);
+    (0, buffer_1.writeOptionalU16)(data, mgmtFeeBps);
+    (0, buffer_1.writeOptionalU16)(data, perfFeeBps);
+    (0, buffer_1.writeOptionalU64)(data, vaultCapacity);
+    (0, buffer_1.writeOptionalU64)(data, minDeposit);
+    (0, buffer_1.writeOptionalU16)(data, flags);
+    (0, buffer_1.writeOptionalPubkey)(data, addStrategy);
+    (0, buffer_1.writeOptionalPubkey)(data, removeStrategy);
+    (0, buffer_1.writeOptionalPubkey)(data, lendProgram);
+    (0, buffer_1.writeOptionalU16)(data, dailyWithdrawLimitBps);
+    (0, buffer_1.writeOptionalU16)(data, depositFeeBps);
+    (0, buffer_1.writeOptionalU16)(data, withdrawalFeeBps);
+    if (withdrawalMode != null && (withdrawalMode < 0 || withdrawalMode > 2)) {
+        throw new Error(`withdrawalMode must be 0 (instant), 1 (X) or 2 (X+1); got ${withdrawalMode}`);
+    }
+    (0, buffer_1.writeOptionalU8)(data, withdrawalMode);
+    // vault_admin_or_pending — the last optional-pubkey field.
+    // CREATE path: pass vaultAdmin (required nonzero). Handler rejects None/zero.
+    // UPDATE path: pass pendingAdmin (optional; None = no change, zero pubkey = cancel).
+    // Both share the same wire position; interpretation is per create/update branch.
+    // Wire: 0x00 = None, 0x01 + 32 bytes = Some(pubkey).
+    const vaultAdminOrPending = vaultAdmin ?? pendingAdmin;
+    (0, buffer_1.writeOptionalPubkey)(data, vaultAdminOrPending);
+    // NEW (cca48d8): strategy_staleness_threshold — appended after vault_admin_or_pending.
+    // parse_optional_u32 in init_or_update_stv.rs is called immediately after
+    // vault_admin_or_pending (line 105 of the instruction handler). Old clients
+    // that stop here produce EOF which the handler treats as None (no change).
+    (0, buffer_1.writeOptionalU32)(data, strategyStalenessThreshold);
+    // NEW (warm-admin-guardrails): warm_admin_arg — the LAST optional field,
+    // appended immediately after strategy_staleness_threshold (preserves every
+    // earlier optional's wire position; see the InitOrUpdateStvArgs.warmAdmin
+    // jsdoc above for the full create/update semantics). Old clients that stop
+    // before this position produce EOF, which parse_optional_pubkey treats
+    // identically to an explicit None.
+    (0, buffer_1.writeOptionalPubkey)(data, warmAdmin);
+    // The lend-init tail [lend_strategy_state(RO), lend_position_pda(W)] is consumed
+    // by the program ONLY when lend is being activated, i.e. when
+    // old_lend_program != new_lend && new_lend != 0 (lend_init_size = 2,
+    // init_or_update_stv.rs:723-729). Re-passing the already-set lend program
+    // (old == new) computes lend_init_size = 0 and consumes no tail. Because this
+    // builder has no on-chain state it cannot tell activation from a re-pass, so it
+    // does NOT hard-require the tail: pass lendInitAccounts when activating; omit it
+    // otherwise. A genuinely-missing activation tail is caught on-chain
+    // (IncompleteStrategyAccounts) — a revert, never a wrong-account tx.
+    // Prepend lend-init accounts when lend activation is requested.
+    // On-chain: cpi_lend_init_position reads remaining[0]=lend_strategy_state (RO)
+    // and remaining[1]=lend_position_pda (W) — see lend.rs:488,529 and
+    // init_or_update_stv.rs:554,739. Missing these causes IncompleteStrategyAccounts.
+    const lendInitMeta = lendInitAccounts
+        ? [
+            { pubkey: lendInitAccounts.lendStrategyState, isSigner: false, isWritable: false },
+            { pubkey: lendInitAccounts.lendPositionPda, isSigner: false, isWritable: true },
+        ]
+        : [];
+    return new web3_js_1.TransactionInstruction({
+        keys: [
+            { pubkey: admin, isSigner: true, isWritable: false },
+            { pubkey: payer, isSigner: true, isWritable: true },
+            { pubkey: config, isSigner: false, isWritable: true },
+            { pubkey: stv, isSigner: false, isWritable: true },
+            { pubkey: evMint, isSigner: false, isWritable: true },
+            { pubkey: baseMint, isSigner: false, isWritable: false },
+            { pubkey: vaultAta, isSigner: false, isWritable: true },
+            { pubkey: feeReceiverEvAta, isSigner: false, isWritable: false },
+            { pubkey: tokenProgram, isSigner: false, isWritable: false },
+            { pubkey: ataProgram, isSigner: false, isWritable: false },
+            { pubkey: systemProgram, isSigner: false, isWritable: false },
+            // lend-init accounts (when activating lend): [strategy_state(ro), position_pda(w)]
+            ...lendInitMeta,
+            ...remainingAccounts,
+        ],
+        programId,
+        data: Buffer.from(data),
+    });
+}
+function createDepositIx(args, programId = constants_1.PROGRAM_ID) {
+    const { user, config, stv, vaultAta, userBaseAta, userEvAta, evMint, feeReceiverEvAta, baseMint, tokenProgram, amount, minShares, protocolAumCount = 0, autoRouteCount = 0, delayedDepositRequest, delayedDepositBump, systemProgram = web3_js_1.SystemProgram.programId, remainingAccounts = [], } = args;
+    const data = [constants_1.IX_DEPOSIT];
+    (0, buffer_1.writeU64)(data, amount);
+    (0, buffer_1.writeU64)(data, minShares);
+    data.push(protocolAumCount & 0xff);
+    data.push(autoRouteCount & 0xff);
+    if (delayedDepositRequest) {
+        if (delayedDepositBump == null) {
+            throw new Error("delayedDepositBump is required when delayedDepositRequest is provided");
+        }
+        data.push(delayedDepositBump & 0xff);
+    }
+    const delayedAccounts = delayedDepositRequest
+        ? [
+            { pubkey: delayedDepositRequest, isSigner: false, isWritable: true },
+            { pubkey: systemProgram, isSigner: false, isWritable: false },
+        ]
+        : [];
+    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 },
+            { pubkey: userEvAta, isSigner: false, isWritable: true },
+            { pubkey: evMint, isSigner: false, isWritable: true },
+            { pubkey: feeReceiverEvAta, isSigner: false, isWritable: true },
+            { pubkey: baseMint, isSigner: false, isWritable: false },
+            { pubkey: tokenProgram, isSigner: false, isWritable: false },
+            ...delayedAccounts,
+            ...remainingAccounts,
+        ],
+        programId,
+        data: Buffer.from(data),
+    });
+}
+function createRequestWithdrawIx(args, programId = constants_1.PROGRAM_ID) {
+    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 },
+            { pubkey: escrowEvAta, isSigner: false, isWritable: true },
+            { pubkey: evMint, isSigner: false, isWritable: false },
+            { pubkey: tokenProgram, isSigner: false, isWritable: false },
+            { pubkey: systemProgram, isSigner: false, isWritable: false },
+        ],
+        programId,
+        data: Buffer.from(data),
+    });
+}
+function createClaimWithdrawIx(args, programId = constants_1.PROGRAM_ID) {
+    const { user, config, stv, withdrawRequest, vaultAta, userBaseAta, feeReceiverBaseAta, baseMint, tokenProgram, remainingAccounts = [], autoUnrouteCount = 0, protocolAumCount = 0, } = args;
+    // Data: auto_unroute_count(1) + protocol_aum_count(1). Both always serialized —
+    // the on-chain handler reads data[0] and data[1].
+    const data = Buffer.from([constants_1.IX_CLAIM_WITHDRAW, autoUnrouteCount & 0xff, protocolAumCount & 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 },
+            { pubkey: userBaseAta, isSigner: false, isWritable: true },
+            { pubkey: feeReceiverBaseAta, isSigner: false, isWritable: true },
+            { pubkey: baseMint, isSigner: false, isWritable: false },
+            { pubkey: tokenProgram, isSigner: false, isWritable: false },
+            ...remainingAccounts,
+        ],
+        programId,
+        data,
+    });
+}
+function createOverrideClaimWithdrawIx(args, programId = constants_1.PROGRAM_ID) {
+    const { authority, config, user, stv, withdrawRequest, vaultAta, userBaseAta, feeReceiverBaseAta, baseMint, tokenProgram, remainingAccounts = [], autoUnrouteCount = 0, protocolAumCount = 0, } = args;
+    // Data: auto_unroute_count(1) + protocol_aum_count(1) — protocol_aum_count is data[1],
+    // so always serialize both bytes (handler reads data[0]/data[1]). Data layout
+    // is unchanged by warm-admin-guardrails — only the account list changed.
+    const data = Buffer.from([constants_1.IX_OVERRIDE_CLAIM_WITHDRAW, autoUnrouteCount & 0xff, protocolAumCount & 0xff]);
+    return new web3_js_1.TransactionInstruction({
+        keys: [
+            { pubkey: authority, isSigner: true, 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 },
+            { pubkey: vaultAta, isSigner: false, isWritable: true },
+            { pubkey: userBaseAta, isSigner: false, isWritable: true },
+            { pubkey: feeReceiverBaseAta, isSigner: false, isWritable: true },
+            { pubkey: baseMint, isSigner: false, isWritable: false },
+            { pubkey: tokenProgram, isSigner: false, isWritable: false },
+            ...remainingAccounts,
+        ],
+        programId,
+        data,
+    });
+}
+function createProcessEpochIx(args, programId = constants_1.PROGRAM_ID) {
+    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 },
+            { pubkey: escrowEvAta, isSigner: false, isWritable: true },
+            // vaultAta: read-only. check_vault_ata performs address+owner validation only
+            // (no transfer or balance mutation). process_epoch.rs never writes vault_ata.
+            { pubkey: vaultAta, isSigner: false, isWritable: false },
+            { pubkey: tokenProgram, isSigner: false, isWritable: false },
+            ...remainingAccounts,
+        ],
+        programId,
+        data: Buffer.from([constants_1.IX_PROCESS_EPOCH, advanceEpoch ? 1 : 0, protocolAumCount & 0xff]),
+    });
+}
+function createProcessDelayedDepositIx(args, programId = constants_1.PROGRAM_ID) {
+    const { payer, config, stv, delayedDepositRequest, user, vaultAta, userEvAta, evMint, feeReceiverEvAta, tokenProgram, protocolAumCount = 0, remainingAccounts = [], } = args;
+    return new web3_js_1.TransactionInstruction({
+        keys: [
+            { pubkey: payer, isSigner: true, isWritable: false },
+            { pubkey: config, isSigner: false, isWritable: false },
+            { pubkey: stv, isSigner: false, isWritable: true },
+            { pubkey: delayedDepositRequest, isSigner: false, isWritable: true },
+            { pubkey: user, isSigner: false, isWritable: true },
+            { pubkey: vaultAta, isSigner: false, isWritable: true },
+            { pubkey: userEvAta, isSigner: false, isWritable: true },
+            { pubkey: evMint, isSigner: false, isWritable: true },
+            { pubkey: feeReceiverEvAta, isSigner: false, isWritable: true },
+            { pubkey: tokenProgram, isSigner: false, isWritable: false },
+            ...remainingAccounts,
+        ],
+        programId,
+        data: Buffer.from([constants_1.IX_PROCESS_DELAYED_DEPOSIT, protocolAumCount & 0xff]),
+    });
+}
+function createDepositToStrategyIx(args, programId = constants_1.PROGRAM_ID) {
+    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);
+    }
+    return new web3_js_1.TransactionInstruction({
+        keys: [
+            { pubkey: manager, isSigner: true, isWritable: false },
+            { 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 },
+            { pubkey: strategyProgram, isSigner: false, isWritable: false },
+            { pubkey: strategyState, isSigner: false, isWritable: true },
+            { pubkey: stvPosition, isSigner: false, isWritable: true },
+            { pubkey: strategyBaseAta, isSigner: false, isWritable: true },
+            { pubkey: tokenProgram, isSigner: false, isWritable: false },
+            ...remainingAccounts,
+        ],
+        programId,
+        data: Buffer.from(data),
+    });
+}
+function createWithdrawFromStrategyIx(args, programId = constants_1.PROGRAM_ID) {
+    const { manager, managerRole, config, stv, vaultAta, baseMint, strategyProgram, strategyState, stvPosition, strategyBaseAta, tokenProgram, shares, protocolAumCount = 0, remainingAccounts = [], } = args;
+    // Data: shares(8) + protocol_aum_count(1).
+    const data = [constants_1.IX_WITHDRAW_FROM_STRATEGY];
+    (0, buffer_1.writeU64)(data, shares);
+    data.push(protocolAumCount & 0xff);
+    return new web3_js_1.TransactionInstruction({
+        keys: [
+            { pubkey: manager, isSigner: true, isWritable: false },
+            { 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 },
+            { pubkey: strategyProgram, isSigner: false, isWritable: false },
+            { pubkey: strategyState, isSigner: false, isWritable: true },
+            { pubkey: stvPosition, isSigner: false, isWritable: true },
+            { pubkey: strategyBaseAta, isSigner: false, isWritable: true },
+            { pubkey: tokenProgram, isSigner: false, isWritable: false },
+            ...remainingAccounts,
+        ],
+        programId,
+        data: Buffer.from(data),
+    });
+}
+function createCloseStvIx(args, programId = constants_1.PROGRAM_ID) {
+    const { admin, payer, config, stv, evMint, vaultAta, tokenProgram, escrowEvAta, baseMint, adminBaseAta, strategyProgram, stvPosition, } = args;
+    // FIX B: guard against partial seeded-tail or partial strategy-tail.
+    // The seeded tail [escrowEvAta, baseMint, adminBaseAta] is ALL-or-none:
+    // partial supply leads to a silently malformed account list.
+    const seededCount = [escrowEvAta, baseMint, adminBaseAta].filter(x => x !== undefined).length;
+    if (seededCount > 0 && seededCount < 3) {
+        throw new Error("createCloseStvIx: seeded-path tail requires all three accounts " +
+            "(escrowEvAta, baseMint, adminBaseAta) — got " + seededCount + " of 3");
+    }
+    // The strategy sub-tail [strategyProgram, stvPosition] is ALL-or-none.
+    const strategyCount = [strategyProgram, stvPosition].filter(x => x !== undefined).length;
+    if (strategyCount > 0 && strategyCount < 2) {
+        throw new Error("createCloseStvIx: strategy sub-tail requires both accounts " +
+            "(strategyProgram, stvPosition) — got " + strategyCount + " of 2");
+    }
+    const 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: evMint, isSigner: false, isWritable: true },
+        { pubkey: vaultAta, isSigner: false, isWritable: true },
+        { pubkey: tokenProgram, isSigner: false, isWritable: false },
+    ];
+    // Seeded path trailing accounts (close_stv.rs:122)
+    if (escrowEvAta !== undefined && baseMint !== undefined && adminBaseAta !== undefined) {
+        keys.push({ pubkey: escrowEvAta, isSigner: false, isWritable: true }, { pubkey: baseMint, isSigner: false, isWritable: false }, { pubkey: adminBaseAta, isSigner: false, isWritable: true });
+        // Strategy sub-path (close_stv.rs:149): required when stv.strategy != 0
+        if (strategyProgram !== undefined && stvPosition !== undefined) {
+            keys.push({ pubkey: strategyProgram, isSigner: false, isWritable: false }, { pubkey: stvPosition, isSigner: false, isWritable: false });
+        }
+    }
+    return new web3_js_1.TransactionInstruction({
+        keys,
+        programId,
+        data: Buffer.from([constants_1.IX_CLOSE_STV]),
+    });
+}
+function createAddManagerIx(args, programId = constants_1.PROGRAM_ID) {
+    const { admin, payer, config, stv, managerRole, managerRoleBump, manager, systemProgram = web3_js_1.SystemProgram.programId, } = args;
+    const data = [constants_1.IX_ADD_MANAGER, managerRoleBump & 0xff];
+    data.push(...manager.toBuffer());
+    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: false },
+            { pubkey: managerRole, isSigner: false, isWritable: true },
+            { pubkey: systemProgram, isSigner: false, isWritable: false },
+        ],
+        programId,
+        data: Buffer.from(data),
+    });
+}
+function createRemoveManagerIx(args, programId = constants_1.PROGRAM_ID) {
+    const { admin, payer, stv, managerRole } = args;
+    return new web3_js_1.TransactionInstruction({
+        keys: [
+            { pubkey: admin, isSigner: true, isWritable: false },
+            { pubkey: payer, isSigner: false, isWritable: true },
+            { pubkey: stv, isSigner: false, isWritable: false },
+            { pubkey: managerRole, isSigner: false, isWritable: true },
+        ],
+        programId,
+        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, newProtocolAumCount = 0, remainingAccounts = [], } = args;
+    // Data: old_lend(32) + new_lend(32) + protocol_aum_count(1) + auto_unroute_count(1)
+    //        + new_protocol_aum_count(1).
+    const data = [constants_1.IX_MIGRATE_LEND];
+    data.push(...oldLendProgram.toBuffer());
+    data.push(...newLendProgram.toBuffer());
+    data.push(protocolAumCount & 0xff);
+    data.push(autoUnrouteCount & 0xff);
+    data.push(newProtocolAumCount & 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),
+    });
+}
+/**
+ * Instruction data layout (17 bytes, after the 1-byte disc is stripped by the
+ * dispatcher): shares(u64 LE) + wr_bump(u8) + min_dest_shares(u64 LE).
+ * Confirmed against migrate_request.rs:53-66.
+ */
+function createMigrateRequestIx(args, programId = constants_1.PROGRAM_ID) {
+    const { user, config, sourceStv, destStv, evMint, userEvAta, escrowEvAta, migrateRequest, tokenProgram, systemProgram = web3_js_1.SystemProgram.programId, shares, wrBump, minDestShares, } = args;
+    const data = [constants_1.IX_MIGRATE_REQUEST];
+    (0, buffer_1.writeU64)(data, shares);
+    data.push(wrBump & 0xff);
+    (0, buffer_1.writeU64)(data, minDestShares);
+    return new web3_js_1.TransactionInstruction({
+        keys: [
+            { pubkey: user, isSigner: true, isWritable: true },
+            { pubkey: config, isSigner: false, isWritable: false },
+            { pubkey: sourceStv, isSigner: false, isWritable: true },
+            { pubkey: destStv, isSigner: false, isWritable: false },
+            { pubkey: evMint, isSigner: false, isWritable: false },
+            { pubkey: userEvAta, isSigner: false, isWritable: true },
+            { pubkey: escrowEvAta, isSigner: false, isWritable: true },
+            { pubkey: migrateRequest, isSigner: false, isWritable: true },
+            { pubkey: systemProgram, isSigner: false, isWritable: false },
+            { pubkey: tokenProgram, isSigner: false, isWritable: false },
+        ],
+        programId,
+        data: Buffer.from(data),
+    });
+}
+/**
+ * 14 fixed accounts (migrate_execute.rs:97 destructure). Permissionless.
+ * Instruction data: 4 bytes always; 5th byte (dest_delayed_bump) required
+ * on the deferred path (migrate_execute.rs:104-114 / 387-401).
+ */
+function createMigrateExecuteIx(args, programId = constants_1.PROGRAM_ID) {
+    const { caller, config, sourceStv, destStv, wrAccount, sourceVaultAta, destVaultAta, destEvMint, userDestEvAta, sourceFeeRecvAta, destFeeRecvEvAta, baseMint, tokenProgram, wrUserAccount, srcProtocolAumCount, dstProtocolAumCount, srcAutoUnrouteCount, dstAutoRouteCount, destDelayedRequest, destDelayedBump, systemProgram, remainingAccounts = [], } = args;
+    const dataBytes = [
+        constants_1.IX_MIGRATE_EXECUTE,
+        srcProtocolAumCount & 0xff,
+        dstProtocolAumCount & 0xff,
+        srcAutoUnrouteCount & 0xff,
+        dstAutoRouteCount & 0xff,
+    ];
+    // 5th byte required on deferred path (migrate_execute.rs:388-390)
+    if (destDelayedRequest !== undefined) {
+        if (destDelayedBump === undefined) {
+            throw new Error("createMigrateExecuteIx: destDelayedBump is required when destDelayedRequest is provided");
+        }
+        dataBytes.push(destDelayedBump & 0xff);
+    }
+    // Trailing accounts for deferred path (migrate_execute.rs:393-401):
+    // [dest_delayed_request(w), system_program] appended after remaining.
+    const trailingKeys = [];
+    if (destDelayedRequest !== undefined) {
+        trailingKeys.push({ pubkey: destDelayedRequest, isSigner: false, isWritable: true }, { pubkey: systemProgram ?? web3_js_1.SystemProgram.programId, isSigner: false, isWritable: false });
+    }
+    return new web3_js_1.TransactionInstruction({
+        keys: [
+            // caller must be writable on the deferred path: the handler calls
+            // check_writable(caller) at migrate_execute.rs:400 because caller funds
+            // the dest_delayed_request CreateAccount rent.  Read-only on immediate path.
+            { pubkey: caller, isSigner: true, isWritable: destDelayedRequest !== undefined },
+            { pubkey: config, isSigner: false, isWritable: false },
+            { pubkey: sourceStv, isSigner: false, isWritable: true },
+            { pubkey: destStv, isSigner: false, isWritable: true },
+            { pubkey: wrAccount, isSigner: false, isWritable: true },
+            { pubkey: sourceVaultAta, isSigner: false, isWritable: true },
+            { pubkey: destVaultAta, isSigner: false, isWritable: true },
+            { pubkey: destEvMint, isSigner: false, isWritable: true },
+            { pubkey: userDestEvAta, isSigner: false, isWritable: true },
+            { pubkey: sourceFeeRecvAta, isSigner: false, isWritable: true },
+            { pubkey: destFeeRecvEvAta, isSigner: false, isWritable: true },
+            { pubkey: baseMint, isSigner: false, isWritable: false },
+            { pubkey: tokenProgram, isSigner: false, isWritable: false },
+            { pubkey: wrUserAccount, isSigner: false, isWritable: true },
+            ...remainingAccounts,
+            ...trailingKeys,
+        ],
+        programId,
+        data: Buffer.from(dataBytes),
+    });
+}
+function createMigrateCancelIx(args, programId = constants_1.PROGRAM_ID) {
+    const { user, config, stv, wrAccount, vaultAta, userBaseAta, feeReceiverBaseAta, baseMint, tokenProgram, autoUnrouteCount = 0, protocolAumCount = 0, remainingAccounts = [], } = args;
+    // Data bytes: [disc, auto_unroute_count, protocol_aum_count]
+    // Both counts are optional on-chain (data.is_empty() / data.len() > 1).
+    const data = Buffer.from([constants_1.IX_MIGRATE_CANCEL, autoUnrouteCount & 0xff, protocolAumCount & 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: wrAccount, isSigner: false, isWritable: true },
+            { pubkey: vaultAta, isSigner: false, isWritable: true },
+            { pubkey: userBaseAta, isSigner: false, isWritable: true },
+            { pubkey: feeReceiverBaseAta, isSigner: false, isWritable: true },
+            { pubkey: baseMint, isSigner: false, isWritable: false },
+            { pubkey: tokenProgram, isSigner: false, isWritable: false },
+            ...remainingAccounts,
+        ],
+        programId,
+        data,
+    });
+}
+// ---------------------------------------------------------------------------
+// Remaining Accounts Helpers
+// ---------------------------------------------------------------------------
+function buildLendRemainingAccounts(lend) {
+    return [
+        { pubkey: lend.lendProgram, isSigner: false, isWritable: false },
+        { pubkey: lend.lendStrategyState, isSigner: false, isWritable: true },
+        { pubkey: lend.lendStvPosition, isSigner: false, isWritable: true },
+        { pubkey: lend.lendBaseAta, isSigner: false, isWritable: true },
+    ];
+}
+/**
+ * Assemble the migrate_execute remaining_accounts in the exact order
+ * parse_lend_accounts expects (migrate_execute.rs:298-338):
+ *
+ *   [ source-lend section ]  src.lend(4 fixed) + src.protocolAum(P_src)
+ *   [ source auto-unroute  ]  src.autoUnroute (U accounts)
+ *   [ dest-lend section    ]  dst.lend(4 fixed) + dst.protocolAum(P_dst)
+ *   [ dest strategy + route]  dst.strategy(0 or 2) + dst.autoRoute (R accounts)
+ *
+ * Pass `undefined` for a `lend` side whose STV has no lend_program (the 4
+ * fixed accounts + protocol AUM are omitted, matching the early return in
+ * parse_lend_accounts when lend_program_key == default).
+ *
+ * The 4 fixed lend accounts mirror `buildLendRemainingAccounts`:
+ *   [lendProgram(ro), lendStrategyState(w), lendStvPosition(w), lendBaseAta(w)]
+ * `protocolAum` / `autoUnroute` / `autoRoute` / `strategy` accounts are passed
+ * through verbatim; the caller sets their writable flags per protocol.
+ */
+function buildMigrateRemainingAccounts(opts) {
+    const out = [];
+    // ---- source-lend section ----
+    if (opts.source.lend) {
+        out.push(...buildLendRemainingAccounts(opts.source.lend));
+        if (opts.source.protocolAum)
+            out.push(...opts.source.protocolAum);
+    }
+    // ---- source auto-unroute ----
+    if (opts.source.autoUnroute)
+        out.push(...opts.source.autoUnroute);
+    // ---- dest-lend section ----
+    if (opts.dest.lend) {
+        out.push(...buildLendRemainingAccounts(opts.dest.lend));
+        if (opts.dest.protocolAum)
+            out.push(...opts.dest.protocolAum);
+    }
+    // ---- dest strategy pair (writable state, read-only position) ----
+    if (opts.dest.strategy) {
+        out.push({ pubkey: opts.dest.strategy.strategyState, isSigner: false, isWritable: true }, { pubkey: opts.dest.strategy.stvPosition, isSigner: false, isWritable: false });
+    }
+    // ---- dest auto-route ----
+    if (opts.dest.autoRoute)
+        out.push(...opts.dest.autoRoute);
+    return out;
+}
+function buildStrategyRemainingAccounts(strategies) {
+    const accounts = [];
+    for (const s of strategies) {
+        accounts.push({ pubkey: s.strategyState, isSigner: false, isWritable: true }, { pubkey: s.stvPosition, isSigner: false, isWritable: false });
+    }
+    return accounts;
+}
+function createInstantWithdrawIx(args, programId = constants_1.PROGRAM_ID) {
+    const { user, config, stv, vaultAta, userBaseAta, feeReceiverBaseAta, feeReceiverEvAta, baseMint, evMint, userEvAta, tokenProgram, shares, minBaseOut, protocolAumCount = 0, autoUnrouteCount = 0, remainingAccounts = [], } = args;
+    // Data: shares(8) + min_base_out(8) + protocol_aum_count(1) + auto_unroute_count(1) = 18.
+    const data = [constants_1.IX_INSTANT_WITHDRAW];
+    (0, buffer_1.writeU64)(data, shares);
+    (0, buffer_1.writeU64)(data, minBaseOut);
+    data.push(protocolAumCount & 0xff);
+    data.push(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: vaultAta, isSigner: false, isWritable: true },
+            { pubkey: userBaseAta, isSigner: false, isWritable: true },
+            { pubkey: feeReceiverBaseAta, isSigner: false, isWritable: true },
+            { pubkey: feeReceiverEvAta, isSigner: false, isWritable: true },
+            { pubkey: baseMint, isSigner: false, isWritable: false },
+            { pubkey: evMint, isSigner: false, isWritable: true },
+            { pubkey: userEvAta, isSigner: false, isWritable: true },
+            { pubkey: tokenProgram, isSigner: false, isWritable: false },
+            ...remainingAccounts,
+        ],
+        programId,
+        data: Buffer.from(data),
+    });
+}
+function createSeedStvIx(args, programId = constants_1.PROGRAM_ID) {
+    const { admin, config, stv, evMint, escrowEvAta, vaultAta, adminBaseAta, baseMint, tokenProgram, ataProgram = spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID, systemProgram = web3_js_1.SystemProgram.programId, amount, } = args;
+    // Data: amount(8).
+    const data = [constants_1.IX_SEED_STV];
+    (0, buffer_1.writeU64)(data, amount);
+    return new web3_js_1.TransactionInstruction({
+        keys: [
+            { pubkey: admin, isSigner: true, isWritable: true },
+            { pubkey: config, isSigner: false, isWritable: false },
+            { pubkey: stv, isSigner: false, isWritable: true },
+            { pubkey: evMint, isSigner: false, isWritable: true },
+            { pubkey: escrowEvAta, isSigner: false, isWritable: true },
+            { pubkey: vaultAta, isSigner: false, isWritable: true },
+            { pubkey: adminBaseAta, isSigner: false, isWritable: true },
+            { pubkey: baseMint, isSigner: false, isWritable: false },
+            { pubkey: tokenProgram, isSigner: false, isWritable: false },
+            { pubkey: ataProgram, isSigner: false, isWritable: false },
+            { pubkey: systemProgram, isSigner: false, isWritable: false },
+        ],
+        programId,
+        data: Buffer.from(data),
+    });
+}
+function createAcceptVaultAdminIx(args, programId = constants_1.PROGRAM_ID) {
+    const { pendingAdmin, stv } = args;
+    return new web3_js_1.TransactionInstruction({
+        keys: [
+            { pubkey: pendingAdmin, isSigner: true, isWritable: false },
+            { pubkey: stv, isSigner: false, isWritable: true },
+        ],
+        programId,
+        data: Buffer.from([constants_1.IX_ACCEPT_VAULT_ADMIN]),
+    });
+}
+function createTripCircuitBreakerIx(args, programId = constants_1.PROGRAM_ID) {
+    const { authority, stv, managerRole } = args;
+    const keys = [
+        { pubkey: authority, isSigner: true, isWritable: false },
+        { pubkey: stv, isSigner: false, isWritable: true },
+    ];
+    if (managerRole !== undefined) {
+        keys.push({ pubkey: managerRole, isSigner: false, isWritable: false });
+    }
+    return new web3_js_1.TransactionInstruction({
+        keys,
+        programId,
+        data: Buffer.from([constants_1.IX_TRIP_CIRCUIT_BREAKER]),
+    });
+}