@elemental-stv-core/sdk 0.9.3 → 0.12.0

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

@@ -18,6 +18,8 @@ export interface InitOrUpdateStvArgs {
     evMint: PublicKey;
     baseMint: PublicKey;
     vaultAta: PublicKey;
+    /** Canonical ATA for feeReceiver + evMint, pinned on STV. */
+    feeReceiverEvAta: PublicKey;
     tokenProgram: PublicKey;
     ataProgram?: PublicKey;
     systemProgram?: PublicKey;
@@ -37,6 +39,36 @@ export interface InitOrUpdateStvArgs {
     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`.
+     */
+    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.admin` post-create/migration.
+     * A pending admin has ZERO authority before accept.
+     */
+    pendingAdmin?: PublicKey;
     remainingAccounts?: AccountMeta[];
 }
 export declare function createInitOrUpdateStvIx(args: InitOrUpdateStvArgs, programId?: PublicKey): TransactionInstruction;
@@ -58,6 +90,12 @@ export interface DepositArgs {
     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;
@@ -84,11 +122,21 @@ export interface ClaimWithdrawArgs {
     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 {
@@ -101,10 +149,14 @@ export interface OverrideClaimWithdrawArgs {
     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 {
@@ -123,6 +175,24 @@ export interface ProcessEpochArgs {
     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;
@@ -163,6 +233,12 @@ export interface WithdrawFromStrategyArgs {
     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;
@@ -188,9 +264,11 @@ export interface AddManagerArgs {
 }
 export declare function createAddManagerIx(args: AddManagerArgs, programId?: PublicKey): TransactionInstruction;
 export interface RemoveManagerArgs {
+    /** Must be the per-vault admin (stv.admin). NOT the global config admin. */
     admin: PublicKey;
     payer: PublicKey;
-    config: PublicKey;
+    /** STV PDA — required for vault-admin auth check (stv.admin == admin). */
+    stv: PublicKey;
     managerRole: PublicKey;
 }
 export declare function createRemoveManagerIx(args: RemoveManagerArgs, programId?: PublicKey): TransactionInstruction;
@@ -211,24 +289,245 @@ export interface MigrateLendArgs {
     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, 4 accounts):
-     *     [newLendProgram, newStrategyState, newPositionPda, newBaseAta]
+     *   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 {
+    manager: PublicKey;
+    /** ManagerRole PDA for (sourceStv, manager). */
+    managerRole: 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 14). */
+    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;
+    /**
+     * 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.
+     */
+    remainingAccounts?: AccountMeta[];
+}
+/**
+ * 15 fixed accounts confirmed against migrate_execute.rs:87-91 (destructure)
+ * and the doc header at lines 29-52. Slot 14 = wrUserAccount (writable; must
+ * equal wr.user). Instruction data (4 bytes): src_protocol_aum_count,
+ * dst_protocol_aum_count, src_auto_unroute_count, dst_auto_route_count
+ * (migrate_execute.rs:94-100).
+ */
+export declare function createMigrateExecuteIx(args: MigrateExecuteArgs, 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 MigrateStvLayoutArgs {
+    /** Must match GlobalConfig.admin. */
+    admin: PublicKey;
+    /** GlobalConfig PDA. */
+    config: PublicKey;
+    /** The v1-shaped STV account to migrate (writable). */
+    stv: PublicKey;
+    /**
+     * Expected vault_id from the v1 account (guards against passing the wrong STV
+     * for a given arg set — the handler hard-reverts on mismatch).
+     */
+    expectedVaultId: BN | number;
+    /**
+     * Expected withdrawal_mode byte at the v1 offset (416). The handler validates
+     * this before the shuffle. Guards against stale ops scripts.
+     */
+    expectedOldWithdrawalMode: number;
+    /**
+     * Optional withdrawal_mode backfill. When provided, the handler applies
+     * queue-empty guards and instant-mode restrictions before writing the new mode
+     * at the v2 offset (464). When undefined/omitted, the shuffled v1 byte is preserved.
+     *
+     * Values: 0=instant, 1=X, 2=X+1.
+     */
+    newWithdrawalMode?: number;
+}
+export declare function createMigrateStvLayoutIx(args: MigrateStvLayoutArgs, 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;