@elmntl/jlpd-sdk 0.1.11 → 0.13.4

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

@@ -0,0 +1,637 @@
+import { PublicKey, TransactionInstruction, AccountMeta } from "@solana/web3.js";
+import BN from "bn.js";
+export interface InitOrUpdateConfigArgs {
+    admin: PublicKey;
+    payer: PublicKey;
+    config: PublicKey;
+    systemProgram?: PublicKey;
+    bump: number;
+    newAdmin?: PublicKey;
+    newFlags?: number;
+}
+export declare function createInitOrUpdateConfigIx(args: InitOrUpdateConfigArgs, programId?: PublicKey): TransactionInstruction;
+export interface InitOrUpdateStvArgs {
+    admin: PublicKey;
+    payer: PublicKey;
+    config: PublicKey;
+    stv: PublicKey;
+    evMint: PublicKey;
+    baseMint: PublicKey;
+    vaultAta: PublicKey;
+    /** Canonical ATA for feeReceiver + evMint, pinned on STV. */
+    feeReceiverEvAta: PublicKey;
+    tokenProgram: PublicKey;
+    ataProgram?: PublicKey;
+    systemProgram?: PublicKey;
+    vaultId: number | BN;
+    stvBump: number;
+    evMintBump: number;
+    feeReceiver?: PublicKey;
+    strategy?: PublicKey;
+    epochSec?: number;
+    mgmtFeeBps?: number;
+    perfFeeBps?: number;
+    vaultCapacity?: BN | number;
+    minDeposit?: BN | number;
+    flags?: number;
+    addStrategy?: PublicKey;
+    removeStrategy?: PublicKey;
+    lendProgram?: PublicKey;
+    /** Max % of AUM claimable per epoch window (BPS, 0 = unlimited, max 10000) */
+    dailyWithdrawLimitBps?: number;
+    /** Migrate-in fee (BPS, max MAX_FEE_BPS=1000). Applied when FLAG_DEPOSIT_FEE_ON_MIGRATE set. */
+    depositFeeBps?: number;
+    /** Migrate-out fee (BPS, max MAX_FEE_BPS=1000). Applied when FLAG_WITHDRAWAL_FEE_ON_MIGRATE set. */
+    withdrawalFeeBps?: number;
+    /**
+     * Withdrawal mode: 0=instant, 1=X, 2=X+1. CREATE-ONLY — immutable after the STV
+     * exists (the handler rejects a change on update). Instant (0) additionally
+     * requires a C-1 seed floor and a non-allocator vault.
+     */
+    withdrawalMode?: number;
+    /**
+     * CREATE path (STV does not yet exist): REQUIRED. Per-vault admin pubkey. Must be
+     * nonzero — the handler rejects zero / None. The global admin is the signer here;
+     * vaultAdmin can be a different key (e.g. a Squads multi-sig vault PDA).
+     *
+     * Wire encoding: `0x01 + 32 bytes` (Some(nonzero)). The handler will reject
+     * `None` (0x00) and `Some([0;32])` with `InvalidParameter`.
+     *
+     * MUST NOT be supplied together with `pendingAdmin` — they share the same wire
+     * position but are branch-interpreted. Pass exactly one of the two.
+     */
+    vaultAdmin?: PublicKey;
+    /**
+     * UPDATE path (STV already exists): three-value encoding matching the handler:
+     *   undefined / not provided → None → no change to pending rotation
+     *   PublicKey.default ([0u8;32]) → Some([0;32]) → cancel pending rotation
+     *   any nonzero PublicKey → Some(nonzero) → start/replace rotation; emits AdminRotationStarted
+     *
+     * Wire encoding: `0x00` (None) or `0x01 + 32 bytes` (Some).
+     * ONLY `accept_vault_admin` may change `stv.coldAdmin` post-create/migration.
+     * A pending admin has ZERO authority before accept.
+     *
+     * MUST NOT be supplied together with `vaultAdmin` — they share the same wire
+     * position but are branch-interpreted. Pass exactly one of the two.
+     */
+    pendingAdmin?: PublicKey;
+    /**
+     * Per-vault strategy staleness window in seconds (u32).
+     * `0` = use the on-chain default (24 h). `undefined` = omit from wire (no change
+     * on update; resolves to 0/default on create because the STV is zero-initialized).
+     * Admin is trusted; no range validation on-chain. This is the LAST optional field
+     * in the instruction data — old clients that omit it are wire-compatible (program
+     * sees EOF -> None -> no change). Wire: 0x00 (absent) or 0x01 + 4 bytes LE (present).
+     */
+    strategyStalenessThreshold?: number;
+    /**
+     * Warm admin (offset 476 in v2 layout). Operational authority:
+     * `add_manager`, `remove_manager`, `override_claim_withdraw`,
+     * `trip_circuit_breaker` — NOT this instruction / `close_stv` / `seed_stv`
+     * / `migrate_lend` (cold-only). See docs/spec-warm-admin-guardrails.md §2-3.
+     *
+     * CREATE path (`vaultAdmin` supplied): `undefined` / `PublicKey.default`
+     * (`[0u8;32]`) / a value equal to `vaultAdmin` all normalize on-chain to
+     * the `[0;32]` "follow cold" sentinel (no split — warm tracks the vault's
+     * cold admin automatically, including across future
+     * `accept_vault_admin` rotations). Any other nonzero key is stored as an
+     * explicit split warm admin.
+     *
+     * UPDATE path (`pendingAdmin` position in use, or neither admin arg
+     * supplied): `undefined` → no change to the stored warm admin.
+     * `PublicKey.default` → reset to the follow-cold sentinel (undoes a
+     * split). A value equal to the CURRENT on-chain `stv.coldAdmin` → normalizes
+     * to the sentinel (same invariant). Any other nonzero key → sets
+     * `stv.warm_admin` directly (cold is superior and can always re-set; no
+     * two-step). Only the cold admin (the update-path signer) can reach this
+     * — warm cannot rotate itself.
+     *
+     * Wire position: appended LAST, immediately after
+     * `strategyStalenessThreshold` — preserves every earlier optional's wire
+     * position (spec-warm-admin-guardrails.md §3 wire-format table). Wire:
+     * `0x00` (None / no-change) or `0x01 + 32 bytes` (Some). Like every other
+     * optional field in this builder, the tag byte is ALWAYS emitted
+     * (`undefined` still serializes an explicit `0x00`, never a true
+     * end-of-data omission) — a pre-this-field client that stops before this
+     * position is still wire-compatible, since the on-chain parser treats EOF
+     * identically to an explicit `0x00`.
+     *
+     * PRE-DEPLOY CAVEAT: the currently-deployed mainnet program does not parse
+     * this field yet (predates the warm-admin-guardrails upgrade) — extra
+     * trailing bytes sent against the old program are simply never read
+     * (inert), so building this shape ahead of the upgrade is safe but has no
+     * effect until the program is upgraded.
+     */
+    warmAdmin?: PublicKey;
+    /**
+     * Lend-activation path: when `lendProgram` is set on a CREATE (or on an UPDATE
+     * that activates lend for the first time), the handler CPIs `lend.init_position`
+     * and consumes the first two remaining_accounts as:
+     *   remaining[0] = lend_strategy_state (readonly, owned by lendProgram)
+     *   remaining[1] = lend_position_pda   (writable, to be initialised)
+     *
+     * Supply these via `lendInitAccounts` and they will be prepended to
+     * `remainingAccounts`. If `lendProgram` is set but neither `lendInitAccounts`
+     * nor the equivalent entries in `remainingAccounts` are provided, the
+     * instruction will fail on-chain with `IncompleteStrategyAccounts`.
+     */
+    lendInitAccounts?: {
+        /** LendStrategyState PDA (readonly). Must be owned by lendProgram. */
+        lendStrategyState: PublicKey;
+        /** StvPosition PDA to initialise (writable). */
+        lendPositionPda: PublicKey;
+    };
+    remainingAccounts?: AccountMeta[];
+}
+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;
+    userEvAta: PublicKey;
+    evMint: PublicKey;
+    feeReceiverEvAta: PublicKey;
+    baseMint: PublicKey;
+    tokenProgram: PublicKey;
+    amount: BN | number;
+    minShares: BN | number;
+    /** Number of protocol AUM accounts in remaining_accounts (after 4 lend accounts) */
+    protocolAumCount?: number;
+    /** Number of auto-route accounts in remaining_accounts (after strategy pairs) */
+    autoRouteCount?: number;
+    /** DelayedDepositRequest PDA. Required when the STV has FLAG_DELAYED_DEPOSIT set. */
+    delayedDepositRequest?: PublicKey;
+    /** PDA bump for delayedDepositRequest. Required when delayedDepositRequest is passed. */
+    delayedDepositBump?: number;
+    /** System program. Required for delayed deposits because the request PDA may be created. */
+    systemProgram?: PublicKey;
+    remainingAccounts?: AccountMeta[];
+}
+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;
+    escrowEvAta: PublicKey;
+    evMint: PublicKey;
+    tokenProgram: PublicKey;
+    systemProgram?: PublicKey;
+    shares: BN | number;
+    wrBump: number;
+}
+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;
+    userBaseAta: PublicKey;
+    /** Fee receiver's base-mint ATA. Required even when withdrawalFeeBps == 0. */
+    feeReceiverBaseAta: PublicKey;
+    baseMint: PublicKey;
+    tokenProgram: PublicKey;
+    remainingAccounts?: AccountMeta[];
+    /** Number of auto-unroute accounts appended after lend accounts (0 = no auto-unroute) */
+    autoUnrouteCount?: number;
+    /**
+     * Number of protocol-AUM accounts (kVault 2 / Jupiter 3 per protocol) placed in
+     * remainingAccounts AFTER the 4 fixed lend accounts and BEFORE the auto-unroute
+     * accounts. Feeds the pre-unsweep update_aum refresh. MUST equal the lend strategy's
+     * live protocol set when lend has protocols (lend reverts an incomplete tail);
+     * pass 0 only when the lend strategy has no protocols.
+     */
+    protocolAumCount?: number;
+}
+export declare function createClaimWithdrawIx(args: ClaimWithdrawArgs, programId?: PublicKey): TransactionInstruction;
+export interface OverrideClaimWithdrawArgs {
+    /** Cold admin (stv.coldAdmin) or warm admin (stv.warmAdminEffective()). Manager is hard-cut — no ManagerRole account. */
+    authority: PublicKey;
+    /** GlobalConfig PDA — checked for CFG_FLAG_GLOBAL_PAUSED */
+    config: PublicKey;
+    /** WithdrawRequest owner. NOT a signer — authority acts on their behalf. */
+    user: PublicKey;
+    stv: PublicKey;
+    withdrawRequest: PublicKey;
+    vaultAta: PublicKey;
+    userBaseAta: PublicKey;
+    /** Fee receiver's base-mint ATA. Required even when withdrawalFeeBps == 0. */
+    feeReceiverBaseAta: PublicKey;
+    baseMint: PublicKey;
+    tokenProgram: PublicKey;
+    remainingAccounts?: AccountMeta[];
+    autoUnrouteCount?: number;
+    /** Protocol-AUM accounts count for the pre-unsweep refresh — see ClaimWithdrawArgs. */
+    protocolAumCount?: number;
+}
+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;
+    escrowEvAta: PublicKey;
+    vaultAta: PublicKey;
+    tokenProgram: PublicKey;
+    advanceEpoch: boolean;
+    /** Number of protocol AUM accounts in remaining_accounts (after 4 lend accounts) */
+    protocolAumCount?: number;
+    remainingAccounts?: AccountMeta[];
+}
+export declare function createProcessEpochIx(args: ProcessEpochArgs, programId?: PublicKey): TransactionInstruction;
+export interface ProcessDelayedDepositArgs {
+    payer: PublicKey;
+    /** GlobalConfig PDA — checked for CFG_FLAG_GLOBAL_PAUSED */
+    config: PublicKey;
+    stv: PublicKey;
+    delayedDepositRequest: PublicKey;
+    /** User account stored on the delayed deposit request; receives closed-account rent. */
+    user: PublicKey;
+    vaultAta: PublicKey;
+    userEvAta: PublicKey;
+    evMint: PublicKey;
+    feeReceiverEvAta: PublicKey;
+    tokenProgram: PublicKey;
+    /** Number of protocol AUM accounts in remaining_accounts (after 4 lend accounts) */
+    protocolAumCount?: number;
+    remainingAccounts?: AccountMeta[];
+}
+export declare function createProcessDelayedDepositIx(args: ProcessDelayedDepositArgs, programId?: PublicKey): TransactionInstruction;
+export interface DepositToStrategyArgs {
+    manager: PublicKey;
+    managerRole: PublicKey;
+    /** GlobalConfig PDA — checked for CFG_FLAG_GLOBAL_PAUSED */
+    config: PublicKey;
+    stv: PublicKey;
+    vaultAta: PublicKey;
+    baseMint: PublicKey;
+    strategyProgram: PublicKey;
+    strategyState: PublicKey;
+    stvPosition: PublicKey;
+    strategyBaseAta: PublicKey;
+    tokenProgram: PublicKey;
+    amount: BN | number;
+    minShares: BN | number;
+    /**
+     * 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[];
+}
+export declare function createDepositToStrategyIx(args: DepositToStrategyArgs, programId?: PublicKey): TransactionInstruction;
+export interface WithdrawFromStrategyArgs {
+    manager: PublicKey;
+    managerRole: PublicKey;
+    /** GlobalConfig PDA — checked for CFG_FLAG_GLOBAL_PAUSED */
+    config: PublicKey;
+    stv: PublicKey;
+    vaultAta: PublicKey;
+    baseMint: PublicKey;
+    strategyProgram: PublicKey;
+    strategyState: PublicKey;
+    stvPosition: PublicKey;
+    strategyBaseAta: PublicKey;
+    tokenProgram: PublicKey;
+    shares: BN | number;
+    /**
+     * remainingAccounts when lend is active: [4 fixed lend, protocolAumCount protocol-AUM
+     * accounts]. The protocol-AUM accounts feed the pre-sweep update_aum refresh so the
+     * swept base mints lend shares at a fresh pps. Pass 0 only when lend has no protocols.
+     */
+    protocolAumCount?: number;
+    remainingAccounts?: AccountMeta[];
+}
+export declare function createWithdrawFromStrategyIx(args: WithdrawFromStrategyArgs, programId?: PublicKey): TransactionInstruction;
+export interface CloseStvArgs {
+    admin: PublicKey;
+    payer: PublicKey;
+    config: PublicKey;
+    stv: PublicKey;
+    evMint: PublicKey;
+    vaultAta: PublicKey;
+    tokenProgram: PublicKey;
+    /** canonical ATA(stv_pda, ev_mint) — escrow holding seed shares. */
+    escrowEvAta?: PublicKey;
+    baseMint?: PublicKey;
+    /** ATA(admin, base_mint) — receives drained seed base. */
+    adminBaseAta?: PublicKey;
+    strategyProgram?: PublicKey;
+    stvPosition?: PublicKey;
+}
+export declare function createCloseStvIx(args: CloseStvArgs, programId?: PublicKey): TransactionInstruction;
+export interface AddManagerArgs {
+    /** Cold admin (stv.coldAdmin) or warm admin (stv.warmAdminEffective()). NOT the global config admin. */
+    admin: PublicKey;
+    payer: PublicKey;
+    config: PublicKey;
+    stv: PublicKey;
+    managerRole: PublicKey;
+    managerRoleBump: number;
+    manager: PublicKey;
+    systemProgram?: PublicKey;
+}
+export declare function createAddManagerIx(args: AddManagerArgs, programId?: PublicKey): TransactionInstruction;
+export interface RemoveManagerArgs {
+    /**
+     * Must be the per-vault cold admin (stv.coldAdmin) or warm admin
+     * (stv.warmAdminEffective()). NOT the global config admin.
+     */
+    admin: PublicKey;
+    payer: PublicKey;
+    /** STV PDA — required for vault-admin auth check (cold or warm admin). */
+    stv: PublicKey;
+    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;
+    /**
+     * Protocol-AUM accounts for the NEW lend's pre-sweep update_aum refresh, trailing
+     * the 4 fixed new-lend accounts in the new section. Pass 0 when deactivating lend or
+     * when the new lend has no protocols (else lend reverts an incomplete tail).
+     */
+    newProtocolAumCount?: number;
+    /**
+     * remaining_accounts layout:
+     *   Old section (4 + protocolAumCount + autoUnrouteCount):
+     *     [oldLendProgram, oldStrategyState, oldStvPosition, oldBaseAta,
+     *      ...protocolAumAccounts, ...autoUnrouteAccounts]
+     *   New section (if newLendProgram != default):
+     *     [newLendProgram, newStrategyState, newPositionPda, newBaseAta,
+     *      ...newProtocolAumAccounts (count = newProtocolAumCount, for the pre-sweep refresh)]
+     */
+    remainingAccounts?: AccountMeta[];
+}
+export declare function createMigrateLendIx(args: MigrateLendArgs, programId?: PublicKey): TransactionInstruction;
+export interface MigrateRequestArgs {
+    /** The LP migrating (signer, writable). */
+    user: PublicKey;
+    /** GlobalConfig PDA — checked for CFG_FLAG_GLOBAL_PAUSED. */
+    config: PublicKey;
+    /** STV migrating FROM (writable). */
+    sourceStv: PublicKey;
+    /** STV migrating TO (read-only; base_mint must match source). */
+    destStv: PublicKey;
+    /** Source STV's evX mint. */
+    evMint: PublicKey;
+    /** User's source evX token account (writable). */
+    userEvAta: PublicKey;
+    /** Source STV escrow evX account, owner = source_stv PDA (writable). */
+    escrowEvAta: PublicKey;
+    /** Migrate-kind WithdrawRequest PDA to initialize — use findMigrateRequestPda. */
+    migrateRequest: PublicKey;
+    tokenProgram: PublicKey;
+    systemProgram?: PublicKey;
+    /** evX shares to migrate. */
+    shares: BN | number;
+    /** Bump for the migrate_request PDA (findMigrateRequestPda[1]). */
+    wrBump: number;
+    /** Minimum dest shares accepted at execute time (slippage floor; 0 = none). */
+    minDestShares: BN | number;
+}
+/**
+ * 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.
+ */
+export declare function createMigrateRequestIx(args: MigrateRequestArgs, programId?: PublicKey): TransactionInstruction;
+export interface MigrateExecuteArgs {
+    /** Any signer. Permissionless — no ManagerRole required. */
+    caller: PublicKey;
+    /** GlobalConfig PDA — checked for CFG_FLAG_GLOBAL_PAUSED. */
+    config: PublicKey;
+    sourceStv: PublicKey;
+    destStv: PublicKey;
+    /** Migrate-kind WithdrawRequest PDA (writable, program-owned). */
+    wrAccount: PublicKey;
+    sourceVaultAta: PublicKey;
+    destVaultAta: PublicKey;
+    destEvMint: PublicKey;
+    /** WR user's dest evX ATA (mint = dest ev_mint, owner = wr.user). */
+    userDestEvAta: PublicKey;
+    /** Source fee receiver's base ATA (withdrawal fee). */
+    sourceFeeRecvAta: PublicKey;
+    /** Dest fee receiver's evX ATA (deposit fee). */
+    destFeeRecvEvAta: PublicKey;
+    baseMint: PublicKey;
+    tokenProgram: PublicKey;
+    /** Account that receives the WR rent on close — must equal wr.user (slot 13). */
+    wrUserAccount: PublicKey;
+    /** Source-lend protocol AUM account count for update_aum. */
+    srcProtocolAumCount: number;
+    /** Dest-lend protocol AUM account count for update_aum. */
+    dstProtocolAumCount: number;
+    /** Source-lend auto-unroute account count (withdraw deficit). */
+    srcAutoUnrouteCount: number;
+    /** Dest-lend auto-route account count (sweep). */
+    dstAutoRouteCount: number;
+    /**
+     * Deferred path (dest has FLAG_DELAYED_DEPOSIT and FLAG_BYPASS_MIGRATE_DST_WAITOUT
+     * is unset): pass the DelayedDepositRequest PDA (writable, new account).
+     * The PDA is appended as the last two remaining_accounts after the normal
+     * lend/strategy accounts: [dest_delayed_request(w), system_program].
+     * Also requires destDelayedBump (the bump for the new PDA).
+     */
+    destDelayedRequest?: PublicKey;
+    destDelayedBump?: number;
+    systemProgram?: PublicKey;
+    /**
+     * remaining_accounts (assemble with buildMigrateRemainingAccounts):
+     *   src lend fixed(4) + src protocol AUM(srcProtocolAumCount)
+     *   + src auto-unroute(srcAutoUnrouteCount)
+     *   + dst lend fixed(4) + dst protocol AUM(dstProtocolAumCount)
+     *   + dst strategy pairs(0 or 2) + dst auto-route(dstAutoRouteCount)
+     * Omit a lend section entirely when that side's lend_program is unset.
+     * Do NOT include dest_delayed_request/system_program here — pass them via
+     * destDelayedRequest/systemProgram instead; they are appended automatically.
+     */
+    remainingAccounts?: AccountMeta[];
+}
+/**
+ * 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).
+ */
+export declare function createMigrateExecuteIx(args: MigrateExecuteArgs, programId?: PublicKey): TransactionInstruction;
+export interface MigrateCancelArgs {
+    /** Must equal wr.user. Signer + writable (receives WR rent back). */
+    user: PublicKey;
+    /** GlobalConfig PDA. */
+    config: PublicKey;
+    /** Source STV (writable). */
+    stv: PublicKey;
+    /** Migrate-kind WithdrawRequest PDA (writable). */
+    wrAccount: PublicKey;
+    /** Canonical vault ATA (writable). */
+    vaultAta: PublicKey;
+    /** User's base token ATA (receives base). */
+    userBaseAta: PublicKey;
+    /** Fee receiver's base ATA. */
+    feeReceiverBaseAta: PublicKey;
+    baseMint: PublicKey;
+    tokenProgram: PublicKey;
+    /** Lend auto-unroute accounts (0 = none). */
+    autoUnrouteCount?: number;
+    /** Lend protocol AUM accounts (0 = none). */
+    protocolAumCount?: number;
+    remainingAccounts?: AccountMeta[];
+}
+export declare function createMigrateCancelIx(args: MigrateCancelArgs, programId?: PublicKey): TransactionInstruction;
+export declare function buildLendRemainingAccounts(lend: {
+    lendProgram: PublicKey;
+    lendStrategyState: PublicKey;
+    lendStvPosition: PublicKey;
+    lendBaseAta: PublicKey;
+}): AccountMeta[];
+/**
+ * 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.
+ */
+export declare function buildMigrateRemainingAccounts(opts: {
+    source: {
+        lend?: {
+            lendProgram: PublicKey;
+            lendStrategyState: PublicKey;
+            lendStvPosition: PublicKey;
+            lendBaseAta: PublicKey;
+        };
+        protocolAum?: AccountMeta[];
+        autoUnroute?: AccountMeta[];
+    };
+    dest: {
+        lend?: {
+            lendProgram: PublicKey;
+            lendStrategyState: PublicKey;
+            lendStvPosition: PublicKey;
+            lendBaseAta: PublicKey;
+        };
+        protocolAum?: AccountMeta[];
+        /** Dest strategy pair [strategyState(w), stvPosition(ro)] when dest has a strategy. */
+        strategy?: {
+            strategyState: PublicKey;
+            stvPosition: PublicKey;
+        };
+        autoRoute?: AccountMeta[];
+    };
+}): AccountMeta[];
+export declare function buildStrategyRemainingAccounts(strategies: {
+    strategyState: PublicKey;
+    stvPosition: PublicKey;
+}[]): AccountMeta[];
+export interface InstantWithdrawArgs {
+    user: PublicKey;
+    /** GlobalConfig PDA — checked for CFG_FLAG_GLOBAL_PAUSED */
+    config: PublicKey;
+    stv: PublicKey;
+    /** canonical ATA(stv, base_mint) */
+    vaultAta: PublicKey;
+    /** ATA(user, base_mint) — receives net_base */
+    userBaseAta: PublicKey;
+    /** ATA(stv.fee_receiver, base_mint) */
+    feeReceiverBaseAta: PublicKey;
+    /** pinned fee-receiver evX ATA — settle_fees mints fee shares here */
+    feeReceiverEvAta: PublicKey;
+    baseMint: PublicKey;
+    evMint: PublicKey;
+    /** source of the user-signed burn — ATA(user, ev_mint) */
+    userEvAta: PublicKey;
+    tokenProgram: PublicKey;
+    /** evX shares to redeem */
+    shares: BN | number;
+    /** minimum net base out (slippage floor) — must be > 0 */
+    minBaseOut: BN | number;
+    /** number of protocol AUM accounts after the 4 fixed lend accounts (0 = none) */
+    protocolAumCount?: number;
+    /** number of auto-unroute accounts appended after the lend section (0 = none) */
+    autoUnrouteCount?: number;
+    /**
+     * Trailing accounts after token_program, in order:
+     *   [4 fixed lend + protocolAumCount][strategy_state, stv_position,
+     *    strategy_program, strategy_base_ata (only if stv.strategy != 0)][auto_unroute]
+     */
+    remainingAccounts?: AccountMeta[];
+}
+export declare function createInstantWithdrawIx(args: InstantWithdrawArgs, programId?: PublicKey): TransactionInstruction;
+export interface SeedStvArgs {
+    /** config.admin; pays escrow-ATA rent */
+    admin: PublicKey;
+    config: PublicKey;
+    stv: PublicKey;
+    evMint: PublicKey;
+    /** canonical ATA(stv_pda, ev_mint) — created idempotently */
+    escrowEvAta: PublicKey;
+    /** canonical ATA(stv_pda, base_mint) */
+    vaultAta: PublicKey;
+    /** ATA(admin, base_mint) — source of the seed base */
+    adminBaseAta: PublicKey;
+    baseMint: PublicKey;
+    tokenProgram: PublicKey;
+    ataProgram?: PublicKey;
+    systemProgram?: PublicKey;
+    /** base to seed; with any pre-donated base, sets the minted seed-share floor */
+    amount: BN | number;
+}
+export declare function createSeedStvIx(args: SeedStvArgs, programId?: PublicKey): TransactionInstruction;
+export interface AcceptVaultAdminArgs {
+    /** Must equal stv.pending_admin on-chain. Signer proves the new key is live. */
+    pendingAdmin: PublicKey;
+    /** STV account (writable). */
+    stv: PublicKey;
+}
+export declare function createAcceptVaultAdminIx(args: AcceptVaultAdminArgs, programId?: PublicKey): TransactionInstruction;
+export interface TripCircuitBreakerArgs {
+    /** Cold admin (stv.coldAdmin), warm admin (stv.warmAdminEffective()), or a valid manager. */
+    authority: PublicKey;
+    stv: PublicKey;
+    /**
+     * ManagerRole PDA for (stv, authority). Only required when `authority` is
+     * neither the cold nor the warm admin (the manager path) — the on-chain
+     * OR-auth precedence means a cold/warm signer succeeds regardless of
+     * whether this is supplied. Omit when `authority` is known to be cold or
+     * warm.
+     */
+    managerRole?: PublicKey;
+}
+export declare function createTripCircuitBreakerIx(args: TripCircuitBreakerArgs, programId?: PublicKey): TransactionInstruction;