@elemental-stv-core/sdk 0.9.3 → 0.11.0

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

@@ -56,7 +56,8 @@ function parseEventsFromLogs(logs, programId = constants_1.PROGRAM_ID) {
  *                               [47..55] vaultCapacity | [55..63] minDeposit |
  *                               [63..64] childVaultCount | [64..96] lendProgram
  *   Deposited                   [0..1] disc | [1..9]  vaultId    | [9..41]  user         |
- *                               [41..49] amount | [49..57] sharesMinted | [57..65] pps
+ *                               [41..49] amount | [49..57] sharesMinted | [57..65] depositFeeShares |
+ *                               [65..73] pps
  *   WithdrawRequested           [0..1] disc | [1..9]  vaultId    | [9..41]  user         |
  *                               [41..49] shares | [49..53] epochId
  *   WithdrawRequestIncreased    [0..1] disc | [1..9]  vaultId    | [9..41]  user         |
@@ -78,6 +79,10 @@ function parseEventsFromLogs(logs, programId = constants_1.PROGRAM_ID) {
  *   StvClosed                   [0..1] disc | [1..9]  vaultId
  *   ManagerAdded                [0..1] disc | [1..33] stv        | [33..65] manager
  *   ManagerRemoved              [0..1] disc | [1..33] stv        | [33..65] manager
+ *   DelayedDepositProcessed     [0..1] disc | [1..9] vaultId     | [9..41] user |
+ *                               [41..49] amount | [49..57] sharesMinted |
+ *                               [57..65] depositFeeShares | [65..73] pps |
+ *                               [73..77] requestEpochId
  */
 function parseEventBuffer(data) {
     if (data.length === 0)
@@ -103,9 +108,10 @@ function parseEventBuffer(data) {
                 childVaultCount: data[63], lendProgram: (0, buffer_1.readPubkey)(data, 64),
             } : null;
         case constants_1.EVT_DEPOSITED:
-            return data.length >= 65 ? {
+            return data.length >= 73 ? {
                 name: "Deposited", vaultId: (0, buffer_1.readU64)(data, 1), user: (0, buffer_1.readPubkey)(data, 9),
-                amount: (0, buffer_1.readU64)(data, 41), sharesMinted: (0, buffer_1.readU64)(data, 49), pps: (0, buffer_1.readU64)(data, 57),
+                amount: (0, buffer_1.readU64)(data, 41), sharesMinted: (0, buffer_1.readU64)(data, 49),
+                depositFeeShares: (0, buffer_1.readU64)(data, 57), pps: (0, buffer_1.readU64)(data, 65),
             } : null;
         case constants_1.EVT_WITHDRAW_REQUESTED:
             return data.length >= 53 ? {
@@ -118,9 +124,11 @@ function parseEventBuffer(data) {
                 additionalShares: (0, buffer_1.readU64)(data, 41), totalShares: (0, buffer_1.readU64)(data, 49), epochId: (0, buffer_1.readU32)(data, 57),
             } : null;
         case constants_1.EVT_WITHDRAW_CLAIMED:
-            return data.length >= 61 ? {
+            // Rust: vault_id(8), user(32), shares(8), net_base(8), withdrawal_fee_base(8), epoch_id(4)
+            return data.length >= 69 ? {
                 name: "WithdrawClaimed", vaultId: (0, buffer_1.readU64)(data, 1), user: (0, buffer_1.readPubkey)(data, 9),
-                shares: (0, buffer_1.readU64)(data, 41), baseAmount: (0, buffer_1.readU64)(data, 49), epochId: (0, buffer_1.readU32)(data, 57),
+                shares: (0, buffer_1.readU64)(data, 41), baseAmount: (0, buffer_1.readU64)(data, 49),
+                withdrawalFeeBase: (0, buffer_1.readU64)(data, 57), epochId: (0, buffer_1.readU32)(data, 65),
             } : null;
         case constants_1.EVT_DEPOSITED_TO_STRATEGY:
             return data.length >= 57 ? {
@@ -160,19 +168,50 @@ function parseEventBuffer(data) {
                 name: "ManagerRemoved", stv: (0, buffer_1.readPubkey)(data, 1), manager: (0, buffer_1.readPubkey)(data, 33),
             } : null;
         case constants_1.EVT_WITHDRAW_OVERRIDE_CLAIMED:
-            return data.length >= 109 ? {
+            // Rust: vault_id(8), manager(32), user(32), shares(8), net_base(8),
+            //       withdrawal_fee_base(8), epoch_id(4), daily_withdrawn(8), daily_limit(8)
+            return data.length >= 117 ? {
                 name: "WithdrawOverrideClaimed", vaultId: (0, buffer_1.readU64)(data, 1), manager: (0, buffer_1.readPubkey)(data, 9),
                 user: (0, buffer_1.readPubkey)(data, 41), shares: (0, buffer_1.readU64)(data, 73), baseAmount: (0, buffer_1.readU64)(data, 81),
-                epochId: (0, buffer_1.readU32)(data, 89), dailyWithdrawnBase: (0, buffer_1.readU64)(data, 93), dailyLimit: (0, buffer_1.readU64)(data, 101),
+                withdrawalFeeBase: (0, buffer_1.readU64)(data, 89), epochId: (0, buffer_1.readU32)(data, 97),
+                dailyWithdrawnBase: (0, buffer_1.readU64)(data, 101), dailyLimit: (0, buffer_1.readU64)(data, 109),
             } : null;
         case constants_1.EVT_LEND_MIGRATED:
             return data.length >= 89 ? {
                 name: "LendMigrated", vaultId: (0, buffer_1.readU64)(data, 1), oldLendProgram: (0, buffer_1.readPubkey)(data, 9),
                 newLendProgram: (0, buffer_1.readPubkey)(data, 41), sharesWithdrawn: (0, buffer_1.readU64)(data, 73), baseMigrated: (0, buffer_1.readU64)(data, 81),
             } : null;
-        case constants_1.EVT_VAULT_ATA_BACKFILLED:
-            return data.length >= 41 ? {
-                name: "VaultAtaBackfilled", vaultId: (0, buffer_1.readU64)(data, 1), vaultAta: (0, buffer_1.readPubkey)(data, 9),
+        case constants_1.EVT_MIGRATE_REQUESTED:
+            // Rust: src_vault_id(8), dest_vault_id(8), user(32), shares(8), epoch_id(4)
+            return data.length >= 61 ? {
+                name: "MigrateRequested", srcVaultId: (0, buffer_1.readU64)(data, 1), destVaultId: (0, buffer_1.readU64)(data, 9),
+                user: (0, buffer_1.readPubkey)(data, 17), shares: (0, buffer_1.readU64)(data, 49), epochId: (0, buffer_1.readU32)(data, 57),
+            } : null;
+        case constants_1.EVT_MIGRATE_EXECUTED:
+            // Rust: src_vault_id(8), dst_vault_id(8), user(32), shares_burned(8), base_moved(8),
+            //       withdrawal_fee_base(8), deposit_fee_base(8), user_dest_shares(8), epoch_id(4)
+            return data.length >= 93 ? {
+                name: "MigrateExecuted", srcVaultId: (0, buffer_1.readU64)(data, 1), destVaultId: (0, buffer_1.readU64)(data, 9),
+                user: (0, buffer_1.readPubkey)(data, 17), sharesBurned: (0, buffer_1.readU64)(data, 49), baseMoved: (0, buffer_1.readU64)(data, 57),
+                withdrawalFeeBase: (0, buffer_1.readU64)(data, 65), depositFeeBase: (0, buffer_1.readU64)(data, 73),
+                userDestShares: (0, buffer_1.readU64)(data, 81), epochId: (0, buffer_1.readU32)(data, 89),
+            } : null;
+        case constants_1.EVT_DELAYED_DEPOSIT_PROCESSED:
+            return data.length >= 77 ? {
+                name: "DelayedDepositProcessed", vaultId: (0, buffer_1.readU64)(data, 1), user: (0, buffer_1.readPubkey)(data, 9),
+                amount: (0, buffer_1.readU64)(data, 41), sharesMinted: (0, buffer_1.readU64)(data, 49),
+                depositFeeShares: (0, buffer_1.readU64)(data, 57), pps: (0, buffer_1.readU64)(data, 65),
+                requestEpochId: (0, buffer_1.readU32)(data, 73),
+            } : null;
+        case constants_1.EVT_INSTANT_WITHDRAWN:
+            return data.length >= 65 ? {
+                name: "InstantWithdrawn", vaultId: (0, buffer_1.readU64)(data, 1), user: (0, buffer_1.readPubkey)(data, 9),
+                shares: (0, buffer_1.readU64)(data, 41), netBase: (0, buffer_1.readU64)(data, 49),
+                withdrawalFeeBase: (0, buffer_1.readU64)(data, 57),
+            } : null;
+        case constants_1.EVT_STV_SEEDED:
+            return data.length >= 17 ? {
+                name: "StvSeeded", vaultId: (0, buffer_1.readU64)(data, 1), amount: (0, buffer_1.readU64)(data, 9),
             } : null;
         default:
             return null;

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,16 @@ 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;
     remainingAccounts?: AccountMeta[];
 }
 export declare function createInitOrUpdateStvIx(args: InitOrUpdateStvArgs, programId?: PublicKey): TransactionInstruction;
@@ -58,6 +70,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 +102,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 +129,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 +155,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 +213,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;
@@ -211,24 +267,211 @@ 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;