@percolatorct/sdk 1.0.0-beta.15 → 1.0.0-beta.16

package/dist/solana/slab.d.ts

@@ -0,0 +1,421 @@
+import { Connection, PublicKey } from "@solana/web3.js";
+/**
+ * Full slab layout descriptor. Returned by detectSlabLayout().
+ * All engine field offsets are relative to engineOff.
+ */
+export interface SlabLayout {
+    version: 0 | 1 | 2;
+    headerLen: number;
+    configOffset: number;
+    configLen: number;
+    reservedOff: number;
+    engineOff: number;
+    accountSize: number;
+    maxAccounts: number;
+    bitmapWords: number;
+    accountsOff: number;
+    engineInsuranceOff: number;
+    engineParamsOff: number;
+    paramsSize: number;
+    engineCurrentSlotOff: number;
+    engineFundingIndexOff: number;
+    engineLastFundingSlotOff: number;
+    engineFundingRateBpsOff: number;
+    engineMarkPriceOff: number;
+    engineLastCrankSlotOff: number;
+    engineMaxCrankStalenessOff: number;
+    engineTotalOiOff: number;
+    engineLongOiOff: number;
+    engineShortOiOff: number;
+    engineCTotOff: number;
+    enginePnlPosTotOff: number;
+    engineLiqCursorOff: number;
+    engineGcCursorOff: number;
+    engineLastSweepStartOff: number;
+    engineLastSweepCompleteOff: number;
+    engineCrankCursorOff: number;
+    engineSweepStartIdxOff: number;
+    engineLifetimeLiquidationsOff: number;
+    engineLifetimeForceClosesOff: number;
+    engineNetLpPosOff: number;
+    engineLpSumAbsOff: number;
+    engineLpMaxAbsOff: number;
+    engineLpMaxAbsSweepOff: number;
+    engineEmergencyOiModeOff: number;
+    engineEmergencyStartSlotOff: number;
+    engineLastBreakerSlotOff: number;
+    engineBitmapOff: number;
+    postBitmap: number;
+    acctOwnerOff: number;
+    hasInsuranceIsolation: boolean;
+    engineInsuranceIsolatedOff: number;
+    engineInsuranceIsolationBpsOff: number;
+}
+export declare const ENGINE_OFF = 600;
+export declare const ENGINE_MARK_PRICE_OFF = 400;
+/**
+ * V2 slab tier sizes (small and large) for discovery.
+ * V2 uses ENGINE_OFF=600, BITMAP_OFF=432, ACCOUNT_SIZE=248, postBitmap=18.
+ * Sizes overlap with V1D (postBitmap=2) — disambiguation requires reading the version field.
+ */
+export declare const SLAB_TIERS_V2: {
+    readonly small: {
+        readonly maxAccounts: 256;
+        readonly dataSize: 65088;
+        readonly label: "Small";
+        readonly description: "256 slots (V2 BPF intermediate)";
+    };
+    readonly large: {
+        readonly maxAccounts: 4096;
+        readonly dataSize: 1025568;
+        readonly label: "Large";
+        readonly description: "4,096 slots (V2 BPF intermediate)";
+    };
+};
+/**
+ * V1M slab tier sizes — mainnet-deployed V1 program (ESa89R5).
+ * ENGINE_OFF=640, BITMAP_OFF=726, ACCOUNT_SIZE=248, postBitmap=18.
+ * Expanded RiskParams (336 bytes) and trade_twap runtime fields.
+ * Confirmed by on-chain probing of slab 8NY7rvQ (SOL/USDC Perpetual, 257512 bytes).
+ */
+export declare const SLAB_TIERS_V1M: Record<string, {
+    maxAccounts: number;
+    dataSize: number;
+    label: string;
+    description: string;
+}>;
+/**
+ * V1M2 slab tier sizes — mainnet program rebuilt from main@4861c56 with 312-byte accounts.
+ * ENGINE_OFF=616, BITMAP_OFF=1008 (empirically verified from CCTegYZ...).
+ * Engine struct is layout-identical to V_ADL; differs only in engineOff (616 vs 624).
+ * Sizes are unique from V_ADL after the bitmap correction: medium=323312 vs V_ADL=323320.
+ */
+export declare const SLAB_TIERS_V1M2: Record<string, {
+    maxAccounts: number;
+    dataSize: number;
+    label: string;
+    description: string;
+}>;
+/**
+ * V_ADL slab tier sizes — PERC-8270/8271 ADL-upgraded program.
+ * ENGINE_OFF=624, BITMAP_OFF=1008, ACCOUNT_SIZE=312, postBitmap=18.
+ * New account layout adds ADL tracking fields (+64 bytes/account including alignment padding).
+ * BPF SLAB_LEN verified by cargo build-sbf in PERC-8271: large (4096) = 1288320 bytes.
+ */
+export declare const SLAB_TIERS_V_ADL: Record<string, {
+    maxAccounts: number;
+    dataSize: number;
+    label: string;
+    description: string;
+}>;
+/**
+ * V_SETDEXPOOL slab tier sizes — PERC-SetDexPool security fix.
+ * ENGINE_OFF=632, BITMAP_OFF=1008, ACCOUNT_SIZE=312, CONFIG_LEN=528.
+ * e.g. large (4096 accts) = 1288336 bytes.
+ */
+export declare const SLAB_TIERS_V_SETDEXPOOL: Record<string, {
+    maxAccounts: number;
+    dataSize: number;
+    label: string;
+    description: string;
+}>;
+/**
+ * V12_1 slab tier sizes — percolator-core v12.1 merge.
+ * ENGINE_OFF=648, BITMAP_OFF=1016, ACCOUNT_SIZE=320.
+ * Verified by cargo build-sbf compile-time assertions.
+ */
+export declare const SLAB_TIERS_V12_1: Record<string, {
+    maxAccounts: number;
+    dataSize: number;
+    label: string;
+    description: string;
+}>;
+/**
+ * V12_15 slab tier sizes — percolator v12.15 (engine+prog sync).
+ * ENGINE_OFF=624, BITMAP_OFF=862 (relative), ACCOUNT_SIZE=4400, postBitmap=18.
+ * MAX_ACCOUNTS default changed from 4096 to 2048. Verified SLAB_LEN=1,128,448 for small (256).
+ * Account layout completely redesigned with reserve cohort arrays.
+ */
+export declare const SLAB_TIERS_V12_15: Record<string, {
+    maxAccounts: number;
+    dataSize: number;
+    label: string;
+    description: string;
+}>;
+/**
+ * Detect the slab layout version from the raw account data length.
+ * Returns the full SlabLayout descriptor, or null if the size is unrecognised.
+ * Checks V12_15, V12_1, V_SETDEXPOOL, V1M2, V_ADL, V1M, V0, V1D, V1D-legacy, V1, and V1-legacy sizes.
+ *
+ * When `data` is provided and the size matches V1D, the version field at offset 8 is read
+ * to disambiguate V2 slabs (which produce identical sizes to V1D with postBitmap=2).
+ * V2 slabs have version===2 at offset 8 (u32 LE).
+ *
+ * @param dataLen - The slab account data length in bytes
+ * @param data    - Optional raw slab data for version-field disambiguation
+ */
+export declare function detectSlabLayout(dataLen: number, data?: Uint8Array): SlabLayout | null;
+/**
+ * Legacy detectLayout for backward compat.
+ * Returns { bitmapWords, accountsOff, maxAccounts } or null.
+ *
+ * GH#1238: previously recomputed accountsOff with hardcoded postBitmap=18, which gave a value
+ * 16 bytes too large for V1D slabs (which use postBitmap=2). Now delegates directly to the
+ * SlabLayout descriptor so each variant uses its own correct accountsOff.
+ */
+export declare function detectLayout(dataLen: number): {
+    bitmapWords: number;
+    accountsOff: number;
+    maxAccounts: number;
+} | null;
+export interface SlabHeader {
+    magic: bigint;
+    version: number;
+    bump: number;
+    flags: number;
+    resolved: boolean;
+    paused: boolean;
+    admin: PublicKey;
+    nonce: bigint;
+    lastThrUpdateSlot: bigint;
+}
+export interface MarketConfig {
+    collateralMint: PublicKey;
+    vaultPubkey: PublicKey;
+    indexFeedId: PublicKey;
+    maxStalenessSlots: bigint;
+    confFilterBps: number;
+    vaultAuthorityBump: number;
+    invert: number;
+    unitScale: number;
+    fundingHorizonSlots: bigint;
+    fundingKBps: bigint;
+    fundingInvScaleNotionalE6: bigint;
+    fundingMaxPremiumBps: bigint;
+    fundingMaxBpsPerSlot: bigint;
+    /** @deprecated Removed in V12_1 — always 0 */ fundingPremiumWeightBps: bigint;
+    /** @deprecated Removed in V12_1 — always 0 */ fundingSettlementIntervalSlots: bigint;
+    /** @deprecated Removed in V12_1 — always 0 */ fundingPremiumDampeningE6: bigint;
+    /** @deprecated Removed in V12_1 — always 0 */ fundingPremiumMaxBpsPerSlot: bigint;
+    threshFloor: bigint;
+    threshRiskBps: bigint;
+    threshUpdateIntervalSlots: bigint;
+    threshStepBps: bigint;
+    threshAlphaBps: bigint;
+    threshMin: bigint;
+    threshMax: bigint;
+    threshMinStep: bigint;
+    oracleAuthority: PublicKey;
+    authorityPriceE6: bigint;
+    authorityTimestamp: bigint;
+    oraclePriceCapE2bps: bigint;
+    lastEffectivePriceE6: bigint;
+    oiCapMultiplierBps: bigint;
+    maxPnlCap: bigint;
+    adaptiveFundingEnabled: boolean;
+    adaptiveScaleBps: number;
+    adaptiveMaxFundingBps: bigint;
+    marketCreatedSlot: bigint;
+    oiRampSlots: bigint;
+    resolvedSlot: bigint;
+    insuranceIsolationBps: number;
+    /** PERC-622: Oracle phase (0=Nascent, 1=Growing, 2=Mature) */
+    oraclePhase: number;
+    /** PERC-622: Cumulative trade volume in e6 format */
+    cumulativeVolumeE6: bigint;
+    /** PERC-622: Slots elapsed from market creation to Phase 2 entry (u24) */
+    phase2DeltaSlots: number;
+    /**
+     * PERC-SetDexPool: Admin-pinned DEX pool pubkey for HYPERP markets.
+     * Null when reading old slabs (pre-SetDexPool configLen < 528) or when
+     * SetDexPool has never been called (all-zero pubkey).
+     * Non-null means the program will reject any UpdateHyperpMark that passes
+     * a different pool account.
+     */
+    dexPool: PublicKey | null;
+}
+export interface InsuranceFund {
+    balance: bigint;
+    feeRevenue: bigint;
+    isolatedBalance: bigint;
+    isolationBps: number;
+}
+export interface RiskParams {
+    /**
+     * @deprecated Split into hMin/hMax in v12.15 RiskParams. On V12_15 slabs this field returns
+     * hMin for backwards compatibility. On pre-v12.15 slabs hMin/hMax both mirror this value.
+     */
+    warmupPeriodSlots: bigint;
+    maintenanceMarginBps: bigint;
+    initialMarginBps: bigint;
+    tradingFeeBps: bigint;
+    maxAccounts: bigint;
+    newAccountFee: bigint;
+    riskReductionThreshold: bigint;
+    maintenanceFeePerSlot: bigint;
+    maxCrankStalenessSlots: bigint;
+    liquidationFeeBps: bigint;
+    liquidationFeeCap: bigint;
+    liquidationBufferBps: bigint;
+    minLiquidationAbs: bigint;
+    /** Minimum horizon slots (v12.15+). Replaces warmupPeriodSlots. 0n on pre-v12.15 slabs. */
+    hMin: bigint;
+    /** Maximum horizon slots (v12.15+). 0n on pre-v12.15 slabs. */
+    hMax: bigint;
+}
+export interface EngineState {
+    vault: bigint;
+    insuranceFund: InsuranceFund;
+    currentSlot: bigint;
+    fundingIndexQpbE6: bigint;
+    lastFundingSlot: bigint;
+    /**
+     * Funding rate per slot. On pre-v12.15 slabs: i64 in BPS units.
+     * On v12.15+ slabs: i128 in e9 units (field renamed `funding_rate_e9` on-chain).
+     * Use `fundingRateE9` for v12.15-aware code.
+     */
+    fundingRateBpsPerSlotLast: bigint;
+    /**
+     * Funding rate in e9 units (i128). v12.15+ only.
+     * 0n on pre-v12.15 slabs (use `fundingRateBpsPerSlotLast` instead).
+     */
+    fundingRateE9: bigint;
+    /**
+     * Market mode. v12.15+ only.
+     * 0 = Live, 1 = Resolved. null on pre-v12.15 slabs.
+     */
+    marketMode: 0 | 1 | null;
+    lastCrankSlot: bigint;
+    maxCrankStalenessSlots: bigint;
+    totalOpenInterest: bigint;
+    longOi: bigint;
+    shortOi: bigint;
+    cTot: bigint;
+    pnlPosTot: bigint;
+    /**
+     * Matured (settled) positive PnL total (u128). v12.15+ only.
+     * 0n on pre-v12.15 slabs.
+     */
+    pnlMaturedPosTot: bigint;
+    liqCursor: number;
+    gcCursor: number;
+    lastSweepStartSlot: bigint;
+    lastSweepCompleteSlot: bigint;
+    crankCursor: number;
+    sweepStartIdx: number;
+    lifetimeLiquidations: bigint;
+    lifetimeForceCloses: bigint;
+    netLpPos: bigint;
+    lpSumAbs: bigint;
+    lpMaxAbs: bigint;
+    lpMaxAbsSweep: bigint;
+    emergencyOiMode: boolean;
+    emergencyStartSlot: bigint;
+    lastBreakerSlot: bigint;
+    numUsedAccounts: number;
+    nextAccountId: bigint;
+    markPriceE6: bigint;
+}
+export declare enum AccountKind {
+    User = 0,
+    LP = 1
+}
+/** Parsed reserve cohort (64 bytes on-chain). Raw bytes; structure is program-internal. */
+export type ReserveCohortBytes = Uint8Array;
+export interface Account {
+    kind: AccountKind;
+    accountId: bigint;
+    capital: bigint;
+    pnl: bigint;
+    reservedPnl: bigint;
+    /** @deprecated Removed in v12.15. Always 0n on V12_15 slabs. */
+    warmupStartedAtSlot: bigint;
+    /** @deprecated Removed in v12.15. Always 0n on V12_15 slabs. */
+    warmupSlopePerStep: bigint;
+    positionSize: bigint;
+    /** Entry price in e6 units. Present in V12_15 (offset 120) and V_ADL/V12_1_EP. -1 signals absent. */
+    entryPrice: bigint;
+    fundingIndex: bigint;
+    matcherProgram: PublicKey;
+    matcherContext: PublicKey;
+    owner: PublicKey;
+    feeCredits: bigint;
+    /** @deprecated Removed in v12.15. Always 0n on V12_15 slabs. */
+    lastFeeSlot: bigint;
+    /** Total fees earned over account lifetime (u128). Present from v12.15. 0n on older layouts. */
+    feesEarnedTotal: bigint;
+    /**
+     * Reserve cohorts array (v12.15+). Up to 62 cohorts of 64 bytes each.
+     * `null` on pre-v12.15 slabs. Parse the raw bytes according to the on-chain ReserveCohort struct.
+     */
+    exactReserveCohorts: ReserveCohortBytes[] | null;
+    /** Number of active reserve cohorts (0–62). null on pre-v12.15 slabs. */
+    exactCohortCount: number | null;
+    /** Overflow (oldest) cohort raw bytes. null on pre-v12.15 slabs or when not present. */
+    overflowOlder: ReserveCohortBytes | null;
+    /** True if overflowOlder contains valid data. null on pre-v12.15 slabs. */
+    overflowOlderPresent: boolean | null;
+    /** Overflow (newest) cohort raw bytes. null on pre-v12.15 slabs or when not present. */
+    overflowNewest: ReserveCohortBytes | null;
+    /** True if overflowNewest contains valid data. null on pre-v12.15 slabs. */
+    overflowNewestPresent: boolean | null;
+}
+export declare function fetchSlab(connection: Connection, slabPubkey: PublicKey): Promise<Uint8Array>;
+export declare const RAMP_START_BPS = 1000n;
+export declare const DEFAULT_OI_RAMP_SLOTS = 432000n;
+export declare function computeEffectiveOiCapBps(config: MarketConfig, currentSlot: bigint): bigint;
+export declare function readNonce(data: Uint8Array): bigint;
+export declare function readLastThrUpdateSlot(data: Uint8Array): bigint;
+/**
+ * Parse slab header (first 72 bytes — layout-independent).
+ */
+export declare function parseHeader(data: Uint8Array): SlabHeader;
+/**
+ * Parse market config. Layout-version aware.
+ * For V0 slabs, fields beyond the basic config are read if present in the data,
+ * otherwise defaults are returned.
+ *
+ * @param data - Slab data (may be a partial slice for discovery; pass layoutHint in that case)
+ * @param layoutHint - Pre-detected layout to use; if omitted, detected from data.length.
+ */
+export declare function parseConfig(data: Uint8Array, layoutHint?: SlabLayout | null): MarketConfig;
+/**
+ * Parse RiskParams from engine data. Layout-version aware.
+ * For V0 slabs, extended params (risk_threshold, maintenance_fee, etc.) are
+ * not present on-chain, so defaults (0) are returned.
+ *
+ * @param data - Slab data (may be a partial slice; pass layoutHint in that case)
+ * @param layoutHint - Pre-detected layout to use; if omitted, detected from data.length.
+ */
+export declare function parseParams(data: Uint8Array, layoutHint?: SlabLayout | null): RiskParams;
+/**
+ * Parse RiskEngine state (excluding accounts array). Layout-version aware.
+ */
+export declare function parseEngine(data: Uint8Array): EngineState;
+/**
+ * Read bitmap to get list of used account indices.
+ */
+/**
+ * Return all account indices whose bitmap bit is set (i.e. slot is in use).
+ * Uses the layout-aware bitmap offset so V1_LEGACY slabs (bitmap at rel+672) are handled correctly.
+ */
+export declare function parseUsedIndices(data: Uint8Array): number[];
+/**
+ * Check if a specific account index is used.
+ */
+export declare function isAccountUsed(data: Uint8Array, idx: number): boolean;
+/**
+ * Calculate the maximum valid account index for a given slab size.
+ */
+export declare function maxAccountIndex(dataLen: number): number;
+/**
+ * Parse a single account by index.
+ */
+export declare function parseAccount(data: Uint8Array, idx: number): Account;
+/**
+ * Parse all used accounts.
+ */
+export declare function parseAllAccounts(data: Uint8Array): {
+    idx: number;
+    account: Account;
+}[];

package/dist/solana/stake.d.ts

@@ -0,0 +1,216 @@
+/**
+ * @module stake
+ * Percolator Insurance LP Staking program — instruction encoders, PDA derivation, and account specs.
+ *
+ * Program: percolator-stake (dcccrypto/percolator-stake)
+ * Deployed devnet:  6aJb1F9CDCVWCNYFwj8aQsVb696YnW6J1FznteHq4Q6k
+ * Deployed mainnet: (pending deployment — DevOps must set STAKE_PROGRAM_ID env var or deploy and update STAKE_PROGRAM_IDS.mainnet)
+ */
+import { PublicKey } from '@solana/web3.js';
+/** Known stake program addresses per network. */
+export declare const STAKE_PROGRAM_IDS: {
+    readonly devnet: "6aJb1F9CDCVWCNYFwj8aQsVb696YnW6J1FznteHq4Q6k";
+    readonly mainnet: "DC5fovFQD5SZYsetwvEqd4Wi4PFY1Yfnc669VMe6oa7F";
+};
+/**
+ * Resolve the stake program ID for the given network.
+ *
+ * Priority:
+ *  1. STAKE_PROGRAM_ID env var (explicit override — DevOps sets this for mainnet until constant is filled)
+ *  2. Network-specific constant from STAKE_PROGRAM_IDS
+ *
+ * Throws a clear error on mainnet when no address is available so callers
+ * surface the gap instead of silently hitting the devnet program.
+ */
+export declare function getStakeProgramId(network?: 'devnet' | 'mainnet'): PublicKey;
+/**
+ * Default export — resolves for the current runtime network.
+ * Use getStakeProgramId() with an explicit network argument where possible.
+ *
+ * @deprecated Direct use of STAKE_PROGRAM_ID is being phased out in favour of
+ *   getStakeProgramId() so mainnet callers get a clear error rather than silently
+ *   resolving to the devnet address.
+ */
+export declare const STAKE_PROGRAM_ID: PublicKey;
+export declare const STAKE_IX: {
+    readonly InitPool: 0;
+    readonly Deposit: 1;
+    readonly Withdraw: 2;
+    readonly FlushToInsurance: 3;
+    readonly UpdateConfig: 4;
+    readonly TransferAdmin: 5;
+    readonly AdminSetOracleAuthority: 6;
+    readonly AdminSetRiskThreshold: 7;
+    readonly AdminSetMaintenanceFee: 8;
+    readonly AdminResolveMarket: 9;
+    readonly AdminWithdrawInsurance: 10;
+    readonly AdminSetInsurancePolicy: 11;
+    /** PERC-272: Accrue trading fees to LP vault */
+    readonly AccrueFees: 12;
+    /** PERC-272: Init pool in trading LP mode */
+    readonly InitTradingPool: 13;
+    /** PERC-313: Set HWM config (enable + floor bps) */
+    readonly AdminSetHwmConfig: 14;
+    /** PERC-303: Enable/configure senior-junior LP tranches */
+    readonly AdminSetTrancheConfig: 15;
+    /** PERC-303: Deposit into junior (first-loss) tranche */
+    readonly DepositJunior: 16;
+};
+/** Derive the stake pool PDA for a given slab (market). */
+export declare function deriveStakePool(slab: PublicKey, programId?: PublicKey): [PublicKey, number];
+/** Derive the vault authority PDA (signs CPI, owns LP mint + vault). */
+export declare function deriveStakeVaultAuth(pool: PublicKey, programId?: PublicKey): [PublicKey, number];
+/** Derive the per-user deposit PDA (tracks cooldown, deposit time). */
+export declare function deriveDepositPda(pool: PublicKey, user: PublicKey, programId?: PublicKey): [PublicKey, number];
+/** Tag 0: InitPool — create stake pool for a slab. */
+export declare function encodeStakeInitPool(cooldownSlots: bigint | number, depositCap: bigint | number): Uint8Array;
+/** Tag 1: Deposit — deposit collateral, receive LP tokens. */
+export declare function encodeStakeDeposit(amount: bigint | number): Uint8Array;
+/** Tag 2: Withdraw — burn LP tokens, receive collateral (subject to cooldown). */
+export declare function encodeStakeWithdraw(lpAmount: bigint | number): Uint8Array;
+/** Tag 3: FlushToInsurance — move collateral from stake vault to wrapper insurance. */
+export declare function encodeStakeFlushToInsurance(amount: bigint | number): Uint8Array;
+/** Tag 4: UpdateConfig — update cooldown and/or deposit cap. */
+export declare function encodeStakeUpdateConfig(newCooldownSlots?: bigint | number, newDepositCap?: bigint | number): Uint8Array;
+/** Tag 5: TransferAdmin — transfer wrapper admin to pool PDA. */
+export declare function encodeStakeTransferAdmin(): Uint8Array;
+/** Tag 6: AdminSetOracleAuthority — forward to wrapper via CPI. */
+export declare function encodeStakeAdminSetOracleAuthority(newAuthority: PublicKey): Uint8Array;
+/** Tag 7: AdminSetRiskThreshold — forward to wrapper via CPI. */
+export declare function encodeStakeAdminSetRiskThreshold(newThreshold: bigint | number): Uint8Array;
+/** Tag 8: AdminSetMaintenanceFee — forward to wrapper via CPI. */
+export declare function encodeStakeAdminSetMaintenanceFee(newFee: bigint | number): Uint8Array;
+/** Tag 9: AdminResolveMarket — forward to wrapper via CPI. */
+export declare function encodeStakeAdminResolveMarket(): Uint8Array;
+/** Tag 10: AdminWithdrawInsurance — withdraw insurance after market resolution. */
+export declare function encodeStakeAdminWithdrawInsurance(amount: bigint | number): Uint8Array;
+/** Tag 12: AccrueFees — permissionless: accrue trading fees to LP vault. */
+export declare function encodeStakeAccrueFees(): Uint8Array;
+/** Tag 13: InitTradingPool — create pool in trading LP mode (pool_mode = 1). */
+export declare function encodeStakeInitTradingPool(cooldownSlots: bigint | number, depositCap: bigint | number): Uint8Array;
+/** Tag 14 (PERC-313): AdminSetHwmConfig — enable HWM protection and set floor BPS. */
+export declare function encodeStakeAdminSetHwmConfig(enabled: boolean, hwmFloorBps: number): Uint8Array;
+/** Tag 15 (PERC-303): AdminSetTrancheConfig — enable senior/junior LP tranches. */
+export declare function encodeStakeAdminSetTrancheConfig(juniorFeeMultBps: number): Uint8Array;
+/** Tag 16 (PERC-303): DepositJunior — deposit into first-loss junior tranche. */
+export declare function encodeStakeDepositJunior(amount: bigint | number): Uint8Array;
+/** Tag 11: AdminSetInsurancePolicy — set withdrawal policy on wrapper. */
+export declare function encodeStakeAdminSetInsurancePolicy(authority: PublicKey, minWithdrawBase: bigint | number, maxWithdrawBps: number, cooldownSlots: bigint | number): Uint8Array;
+/**
+ * Decoded StakePool state (352 bytes on-chain).
+ * Includes PERC-272 (fee yield), PERC-313 (HWM), and PERC-303 (tranches).
+ */
+export interface StakePoolState {
+    isInitialized: boolean;
+    bump: number;
+    vaultAuthorityBump: number;
+    adminTransferred: boolean;
+    slab: PublicKey;
+    admin: PublicKey;
+    collateralMint: PublicKey;
+    lpMint: PublicKey;
+    vault: PublicKey;
+    totalDeposited: bigint;
+    totalLpSupply: bigint;
+    cooldownSlots: bigint;
+    depositCap: bigint;
+    totalFlushed: bigint;
+    totalReturned: bigint;
+    totalWithdrawn: bigint;
+    percolatorProgram: PublicKey;
+    totalFeesEarned: bigint;
+    lastFeeAccrualSlot: bigint;
+    lastVaultSnapshot: bigint;
+    poolMode: number;
+    hwmEnabled: boolean;
+    epochHighWaterTvl: bigint;
+    hwmFloorBps: number;
+    trancheEnabled: boolean;
+    juniorBalance: bigint;
+    juniorTotalLp: bigint;
+    juniorFeeMultBps: number;
+}
+/** Size of StakePool on-chain (bytes). */
+export declare const STAKE_POOL_SIZE = 352;
+/**
+ * Decode a StakePool account from raw data buffer. * Uses DataView for all u64/u16 reads — browser-safe.
+ */
+export declare function decodeStakePool(data: Uint8Array): StakePoolState;
+export interface StakeAccounts {
+    /** InitPool accounts */
+    initPool: {
+        admin: PublicKey;
+        slab: PublicKey;
+        pool: PublicKey;
+        lpMint: PublicKey;
+        vault: PublicKey;
+        vaultAuth: PublicKey;
+        collateralMint: PublicKey;
+        percolatorProgram: PublicKey;
+    };
+    /** Deposit accounts */
+    deposit: {
+        user: PublicKey;
+        pool: PublicKey;
+        userCollateralAta: PublicKey;
+        vault: PublicKey;
+        lpMint: PublicKey;
+        userLpAta: PublicKey;
+        vaultAuth: PublicKey;
+        depositPda: PublicKey;
+    };
+    /** Withdraw accounts */
+    withdraw: {
+        user: PublicKey;
+        pool: PublicKey;
+        userLpAta: PublicKey;
+        lpMint: PublicKey;
+        vault: PublicKey;
+        userCollateralAta: PublicKey;
+        vaultAuth: PublicKey;
+        depositPda: PublicKey;
+    };
+    /** FlushToInsurance accounts (CPI from stake → percolator) */
+    flushToInsurance: {
+        caller: PublicKey;
+        pool: PublicKey;
+        vault: PublicKey;
+        vaultAuth: PublicKey;
+        slab: PublicKey;
+        wrapperVault: PublicKey;
+        percolatorProgram: PublicKey;
+    };
+}
+/**
+ * Build account keys for InitPool instruction.
+ * Returns array of {pubkey, isSigner, isWritable} in the order the program expects.
+ */
+export declare function initPoolAccounts(a: StakeAccounts['initPool']): {
+    pubkey: PublicKey;
+    isSigner: boolean;
+    isWritable: boolean;
+}[];
+/**
+ * Build account keys for Deposit instruction.
+ */
+export declare function depositAccounts(a: StakeAccounts['deposit']): {
+    pubkey: PublicKey;
+    isSigner: boolean;
+    isWritable: boolean;
+}[];
+/**
+ * Build account keys for Withdraw instruction.
+ */
+export declare function withdrawAccounts(a: StakeAccounts['withdraw']): {
+    pubkey: PublicKey;
+    isSigner: boolean;
+    isWritable: boolean;
+}[];
+/**
+ * Build account keys for FlushToInsurance instruction.
+ */
+export declare function flushToInsuranceAccounts(a: StakeAccounts['flushToInsurance']): {
+    pubkey: PublicKey;
+    isSigner: boolean;
+    isWritable: boolean;
+}[];