@kestrelfi/lyc-sdk 1.0.1

package/dist/shared/oracle-service/src/oracle.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.oracle = exports.OracleService = void 0;
+const kit_1 = require("@solana/kit");
+const common_1 = require("common");
+const pyth_1 = require("./constants/pyth");
+const switchboard_1 = require("./constants/switchboard");
+const jupiter_1 = require("./feeds/jupiter");
+const pyth_2 = require("./feeds/pyth");
+const switchboard_2 = require("./feeds/switchboard");
+const custom_1 = require("./feeds/custom");
+const utils_1 = require("./utils");
+class OracleService {
+    constructor() {
+        this.jupiter = new jupiter_1.JupiterPrices();
+        this.pyth = new pyth_2.PythPrices();
+        this.switchboard = new switchboard_2.SwitchboardPrices();
+        this.custom = new custom_1.CustomPrices();
+    }
+    /**
+     * Register a custom oracle for a given mint.
+     * Custom-registered mints take priority over all other oracle sources.
+     */
+    registerCustomOracle(mint, oracle) {
+        this.custom.registerCustomOracle(mint, oracle);
+    }
+    getOracleData(mint) {
+        const customOracle = this.custom.getCustomOracle(mint);
+        if (customOracle) {
+            return {
+                oracle: customOracle.oracle,
+                oracleType: customOracle.oracleType,
+                secondaryOracle: customOracle.secondaryOracle,
+            };
+        }
+        const symbol = common_1.mints.get(mint)?.symbol;
+        const pythSymbol = symbol ? (0, common_1.findKeyIgnoreCase)(pyth_1.PYTH_FEEDS, symbol) : undefined;
+        const switchboardSymbol = symbol
+            ? (0, common_1.findKeyIgnoreCase)(switchboard_1.SWITCHBOARD_PRICE_FEED_IDS, symbol)
+            : undefined;
+        return {
+            oracle: pythSymbol
+                ? pyth_1.PYTH_FEEDS[pythSymbol].account
+                : (0, kit_1.address)(switchboard_1.SWITCHBOARD_PRICE_FEED_IDS[switchboardSymbol].feedId),
+            oracleType: pythSymbol ? common_1.OracleType.Pyth : common_1.OracleType.Switchboard,
+            secondaryOracle: undefined,
+        };
+    }
+    clearCache() {
+        this.jupiter.dataCache.clearAllCache();
+        this.pyth.dataCache.clearAllCache();
+        this.switchboard.dataCache.clearAllCache();
+        this.custom.dataCache.clearAllCache();
+    }
+    async fetchPrices(mints, mode, bypassCache, environment = common_1.ENVIRONMENT) {
+        if (!mints.length) {
+            return {};
+        }
+        const rpcUrl = (0, common_1.getRpcUrl)(environment);
+        const customMints = [];
+        const pythMints = [];
+        const switchboardMints = [];
+        const jupiterMints = [];
+        for (const mint of mints) {
+            if (this.custom.hasCustomOracle(mint)) {
+                customMints.push(mint);
+            }
+            else {
+                const symbol = common_1.mints.get(mint)?.symbol;
+                if (symbol && (0, common_1.findKeyIgnoreCase)(pyth_1.PYTH_FEEDS, symbol)) {
+                    pythMints.push(mint);
+                }
+                else if (symbol && (0, common_1.findKeyIgnoreCase)(switchboard_1.SWITCHBOARD_PRICE_FEED_IDS, symbol)) {
+                    switchboardMints.push(mint);
+                }
+                else {
+                    jupiterMints.push(mint);
+                }
+            }
+        }
+        const [customPrices, pythPrices, switchboardPrices, jupiterPrices] = await Promise.all([
+            customMints.length ? this.custom.fetchPrices(customMints, bypassCache, { rpcUrl }) : {},
+            pythMints.length ? this.pyth.fetchPrices(pythMints, bypassCache) : {},
+            switchboardMints.length ? this.switchboard.fetchPrices(switchboardMints, bypassCache) : {},
+            jupiterMints.length ? this.jupiter.fetchPrices(jupiterMints, bypassCache) : {},
+        ]);
+        const toNumber = (result) => mode === "realtime" ? result.realtimePrice : (result.emaPrice ?? result.realtimePrice);
+        const prices = {};
+        for (const mint of mints) {
+            const price = toNumber(customPrices[mint] ??
+                pythPrices[mint] ??
+                switchboardPrices[mint] ??
+                jupiterPrices[mint]);
+            const isStablecoin = common_1.mints.get(mint)?.assetType === "Stablecoin";
+            prices[mint] = isStablecoin ? Math.min(price, 1) : price;
+        }
+        return prices;
+    }
+}
+exports.OracleService = OracleService;
+exports.oracle = new OracleService();
+(0, utils_1.registerUsdStarOracle)(exports.oracle);
+(0, utils_1.registerUsdStarJuniorOracle)(exports.oracle);
+(0, utils_1.registerDfdvSolOracle)(exports.oracle);

package/dist/shared/oracle-service/src/types.d.ts

@@ -0,0 +1,4 @@
+export interface PriceResult {
+    realtimePrice: number;
+    emaPrice?: number;
+}

package/dist/shared/oracle-service/src/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/shared/oracle-service/src/utils/general.d.ts

@@ -0,0 +1,20 @@
+import { OracleService } from "../oracle";
+import { SplStakeLstConfig } from "../feeds/splStake";
+export declare function pythRequest(feedIds: string[]): Promise<Response>;
+export declare function registerUsdStarOracle(oracle: OracleService): void;
+/**
+ * Register the Perena USD*-J oracle on an OracleService instance.
+ */
+export declare function registerUsdStarJuniorOracle(oracle: OracleService): void;
+/**
+ * Register an SPL-stake LST oracle (e.g. dfdvSOL) on an OracleService instance.
+ *
+ * Prices the LST as `min(stake_rate × SOL/USD, 1.1 × SOL/USD)`, matching
+ * Kamino/Scope and the on-chain `PythSplStake` oracle. The primary oracle is
+ * the Pyth SOL/USD feed; the SPL stake pool account is the secondary oracle.
+ */
+export declare function registerSplStakeLstOracle(oracle: OracleService, config: SplStakeLstConfig): void;
+/**
+ * Register the dfdvSOL oracle on an OracleService instance.
+ */
+export declare function registerDfdvSolOracle(oracle: OracleService): void;

package/dist/shared/oracle-service/src/utils/general.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pythRequest = pythRequest;
+exports.registerUsdStarOracle = registerUsdStarOracle;
+exports.registerUsdStarJuniorOracle = registerUsdStarJuniorOracle;
+exports.registerSplStakeLstOracle = registerSplStakeLstOracle;
+exports.registerDfdvSolOracle = registerDfdvSolOracle;
+const perena_helpers_1 = require("perena-helpers");
+const common_1 = require("common");
+const splStake_1 = require("../feeds/splStake");
+const pyth_1 = require("../constants/pyth");
+const splStake_2 = require("../constants/splStake");
+async function pythRequest(feedIds) {
+    return await (0, common_1.fetchWithRetry)(`https://hermes.pyth.network/v2/updates/price/latest?${feedIds
+        .map((x) => `ids%5B%5D=${x}`)
+        .join("&")}`);
+}
+/**
+ * Register the Perena USD* oracle on an OracleService instance.
+ */
+/** Static Perena oracle account addresses (PDAs; independent of RPC endpoint). */
+const perenaOracleAccounts = new perena_helpers_1.PerenaClient((0, common_1.getMainnetRpcUrl)());
+function registerUsdStarOracle(oracle) {
+    oracle.registerCustomOracle("USD*", {
+        priceFetcher: (rpcUrl) => new perena_helpers_1.PerenaClient(rpcUrl).getLatestBankMintUiPrice(),
+        oracle: (0, common_1.fromWeb3Pk)(perenaOracleAccounts.sdkClient.bank),
+        oracleType: common_1.OracleType.PerenaBank,
+    });
+}
+/**
+ * Register the Perena USD*-J oracle on an OracleService instance.
+ */
+function registerUsdStarJuniorOracle(oracle) {
+    oracle.registerCustomOracle("USD*-J", {
+        priceFetcher: (rpcUrl) => new perena_helpers_1.PerenaClient(rpcUrl).getLatestJuniorMintUiPrice(),
+        oracle: (0, common_1.fromWeb3Pk)(perenaOracleAccounts.sdkClient.tranche),
+        oracleType: common_1.OracleType.PerenaTranche,
+    });
+}
+/**
+ * Register an SPL-stake LST oracle (e.g. dfdvSOL) on an OracleService instance.
+ *
+ * Prices the LST as `min(stake_rate × SOL/USD, 1.1 × SOL/USD)`, matching
+ * Kamino/Scope and the on-chain `PythSplStake` oracle. The primary oracle is
+ * the Pyth SOL/USD feed; the SPL stake pool account is the secondary oracle.
+ */
+function registerSplStakeLstOracle(oracle, config) {
+    oracle.registerCustomOracle(config.mint, {
+        priceFetcher: (rpcUrl) => (0, splStake_1.getSplStakeLstUiPrice)(rpcUrl, config),
+        oracle: config.pythSolFeed.account,
+        oracleType: common_1.OracleType.PythSplStake,
+        secondaryOracle: config.stakePool,
+    });
+}
+/**
+ * Register the dfdvSOL oracle on an OracleService instance.
+ */
+function registerDfdvSolOracle(oracle) {
+    const dfdvSol = common_1.mints.get("dfdvSOL");
+    registerSplStakeLstOracle(oracle, {
+        mint: dfdvSol.address,
+        stakePool: splStake_2.DFDVSOL_STAKE_POOL,
+        pythSolFeed: pyth_1.PYTH_FEEDS.SOL,
+    });
+}

package/dist/shared/oracle-service/src/utils/index.d.ts

@@ -0,0 +1 @@
+export * from "./general";

package/dist/shared/oracle-service/src/utils/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./general"), exports);

package/dist/shared/perena-helpers/src/accounts.d.ts

@@ -0,0 +1,7 @@
+import type { Address } from "@solana/kit";
+import type { PerenaClient } from "./client";
+/**
+ * Derives the ATA that holds locked junior shares during unstaking, owned
+ * by the tranche state PDA.
+ */
+export declare function getLockedJuniorSharesAta(perenaClient: PerenaClient): Promise<Address>;

package/dist/shared/perena-helpers/src/accounts.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLockedJuniorSharesAta = getLockedJuniorSharesAta;
+const common_1 = require("common");
+/**
+ * Derives the ATA that holds locked junior shares during unstaking, owned
+ * by the tranche state PDA.
+ */
+async function getLockedJuniorSharesAta(perenaClient) {
+    const trancheOwner = (0, common_1.fromWeb3Pk)(perenaClient.sdkClient.bankineco.tranchePDA(perenaClient.sdkClient.bank));
+    return (0, common_1.getAtaAddress)(perenaClient.juniorMint, trancheOwner, common_1.mints.get("USD*").tokenProgram);
+}

package/dist/shared/perena-helpers/src/client.d.ts

@@ -0,0 +1,299 @@
+import { BN } from "@anchor-lang/core";
+import type { Address } from "@solana/kit";
+import { UsdStarClient, type YieldingToBankMintQuoteRes, type BankMintToYieldingQuoteRes, type FetchUnstakeFeeRes } from "@perena/bankineco-sdk";
+import { RoutableSwapClient, SwapQuoteParams, SwapQuote, SwapQuoteCoveringMinOutputParams, SwapInstructionOptions, type TransactionCacheInvalidation, type TokenProtocolClient, type TokenProtocolInfo, CpiData } from "common";
+/**
+ * Raw quote data from Perena SDK.
+ *
+ * Discriminated by `operation`:
+ * - `mint`: yielding → USD* (e.g. USDC → USD*)
+ * - `burn`: USD* → yielding (e.g. USD* → USDC)
+ * - `stake`: USD* → USD*-J
+ * - `unstake`: USD*-J → USD* or yielding (instant, single-tx)
+ * - `request_unstake`: USD*-J → withdrawal queue (lockup period)
+ * - `fulfill_unstake`: withdrawal queue → USD* or yielding (after lockup)
+ */
+export type PerenaRawQuote = {
+    operation: "mint";
+    yieldingMint: Address;
+    sdkQuote: YieldingToBankMintQuoteRes;
+} | {
+    operation: "burn";
+    yieldingMint: Address;
+    sdkQuote: BankMintToYieldingQuoteRes;
+} | {
+    operation: "stake";
+} | {
+    operation: "unstake";
+    targetMint?: Address;
+    unstakeFee: FetchUnstakeFeeRes;
+} | {
+    operation: "request_unstake";
+    targetMint?: Address;
+    unstakeFee: FetchUnstakeFeeRes;
+    queueId: number;
+    payer: Address;
+} | {
+    operation: "fulfill_unstake";
+    withdrawalQueue: Address;
+    queuePayer: Address;
+    owner: Address;
+    targetMint?: Address;
+};
+/** Perena-specific swap quote with typed rawQuote */
+export type PerenaSwapQuote = SwapQuote<PerenaRawQuote>;
+/** Parameters for building a request_unstake_junior CPI. */
+export interface RequestUnstakeParams {
+    /** Number of junior shares to lock */
+    shares: BN | number;
+    /** Queue slot id (0–255), unique per user per bank */
+    queueId: number;
+    /** Address that acts as the user/signer for the unstake */
+    userPublicKey: Address;
+    /** Address that pays rent for the withdrawal queue PDA (often same as user) */
+    payer: Address;
+    /** Optional yielding mint to receive upon fulfillment. Defaults to USD*. */
+    targetMint?: Address;
+}
+/** Parameters for building a fulfill_unstake_junior CPI. */
+export interface FulfillUnstakeParams {
+    /** Address of the withdrawal queue PDA */
+    withdrawalQueue: Address;
+    /** The signer executing the fulfillment (queue owner or fulfiller) */
+    signer: Address;
+    /** The original payer who funded the queue rent (receives refund) */
+    queuePayer: Address;
+    /** The queue owner (needed to derive owner_bank_mint_ata) */
+    owner: Address;
+    /** Optional yielding mint — if the queue's target_mint is a yielding mint */
+    targetMint?: Address;
+}
+/**
+ * Perena USD* client implementing RoutableSwapClient and TokenProtocolClient.
+ *
+ * Provides a unified API for:
+ * - Minting and burning USD*
+ * - Querying protocol capabilities and info (YieldProtocolClient interface)
+ *
+ * @example
+ * ```typescript
+ * import { PerenaClient } from "perena-helpers";
+ * import { defaultMints } from "common/services/mints";
+ *
+ * const client = new PerenaClient(rpcUrl);
+ * const usdc = defaultMints.get("USDC")!;
+ * const usdStar = defaultMints.get("USD*")!;
+ *
+ * // Mint: USDC → USD*
+ * const mintQuote = await client.getQuote({
+ *   inputMint: usdc.address,
+ *   outputMint: usdStar.address,
+ *   amount: 10_000_000, // 10 USDC
+ *   slippageBps: 100,
+ * });
+ *
+ * // Burn: USD* → USDC
+ * const burnQuote = await client.getQuote({
+ *   inputMint: usdStar.address,
+ *   outputMint: usdc.address,
+ *   amount: 10_000_000, // 10 USD*
+ *   slippageBps: 100,
+ * });
+ *
+ * // Get CPI accounts for instruction
+ * const { accounts, programId } = await client.getSwapCpiData(
+ *   mintQuote,
+ *   userPda
+ * );
+ * ```
+ */
+export declare class PerenaClient implements RoutableSwapClient<PerenaRawQuote>, TokenProtocolClient {
+    readonly sdkClient: UsdStarClient;
+    private readonly cache;
+    /**
+     * The bank mint (USD*).
+     */
+    readonly bankMint: Address;
+    /**
+     * The junior tranche token (USD*-J).
+     */
+    readonly juniorMint: Address;
+    /**
+     * Mints that can appear on either side of a Perena-routed swap (USD*, USD*-J,
+     * and idle vault yielding mints). Same reference as {@link outputMints}.
+     */
+    readonly inputMints: readonly Address[];
+    /**
+     * Same as {@link inputMints} — Perena routes are symmetric in terms of
+     * allowed mints; {@link routeAnchorMints} encodes the “must touch USD* or USD*-J” rule.
+     */
+    readonly outputMints: readonly Address[];
+    /**
+     * A valid route must involve at least one of USD* or USD*-J (prevents e.g. USDC↔USDT).
+     */
+    readonly routeAnchorMints: readonly Address[];
+    /**
+     * Creates a new Perena client.
+     *
+     * @param rpcUrl - Solana RPC URL
+     */
+    constructor(rpcUrl: string);
+    /**
+     * Get mints that can directly mint USD*.
+     */
+    getSupportedSourceMints(): Promise<Address[]>;
+    /**
+     * Get current protocol info for a source mint.
+     * @param sourceMint - The source mint to get info for (i.e. USDC, USDT, etc.)
+     * @returns Protocol info including fees and limits
+     * @throws Error if sourceMint is not supported by Perena
+     */
+    getProtocolInfo(sourceMint: Address): Promise<TokenProtocolInfo>;
+    /**
+     * Get the latest USD* price in UI units (e.g. dollars).
+     *
+     * @returns The current bank mint price as a number
+     */
+    getLatestBankMintUiPrice(): Promise<number>;
+    /**
+     * Get the latest USD*-J price in UI units (e.g. dollars).
+     *
+     * @returns The current junior mint price as a number
+     */
+    getLatestJuniorMintUiPrice(): Promise<number>;
+    /**
+     * Size a USD* burn so the routed yielding output (e.g. USDC) is at least
+     * `minYieldingOut` base units, without scanning inputs.
+     *
+     * Perena's `bankMintToYieldingQuote` is linear in the burn amount for fixed
+     * oracles: bank-mint price, yielding price, burn fee bps, and decimal
+     * rescales are all proportional in `amountToBurn`. We take **one** reference
+     * quote at exactly 1.0 bank-mint token (10^decimals base units) to read the
+     * effective `yieldingOut / bankMintIn` rate implied by the current prices,
+     * then `ceil(need * refIn / refOut)` and re-quote once at that input so the
+     * returned {@link PerenaSwapQuote} matches the CPI.
+     */
+    /**
+     * @deprecated Prefer {@link getQuoteCoveringMinOutput} — same behavior with generic param names.
+     */
+    getQuoteCoveringYieldingOut(params: {
+        inputMint: Address;
+        outputMint: Address;
+        minYieldingOut: bigint;
+        maxBankMintIn: bigint;
+        slippageBps?: number;
+    }): Promise<PerenaSwapQuote>;
+    getQuoteCoveringMinOutput(params: SwapQuoteCoveringMinOutputParams): Promise<PerenaSwapQuote>;
+    /**
+     * Get a quote for minting/burning USD* or staking/unstaking USD*-J.
+     *
+     * The operation is determined by the mints:
+     * - outputMint is USD*: mint (yielding → USD*)
+     * - inputMint is USD*: burn (USD* → yielding)
+     * - outputMint is USD*-J: stake (USD* → USD*-J)
+     * - inputMint is USD*-J: unstake (USD*-J → USD* or yielding)
+     *
+     * @param params - Quote parameters
+     * @returns Normalized swap quote
+     * @throws Error if the mint pair is not supported
+     */
+    getQuote(params: SwapQuoteParams): Promise<PerenaSwapQuote>;
+    /**
+     * Quote for staking USD* → USD*-J.
+     *
+     * Shares minted = amount × bankMintPrice / sharePrice.
+     * Staking has no fee; the on-chain conversion is deterministic.
+     */
+    private getStakeQuote;
+    /**
+     * Quote for unstaking USD*-J → USD* or yielding mint.
+     *
+     * Uses `fetchUnstakeFee` with `early: true` because instant unstake
+     * always applies the early fee.
+     */
+    private getUnstakeQuote;
+    /**
+     * Get CPI accounts for a Perena instruction.
+     *
+     * Account order matches the IDL for the respective instruction.
+     *
+     * @param quote - Quote from getQuote()
+     * @param userPublicKey - Address that will execute the swap (can be a PDA)
+     * @param options - Options on building the CPI
+     * @returns CPI accounts, program ID, and serialized instruction data
+     */
+    getSwapCpiData(quote: PerenaSwapQuote, userPublicKey: Address, _options?: SwapInstructionOptions): Promise<CpiData>;
+    /**
+     * Derive the withdrawal queue PDA for a given user and queue slot.
+     */
+    deriveWithdrawalQueue(user: Address, queueId: number): Address;
+    /**
+     * Fetch all active withdrawal queue PDAs owned by `user`.
+     *
+     * "Active" means the queue account exists, is owned by Perena, and currently
+     * holds a non-zero locked amount.
+     */
+    getActiveWithdrawalQueues(user: Address): Promise<Address[]>;
+    /**
+     * Cache invalidation descriptor for the active-withdrawal-queues snapshot of
+     * one owner. Use this when a transaction may create, consume, or otherwise
+     * mutate Perena withdrawal queues outside this exact client instance.
+     */
+    getActiveWithdrawalQueuesCacheInvalidation(owner: Address): TransactionCacheInvalidation;
+    private getActiveWithdrawalQueuesInvalidation;
+    /**
+     * Build CPI data for mint_w_yielding_gen or burn_for_yielding_gen.
+     */
+    private getMintBurnCpiData;
+    /**
+     * Build CPI data for stake_junior.
+     *
+     * Account order matches the IDL:
+     *   user, tranche_state, bank_state, bank_mint, junior_mint,
+     *   user_bank_mint_ata, user_junior_mint_ata, junior_escrow_ata,
+     *   system_program, token_program, associated_token_program
+     */
+    private getStakeCpiData;
+    /**
+     * Build CPI data for instant_unstake_junior.
+     *
+     * Account order matches the IDL:
+     *   user, tranche_state, bank_state, bank_mint, target_mint, junior_mint,
+     *   user_junior_mint_ata, owner_bank_mint_ata, junior_escrow_ata,
+     *   locked_junior_shares_ata, token_program,
+     *   [vault_state, vault_oracle_state, vault_team_state, yielding_mint,
+     *    yielding_vault_ata, owner_yielding_ta, vault_fee_team_ata,
+     *    yielding_mint_program]  (optional, when unstaking to a yielding mint)
+     */
+    private getInstantUnstakeCpiData;
+    /**
+     * Build CPI data for request_unstake_junior.
+     *
+     * Account order matches the IDL:
+     *   user, payer, withdrawal_queue, tranche_state, bank_state, bank_mint,
+     *   target_mint, junior_mint, user_junior_mint_ata, locked_junior_shares_ata,
+     *   system_program, token_program
+     */
+    getRequestUnstakeCpiData(params: RequestUnstakeParams): Promise<CpiData>;
+    /**
+     * Build CPI data for fulfill_unstake_junior.
+     *
+     * Account order matches the IDL:
+     *   signer, queue_payer, withdrawal_queue, tranche_state, bank_state,
+     *   bank_mint, junior_mint, owner_bank_mint_ata, junior_escrow_ata,
+     *   locked_junior_shares_ata, token_program,
+     *   [vault_state, vault_oracle_state, vault_team_state, yielding_mint,
+     *    yielding_vault_ata, owner_yielding_ta, vault_fee_team_ata,
+     *    yielding_mint_program]  (optional, when fulfilling to a yielding mint)
+     */
+    getFulfillUnstakeCpiData(params: FulfillUnstakeParams): Promise<CpiData>;
+    /**
+     * Appends the 8 yielding-redemption account slots that `instant_unstake_junior`
+     * and `fulfill_unstake_junior` expect after `token_program`.
+     *
+     * When a yielding mint is involved, real accounts are pushed. Otherwise Anchor
+     * still requires all 8 slots to be present — each set to the program ID as the
+     * `Option<Account>` sentinel for `None`.
+     */
+    private pushYieldingRedemptionAccounts;
+}