@percolatorct/sdk 0.5.1 → 1.0.0-beta.10

package/dist/index.js

@@ -93,6 +93,7 @@ function concatBytes(...arrays) {
 }
 
 // src/abi/instructions.ts
+var MAX_ORACLE_PRICE = 1000000000000n;
 var IX_TAG = {
   InitMarket: 0,
   InitUser: 1,
@@ -116,16 +117,33 @@ var IX_TAG = {
   ResolveMarket: 19,
   WithdrawInsurance: 20,
   AdminForceClose: 21,
+  // Tags 22-23: on-chain these are SetInsuranceWithdrawPolicy / WithdrawInsuranceLimited.
+  // Legacy aliases (UpdateRiskParams/RenounceAdmin) kept for backward compat.
+  SetInsuranceWithdrawPolicy: 22,
+  /** @deprecated Use SetInsuranceWithdrawPolicy */
   UpdateRiskParams: 22,
+  WithdrawInsuranceLimited: 23,
+  /** @deprecated Use WithdrawInsuranceLimited */
   RenounceAdmin: 23,
-  CreateInsuranceMint: 24,
-  DepositInsuranceLP: 25,
-  WithdrawInsuranceLP: 26,
+  // Tags 24–26: on-chain = QueryLpFees/ReclaimEmptyAccount/SettleAccount.
+  // Old insurance LP tags removed — those moved to percolator-stake.
+  QueryLpFees: 24,
+  ReclaimEmptyAccount: 25,
+  SettleAccount: 26,
+  // Tags 27-28: on-chain = DepositFeeCredits/ConvertReleasedPnl.
+  // Legacy aliases (PauseMarket/UnpauseMarket) kept — those instructions don't exist on-chain.
+  DepositFeeCredits: 27,
+  /** @deprecated No on-chain PauseMarket instruction */
   PauseMarket: 27,
+  ConvertReleasedPnl: 28,
+  /** @deprecated No on-chain UnpauseMarket instruction */
   UnpauseMarket: 28,
+  // Tags 29-30: on-chain = ResolvePermissionless/ForceCloseResolved.
+  ResolvePermissionless: 29,
+  /** @deprecated Use ResolvePermissionless */
   AcceptAdmin: 29,
-  SetInsuranceWithdrawPolicy: 30,
-  WithdrawInsuranceLimited: 31,
+  ForceCloseResolved: 30,
+  // Tag 31: gap (no decode arm on-chain)
   SetPythOracle: 32,
   UpdateMarkPrice: 33,
   UpdateHyperpMark: 34,
@@ -199,8 +217,17 @@ var IX_TAG = {
   /** PERC-8111: Set per-wallet position cap (admin only, cap_e6=0 disables). */
   SetWalletCap: 70,
   /** PERC-8110: Set OI imbalance hard-block threshold (admin only). */
-  SetOiImbalanceHardBlock: 71
+  SetOiImbalanceHardBlock: 71,
+  /** PERC-8270: Rescue orphan vault — recover tokens from a closed market's vault (admin). */
+  RescueOrphanVault: 72,
+  /** PERC-8270: Close orphan slab — reclaim rent from a slab whose market closed unexpectedly (admin). */
+  CloseOrphanSlab: 73,
+  /** PERC-SetDexPool: Pin admin-approved DEX pool address for a HYPERP market (admin). */
+  SetDexPool: 74,
+  /** CPI to the matcher program to initialize a matcher context account for an LP slot. Admin-only. */
+  InitMatcherCtx: 75
 };
+Object.freeze(IX_TAG);
 var HEX_RE = /^[0-9a-fA-F]{64}$/;
 function encodeFeedId(feedId) {
   const hex = feedId.startsWith("0x") ? feedId.slice(2) : feedId;
@@ -211,11 +238,17 @@ function encodeFeedId(feedId) {
   }
   const bytes = new Uint8Array(32);
   for (let i = 0; i < 64; i += 2) {
-    bytes[i / 2] = parseInt(hex.substring(i, i + 2), 16);
+    const byte = parseInt(hex.substring(i, i + 2), 16);
+    if (Number.isNaN(byte)) {
+      throw new Error(
+        `Failed to parse hex byte at position ${i}: "${hex.substring(i, i + 2)}"`
+      );
+    }
+    bytes[i / 2] = byte;
   }
   return bytes;
 }
-var INIT_MARKET_DATA_LEN = 264;
+var INIT_MARKET_DATA_LEN = 352;
 function encodeInitMarket(args) {
   const data = concatBytes(
     encU8(IX_TAG.InitMarket),
@@ -227,6 +260,11 @@ function encodeInitMarket(args) {
     encU8(args.invert),
     encU32(args.unitScale),
     encU64(args.initialMarkPriceE6),
+    // 3 fields between header and RiskParams (immutable after init)
+    encU128(args.maxMaintenanceFeePerSlot ?? 0n),
+    encU128(args.maxInsuranceFloor ?? 0n),
+    encU64(args.minOraclePriceCap ?? 0n),
+    // RiskParams block (15 fields)
     encU64(args.warmupPeriodSlots),
     encU64(args.maintenanceMarginBps),
     encU64(args.initialMarginBps),
@@ -239,7 +277,10 @@ function encodeInitMarket(args) {
     encU64(args.liquidationFeeBps),
     encU128(args.liquidationFeeCap),
     encU64(args.liquidationBufferBps),
-    encU128(args.minLiquidationAbs)
+    encU128(args.minLiquidationAbs),
+    encU128(args.minInitialDeposit),
+    encU128(args.minNonzeroMmReq),
+    encU128(args.minNonzeroImReq)
   );
   if (data.length !== INIT_MARKET_DATA_LEN) {
     throw new Error(
@@ -362,9 +403,16 @@ function encodeSetOracleAuthority(args) {
   );
 }
 function encodePushOraclePrice(args) {
+  const price = typeof args.priceE6 === "string" ? BigInt(args.priceE6) : args.priceE6;
+  if (price === 0n) {
+    throw new Error("encodePushOraclePrice: price cannot be zero (division by zero in engine)");
+  }
+  if (price > MAX_ORACLE_PRICE) {
+    throw new Error(`encodePushOraclePrice: price exceeds maximum (${MAX_ORACLE_PRICE}), got ${price}`);
+  }
   return concatBytes(
     encU8(IX_TAG.PushOraclePrice),
-    encU64(args.priceE6),
+    encU64(price),
     encI64(args.timestamp)
   );
 }
@@ -405,15 +453,6 @@ function encodeRenounceAdmin() {
     encU64(RENOUNCE_ADMIN_CONFIRMATION)
   );
 }
-function encodeCreateInsuranceMint() {
-  return encU8(IX_TAG.CreateInsuranceMint);
-}
-function encodeDepositInsuranceLP(args) {
-  return concatBytes(encU8(IX_TAG.DepositInsuranceLP), encU64(args.amount));
-}
-function encodeWithdrawInsuranceLP(args) {
-  return concatBytes(encU8(IX_TAG.WithdrawInsuranceLP), encU64(args.lpAmount));
-}
 function encodeLpVaultWithdraw(args) {
   return concatBytes(encU8(IX_TAG.LpVaultWithdraw), encU64(args.lpAmount));
 }
@@ -441,17 +480,15 @@ function encodeSetPythOracle(args) {
 }
 var PYTH_RECEIVER_PROGRAM_ID = "rec5EKMGg6MxZYaMdyBfgwp4d5rB9T1VQH5pJv5LtFJ";
 async function derivePythPriceUpdateAccount(feedId, shardId = 0) {
-  const { PublicKey: PublicKey12 } = await import("@solana/web3.js");
+  const { PublicKey: PublicKey15 } = await import("@solana/web3.js");
   const shardBuf = new Uint8Array(2);
   new DataView(shardBuf.buffer).setUint16(0, shardId, true);
-  const [pda] = PublicKey12.findProgramAddressSync(
+  const [pda] = PublicKey15.findProgramAddressSync(
     [shardBuf, feedId],
-    new PublicKey12(PYTH_RECEIVER_PROGRAM_ID)
+    new PublicKey15(PYTH_RECEIVER_PROGRAM_ID)
   );
   return pda.toBase58();
 }
-IX_TAG["SetPythOracle"] = 32;
-IX_TAG["UpdateMarkPrice"] = 33;
 function encodeUpdateMarkPrice() {
   return new Uint8Array([33]);
 }
@@ -462,7 +499,7 @@ function computeEmaMarkPrice(markPrevE6, oracleE6, dtSlots, alphaE6 = MARK_PRICE
   if (markPrevE6 === 0n || dtSlots === 0n) return oracleE6;
   let oracleClamped = oracleE6;
   if (capE2bps > 0n) {
-    const maxDelta = markPrevE6 * capE2bps * dtSlots / 1000000n;
+    const maxDelta = markPrevE6 * capE2bps / 1000000n * dtSlots;
     const lo = markPrevE6 > maxDelta ? markPrevE6 - maxDelta : 0n;
     const hi = markPrevE6 + maxDelta;
     if (oracleClamped < lo) oracleClamped = lo;
@@ -472,7 +509,6 @@ function computeEmaMarkPrice(markPrevE6, oracleE6, dtSlots, alphaE6 = MARK_PRICE
   const oneMinusAlpha = 1000000n - effectiveAlpha;
   return (oracleClamped * effectiveAlpha + markPrevE6 * oneMinusAlpha) / 1000000n;
 }
-IX_TAG["UpdateHyperpMark"] = 34;
 function encodeUpdateHyperpMark() {
   return new Uint8Array([34]);
 }
@@ -616,6 +652,74 @@ function encodeTransferOwnershipCpi(args) {
 function encodeSetWalletCap(args) {
   return concatBytes(encU8(IX_TAG.SetWalletCap), encU64(args.capE6));
 }
+function encodeInitMatcherCtx(args) {
+  return concatBytes(
+    encU8(IX_TAG.InitMatcherCtx),
+    encU16(args.lpIdx),
+    encU8(args.kind),
+    encU32(args.tradingFeeBps),
+    encU32(args.baseSpreadBps),
+    encU32(args.maxTotalBps),
+    encU32(args.impactKBps),
+    encU128(args.liquidityNotionalE6),
+    encU128(args.maxFillAbs),
+    encU128(args.maxInventoryAbs),
+    encU16(args.feeToInsuranceBps),
+    encU16(args.skewSpreadMultBps)
+  );
+}
+function encodeSetInsuranceWithdrawPolicy(args) {
+  return concatBytes(encU8(IX_TAG.SetInsuranceWithdrawPolicy), encPubkey(args.authority), encU64(args.minWithdrawBase), encU16(args.maxWithdrawBps), encU64(args.cooldownSlots));
+}
+function encodeWithdrawInsuranceLimited(args) {
+  return concatBytes(encU8(IX_TAG.WithdrawInsuranceLimited), encU64(args.amount));
+}
+function encodeResolvePermissionless() {
+  return concatBytes(encU8(IX_TAG.ResolvePermissionless));
+}
+function encodeForceCloseResolved(args) {
+  return concatBytes(encU8(IX_TAG.ForceCloseResolved), encU16(args.userIdx));
+}
+function encodeCreateLpVault(args) {
+  const parts = [encU8(IX_TAG.CreateLpVault), encU64(args.feeShareBps)];
+  if (args.utilCurveEnabled !== void 0) {
+    parts.push(encU8(args.utilCurveEnabled ? 1 : 0));
+  }
+  return concatBytes(...parts);
+}
+function encodeLpVaultDeposit(args) {
+  return concatBytes(encU8(IX_TAG.LpVaultDeposit), encU64(args.amount));
+}
+function encodeLpVaultCrankFees() {
+  return concatBytes(encU8(IX_TAG.LpVaultCrankFees));
+}
+function encodeChallengeSettlement(args) {
+  return concatBytes(encU8(IX_TAG.ChallengeSettlement), encU64(args.proposedPriceE6));
+}
+function encodeResolveDispute(args) {
+  return concatBytes(encU8(IX_TAG.ResolveDispute), encU8(args.accept));
+}
+function encodeDepositLpCollateral(args) {
+  return concatBytes(encU8(IX_TAG.DepositLpCollateral), encU16(args.userIdx), encU64(args.lpAmount));
+}
+function encodeWithdrawLpCollateral(args) {
+  return concatBytes(encU8(IX_TAG.WithdrawLpCollateral), encU16(args.userIdx), encU64(args.lpAmount));
+}
+function encodeSetOffsetPair(args) {
+  return concatBytes(encU8(IX_TAG.SetOffsetPair), encU16(args.offsetBps));
+}
+function encodeAttestCrossMargin(args) {
+  return concatBytes(encU8(IX_TAG.AttestCrossMargin), encU16(args.userIdxA), encU16(args.userIdxB));
+}
+function encodeRescueOrphanVault() {
+  return concatBytes(encU8(IX_TAG.RescueOrphanVault));
+}
+function encodeCloseOrphanSlab() {
+  return concatBytes(encU8(IX_TAG.CloseOrphanSlab));
+}
+function encodeSetDexPool(args) {
+  return concatBytes(encU8(IX_TAG.SetDexPool), encPubkey(args.pool));
+}
 
 // src/abi/accounts.ts
 import {
@@ -790,37 +894,6 @@ function buildAccountMetas(spec, keys) {
     isWritable: s.writable
   }));
 }
-var ACCOUNTS_CREATE_INSURANCE_MINT = [
-  { name: "admin", signer: true, writable: false },
-  { name: "slab", signer: false, writable: false },
-  { name: "insLpMint", signer: false, writable: true },
-  { name: "vaultAuthority", signer: false, writable: false },
-  { name: "collateralMint", signer: false, writable: false },
-  { name: "systemProgram", signer: false, writable: false },
-  { name: "tokenProgram", signer: false, writable: false },
-  { name: "rent", signer: false, writable: false },
-  { name: "payer", signer: true, writable: true }
-];
-var ACCOUNTS_DEPOSIT_INSURANCE_LP = [
-  { name: "depositor", signer: true, writable: false },
-  { name: "slab", signer: false, writable: true },
-  { name: "depositorAta", signer: false, writable: true },
-  { name: "vault", signer: false, writable: true },
-  { name: "tokenProgram", signer: false, writable: false },
-  { name: "insLpMint", signer: false, writable: true },
-  { name: "depositorLpAta", signer: false, writable: true },
-  { name: "vaultAuthority", signer: false, writable: false }
-];
-var ACCOUNTS_WITHDRAW_INSURANCE_LP = [
-  { name: "withdrawer", signer: true, writable: false },
-  { name: "slab", signer: false, writable: true },
-  { name: "withdrawerAta", signer: false, writable: true },
-  { name: "vault", signer: false, writable: true },
-  { name: "tokenProgram", signer: false, writable: false },
-  { name: "insLpMint", signer: false, writable: true },
-  { name: "withdrawerLpAta", signer: false, writable: true },
-  { name: "vaultAuthority", signer: false, writable: false }
-];
 var ACCOUNTS_LP_VAULT_WITHDRAW = [
   { name: "withdrawer", signer: true, writable: false },
   { name: "slab", signer: false, writable: true },
@@ -942,6 +1015,13 @@ var ACCOUNTS_SET_WALLET_CAP = [
   { name: "admin", signer: true, writable: false },
   { name: "slab", signer: false, writable: true }
 ];
+var ACCOUNTS_INIT_MATCHER_CTX = [
+  { name: "admin", signer: true, writable: false },
+  { name: "slab", signer: false, writable: false },
+  { name: "matcherCtx", signer: false, writable: true },
+  { name: "matcherProg", signer: false, writable: false },
+  { name: "lpPda", signer: false, writable: false }
+];
 var WELL_KNOWN = {
   tokenProgram: TOKEN_PROGRAM_ID,
   clock: SYSVAR_CLOCK_PUBKEY,
@@ -1226,11 +1306,24 @@ function getErrorName(code) {
 function getErrorHint(code) {
   return PERCOLATOR_ERRORS[code]?.hint;
 }
+var LIGHTHOUSE_PROGRAM_ID_STR = "L2TExMFKdjpN9kozasaurPirfHy9P8sbXoAN1qA3S95";
+var ANCHOR_ERROR_RANGE_START = 6e3;
+var ANCHOR_ERROR_RANGE_END = 8191;
+var ANCHOR_ERROR_NAMES = {
+  6032: "ConstraintMut",
+  6036: "ConstraintOwner",
+  6038: "ConstraintSeeds",
+  6400: "ConstraintAddress"
+};
+function isAnchorErrorCode(code) {
+  return code >= ANCHOR_ERROR_RANGE_START && code <= ANCHOR_ERROR_RANGE_END;
+}
 var CUSTOM_ERROR_HEX_MAX_LEN = 8;
 function parseErrorFromLogs(logs) {
   if (!Array.isArray(logs)) {
     return null;
   }
+  let insideLighthouse = false;
   const re = new RegExp(
     `custom program error: 0x([0-9a-fA-F]{1,${CUSTOM_ERROR_HEX_MAX_LEN}})(?![0-9a-fA-F])`,
     "i"
@@ -1239,17 +1332,32 @@ function parseErrorFromLogs(logs) {
     if (typeof log !== "string") {
       continue;
     }
+    if (log.includes(`Program ${LIGHTHOUSE_PROGRAM_ID_STR} invoke`)) {
+      insideLighthouse = true;
+    } else if (log.includes(`Program ${LIGHTHOUSE_PROGRAM_ID_STR} success`)) {
+      insideLighthouse = false;
+    }
     const match = log.match(re);
     if (match) {
       const code = parseInt(match[1], 16);
       if (!Number.isFinite(code) || code < 0 || code > 4294967295) {
         continue;
       }
+      if (isAnchorErrorCode(code) || insideLighthouse) {
+        const anchorName = ANCHOR_ERROR_NAMES[code] ?? `AnchorError(0x${code.toString(16)})`;
+        return {
+          code,
+          name: `Lighthouse:${anchorName}`,
+          hint: "This error comes from the Lighthouse/Blowfish wallet guard, not from Percolator. The transaction itself is valid. Disable transaction simulation in your wallet settings, or use a wallet without Blowfish protection (e.g., Backpack, Solflare).",
+          source: "lighthouse"
+        };
+      }
       const info = decodeError(code);
       return {
         code,
         name: info?.name ?? `Unknown(${code})`,
-        hint: info?.hint
+        hint: info?.hint,
+        source: info ? "percolator" : "unknown"
       };
     }
   }
@@ -1416,6 +1524,8 @@ var V2_ENGINE_LP_MAX_ABS_OFF = 536;
 var V2_ENGINE_LP_MAX_ABS_SWEEP_OFF = 552;
 var V_ADL_ENGINE_OFF = 624;
 var V_ADL_CONFIG_LEN = 520;
+var V_SETDEXPOOL_CONFIG_LEN = 544;
+var V_SETDEXPOOL_ENGINE_OFF = 648;
 var V_ADL_ACCOUNT_SIZE = 312;
 var V_ADL_ENGINE_PARAMS_OFF = 96;
 var V_ADL_PARAMS_SIZE = 336;
@@ -1446,7 +1556,7 @@ var V_ADL_ENGINE_LP_MAX_ABS_SWEEP_OFF = 952;
 var V_ADL_ENGINE_EMERGENCY_OI_MODE_OFF = 968;
 var V_ADL_ENGINE_EMERGENCY_START_SLOT_OFF = 976;
 var V_ADL_ENGINE_LAST_BREAKER_SLOT_OFF = 984;
-var V_ADL_ENGINE_BITMAP_OFF = 1006;
+var V_ADL_ENGINE_BITMAP_OFF = 1008;
 var V_ADL_ACCT_WARMUP_STARTED_OFF = 64;
 var V_ADL_ACCT_WARMUP_SLOPE_OFF = 72;
 var V_ADL_ACCT_POSITION_SIZE_OFF = 88;
@@ -1457,6 +1567,47 @@ var V_ADL_ACCT_MATCHER_CONTEXT_OFF = 160;
 var V_ADL_ACCT_OWNER_OFF = 192;
 var V_ADL_ACCT_FEE_CREDITS_OFF = 224;
 var V_ADL_ACCT_LAST_FEE_SLOT_OFF = 240;
+var V12_1_ENGINE_OFF = 648;
+var V12_1_ACCOUNT_SIZE = 320;
+var V12_1_ACCOUNT_SIZE_SBF = 280;
+var V12_1_ENGINE_BITMAP_OFF = 1016;
+var V12_1_ENGINE_PARAMS_OFF = 96;
+var V12_1_PARAMS_SIZE = 352;
+var V12_1_ENGINE_CURRENT_SLOT_OFF = 448;
+var V12_1_ENGINE_FUNDING_RATE_BPS_OFF = 456;
+var V12_1_ENGINE_LAST_CRANK_SLOT_OFF = 464;
+var V12_1_ENGINE_MAX_CRANK_STALENESS_OFF = 472;
+var V12_1_ENGINE_C_TOT_OFF = 480;
+var V12_1_ENGINE_PNL_POS_TOT_OFF = 496;
+var V12_1_ENGINE_LIQ_CURSOR_OFF = 528;
+var V12_1_ENGINE_GC_CURSOR_OFF = 530;
+var V12_1_ENGINE_LAST_SWEEP_START_OFF = 536;
+var V12_1_ENGINE_LAST_SWEEP_COMPLETE_OFF = 544;
+var V12_1_ENGINE_CRANK_CURSOR_OFF = 552;
+var V12_1_ENGINE_SWEEP_START_IDX_OFF = 554;
+var V12_1_ENGINE_LIFETIME_LIQUIDATIONS_OFF = 560;
+var V12_1_ENGINE_TOTAL_OI_OFF = 816;
+var V12_1_ENGINE_LONG_OI_OFF = 832;
+var V12_1_ENGINE_SHORT_OI_OFF = 848;
+var V12_1_ENGINE_NET_LP_POS_OFF = 864;
+var V12_1_ENGINE_LP_SUM_ABS_OFF = 880;
+var V12_1_ENGINE_LP_MAX_ABS_OFF = 896;
+var V12_1_ENGINE_LP_MAX_ABS_SWEEP_OFF = 912;
+var V12_1_ENGINE_MARK_PRICE_OFF = 928;
+var V12_1_ENGINE_FUNDING_INDEX_OFF = 936;
+var V12_1_ENGINE_LAST_FUNDING_SLOT_OFF = 944;
+var V12_1_ENGINE_EMERGENCY_OI_MODE_OFF = 968;
+var V12_1_ENGINE_EMERGENCY_START_SLOT_OFF = 976;
+var V12_1_ENGINE_LAST_BREAKER_SLOT_OFF = 984;
+var V12_1_ENGINE_LIFETIME_FORCE_CLOSES_OFF = 1008;
+var V12_1_ACCT_MATCHER_PROGRAM_OFF = 144;
+var V12_1_ACCT_MATCHER_CONTEXT_OFF = 176;
+var V12_1_ACCT_OWNER_OFF = 208;
+var V12_1_ACCT_FEE_CREDITS_OFF = 240;
+var V12_1_ACCT_LAST_FEE_SLOT_OFF = 256;
+var V12_1_ACCT_POSITION_SIZE_OFF = 88;
+var V12_1_ACCT_ENTRY_PRICE_OFF = -1;
+var V12_1_ACCT_FUNDING_INDEX_OFF = 288;
 var V1M_ENGINE_OFF = 640;
 var V1M_CONFIG_LEN = 536;
 var V1M_ACCOUNT_SIZE = 248;
@@ -1494,15 +1645,7 @@ var V1M_ENGINE_EMERGENCY_START_SLOT_OFF = 688;
 var V1M_ENGINE_LAST_BREAKER_SLOT_OFF = 696;
 var V1M_ENGINE_BITMAP_OFF = 720;
 var V1M2_ACCOUNT_SIZE = 312;
-var V1M2_ENGINE_BITMAP_OFF = 990;
-var V1M2_ENGINE_CURRENT_SLOT_OFF = 408;
-var V1M2_ENGINE_FUNDING_INDEX_OFF = 416;
-var V1M2_ENGINE_LAST_FUNDING_SLOT_OFF = 432;
-var V1M2_ENGINE_FUNDING_RATE_BPS_OFF = 440;
-var V1M2_ENGINE_MARK_PRICE_OFF = 480;
-var V1M2_ENGINE_LAST_CRANK_SLOT_OFF = 504;
-var V1M2_ENGINE_MAX_CRANK_STALENESS_OFF = 512;
-var V1M2_RUNTIME_SHIFT = 32;
+var V1M2_ENGINE_BITMAP_OFF = 1008;
 var ENGINE_OFF = V1_ENGINE_OFF;
 var ENGINE_MARK_PRICE_OFF = V1_ENGINE_MARK_PRICE_OFF;
 function computeSlabSize(engineOff, bitmapOff, accountSize, maxAccounts, postBitmap = 18) {
@@ -1521,6 +1664,9 @@ var V1D_SIZES = /* @__PURE__ */ new Map();
 var V2_SIZES = /* @__PURE__ */ new Map();
 var V1M_SIZES = /* @__PURE__ */ new Map();
 var V_ADL_SIZES = /* @__PURE__ */ new Map();
+var V1M2_SIZES = /* @__PURE__ */ new Map();
+var V_SETDEXPOOL_SIZES = /* @__PURE__ */ new Map();
+var V12_1_SIZES = /* @__PURE__ */ new Map();
 var V1D_SIZES_LEGACY = /* @__PURE__ */ new Map();
 for (const n of TIERS) {
   V0_SIZES.set(computeSlabSize(V0_ENGINE_OFF, V0_ENGINE_BITMAP_OFF, V0_ACCOUNT_SIZE, n), n);
@@ -1531,6 +1677,18 @@ for (const n of TIERS) {
   V2_SIZES.set(computeSlabSize(V2_ENGINE_OFF, V2_ENGINE_BITMAP_OFF, V2_ACCOUNT_SIZE, n, 18), n);
   V1M_SIZES.set(computeSlabSize(V1M_ENGINE_OFF, V1M_ENGINE_BITMAP_OFF, V1M_ACCOUNT_SIZE, n, 18), n);
   V_ADL_SIZES.set(computeSlabSize(V_ADL_ENGINE_OFF, V_ADL_ENGINE_BITMAP_OFF, V_ADL_ACCOUNT_SIZE, n, 18), n);
+  V1M2_SIZES.set(computeSlabSize(V1M2_ENGINE_OFF, V1M2_ENGINE_BITMAP_OFF, V1M2_ACCOUNT_SIZE, n, 18), n);
+  V_SETDEXPOOL_SIZES.set(computeSlabSize(V_SETDEXPOOL_ENGINE_OFF, V_ADL_ENGINE_BITMAP_OFF, V_ADL_ACCOUNT_SIZE, n, 18), n);
+  V12_1_SIZES.set(computeSlabSize(V12_1_ENGINE_OFF, V12_1_ENGINE_BITMAP_OFF, V12_1_ACCOUNT_SIZE, n, 18), n);
+}
+var V12_1_SBF_ACCOUNT_SIZE = 280;
+var V12_1_SBF_ENGINE_PREAMBLE = 558;
+for (const [, n] of [["Micro", 64], ["Small", 256], ["Medium", 1024], ["Large", 4096]]) {
+  const bitmapBytes = Math.ceil(n / 64) * 8;
+  const preAccLen = V12_1_SBF_ENGINE_PREAMBLE + bitmapBytes + 18 + n * 2;
+  const accountsOff = Math.ceil(preAccLen / 8) * 8;
+  const total = V12_1_ENGINE_OFF + accountsOff + n * V12_1_SBF_ACCOUNT_SIZE;
+  V12_1_SIZES.set(total, n);
 }
 var SLAB_TIERS_V2 = {
   small: { maxAccounts: 256, dataSize: 65088, label: "Small", description: "256 slots (V2 BPF intermediate)" },
@@ -1826,41 +1984,68 @@ function buildLayoutV1M2(maxAccounts) {
     accountsOff: engineOff + accountsOffRel,
     engineInsuranceOff: 16,
     engineParamsOff: V1M2_ENGINE_PARAMS_OFF,
-    // 96 — expanded InsuranceFund
-    paramsSize: V1M_PARAMS_SIZE,
-    // 336 — same as V1M
-    // Runtime fields: same as V1M up to fundingRateBps, then +32 shift
-    engineCurrentSlotOff: V1M2_ENGINE_CURRENT_SLOT_OFF,
-    engineFundingIndexOff: V1M2_ENGINE_FUNDING_INDEX_OFF,
-    engineLastFundingSlotOff: V1M2_ENGINE_LAST_FUNDING_SLOT_OFF,
-    engineFundingRateBpsOff: V1M2_ENGINE_FUNDING_RATE_BPS_OFF,
-    engineMarkPriceOff: V1M2_ENGINE_MARK_PRICE_OFF,
-    engineLastCrankSlotOff: V1M2_ENGINE_LAST_CRANK_SLOT_OFF,
-    engineMaxCrankStalenessOff: V1M2_ENGINE_MAX_CRANK_STALENESS_OFF,
-    // Fields after maxCrankStaleness: apply same +32 shift from V1M
-    engineTotalOiOff: V1M_ENGINE_TOTAL_OI_OFF + V1M2_RUNTIME_SHIFT,
-    engineLongOiOff: V1M_ENGINE_LONG_OI_OFF + V1M2_RUNTIME_SHIFT,
-    engineShortOiOff: V1M_ENGINE_SHORT_OI_OFF + V1M2_RUNTIME_SHIFT,
-    engineCTotOff: V1M_ENGINE_C_TOT_OFF + V1M2_RUNTIME_SHIFT,
-    enginePnlPosTotOff: V1M_ENGINE_PNL_POS_TOT_OFF + V1M2_RUNTIME_SHIFT,
-    engineLiqCursorOff: V1M_ENGINE_LIQ_CURSOR_OFF + V1M2_RUNTIME_SHIFT,
-    engineGcCursorOff: V1M_ENGINE_GC_CURSOR_OFF + V1M2_RUNTIME_SHIFT,
-    engineLastSweepStartOff: V1M_ENGINE_LAST_SWEEP_START_OFF + V1M2_RUNTIME_SHIFT,
-    engineLastSweepCompleteOff: V1M_ENGINE_LAST_SWEEP_COMPLETE_OFF + V1M2_RUNTIME_SHIFT,
-    engineCrankCursorOff: V1M_ENGINE_CRANK_CURSOR_OFF + V1M2_RUNTIME_SHIFT,
-    engineSweepStartIdxOff: V1M_ENGINE_SWEEP_START_IDX_OFF + V1M2_RUNTIME_SHIFT,
-    engineLifetimeLiquidationsOff: V1M_ENGINE_LIFETIME_LIQUIDATIONS_OFF + V1M2_RUNTIME_SHIFT,
-    engineLifetimeForceClosesOff: V1M_ENGINE_LIFETIME_FORCE_CLOSES_OFF + V1M2_RUNTIME_SHIFT,
-    engineNetLpPosOff: V1M_ENGINE_NET_LP_POS_OFF + V1M2_RUNTIME_SHIFT,
-    engineLpSumAbsOff: V1M_ENGINE_LP_SUM_ABS_OFF + V1M2_RUNTIME_SHIFT,
-    engineLpMaxAbsOff: V1M_ENGINE_LP_MAX_ABS_OFF + V1M2_RUNTIME_SHIFT,
-    engineLpMaxAbsSweepOff: V1M_ENGINE_LP_MAX_ABS_SWEEP_OFF + V1M2_RUNTIME_SHIFT,
-    engineEmergencyOiModeOff: V1M_ENGINE_EMERGENCY_OI_MODE_OFF + V1M2_RUNTIME_SHIFT,
-    engineEmergencyStartSlotOff: V1M_ENGINE_EMERGENCY_START_SLOT_OFF + V1M2_RUNTIME_SHIFT,
-    engineLastBreakerSlotOff: V1M_ENGINE_LAST_BREAKER_SLOT_OFF + V1M2_RUNTIME_SHIFT,
+    // 96 — expanded InsuranceFund (same as V_ADL)
+    paramsSize: V_ADL_PARAMS_SIZE,
+    // 336 — same as V_ADL
+    // Runtime fields: V1M2 engine struct is layout-identical to V_ADL — reuse V_ADL constants.
+    engineCurrentSlotOff: V_ADL_ENGINE_CURRENT_SLOT_OFF,
+    // 432
+    engineFundingIndexOff: V_ADL_ENGINE_FUNDING_INDEX_OFF,
+    // 440
+    engineLastFundingSlotOff: V_ADL_ENGINE_LAST_FUNDING_SLOT_OFF,
+    // 456
+    engineFundingRateBpsOff: V_ADL_ENGINE_FUNDING_RATE_BPS_OFF,
+    // 464
+    engineMarkPriceOff: V_ADL_ENGINE_MARK_PRICE_OFF,
+    // 504
+    engineLastCrankSlotOff: V_ADL_ENGINE_LAST_CRANK_SLOT_OFF,
+    // 528
+    engineMaxCrankStalenessOff: V_ADL_ENGINE_MAX_CRANK_STALENESS_OFF,
+    // 536
+    engineTotalOiOff: V_ADL_ENGINE_TOTAL_OI_OFF,
+    // 544
+    engineLongOiOff: V_ADL_ENGINE_LONG_OI_OFF,
+    // 560
+    engineShortOiOff: V_ADL_ENGINE_SHORT_OI_OFF,
+    // 576
+    engineCTotOff: V_ADL_ENGINE_C_TOT_OFF,
+    // 592
+    enginePnlPosTotOff: V_ADL_ENGINE_PNL_POS_TOT_OFF,
+    // 608
+    engineLiqCursorOff: V_ADL_ENGINE_LIQ_CURSOR_OFF,
+    // 640
+    engineGcCursorOff: V_ADL_ENGINE_GC_CURSOR_OFF,
+    // 642
+    engineLastSweepStartOff: V_ADL_ENGINE_LAST_SWEEP_START_OFF,
+    // 648
+    engineLastSweepCompleteOff: V_ADL_ENGINE_LAST_SWEEP_COMPLETE_OFF,
+    // 656
+    engineCrankCursorOff: V_ADL_ENGINE_CRANK_CURSOR_OFF,
+    // 664
+    engineSweepStartIdxOff: V_ADL_ENGINE_SWEEP_START_IDX_OFF,
+    // 666
+    engineLifetimeLiquidationsOff: V_ADL_ENGINE_LIFETIME_LIQUIDATIONS_OFF,
+    // 672
+    engineLifetimeForceClosesOff: V_ADL_ENGINE_LIFETIME_FORCE_CLOSES_OFF,
+    // 680
+    engineNetLpPosOff: V_ADL_ENGINE_NET_LP_POS_OFF,
+    // 904
+    engineLpSumAbsOff: V_ADL_ENGINE_LP_SUM_ABS_OFF,
+    // 920
+    engineLpMaxAbsOff: V_ADL_ENGINE_LP_MAX_ABS_OFF,
+    // 936
+    engineLpMaxAbsSweepOff: V_ADL_ENGINE_LP_MAX_ABS_SWEEP_OFF,
+    // 952
+    engineEmergencyOiModeOff: V_ADL_ENGINE_EMERGENCY_OI_MODE_OFF,
+    // 968
+    engineEmergencyStartSlotOff: V_ADL_ENGINE_EMERGENCY_START_SLOT_OFF,
+    // 976
+    engineLastBreakerSlotOff: V_ADL_ENGINE_LAST_BREAKER_SLOT_OFF,
+    // 984
     engineBitmapOff: V1M2_ENGINE_BITMAP_OFF,
     postBitmap: 18,
-    acctOwnerOff: ACCT_OWNER_OFF,
+    acctOwnerOff: V_ADL_ACCT_OWNER_OFF,
+    // 192 — same shift as V_ADL (reserved_pnl u64→u128)
     hasInsuranceIsolation: true,
     engineInsuranceIsolatedOff: 48,
     engineInsuranceIsolationBpsOff: 64
@@ -1950,7 +2135,7 @@ function buildLayoutVADL(maxAccounts) {
     engineLastBreakerSlotOff: V_ADL_ENGINE_LAST_BREAKER_SLOT_OFF,
     // 984
     engineBitmapOff: V_ADL_ENGINE_BITMAP_OFF,
-    // 1006
+    // 1008
     postBitmap: 18,
     acctOwnerOff: V_ADL_ACCT_OWNER_OFF,
     // 192
@@ -1959,17 +2144,151 @@ function buildLayoutVADL(maxAccounts) {
     engineInsuranceIsolationBpsOff: 64
   };
 }
+var SLAB_TIERS_V_SETDEXPOOL = {};
+for (const [label, n] of [["Micro", 64], ["Small", 256], ["Medium", 1024], ["Large", 4096]]) {
+  const size = computeSlabSize(V_SETDEXPOOL_ENGINE_OFF, V_ADL_ENGINE_BITMAP_OFF, V_ADL_ACCOUNT_SIZE, n, 18);
+  SLAB_TIERS_V_SETDEXPOOL[label.toLowerCase()] = { maxAccounts: n, dataSize: size, label, description: `${n} slots (V_SETDEXPOOL PERC-SetDexPool)` };
+}
+var SLAB_TIERS_V12_1 = {};
+for (const [label, n] of [["Micro", 64], ["Small", 256], ["Medium", 1024], ["Large", 4096]]) {
+  const size = computeSlabSize(V12_1_ENGINE_OFF, V12_1_ENGINE_BITMAP_OFF, V12_1_ACCOUNT_SIZE, n, 18);
+  SLAB_TIERS_V12_1[label.toLowerCase()] = { maxAccounts: n, dataSize: size, label, description: `${n} slots (v12.1)` };
+}
+function buildLayoutVSetDexPool(maxAccounts) {
+  const engineOff = V_SETDEXPOOL_ENGINE_OFF;
+  const bitmapOff = V_ADL_ENGINE_BITMAP_OFF;
+  const accountSize = V_ADL_ACCOUNT_SIZE;
+  const bitmapWords = Math.ceil(maxAccounts / 64);
+  const bitmapBytes = bitmapWords * 8;
+  const postBitmap = 18;
+  const nextFreeBytes = maxAccounts * 2;
+  const preAccountsLen = bitmapOff + bitmapBytes + postBitmap + nextFreeBytes;
+  const accountsOffRel = Math.ceil(preAccountsLen / 8) * 8;
+  return {
+    version: 1,
+    headerLen: V1_HEADER_LEN,
+    configOffset: V1_HEADER_LEN,
+    configLen: V_SETDEXPOOL_CONFIG_LEN,
+    // 544
+    reservedOff: V1_RESERVED_OFF,
+    engineOff,
+    accountSize,
+    maxAccounts,
+    bitmapWords,
+    accountsOff: engineOff + accountsOffRel,
+    engineInsuranceOff: 16,
+    engineParamsOff: V_ADL_ENGINE_PARAMS_OFF,
+    paramsSize: V_ADL_PARAMS_SIZE,
+    engineCurrentSlotOff: V_ADL_ENGINE_CURRENT_SLOT_OFF,
+    engineFundingIndexOff: V_ADL_ENGINE_FUNDING_INDEX_OFF,
+    engineLastFundingSlotOff: V_ADL_ENGINE_LAST_FUNDING_SLOT_OFF,
+    engineFundingRateBpsOff: V_ADL_ENGINE_FUNDING_RATE_BPS_OFF,
+    engineMarkPriceOff: V_ADL_ENGINE_MARK_PRICE_OFF,
+    engineLastCrankSlotOff: V_ADL_ENGINE_LAST_CRANK_SLOT_OFF,
+    engineMaxCrankStalenessOff: V_ADL_ENGINE_MAX_CRANK_STALENESS_OFF,
+    engineTotalOiOff: V_ADL_ENGINE_TOTAL_OI_OFF,
+    engineLongOiOff: V_ADL_ENGINE_LONG_OI_OFF,
+    engineShortOiOff: V_ADL_ENGINE_SHORT_OI_OFF,
+    engineCTotOff: V_ADL_ENGINE_C_TOT_OFF,
+    enginePnlPosTotOff: V_ADL_ENGINE_PNL_POS_TOT_OFF,
+    engineLiqCursorOff: V_ADL_ENGINE_LIQ_CURSOR_OFF,
+    engineGcCursorOff: V_ADL_ENGINE_GC_CURSOR_OFF,
+    engineLastSweepStartOff: V_ADL_ENGINE_LAST_SWEEP_START_OFF,
+    engineLastSweepCompleteOff: V_ADL_ENGINE_LAST_SWEEP_COMPLETE_OFF,
+    engineCrankCursorOff: V_ADL_ENGINE_CRANK_CURSOR_OFF,
+    engineSweepStartIdxOff: V_ADL_ENGINE_SWEEP_START_IDX_OFF,
+    engineLifetimeLiquidationsOff: V_ADL_ENGINE_LIFETIME_LIQUIDATIONS_OFF,
+    engineLifetimeForceClosesOff: V_ADL_ENGINE_LIFETIME_FORCE_CLOSES_OFF,
+    engineNetLpPosOff: V_ADL_ENGINE_NET_LP_POS_OFF,
+    engineLpSumAbsOff: V_ADL_ENGINE_LP_SUM_ABS_OFF,
+    engineLpMaxAbsOff: V_ADL_ENGINE_LP_MAX_ABS_OFF,
+    engineLpMaxAbsSweepOff: V_ADL_ENGINE_LP_MAX_ABS_SWEEP_OFF,
+    engineEmergencyOiModeOff: V_ADL_ENGINE_EMERGENCY_OI_MODE_OFF,
+    engineEmergencyStartSlotOff: V_ADL_ENGINE_EMERGENCY_START_SLOT_OFF,
+    engineLastBreakerSlotOff: V_ADL_ENGINE_LAST_BREAKER_SLOT_OFF,
+    engineBitmapOff: V_ADL_ENGINE_BITMAP_OFF,
+    postBitmap: 18,
+    acctOwnerOff: V_ADL_ACCT_OWNER_OFF,
+    hasInsuranceIsolation: true,
+    engineInsuranceIsolatedOff: 48,
+    engineInsuranceIsolationBpsOff: 64
+  };
+}
+function buildLayoutV12_1(maxAccounts, dataLen) {
+  const engineOff = V12_1_ENGINE_OFF;
+  const bitmapOff = V12_1_ENGINE_BITMAP_OFF;
+  const hostSize = computeSlabSize(engineOff, bitmapOff, V12_1_ACCOUNT_SIZE, maxAccounts, 18);
+  const isSbf = dataLen !== void 0 && dataLen !== hostSize;
+  const accountSize = isSbf ? V12_1_ACCOUNT_SIZE_SBF : V12_1_ACCOUNT_SIZE;
+  const bitmapWords = Math.ceil(maxAccounts / 64);
+  const bitmapBytes = bitmapWords * 8;
+  const postBitmap = 18;
+  const nextFreeBytes = maxAccounts * 2;
+  const preAccountsLen = bitmapOff + bitmapBytes + postBitmap + nextFreeBytes;
+  const accountsOffRel = Math.ceil(preAccountsLen / 8) * 8;
+  return {
+    version: 1,
+    // V12_1 upstream rebase uses 72-byte header (SlabHeader only, no V1 extension).
+    // Empirically verified: USDC mint found at offset 72 on mainnet slab BVjPc6rd.
+    headerLen: V0_HEADER_LEN,
+    // 72 (not 104 — V12_1 removed the 32-byte header extension)
+    configOffset: V0_HEADER_LEN,
+    // 72
+    configLen: 576,
+    // 544 + 32 (dex_pool: [u8;32] added in V12_1)
+    reservedOff: V1_RESERVED_OFF,
+    engineOff,
+    accountSize,
+    maxAccounts,
+    bitmapWords,
+    accountsOff: engineOff + accountsOffRel,
+    engineInsuranceOff: 16,
+    engineParamsOff: V12_1_ENGINE_PARAMS_OFF,
+    paramsSize: V12_1_PARAMS_SIZE,
+    engineCurrentSlotOff: V12_1_ENGINE_CURRENT_SLOT_OFF,
+    engineFundingIndexOff: V12_1_ENGINE_FUNDING_INDEX_OFF,
+    engineLastFundingSlotOff: V12_1_ENGINE_LAST_FUNDING_SLOT_OFF,
+    engineFundingRateBpsOff: V12_1_ENGINE_FUNDING_RATE_BPS_OFF,
+    engineMarkPriceOff: V12_1_ENGINE_MARK_PRICE_OFF,
+    engineLastCrankSlotOff: V12_1_ENGINE_LAST_CRANK_SLOT_OFF,
+    engineMaxCrankStalenessOff: V12_1_ENGINE_MAX_CRANK_STALENESS_OFF,
+    engineTotalOiOff: V12_1_ENGINE_TOTAL_OI_OFF,
+    engineLongOiOff: V12_1_ENGINE_LONG_OI_OFF,
+    engineShortOiOff: V12_1_ENGINE_SHORT_OI_OFF,
+    engineCTotOff: V12_1_ENGINE_C_TOT_OFF,
+    enginePnlPosTotOff: V12_1_ENGINE_PNL_POS_TOT_OFF,
+    engineLiqCursorOff: V12_1_ENGINE_LIQ_CURSOR_OFF,
+    engineGcCursorOff: V12_1_ENGINE_GC_CURSOR_OFF,
+    engineLastSweepStartOff: V12_1_ENGINE_LAST_SWEEP_START_OFF,
+    engineLastSweepCompleteOff: V12_1_ENGINE_LAST_SWEEP_COMPLETE_OFF,
+    engineCrankCursorOff: V12_1_ENGINE_CRANK_CURSOR_OFF,
+    engineSweepStartIdxOff: V12_1_ENGINE_SWEEP_START_IDX_OFF,
+    engineLifetimeLiquidationsOff: V12_1_ENGINE_LIFETIME_LIQUIDATIONS_OFF,
+    engineLifetimeForceClosesOff: V12_1_ENGINE_LIFETIME_FORCE_CLOSES_OFF,
+    engineNetLpPosOff: V12_1_ENGINE_NET_LP_POS_OFF,
+    engineLpSumAbsOff: V12_1_ENGINE_LP_SUM_ABS_OFF,
+    engineLpMaxAbsOff: V12_1_ENGINE_LP_MAX_ABS_OFF,
+    engineLpMaxAbsSweepOff: V12_1_ENGINE_LP_MAX_ABS_SWEEP_OFF,
+    engineEmergencyOiModeOff: V12_1_ENGINE_EMERGENCY_OI_MODE_OFF,
+    engineEmergencyStartSlotOff: V12_1_ENGINE_EMERGENCY_START_SLOT_OFF,
+    engineLastBreakerSlotOff: V12_1_ENGINE_LAST_BREAKER_SLOT_OFF,
+    engineBitmapOff: V12_1_ENGINE_BITMAP_OFF,
+    postBitmap: 18,
+    acctOwnerOff: V12_1_ACCT_OWNER_OFF,
+    hasInsuranceIsolation: true,
+    engineInsuranceIsolatedOff: 48,
+    engineInsuranceIsolationBpsOff: 64
+  };
+}
 function detectSlabLayout(dataLen, data) {
+  const v121n = V12_1_SIZES.get(dataLen);
+  if (v121n !== void 0) return buildLayoutV12_1(v121n, dataLen);
+  const vsdpn = V_SETDEXPOOL_SIZES.get(dataLen);
+  if (vsdpn !== void 0) return buildLayoutVSetDexPool(vsdpn);
+  const v1m2n = V1M2_SIZES.get(dataLen);
+  if (v1m2n !== void 0) return buildLayoutV1M2(v1m2n);
   const vadln = V_ADL_SIZES.get(dataLen);
-  if (vadln !== void 0) {
-    if (data && data.length >= 752) {
-      const maxAcctsV1M2 = readU64LE(data, V1M2_ENGINE_OFF + V1M2_ENGINE_PARAMS_OFF + 32);
-      if (maxAcctsV1M2 === BigInt(vadln)) {
-        return buildLayoutV1M2(vadln);
-      }
-    }
-    return buildLayoutVADL(vadln);
-  }
+  if (vadln !== void 0) return buildLayoutVADL(vadln);
   const v1mn = V1M_SIZES.get(dataLen);
   if (v1mn !== void 0) return buildLayoutV1M(v1mn);
   const v0n = V0_SIZES.get(dataLen);
@@ -2130,14 +2449,6 @@ function parseConfig(data, layoutHint) {
   off += 8;
   const fundingMaxBpsPerSlot = readI64LE(data, off);
   off += 8;
-  const fundingPremiumWeightBps = readU64LE(data, off);
-  off += 8;
-  const fundingSettlementIntervalSlots = readU64LE(data, off);
-  off += 8;
-  const fundingPremiumDampeningE6 = readU64LE(data, off);
-  off += 8;
-  const fundingPremiumMaxBpsPerSlot = readU64LE(data, off);
-  off += 8;
   const threshFloor = readU128LE(data, off);
   off += 16;
   const threshRiskBps = readU64LE(data, off);
@@ -2202,6 +2513,14 @@ function parseConfig(data, layoutHint) {
       }
     }
   }
+  let dexPool = null;
+  const DEX_POOL_REL_OFF = 512;
+  if (configLen >= DEX_POOL_REL_OFF + 32 && data.length >= configOff + DEX_POOL_REL_OFF + 32) {
+    const dexPoolBytes = data.subarray(configOff + DEX_POOL_REL_OFF, configOff + DEX_POOL_REL_OFF + 32);
+    if (dexPoolBytes.some((b) => b !== 0)) {
+      dexPool = new PublicKey3(dexPoolBytes);
+    }
+  }
   return {
     collateralMint,
     vaultPubkey,
@@ -2216,10 +2535,10 @@ function parseConfig(data, layoutHint) {
     fundingInvScaleNotionalE6,
     fundingMaxPremiumBps,
     fundingMaxBpsPerSlot,
-    fundingPremiumWeightBps,
-    fundingSettlementIntervalSlots,
-    fundingPremiumDampeningE6,
-    fundingPremiumMaxBpsPerSlot,
+    fundingPremiumWeightBps: 0n,
+    fundingSettlementIntervalSlots: 0n,
+    fundingPremiumDampeningE6: 0n,
+    fundingPremiumMaxBpsPerSlot: 0n,
     threshFloor,
     threshRiskBps,
     threshUpdateIntervalSlots,
@@ -2244,7 +2563,8 @@ function parseConfig(data, layoutHint) {
     insuranceIsolationBps,
     oraclePhase,
     cumulativeVolumeE6,
-    phase2DeltaSlots
+    phase2DeltaSlots,
+    dexPool
   };
 }
 function parseParams(data, layoutHint) {
@@ -2384,16 +2704,17 @@ function parseAccount(data, idx) {
   if (data.length < base + layout.accountSize) {
     throw new Error("Slab data too short for account");
   }
-  const isAdl = layout.accountSize >= 312;
+  const isV12_1 = layout.engineOff === V12_1_ENGINE_OFF && (layout.accountSize === V12_1_ACCOUNT_SIZE || layout.accountSize === V12_1_ACCOUNT_SIZE_SBF);
+  const isAdl = layout.accountSize >= 312 || isV12_1;
   const warmupStartedOff = isAdl ? V_ADL_ACCT_WARMUP_STARTED_OFF : ACCT_WARMUP_STARTED_OFF;
   const warmupSlopeOff = isAdl ? V_ADL_ACCT_WARMUP_SLOPE_OFF : ACCT_WARMUP_SLOPE_OFF;
-  const positionSizeOff = isAdl ? V_ADL_ACCT_POSITION_SIZE_OFF : ACCT_POSITION_SIZE_OFF;
-  const entryPriceOff = isAdl ? V_ADL_ACCT_ENTRY_PRICE_OFF : ACCT_ENTRY_PRICE_OFF;
-  const fundingIndexOff = isAdl ? V_ADL_ACCT_FUNDING_INDEX_OFF : ACCT_FUNDING_INDEX_OFF;
-  const matcherProgOff = isAdl ? V_ADL_ACCT_MATCHER_PROGRAM_OFF : ACCT_MATCHER_PROGRAM_OFF;
-  const matcherCtxOff = isAdl ? V_ADL_ACCT_MATCHER_CONTEXT_OFF : ACCT_MATCHER_CONTEXT_OFF;
-  const feeCreditsOff = isAdl ? V_ADL_ACCT_FEE_CREDITS_OFF : ACCT_FEE_CREDITS_OFF;
-  const lastFeeSlotOff = isAdl ? V_ADL_ACCT_LAST_FEE_SLOT_OFF : ACCT_LAST_FEE_SLOT_OFF;
+  const positionSizeOff = isV12_1 ? V12_1_ACCT_POSITION_SIZE_OFF : isAdl ? V_ADL_ACCT_POSITION_SIZE_OFF : ACCT_POSITION_SIZE_OFF;
+  const entryPriceOff = isV12_1 ? V12_1_ACCT_ENTRY_PRICE_OFF : isAdl ? V_ADL_ACCT_ENTRY_PRICE_OFF : ACCT_ENTRY_PRICE_OFF;
+  const fundingIndexOff = isV12_1 ? V12_1_ACCT_FUNDING_INDEX_OFF : isAdl ? V_ADL_ACCT_FUNDING_INDEX_OFF : ACCT_FUNDING_INDEX_OFF;
+  const matcherProgOff = isV12_1 ? V12_1_ACCT_MATCHER_PROGRAM_OFF : isAdl ? V_ADL_ACCT_MATCHER_PROGRAM_OFF : ACCT_MATCHER_PROGRAM_OFF;
+  const matcherCtxOff = isV12_1 ? V12_1_ACCT_MATCHER_CONTEXT_OFF : isAdl ? V_ADL_ACCT_MATCHER_CONTEXT_OFF : ACCT_MATCHER_CONTEXT_OFF;
+  const feeCreditsOff = isV12_1 ? V12_1_ACCT_FEE_CREDITS_OFF : isAdl ? V_ADL_ACCT_FEE_CREDITS_OFF : ACCT_FEE_CREDITS_OFF;
+  const lastFeeSlotOff = isV12_1 ? V12_1_ACCT_LAST_FEE_SLOT_OFF : isAdl ? V_ADL_ACCT_LAST_FEE_SLOT_OFF : ACCT_LAST_FEE_SLOT_OFF;
   const kindByte = readU8(data, base + ACCT_KIND_OFF);
   const kind = kindByte === 1 ? 1 /* LP */ : 0 /* User */;
   return {
@@ -2405,8 +2726,10 @@ function parseAccount(data, idx) {
     warmupStartedAtSlot: readU64LE(data, base + warmupStartedOff),
     warmupSlopePerStep: readU128LE(data, base + warmupSlopeOff),
     positionSize: readI128LE(data, base + positionSizeOff),
-    entryPrice: readU64LE(data, base + entryPriceOff),
-    fundingIndex: readI128LE(data, base + fundingIndexOff),
+    entryPrice: entryPriceOff >= 0 ? readU64LE(data, base + entryPriceOff) : 0n,
+    // V12_1: entry_price removed
+    // V12_1 changed funding_index from i128 to i64 (legacy field moved to end of account)
+    fundingIndex: isV12_1 ? BigInt(readI64LE(data, base + fundingIndexOff)) : readI128LE(data, base + fundingIndexOff),
     matcherProgram: new PublicKey3(data.subarray(base + matcherProgOff, base + matcherProgOff + 32)),
     matcherContext: new PublicKey3(data.subarray(base + matcherCtxOff, base + matcherCtxOff + 32)),
     owner: new PublicKey3(data.subarray(base + layout.acctOwnerOff, base + layout.acctOwnerOff + 32)),
@@ -2439,12 +2762,6 @@ function deriveVaultAuthority(programId, slab) {
     programId
   );
 }
-function deriveInsuranceLpMint(programId, slab) {
-  return PublicKey4.findProgramAddressSync(
-    [textEncoder.encode("ins_lp"), slab.toBytes()],
-    programId
-  );
-}
 var LP_INDEX_U16_MAX = 65535;
 function deriveLpPda(programId, slab, lpIdx) {
   if (typeof lpIdx !== "number" || !Number.isInteger(lpIdx) || lpIdx < 0 || lpIdx > LP_INDEX_U16_MAX) {
@@ -2501,7 +2818,14 @@ function derivePythPushOraclePDA(feedIdHex) {
   }
   const feedId = new Uint8Array(32);
   for (let i = 0; i < 32; i++) {
-    feedId[i] = parseInt(normalized.substring(i * 2, i * 2 + 2), 16);
+    const hexPair = normalized.substring(i * 2, i * 2 + 2);
+    const byte = parseInt(hexPair, 16);
+    if (Number.isNaN(byte)) {
+      throw new Error(
+        `derivePythPushOraclePDA: failed to parse hex byte at position ${i}: "${hexPair}"`
+      );
+    }
+    feedId[i] = byte;
   }
   const shardBuf = new Uint8Array(2);
   return PublicKey4.findProgramAddressSync(
@@ -2527,13 +2851,76 @@ async function fetchTokenAccount(connection, address, tokenProgramId = TOKEN_PRO
   return getAccount(connection, address, void 0, tokenProgramId);
 }
 
+// src/solana/discovery.ts
+import { PublicKey as PublicKey6 } from "@solana/web3.js";
+
+// src/solana/static-markets.ts
+import { PublicKey as PublicKey5 } from "@solana/web3.js";
+var MAINNET_MARKETS = [
+  // Populated at mainnet launch — currently empty.
+  // To add entries:
+  //   { slabAddress: "ABC123...", symbol: "SOL-PERP", name: "SOL Perpetual" },
+];
+var DEVNET_MARKETS = [
+  // Populated from prior discoverMarkets() runs on devnet.
+  // These serve as the tier-3 safety net for devnet users.
+];
+var STATIC_REGISTRY = {
+  mainnet: MAINNET_MARKETS,
+  devnet: DEVNET_MARKETS
+};
+var USER_MARKETS = {
+  mainnet: [],
+  devnet: []
+};
+function getStaticMarkets(network) {
+  const builtin = STATIC_REGISTRY[network] ?? [];
+  const user = USER_MARKETS[network] ?? [];
+  if (user.length === 0) return [...builtin];
+  const seen = /* @__PURE__ */ new Map();
+  for (const entry of builtin) {
+    seen.set(entry.slabAddress, entry);
+  }
+  for (const entry of user) {
+    seen.set(entry.slabAddress, entry);
+  }
+  return [...seen.values()];
+}
+function registerStaticMarkets(network, entries) {
+  const existing = USER_MARKETS[network];
+  const seen = new Set(existing.map((e) => e.slabAddress));
+  for (const entry of entries) {
+    if (!entry.slabAddress) continue;
+    if (seen.has(entry.slabAddress)) continue;
+    try {
+      new PublicKey5(entry.slabAddress);
+    } catch {
+      console.warn(
+        `[registerStaticMarkets] Skipping invalid slabAddress: ${entry.slabAddress}`
+      );
+      continue;
+    }
+    seen.add(entry.slabAddress);
+    existing.push(entry);
+  }
+}
+function clearStaticMarkets(network) {
+  if (network) {
+    USER_MARKETS[network] = [];
+  } else {
+    USER_MARKETS.mainnet = [];
+    USER_MARKETS.devnet = [];
+  }
+}
+
 // src/solana/discovery.ts
 var ENGINE_BITMAP_OFF_V0 = 320;
 var MAGIC_BYTES = new Uint8Array([84, 65, 76, 79, 67, 82, 69, 80]);
 var SLAB_TIERS = {
-  small: { maxAccounts: 256, dataSize: 65352, label: "Small", description: "256 slots \xB7 ~0.45 SOL" },
-  medium: { maxAccounts: 1024, dataSize: 257448, label: "Medium", description: "1,024 slots \xB7 ~1.79 SOL" },
-  large: { maxAccounts: 4096, dataSize: 1025832, label: "Large", description: "4,096 slots \xB7 ~7.14 SOL" }
+  micro: SLAB_TIERS_V12_1["micro"],
+  small: SLAB_TIERS_V12_1["small"],
+  medium: SLAB_TIERS_V12_1["medium"],
+  large: SLAB_TIERS_V12_1["large"]
 };
 var SLAB_TIERS_V0 = {
   small: { maxAccounts: 256, dataSize: 62808, label: "Small", description: "256 slots \xB7 ~0.44 SOL" },
@@ -2911,22 +3298,77 @@ async function discoverMarkets(connection, programId, options = {}) {
       "[discoverMarkets] dataSize filters failed, falling back to memcmp:",
       err instanceof Error ? err.message : err
     );
-    const fallback = await connection.getProgramAccounts(programId, {
-      filters: [
-        {
-          memcmp: {
-            offset: 0,
-            bytes: "F6P2QNqpQV5"
-            // base58 of TALOCREP (u64 LE magic)
+    try {
+      const fallback = await connection.getProgramAccounts(programId, {
+        filters: [
+          {
+            memcmp: {
+              offset: 0,
+              bytes: "F6P2QNqpQV5"
+              // base58 of TALOCREP (u64 LE magic)
+            }
           }
-        }
-      ],
-      dataSlice: { offset: 0, length: HEADER_SLICE_LENGTH }
-    });
-    rawAccounts = [...fallback].map((e) => ({ ...e, maxAccounts: 4096, dataSize: SLAB_TIERS.large.dataSize }));
+        ],
+        dataSlice: { offset: 0, length: HEADER_SLICE_LENGTH }
+      });
+      rawAccounts = [...fallback].map((e) => ({ ...e, maxAccounts: 4096, dataSize: SLAB_TIERS.large.dataSize }));
+    } catch (memcmpErr) {
+      console.warn(
+        "[discoverMarkets] memcmp fallback also failed:",
+        memcmpErr instanceof Error ? memcmpErr.message : memcmpErr
+      );
+    }
   }
-  const accounts = rawAccounts;
-  const markets = [];
+  if (rawAccounts.length === 0 && options.apiBaseUrl) {
+    console.warn(
+      "[discoverMarkets] RPC discovery returned 0 markets, falling back to REST API"
+    );
+    try {
+      const apiResult = await discoverMarketsViaApi(
+        connection,
+        programId,
+        options.apiBaseUrl,
+        { timeoutMs: options.apiTimeoutMs }
+      );
+      if (apiResult.length > 0) {
+        return apiResult;
+      }
+      console.warn(
+        "[discoverMarkets] REST API returned 0 markets, checking tier-3 static bundle"
+      );
+    } catch (apiErr) {
+      console.warn(
+        "[discoverMarkets] API fallback also failed:",
+        apiErr instanceof Error ? apiErr.message : apiErr
+      );
+    }
+  }
+  if (rawAccounts.length === 0 && options.network) {
+    const staticEntries = getStaticMarkets(options.network);
+    if (staticEntries.length > 0) {
+      console.warn(
+        `[discoverMarkets] Tier 1+2 failed, falling back to static bundle (${staticEntries.length} addresses for ${options.network})`
+      );
+      try {
+        return await discoverMarketsViaStaticBundle(
+          connection,
+          programId,
+          staticEntries
+        );
+      } catch (staticErr) {
+        console.warn(
+          "[discoverMarkets] Static bundle fallback also failed:",
+          staticErr instanceof Error ? staticErr.message : staticErr
+        );
+      }
+    } else {
+      console.warn(
+        `[discoverMarkets] Static bundle has 0 entries for ${options.network} \u2014 skipping tier 3`
+      );
+    }
+  }
+  const accounts = rawAccounts;
+  const markets = [];
   const seenPubkeys = /* @__PURE__ */ new Set();
   for (const { pubkey, account, maxAccounts, dataSize } of accounts) {
     const pkStr = pubkey.toBase58();
@@ -2963,9 +3405,145 @@ async function discoverMarkets(connection, programId, options = {}) {
   }
   return markets;
 }
+async function getMarketsByAddress(connection, programId, addresses, options = {}) {
+  if (addresses.length === 0) return [];
+  const {
+    batchSize = 100,
+    interBatchDelayMs = 0
+  } = options;
+  const effectiveBatchSize = Math.max(1, Math.min(batchSize, 100));
+  const fetched = [];
+  for (let offset = 0; offset < addresses.length; offset += effectiveBatchSize) {
+    const batch = addresses.slice(offset, offset + effectiveBatchSize);
+    const response = await connection.getMultipleAccountsInfo(batch);
+    for (let i = 0; i < batch.length; i++) {
+      const info = response[i];
+      if (info && info.data) {
+        if (!info.owner.equals(programId)) {
+          console.warn(
+            `[getMarketsByAddress] Skipping ${batch[i].toBase58()}: owner mismatch (expected ${programId.toBase58()}, got ${info.owner.toBase58()})`
+          );
+          continue;
+        }
+        fetched.push({ pubkey: batch[i], data: info.data });
+      }
+    }
+    if (interBatchDelayMs > 0 && offset + effectiveBatchSize < addresses.length) {
+      await new Promise((r) => setTimeout(r, interBatchDelayMs));
+    }
+  }
+  const markets = [];
+  for (const entry of fetched) {
+    if (!entry) continue;
+    const { pubkey, data: rawData } = entry;
+    const data = new Uint8Array(rawData);
+    let valid = true;
+    for (let i = 0; i < MAGIC_BYTES.length; i++) {
+      if (data[i] !== MAGIC_BYTES[i]) {
+        valid = false;
+        break;
+      }
+    }
+    if (!valid) {
+      console.warn(
+        `[getMarketsByAddress] Skipping ${pubkey.toBase58()}: invalid magic bytes`
+      );
+      continue;
+    }
+    const layout = detectSlabLayout(data.length, data);
+    if (!layout) {
+      console.warn(
+        `[getMarketsByAddress] Skipping ${pubkey.toBase58()}: unrecognized layout for dataSize=${data.length}`
+      );
+      continue;
+    }
+    try {
+      const header = parseHeader(data);
+      const config = parseConfig(data, layout);
+      const engine = parseEngineLight(data, layout, layout.maxAccounts);
+      const params = parseParams(data, layout);
+      markets.push({ slabAddress: pubkey, programId, header, config, engine, params });
+    } catch (err) {
+      console.warn(
+        `[getMarketsByAddress] Failed to parse account ${pubkey.toBase58()}:`,
+        err instanceof Error ? err.message : err
+      );
+    }
+  }
+  return markets;
+}
+async function discoverMarketsViaApi(connection, programId, apiBaseUrl, options = {}) {
+  const { timeoutMs = 1e4, onChainOptions } = options;
+  const base = apiBaseUrl.replace(/\/+$/, "");
+  const url = `${base}/markets`;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  let response;
+  try {
+    response = await fetch(url, {
+      method: "GET",
+      headers: { Accept: "application/json" },
+      signal: controller.signal
+    });
+  } finally {
+    clearTimeout(timer);
+  }
+  if (!response.ok) {
+    throw new Error(
+      `[discoverMarketsViaApi] API returned ${response.status} ${response.statusText} from ${url}`
+    );
+  }
+  const body = await response.json();
+  const apiMarkets = body.markets;
+  if (!Array.isArray(apiMarkets) || apiMarkets.length === 0) {
+    console.warn("[discoverMarketsViaApi] API returned 0 markets");
+    return [];
+  }
+  const addresses = [];
+  for (const entry of apiMarkets) {
+    if (!entry.slab_address || typeof entry.slab_address !== "string") continue;
+    try {
+      addresses.push(new PublicKey6(entry.slab_address));
+    } catch {
+      console.warn(
+        `[discoverMarketsViaApi] Skipping invalid slab address: ${entry.slab_address}`
+      );
+    }
+  }
+  if (addresses.length === 0) {
+    console.warn("[discoverMarketsViaApi] No valid slab addresses from API");
+    return [];
+  }
+  console.log(
+    `[discoverMarketsViaApi] API returned ${addresses.length} slab addresses, fetching on-chain data`
+  );
+  return getMarketsByAddress(connection, programId, addresses, onChainOptions);
+}
+async function discoverMarketsViaStaticBundle(connection, programId, entries, options = {}) {
+  if (entries.length === 0) return [];
+  const addresses = [];
+  for (const entry of entries) {
+    if (!entry.slabAddress || typeof entry.slabAddress !== "string") continue;
+    try {
+      addresses.push(new PublicKey6(entry.slabAddress));
+    } catch {
+      console.warn(
+        `[discoverMarketsViaStaticBundle] Skipping invalid slab address: ${entry.slabAddress}`
+      );
+    }
+  }
+  if (addresses.length === 0) {
+    console.warn("[discoverMarketsViaStaticBundle] No valid slab addresses in static bundle");
+    return [];
+  }
+  console.log(
+    `[discoverMarketsViaStaticBundle] Fetching ${addresses.length} slab addresses on-chain`
+  );
+  return getMarketsByAddress(connection, programId, addresses, options.onChainOptions);
+}
 
 // src/solana/dex-oracle.ts
-import { PublicKey as PublicKey5 } from "@solana/web3.js";
+import { PublicKey as PublicKey7 } from "@solana/web3.js";
 function detectDexType(ownerProgramId) {
   if (ownerProgramId.equals(PUMPSWAP_PROGRAM_ID)) return "pumpswap";
   if (ownerProgramId.equals(RAYDIUM_CLMM_PROGRAM_ID)) return "raydium-clmm";
@@ -3001,10 +3579,10 @@ function parsePumpSwapPool(poolAddress, data) {
   return {
     dexType: "pumpswap",
     poolAddress,
-    baseMint: new PublicKey5(data.slice(35, 67)),
-    quoteMint: new PublicKey5(data.slice(67, 99)),
-    baseVault: new PublicKey5(data.slice(131, 163)),
-    quoteVault: new PublicKey5(data.slice(163, 195))
+    baseMint: new PublicKey7(data.slice(35, 67)),
+    quoteMint: new PublicKey7(data.slice(67, 99)),
+    baseVault: new PublicKey7(data.slice(131, 163)),
+    quoteVault: new PublicKey7(data.slice(163, 195))
   };
 }
 var SPL_TOKEN_AMOUNT_MIN_LEN = 72;
@@ -3030,8 +3608,8 @@ function parseRaydiumClmmPool(poolAddress, data) {
   return {
     dexType: "raydium-clmm",
     poolAddress,
-    baseMint: new PublicKey5(data.slice(73, 105)),
-    quoteMint: new PublicKey5(data.slice(105, 137))
+    baseMint: new PublicKey7(data.slice(73, 105)),
+    quoteMint: new PublicKey7(data.slice(105, 137))
   };
 }
 var MAX_TOKEN_DECIMALS = 24;
@@ -3049,9 +3627,7 @@ function computeRaydiumClmmPriceE6(data) {
   }
   const sqrtPriceX64 = readU128LE3(dv3, 253);
   if (sqrtPriceX64 === 0n) return 0n;
-  const scaledSqrt = sqrtPriceX64 * 1000000n;
-  const term = scaledSqrt >> 64n;
-  const priceE6Raw = term * sqrtPriceX64 >> 64n;
+  const priceE6Raw = sqrtPriceX64 * sqrtPriceX64 * 1000000n >> 128n;
   const decimalDiff = 6 + decimals0 - decimals1;
   const adjustedDiff = decimalDiff - 6;
   if (adjustedDiff >= 0) {
@@ -3070,8 +3646,8 @@ function parseMeteoraPool(poolAddress, data) {
   return {
     dexType: "meteora-dlmm",
     poolAddress,
-    baseMint: new PublicKey5(data.slice(81, 113)),
-    quoteMint: new PublicKey5(data.slice(113, 145))
+    baseMint: new PublicKey7(data.slice(81, 113)),
+    quoteMint: new PublicKey7(data.slice(113, 145))
   };
 }
 var MAX_BIN_STEP = 1e4;
@@ -3104,7 +3680,14 @@ function computeMeteoraDlmmPriceE6(data) {
   let exp = isNeg ? BigInt(-activeId) : BigInt(activeId);
   let result = SCALE;
   let b = base;
+  let iterations = 0;
+  const MAX_ITERATIONS = 25;
   while (exp > 0n) {
+    if (iterations++ >= MAX_ITERATIONS) {
+      throw new Error(
+        `Meteora DLMM: exponentiation loop exceeded ${MAX_ITERATIONS} iterations (activeId=${activeId})`
+      );
+    }
     if (exp & 1n) {
       result = result * b / SCALE;
     }
@@ -3135,6 +3718,7 @@ function readU128LE3(dv3, offset) {
 var CHAINLINK_MIN_SIZE = 224;
 var MAX_DECIMALS = 18;
 var CHAINLINK_DECIMALS_OFFSET = 138;
+var CHAINLINK_TIMESTAMP_OFFSET = 168;
 var CHAINLINK_ANSWER_OFFSET = 216;
 function readU82(data, off) {
   return data[off];
@@ -3142,7 +3726,7 @@ function readU82(data, off) {
 function readBigInt64LE(data, off) {
   return new DataView(data.buffer, data.byteOffset, data.byteLength).getBigInt64(off, true);
 }
-function parseChainlinkPrice(data) {
+function parseChainlinkPrice(data, options) {
   if (data.length < CHAINLINK_MIN_SIZE) {
     throw new Error(
       `Oracle account data too small: ${data.length} bytes (need at least ${CHAINLINK_MIN_SIZE})`
@@ -3160,7 +3744,18 @@ function parseChainlinkPrice(data) {
       `Oracle price is non-positive: ${price}`
     );
   }
-  return { price, decimals };
+  const updatedAtBig = readBigInt64LE(data, CHAINLINK_TIMESTAMP_OFFSET);
+  const updatedAt = Number(updatedAtBig);
+  if (options?.maxStalenessSeconds !== void 0 && updatedAt > 0) {
+    const now = Math.floor(Date.now() / 1e3);
+    const age = now - updatedAt;
+    if (age > options.maxStalenessSeconds) {
+      throw new Error(
+        `Oracle price is stale: last updated ${age}s ago (max ${options.maxStalenessSeconds}s)`
+      );
+    }
+  }
+  return { price, decimals, updatedAt: updatedAt > 0 ? updatedAt : void 0 };
 }
 function isValidChainlinkOracle(data) {
   try {
@@ -3172,15 +3767,19 @@ function isValidChainlinkOracle(data) {
 }
 
 // src/solana/token-program.ts
-import { PublicKey as PublicKey6 } from "@solana/web3.js";
+import { PublicKey as PublicKey8 } from "@solana/web3.js";
 import { TOKEN_PROGRAM_ID as TOKEN_PROGRAM_ID3 } from "@solana/spl-token";
-var TOKEN_2022_PROGRAM_ID = new PublicKey6(
+var TOKEN_2022_PROGRAM_ID = new PublicKey8(
   "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb"
 );
 async function detectTokenProgram(connection, mint) {
   const info = await connection.getAccountInfo(mint);
   if (!info) throw new Error(`Mint account not found: ${mint.toBase58()}`);
-  return info.owner;
+  if (info.owner.equals(TOKEN_PROGRAM_ID3)) return TOKEN_PROGRAM_ID3;
+  if (info.owner.equals(TOKEN_2022_PROGRAM_ID)) return TOKEN_2022_PROGRAM_ID;
+  throw new Error(
+    `Mint ${mint.toBase58()} is owned by ${info.owner.toBase58()}, which is neither TOKEN_PROGRAM_ID nor TOKEN_2022_PROGRAM_ID`
+  );
 }
 function isToken2022(tokenProgramId) {
   return tokenProgramId.equals(TOKEN_2022_PROGRAM_ID);
@@ -3190,11 +3789,11 @@ function isStandardToken(tokenProgramId) {
 }
 
 // src/solana/stake.ts
-import { PublicKey as PublicKey8, SystemProgram as SystemProgram2, SYSVAR_RENT_PUBKEY as SYSVAR_RENT_PUBKEY2, SYSVAR_CLOCK_PUBKEY as SYSVAR_CLOCK_PUBKEY2 } from "@solana/web3.js";
+import { PublicKey as PublicKey10, SystemProgram as SystemProgram2, SYSVAR_RENT_PUBKEY as SYSVAR_RENT_PUBKEY2, SYSVAR_CLOCK_PUBKEY as SYSVAR_CLOCK_PUBKEY2 } from "@solana/web3.js";
 import { TOKEN_PROGRAM_ID as TOKEN_PROGRAM_ID4 } from "@solana/spl-token";
 
 // src/config/program-ids.ts
-import { PublicKey as PublicKey7 } from "@solana/web3.js";
+import { PublicKey as PublicKey9 } from "@solana/web3.js";
 function safeEnv(key) {
   try {
     return typeof process !== "undefined" && process?.env ? process.env[key] : void 0;
@@ -3208,30 +3807,34 @@ var PROGRAM_IDS = {
     matcher: "GTRgyTDfrMvBubALAqtHuQwT8tbGyXid7svXZKtWfC9k"
   },
   mainnet: {
-    percolator: "GM8zjJ8LTBMv9xEsverh6H6wLyevgMHEJXcEzyY3rY24",
+    percolator: "ESa89R5Es3rJ5mnwGybVRG1GrNt9etP11Z5V2QWD4edv",
     matcher: "DHP6DtwXP1yJsz8YzfoeigRFPB979gzmumkmCxDLSkUX"
   }
 };
 function getProgramId(network) {
-  const override = safeEnv("PROGRAM_ID");
-  if (override) {
-    console.warn(
-      `[percolator-sdk] PROGRAM_ID env override active: ${override} \u2014 ensure this points to a trusted program`
-    );
-    return new PublicKey7(override);
+  if (!network) {
+    const override = safeEnv("PROGRAM_ID");
+    if (override) {
+      console.warn(
+        `[percolator-sdk] PROGRAM_ID env override active: ${override} \u2014 ensure this points to a trusted program`
+      );
+      return new PublicKey9(override);
+    }
   }
   const detectedNetwork = getCurrentNetwork();
   const targetNetwork = network ?? detectedNetwork;
   const programId = PROGRAM_IDS[targetNetwork].percolator;
-  return new PublicKey7(programId);
+  return new PublicKey9(programId);
 }
 function getMatcherProgramId(network) {
-  const override = safeEnv("MATCHER_PROGRAM_ID");
-  if (override) {
-    console.warn(
-      `[percolator-sdk] MATCHER_PROGRAM_ID env override active: ${override} \u2014 ensure this points to a trusted program`
-    );
-    return new PublicKey7(override);
+  if (!network) {
+    const override = safeEnv("MATCHER_PROGRAM_ID");
+    if (override) {
+      console.warn(
+        `[percolator-sdk] MATCHER_PROGRAM_ID env override active: ${override} \u2014 ensure this points to a trusted program`
+      );
+      return new PublicKey9(override);
+    }
   }
   const detectedNetwork = getCurrentNetwork();
   const targetNetwork = network ?? detectedNetwork;
@@ -3239,7 +3842,7 @@ function getMatcherProgramId(network) {
   if (!programId) {
     throw new Error(`Matcher program not deployed on ${targetNetwork}`);
   }
-  return new PublicKey7(programId);
+  return new PublicKey9(programId);
 }
 function getCurrentNetwork() {
   const network = safeEnv("NETWORK")?.toLowerCase();
@@ -3252,8 +3855,7 @@ function getCurrentNetwork() {
 // src/solana/stake.ts
 var STAKE_PROGRAM_IDS = {
   devnet: "6aJb1F9CDCVWCNYFwj8aQsVb696YnW6J1FznteHq4Q6k",
-  mainnet: ""
-  // TODO: populate once DevOps deploys percolator-stake to mainnet
+  mainnet: "DC5fovFQD5SZYsetwvEqd4Wi4PFY1Yfnc669VMe6oa7F"
 };
 function getStakeProgramId(network) {
   const override = safeEnv("STAKE_PROGRAM_ID");
@@ -3261,7 +3863,7 @@ function getStakeProgramId(network) {
     console.warn(
       `[percolator-sdk] STAKE_PROGRAM_ID env override active: ${override} \u2014 ensure this points to a trusted program`
     );
-    return new PublicKey8(override);
+    return new PublicKey10(override);
   }
   const detectedNetwork = network ?? (() => {
     const n = safeEnv("NEXT_PUBLIC_DEFAULT_NETWORK")?.toLowerCase() ?? safeEnv("NETWORK")?.toLowerCase() ?? "";
@@ -3273,9 +3875,9 @@ function getStakeProgramId(network) {
       `Stake program not deployed on ${detectedNetwork}. Set STAKE_PROGRAM_ID env var or wait for DevOps to deploy and update STAKE_PROGRAM_IDS.mainnet.`
     );
   }
-  return new PublicKey8(id);
+  return new PublicKey10(id);
 }
-var STAKE_PROGRAM_ID = new PublicKey8(STAKE_PROGRAM_IDS.devnet);
+var STAKE_PROGRAM_ID = new PublicKey10(STAKE_PROGRAM_IDS.mainnet);
 var STAKE_IX = {
   InitPool: 0,
   Deposit: 1,
@@ -3302,19 +3904,19 @@ var STAKE_IX = {
 };
 var TEXT = new TextEncoder();
 function deriveStakePool(slab, programId) {
-  return PublicKey8.findProgramAddressSync(
+  return PublicKey10.findProgramAddressSync(
     [TEXT.encode("stake_pool"), slab.toBytes()],
     programId ?? getStakeProgramId()
   );
 }
 function deriveStakeVaultAuth(pool, programId) {
-  return PublicKey8.findProgramAddressSync(
+  return PublicKey10.findProgramAddressSync(
     [TEXT.encode("vault_auth"), pool.toBytes()],
     programId ?? getStakeProgramId()
   );
 }
 function deriveDepositPda(pool, user, programId) {
-  return PublicKey8.findProgramAddressSync(
+  return PublicKey10.findProgramAddressSync(
     [TEXT.encode("deposit"), pool.toBytes(), user.toBytes()],
     programId ?? getStakeProgramId()
   );
@@ -3336,6 +3938,9 @@ function readU16LE3(data, off) {
   );
 }
 function u64Le(v) {
+  if (typeof v === "number" && !Number.isSafeInteger(v)) {
+    throw new Error(`u64Le: number ${v} exceeds Number.MAX_SAFE_INTEGER \u2014 use BigInt`);
+  }
   const big = BigInt(v);
   if (big < 0n) throw new Error(`u64Le: value must be non-negative, got ${big}`);
   if (big > 0xFFFFFFFFFFFFFFFFn) throw new Error(`u64Le: value exceeds u64 max`);
@@ -3344,6 +3949,9 @@ function u64Le(v) {
   return arr;
 }
 function u128Le(v) {
+  if (typeof v === "number" && !Number.isSafeInteger(v)) {
+    throw new Error(`u128Le: number ${v} exceeds Number.MAX_SAFE_INTEGER \u2014 use BigInt`);
+  }
   const big = BigInt(v);
   if (big < 0n) throw new Error(`u128Le: value must be non-negative, got ${big}`);
   if (big > (1n << 128n) - 1n) throw new Error(`u128Le: value exceeds u128 max`);
@@ -3354,7 +3962,7 @@ function u128Le(v) {
   return arr;
 }
 function u16Le(v) {
-  if (v < 0 || v > 65535) throw new Error(`u16Le: value out of u16 range (0..65535), got ${v}`);
+  if (!Number.isInteger(v) || v < 0 || v > 65535) throw new Error(`u16Le: value must be integer in range 0..65535, got ${v}`);
   const arr = new Uint8Array(2);
   new DataView(arr.buffer).setUint16(0, v, true);
   return arr;
@@ -3465,15 +4073,15 @@ function decodeStakePool(data) {
   const adminTransferred = bytes[off] === 1;
   off += 1;
   off += 4;
-  const slab = new PublicKey8(bytes.subarray(off, off + 32));
+  const slab = new PublicKey10(bytes.subarray(off, off + 32));
   off += 32;
-  const admin = new PublicKey8(bytes.subarray(off, off + 32));
+  const admin = new PublicKey10(bytes.subarray(off, off + 32));
   off += 32;
-  const collateralMint = new PublicKey8(bytes.subarray(off, off + 32));
+  const collateralMint = new PublicKey10(bytes.subarray(off, off + 32));
   off += 32;
-  const lpMint = new PublicKey8(bytes.subarray(off, off + 32));
+  const lpMint = new PublicKey10(bytes.subarray(off, off + 32));
   off += 32;
-  const vault = new PublicKey8(bytes.subarray(off, off + 32));
+  const vault = new PublicKey10(bytes.subarray(off, off + 32));
   off += 32;
   const totalDeposited = readU64LE4(bytes, off);
   off += 8;
@@ -3489,7 +4097,7 @@ function decodeStakePool(data) {
   off += 8;
   const totalWithdrawn = readU64LE4(bytes, off);
   off += 8;
-  const percolatorProgram = new PublicKey8(bytes.subarray(off, off + 32));
+  const percolatorProgram = new PublicKey10(bytes.subarray(off, off + 32));
   off += 32;
   const totalFeesEarned = readU64LE4(bytes, off);
   off += 8;
@@ -3609,7 +4217,9 @@ function computePnlPct(pnl, capital) {
 }
 function isAdlTriggered(slabData) {
   const layout = detectSlabLayout(slabData.length);
-  if (!layout) return false;
+  if (!layout) {
+    return false;
+  }
   try {
     const engine = parseEngine(slabData);
     if (engine.pnlPosTot === 0n) return false;
@@ -3652,6 +4262,14 @@ function rankAdlPositions(slabData) {
     if (account.kind !== 0 /* User */) continue;
     if (account.positionSize === 0n) continue;
     const side = account.positionSize > 0n ? "long" : "short";
+    if (side === "long" && account.positionSize <= 0n) {
+      console.warn(`[fetchAdlRankedPositions] account idx=${idx}: side=long but positionSize=${account.positionSize}`);
+      continue;
+    }
+    if (side === "short" && account.positionSize >= 0n) {
+      console.warn(`[fetchAdlRankedPositions] account idx=${idx}: side=short but positionSize=${account.positionSize}`);
+      continue;
+    }
     const pnlPct = computePnlPct(account.pnl, account.capital);
     positions.push({
       idx,
@@ -3725,7 +4343,11 @@ function parseAdlEvent(logs) {
     }
     if (tag !== ADL_EVENT_TAG) continue;
     try {
-      const targetIdx = Number(BigInt(match[2]));
+      const targetIdxBig = BigInt(match[2]);
+      if (targetIdxBig < 0n || targetIdxBig > 65535n) {
+        continue;
+      }
+      const targetIdx = Number(targetIdxBig);
       const price = BigInt(match[3]);
       const closedLo = BigInt(match[4]);
       const closedHi = BigInt(match[5]);
@@ -3753,9 +4375,387 @@ async function fetchAdlRankings(apiBase, slab, fetchFn = fetch) {
     );
   }
   const json = await res.json();
+  if (typeof json !== "object" || json === null) {
+    throw new Error("fetchAdlRankings: API returned non-object response");
+  }
+  const obj = json;
+  if (!Array.isArray(obj.rankings)) {
+    throw new Error("fetchAdlRankings: API response missing rankings array");
+  }
+  for (const entry of obj.rankings) {
+    if (typeof entry !== "object" || entry === null) {
+      throw new Error("fetchAdlRankings: invalid ranking entry (not an object)");
+    }
+    const r = entry;
+    if (typeof r.idx !== "number" || !Number.isInteger(r.idx) || r.idx < 0) {
+      throw new Error(`fetchAdlRankings: invalid ranking idx: ${r.idx}`);
+    }
+  }
   return json;
 }
 
+// src/solana/rpc-pool.ts
+import {
+  Connection as Connection5
+} from "@solana/web3.js";
+async function checkRpcHealth(endpoint, timeoutMs = 5e3) {
+  const conn = new Connection5(endpoint, { commitment: "processed" });
+  const start = performance.now();
+  const timeout = rejectAfter(timeoutMs, `Health probe timed out after ${timeoutMs}ms`);
+  try {
+    const slot = await Promise.race([
+      conn.getSlot("processed"),
+      timeout.promise
+    ]);
+    const latencyMs = Math.round(performance.now() - start);
+    return { endpoint, healthy: true, latencyMs, slot };
+  } catch (err) {
+    const latencyMs = Math.round(performance.now() - start);
+    return {
+      endpoint,
+      healthy: false,
+      latencyMs,
+      slot: 0,
+      error: err instanceof Error ? err.message : String(err)
+    };
+  } finally {
+    timeout.cancel();
+  }
+}
+function resolveRetryConfig(cfg) {
+  if (cfg === false) return null;
+  const c = cfg ?? {};
+  return {
+    maxRetries: c.maxRetries ?? 3,
+    baseDelayMs: c.baseDelayMs ?? 500,
+    maxDelayMs: c.maxDelayMs ?? 1e4,
+    jitterFactor: Math.max(0, Math.min(1, c.jitterFactor ?? 0.25)),
+    retryableStatusCodes: c.retryableStatusCodes ?? [429, 502, 503, 504]
+  };
+}
+function normalizeEndpoint(ep) {
+  if (typeof ep === "string") return { url: ep };
+  return ep;
+}
+function endpointLabel(ep) {
+  if (ep.label) return ep.label;
+  try {
+    return new URL(ep.url).hostname;
+  } catch {
+    return ep.url.slice(0, 40);
+  }
+}
+function isRetryable(err, codes) {
+  if (!err) return false;
+  const msg = err instanceof Error ? err.message : String(err);
+  for (const code of codes) {
+    if (msg.includes(String(code))) return true;
+  }
+  if (msg.toLowerCase().includes("rate limit") || msg.toLowerCase().includes("too many requests") || msg.toLowerCase().includes("econnreset") || msg.toLowerCase().includes("econnrefused") || msg.toLowerCase().includes("socket hang up") || msg.toLowerCase().includes("network") || msg.toLowerCase().includes("timeout") || msg.toLowerCase().includes("abort")) {
+    return true;
+  }
+  return false;
+}
+function computeDelay(attempt, config) {
+  const raw = Math.min(
+    config.baseDelayMs * Math.pow(2, attempt),
+    config.maxDelayMs
+  );
+  const jitter = Math.floor(Math.random() * raw * config.jitterFactor);
+  return raw + jitter;
+}
+function rejectAfter(ms, message) {
+  let timer;
+  const promise = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error(message)), ms);
+  });
+  return { promise, cancel: () => clearTimeout(timer) };
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function redactUrl(raw) {
+  try {
+    const u = new URL(raw);
+    const sensitive = /^(api[-_]?key|access[-_]?token|auth[-_]?token|token|secret|key|password|bearer|credential|jwt)$/i;
+    for (const k of [...u.searchParams.keys()]) {
+      if (sensitive.test(k)) {
+        u.searchParams.set(k, "***");
+      }
+    }
+    return u.toString();
+  } catch {
+    return raw;
+  }
+}
+var RpcPool = class _RpcPool {
+  endpoints;
+  strategy;
+  retryConfig;
+  requestTimeoutMs;
+  verbose;
+  /** Round-robin index tracker. */
+  rrIndex = 0;
+  /** Consecutive failure threshold before marking an endpoint unhealthy. */
+  static UNHEALTHY_THRESHOLD = 3;
+  /** Minimum endpoints before auto-recovery is attempted. */
+  static MIN_HEALTHY = 1;
+  constructor(config) {
+    if (!config.endpoints || config.endpoints.length === 0) {
+      throw new Error("RpcPool: at least one endpoint is required");
+    }
+    this.strategy = config.strategy ?? "failover";
+    this.retryConfig = resolveRetryConfig(config.retry);
+    this.requestTimeoutMs = config.requestTimeoutMs ?? 3e4;
+    this.verbose = config.verbose ?? true;
+    const commitment = config.commitment ?? "confirmed";
+    this.endpoints = config.endpoints.map((raw) => {
+      const ep = normalizeEndpoint(raw);
+      const connConfig = {
+        commitment,
+        ...ep.connectionConfig
+      };
+      return {
+        config: ep,
+        connection: new Connection5(ep.url, connConfig),
+        label: endpointLabel(ep),
+        weight: Math.max(1, ep.weight ?? 1),
+        failures: 0,
+        healthy: true,
+        lastLatencyMs: -1
+      };
+    });
+  }
+  // -----------------------------------------------------------------------
+  // Public API
+  // -----------------------------------------------------------------------
+  /**
+   * Execute a function against a pooled connection with automatic retry
+   * and failover.
+   *
+   * @param fn - Async function that receives a `Connection` and returns a result.
+   * @returns The result of `fn`.
+   * @throws The last error if all retries and failovers are exhausted.
+   *
+   * @example
+   * ```ts
+   * const balance = await pool.call(c => c.getBalance(pubkey));
+   * const markets = await pool.call(c => discoverMarkets(c, programId, opts));
+   * ```
+   */
+  async call(fn) {
+    const maxAttempts = this.retryConfig ? this.retryConfig.maxRetries + 1 : 1;
+    let lastError;
+    const triedEndpoints = /* @__PURE__ */ new Set();
+    const maxTotalIterations = maxAttempts + this.endpoints.length;
+    let totalIterations = 0;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      if (++totalIterations > maxTotalIterations) break;
+      const epIdx = this.selectEndpoint(triedEndpoints);
+      if (epIdx === -1) {
+        break;
+      }
+      const ep = this.endpoints[epIdx];
+      const timeout = rejectAfter(this.requestTimeoutMs, `RPC request timed out after ${this.requestTimeoutMs}ms (${ep.label})`);
+      try {
+        const result = await Promise.race([
+          fn(ep.connection),
+          timeout.promise
+        ]);
+        timeout.cancel();
+        ep.failures = 0;
+        ep.healthy = true;
+        return result;
+      } catch (err) {
+        timeout.cancel();
+        lastError = err;
+        ep.failures++;
+        if (ep.failures >= _RpcPool.UNHEALTHY_THRESHOLD) {
+          ep.healthy = false;
+          if (this.verbose) {
+            console.warn(
+              `[RpcPool] Endpoint ${ep.label} marked unhealthy after ${ep.failures} consecutive failures`
+            );
+          }
+        }
+        const retryable = this.retryConfig ? isRetryable(err, this.retryConfig.retryableStatusCodes) : false;
+        if (!retryable) {
+          if (this.strategy === "failover" && this.endpoints.length > 1) {
+            triedEndpoints.add(epIdx);
+            attempt--;
+            if (triedEndpoints.size >= this.endpoints.length) break;
+            continue;
+          }
+          throw err;
+        }
+        if (this.verbose) {
+          console.warn(
+            `[RpcPool] Retryable error on ${ep.label} (attempt ${attempt + 1}/${maxAttempts}):`,
+            err instanceof Error ? err.message : err
+          );
+        }
+        if (this.strategy === "failover" && this.endpoints.length > 1) {
+          triedEndpoints.add(epIdx);
+        }
+        if (attempt < maxAttempts - 1 && this.retryConfig) {
+          const delay = computeDelay(attempt, this.retryConfig);
+          await sleep(delay);
+        }
+      }
+    }
+    this.maybeRecoverEndpoints();
+    throw lastError ?? new Error("RpcPool: all endpoints exhausted");
+  }
+  /**
+   * Get a raw `Connection` from the current preferred endpoint.
+   * Useful when you need to pass a Connection to external code.
+   *
+   * NOTE: This bypasses retry and failover logic. Prefer `call()`.
+   *
+   * @returns Solana Connection from the current preferred endpoint.
+   *
+   * @example
+   * ```ts
+   * const conn = pool.getConnection();
+   * const balance = await conn.getBalance(pubkey);
+   * ```
+   */
+  getConnection() {
+    const idx = this.selectEndpoint();
+    if (idx === -1) {
+      this.maybeRecoverEndpoints();
+      return this.endpoints[0].connection;
+    }
+    return this.endpoints[idx].connection;
+  }
+  /**
+   * Run a health check against all endpoints in the pool.
+   *
+   * @param timeoutMs - Per-endpoint probe timeout (default: 5000)
+   * @returns Array of health results, one per endpoint.
+   *
+   * @example
+   * ```ts
+   * const results = await pool.healthCheck();
+   * for (const r of results) {
+   *   console.log(`${r.endpoint}: ${r.healthy ? 'UP' : 'DOWN'} (${r.latencyMs}ms, slot ${r.slot})`);
+   * }
+   * ```
+   */
+  async healthCheck(timeoutMs = 5e3) {
+    const results = await Promise.all(
+      this.endpoints.map(async (ep) => {
+        const result = await checkRpcHealth(ep.config.url, timeoutMs);
+        ep.lastLatencyMs = result.latencyMs;
+        ep.healthy = result.healthy;
+        if (result.healthy) ep.failures = 0;
+        result.endpoint = redactUrl(result.endpoint);
+        return result;
+      })
+    );
+    return results;
+  }
+  /**
+   * Get the number of endpoints in the pool.
+   */
+  get size() {
+    return this.endpoints.length;
+  }
+  /**
+   * Get the number of currently healthy endpoints.
+   */
+  get healthyCount() {
+    return this.endpoints.filter((ep) => ep.healthy).length;
+  }
+  /**
+   * Get endpoint labels and their current status.
+   *
+   * @returns Array of `{ label, url, healthy, failures, lastLatencyMs }`.
+   */
+  status() {
+    return this.endpoints.map((ep) => ({
+      label: ep.label,
+      url: redactUrl(ep.config.url),
+      healthy: ep.healthy,
+      failures: ep.failures,
+      lastLatencyMs: ep.lastLatencyMs
+    }));
+  }
+  // -----------------------------------------------------------------------
+  // Internals
+  // -----------------------------------------------------------------------
+  /**
+   * Select the next endpoint based on strategy.
+   * Returns -1 if no endpoint is available.
+   */
+  selectEndpoint(exclude) {
+    const healthy = this.endpoints.map((ep, i) => ({ ep, i })).filter(({ ep, i }) => ep.healthy && !exclude?.has(i));
+    if (healthy.length === 0) {
+      const remaining = this.endpoints.map((_, i) => i).filter((i) => !exclude?.has(i));
+      return remaining.length > 0 ? remaining[0] : -1;
+    }
+    if (this.strategy === "failover") {
+      return healthy[0].i;
+    }
+    const totalWeight = healthy.reduce((sum, { ep }) => sum + ep.weight, 0);
+    this.rrIndex = (this.rrIndex + 1) % totalWeight;
+    let cumulative = 0;
+    for (const { ep, i } of healthy) {
+      cumulative += ep.weight;
+      if (this.rrIndex < cumulative) return i;
+    }
+    return healthy[healthy.length - 1].i;
+  }
+  /**
+   * If all endpoints are unhealthy, reset them so we at least try again.
+   */
+  maybeRecoverEndpoints() {
+    const healthyCount = this.endpoints.filter((ep) => ep.healthy).length;
+    if (healthyCount < _RpcPool.MIN_HEALTHY) {
+      if (this.verbose) {
+        console.warn("[RpcPool] All endpoints unhealthy \u2014 resetting for recovery");
+      }
+      for (const ep of this.endpoints) {
+        ep.healthy = true;
+        ep.failures = 0;
+      }
+    }
+  }
+};
+async function withRetry(fn, config) {
+  const resolved = resolveRetryConfig(config) ?? {
+    maxRetries: 3,
+    baseDelayMs: 500,
+    maxDelayMs: 1e4,
+    jitterFactor: 0.25,
+    retryableStatusCodes: [429, 502, 503, 504]
+  };
+  let lastError;
+  const maxAttempts = resolved.maxRetries + 1;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+      if (!isRetryable(err, resolved.retryableStatusCodes)) {
+        throw err;
+      }
+      if (attempt < maxAttempts - 1) {
+        const delay = computeDelay(attempt, resolved);
+        await sleep(delay);
+      }
+    }
+  }
+  throw lastError ?? new Error("withRetry: all attempts exhausted");
+}
+var _internal = {
+  isRetryable,
+  computeDelay,
+  resolveRetryConfig,
+  normalizeEndpoint,
+  endpointLabel
+};
+
 // src/runtime/tx.ts
 import {
   TransactionInstruction as TransactionInstruction2,
@@ -3907,6 +4907,139 @@ function formatResult(result, jsonMode) {
   return lines.join("\n");
 }
 
+// src/runtime/lighthouse.ts
+import { PublicKey as PublicKey13, Transaction as Transaction2 } from "@solana/web3.js";
+var LIGHTHOUSE_PROGRAM_ID = new PublicKey13(
+  "L2TExMFKdjpN9kozasaurPirfHy9P8sbXoAN1qA3S95"
+);
+var LIGHTHOUSE_PROGRAM_ID_STR2 = "L2TExMFKdjpN9kozasaurPirfHy9P8sbXoAN1qA3S95";
+var LIGHTHOUSE_CONSTRAINT_ADDRESS = 6400;
+var LIGHTHOUSE_ERROR_CODES = /* @__PURE__ */ new Set([
+  6e3,
+  // InstructionMissing
+  6001,
+  // InstructionFallbackNotFound
+  6002,
+  // InstructionDidNotDeserialize
+  6003,
+  // InstructionDidNotSerialize
+  6016,
+  // IdlInstructionStub
+  6032,
+  // ConstraintMut
+  6033,
+  // ConstraintHasOne
+  6034,
+  // ConstraintSigner
+  6035,
+  // ConstraintRaw
+  6036,
+  // ConstraintOwner
+  6037,
+  // ConstraintRentExempt
+  6038,
+  // ConstraintSeeds
+  6039,
+  // ConstraintExecutable
+  6040,
+  // ConstraintState
+  6041,
+  // ConstraintAssociated
+  6042,
+  // ConstraintAssociatedInit
+  6043,
+  // ConstraintClose
+  6400
+  // ConstraintAddress (the one we hit most often)
+]);
+function isLighthouseInstruction(ix) {
+  return ix.programId.equals(LIGHTHOUSE_PROGRAM_ID);
+}
+function isLighthouseError(error) {
+  const msg = extractErrorMessage(error);
+  if (!msg) return false;
+  if (msg.includes(LIGHTHOUSE_PROGRAM_ID_STR2)) return true;
+  if (/custom\s+program\s+error:\s*0x1900\b/i.test(msg)) return true;
+  if (/"Custom"\s*:\s*6400\b/.test(msg) && /InstructionError/i.test(msg)) return true;
+  return false;
+}
+function isLighthouseFailureInLogs(logs) {
+  if (!Array.isArray(logs)) return false;
+  let insideLighthouse = false;
+  for (const line of logs) {
+    if (typeof line !== "string") continue;
+    if (line.includes(`Program ${LIGHTHOUSE_PROGRAM_ID_STR2} invoke`)) {
+      insideLighthouse = true;
+      continue;
+    }
+    if (line.includes(`Program ${LIGHTHOUSE_PROGRAM_ID_STR2} success`)) {
+      insideLighthouse = false;
+      continue;
+    }
+    if (insideLighthouse && /failed/i.test(line)) {
+      return true;
+    }
+    if (line.includes(`Program ${LIGHTHOUSE_PROGRAM_ID_STR2} failed`)) {
+      return true;
+    }
+  }
+  return false;
+}
+function stripLighthouseInstructions(instructions, percolatorProgramId) {
+  if (percolatorProgramId) {
+    const hasPercolatorIx = instructions.some(
+      (ix) => ix.programId.equals(percolatorProgramId)
+    );
+    if (!hasPercolatorIx) {
+      return instructions;
+    }
+  }
+  return instructions.filter((ix) => !isLighthouseInstruction(ix));
+}
+function stripLighthouseFromTransaction(transaction, percolatorProgramId) {
+  if (percolatorProgramId) {
+    const hasPercolatorIx = transaction.instructions.some(
+      (ix) => ix.programId.equals(percolatorProgramId)
+    );
+    if (!hasPercolatorIx) return transaction;
+  }
+  const hasLighthouse = transaction.instructions.some(isLighthouseInstruction);
+  if (!hasLighthouse) return transaction;
+  const clean = new Transaction2();
+  clean.recentBlockhash = transaction.recentBlockhash;
+  clean.feePayer = transaction.feePayer;
+  for (const ix of transaction.instructions) {
+    if (!isLighthouseInstruction(ix)) {
+      clean.add(ix);
+    }
+  }
+  return clean;
+}
+function countLighthouseInstructions(ixsOrTx) {
+  const instructions = Array.isArray(ixsOrTx) ? ixsOrTx : ixsOrTx.instructions;
+  return instructions.filter(isLighthouseInstruction).length;
+}
+var LIGHTHOUSE_USER_MESSAGE = "Your wallet's transaction guard (Blowfish/Lighthouse) is blocking this transaction. This is a known compatibility issue \u2014 the transaction itself is valid. Try one of these workarounds:\n1. Disable transaction simulation in your wallet settings\n2. Use a wallet without Blowfish protection (e.g., Backpack, Solflare)\n3. The SDK will automatically retry without the guard";
+function classifyLighthouseError(error) {
+  if (isLighthouseError(error)) {
+    return LIGHTHOUSE_USER_MESSAGE;
+  }
+  return null;
+}
+function extractErrorMessage(error) {
+  if (!error) return null;
+  if (typeof error === "string") return error;
+  if (error instanceof Error) return error.message;
+  if (typeof error === "object" && "message" in error) {
+    return String(error.message);
+  }
+  try {
+    return JSON.stringify(error);
+  } catch {
+    return null;
+  }
+}
+
 // src/math/trading.ts
 function computeMarkPnl(positionSize, entryPrice, oraclePrice) {
   if (positionSize === 0n || oraclePrice === 0n) return 0n;
@@ -3954,9 +5087,20 @@ function computeFeeSplit(totalFee, config) {
   if (config.lpBps === 0n && config.protocolBps === 0n && config.creatorBps === 0n) {
     return [totalFee, 0n, 0n];
   }
+  const totalBps = config.lpBps + config.protocolBps + config.creatorBps;
+  if (totalBps !== 10000n) {
+    throw new Error(
+      `Fee split must equal exactly 10000 bps (100%): lpBps=${config.lpBps} + protocolBps=${config.protocolBps} + creatorBps=${config.creatorBps} = ${totalBps}`
+    );
+  }
   const lp = totalFee * config.lpBps / 10000n;
   const protocol = totalFee * config.protocolBps / 10000n;
   const creator = totalFee - lp - protocol;
+  if (creator < 0n) {
+    throw new Error(
+      `Internal error: creator fee is negative (${creator}). This should not happen if lpBps + protocolBps + creatorBps === 10000.`
+    );
+  }
   return [lp, protocol, creator];
 }
 function computePnlPercent(pnlTokens, capital) {
@@ -3971,8 +5115,17 @@ function computePnlPercent(pnlTokens, capital) {
 }
 function computeEstimatedEntryPrice(oracleE6, tradingFeeBps, direction) {
   if (oracleE6 === 0n) return 0n;
+  if (tradingFeeBps < 0n) {
+    throw new Error(`computeEstimatedEntryPrice: tradingFeeBps must be non-negative, got ${tradingFeeBps}`);
+  }
   const feeImpact = oracleE6 * tradingFeeBps / 10000n;
-  return direction === "long" ? oracleE6 + feeImpact : oracleE6 - feeImpact;
+  const result = direction === "long" ? oracleE6 + feeImpact : oracleE6 - feeImpact;
+  if (result <= 0n) {
+    throw new Error(
+      `computeEstimatedEntryPrice: result ${result} is non-positive (tradingFeeBps=${tradingFeeBps} too high for oracle=${oracleE6})`
+    );
+  }
+  return result;
 }
 var MAX_SAFE_BIGINT = BigInt(Number.MAX_SAFE_INTEGER);
 var MIN_SAFE_BIGINT = BigInt(-Number.MAX_SAFE_INTEGER);
@@ -3993,7 +5146,12 @@ function computeMaxLeverage(initialMarginBps) {
   if (initialMarginBps <= 0n) {
     throw new Error("computeMaxLeverage: initialMarginBps must be positive");
   }
-  return Number(10000n / initialMarginBps);
+  const scaledResult = 10000n * 1000000n / initialMarginBps;
+  return Number(scaledResult) / 1e6;
+}
+function computeMaxWithdrawable(capital, pnl, reservedPnl) {
+  const maturedPnl = pnl - reservedPnl;
+  return capital + (maturedPnl > 0n ? maturedPnl : 0n);
 }
 
 // src/math/warmup.ts
@@ -4005,6 +5163,9 @@ function computeWarmupUnlockedCapital(totalCapital, currentSlot, warmupStartSlot
   return totalCapital * elapsed / warmupPeriodSlots;
 }
 function computeWarmupLeverageCap(initialMarginBps, totalCapital, currentSlot, warmupStartSlot, warmupPeriodSlots) {
+  if (initialMarginBps <= 0n) {
+    throw new Error("computeWarmupLeverageCap: initialMarginBps must be positive");
+  }
   const maxLev = computeMaxLeverage(initialMarginBps);
   if (warmupPeriodSlots === 0n || warmupStartSlot === 0n) return maxLev;
   if (totalCapital <= 0n) return 1;
@@ -4015,7 +5176,14 @@ function computeWarmupLeverageCap(initialMarginBps, totalCapital, currentSlot, w
     warmupPeriodSlots
   );
   if (unlocked <= 0n) return 1;
-  const effectiveLev = Number(BigInt(maxLev) * unlocked / totalCapital);
+  const scaledResult = BigInt(maxLev) * unlocked / totalCapital;
+  if (scaledResult > BigInt(Number.MAX_SAFE_INTEGER)) {
+    console.warn(
+      `[computeWarmupLeverageCap] Warning: effective leverage ${scaledResult} exceeds MAX_SAFE_INTEGER, returning MAX_SAFE_INTEGER as a safety bound`
+    );
+    return Number.MAX_SAFE_INTEGER;
+  }
+  const effectiveLev = Number(scaledResult);
   return Math.max(1, effectiveLev);
 }
 function computeWarmupMaxPositionSize(initialMarginBps, totalCapital, currentSlot, warmupStartSlot, warmupPeriodSlots) {
@@ -4028,9 +5196,40 @@ function computeWarmupMaxPositionSize(initialMarginBps, totalCapital, currentSlo
   );
   return unlocked * BigInt(maxLev);
 }
+function computeWarmupProgress(currentSlot, warmupStartedAtSlot, warmupPeriodSlots, pnl, reservedPnl) {
+  if (warmupPeriodSlots === 0n || warmupStartedAtSlot === 0n) {
+    return {
+      maturedPnl: pnl > 0n ? pnl : 0n,
+      reservedPnl: 0n,
+      progressBps: 10000n,
+      // 100%
+      slotsRemaining: 0n
+    };
+  }
+  const elapsed = currentSlot >= warmupStartedAtSlot ? currentSlot - warmupStartedAtSlot : 0n;
+  if (elapsed >= warmupPeriodSlots) {
+    return {
+      maturedPnl: pnl > 0n ? pnl : 0n,
+      reservedPnl: 0n,
+      progressBps: 10000n,
+      // 100%
+      slotsRemaining: 0n
+    };
+  }
+  const progressBps = elapsed * 10000n / warmupPeriodSlots;
+  const slotsRemaining = warmupPeriodSlots - elapsed;
+  const maturedPnl = pnl > 0n ? pnl * progressBps / 10000n : 0n;
+  const locked = reservedPnl > 0n ? reservedPnl : 0n;
+  return {
+    maturedPnl,
+    reservedPnl: locked,
+    progressBps,
+    slotsRemaining
+  };
+}
 
 // src/validation.ts
-import { PublicKey as PublicKey11 } from "@solana/web3.js";
+import { PublicKey as PublicKey14 } from "@solana/web3.js";
 var U16_MAX = 65535;
 var U64_MAX = BigInt("18446744073709551615");
 var I64_MIN = BigInt("-9223372036854775808");
@@ -4060,7 +5259,7 @@ var ValidationError = class extends Error {
 };
 function validatePublicKey(value, field) {
   try {
-    return new PublicKey11(value);
+    return new PublicKey14(value);
   } catch {
     throw new ValidationError(
       field,
@@ -4077,18 +5276,20 @@ function validateIndex(value, field) {
       `must be <= ${U16_MAX} (u16 max), got ${t}`
     );
   }
+  if (bi > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw new ValidationError(field, `internal error: u16 value exceeds MAX_SAFE_INTEGER`);
+  }
   return Number(bi);
 }
 function validateAmount(value, field) {
-  let num;
-  try {
-    num = BigInt(value);
-  } catch {
+  const t = value.trim();
+  if (!/^(0|[1-9]\d*)$/.test(t)) {
     throw new ValidationError(
       field,
-      `"${value}" is not a valid number. Use decimal digits only.`
+      `"${value}" is not a valid non-negative integer. Use decimal digits only.`
     );
   }
+  const num = BigInt(t);
   if (num < 0n) {
     throw new ValidationError(field, `must be non-negative, got ${num}`);
   }
@@ -4101,15 +5302,14 @@ function validateAmount(value, field) {
   return num;
 }
 function validateU128(value, field) {
-  let num;
-  try {
-    num = BigInt(value);
-  } catch {
+  const t = value.trim();
+  if (!/^(0|[1-9]\d*)$/.test(t)) {
     throw new ValidationError(
       field,
-      `"${value}" is not a valid number. Use decimal digits only.`
+      `"${value}" is not a valid non-negative integer. Use decimal digits only.`
     );
   }
+  const num = BigInt(t);
   if (num < 0n) {
     throw new ValidationError(field, `must be non-negative, got ${num}`);
   }
@@ -4122,15 +5322,14 @@ function validateU128(value, field) {
   return num;
 }
 function validateI64(value, field) {
-  let num;
-  try {
-    num = BigInt(value);
-  } catch {
+  const t = value.trim();
+  if (!/^-?(0|[1-9]\d*)$/.test(t)) {
     throw new ValidationError(
       field,
-      `"${value}" is not a valid number. Use decimal digits only, with optional leading minus.`
+      `"${value}" is not a valid integer. Use decimal digits only, with optional leading minus.`
     );
   }
+  const num = BigInt(t);
   if (num < I64_MIN) {
     throw new ValidationError(
       field,
@@ -4146,15 +5345,14 @@ function validateI64(value, field) {
   return num;
 }
 function validateI128(value, field) {
-  let num;
-  try {
-    num = BigInt(value);
-  } catch {
+  const t = value.trim();
+  if (!/^-?(0|[1-9]\d*)$/.test(t)) {
     throw new ValidationError(
       field,
-      `"${value}" is not a valid number. Use decimal digits only, with optional leading minus.`
+      `"${value}" is not a valid integer. Use decimal digits only, with optional leading minus.`
     );
   }
+  const num = BigInt(t);
   if (num < I128_MIN) {
     throw new ValidationError(
       field,
@@ -4178,6 +5376,9 @@ function validateBps(value, field) {
       `must be <= 10000 (100%), got ${t}`
     );
   }
+  if (bi > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw new ValidationError(field, `internal error: bps value exceeds MAX_SAFE_INTEGER`);
+  }
   return Number(bi);
 }
 function validateU64(value, field) {
@@ -4192,6 +5393,9 @@ function validateU16(value, field) {
       `must be <= ${U16_MAX} (u16 max), got ${t}`
     );
   }
+  if (bi > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw new ValidationError(field, `internal error: u16 value exceeds MAX_SAFE_INTEGER`);
+  }
   return Number(bi);
 }
 
@@ -4242,7 +5446,9 @@ function parseDexScreenerPairs(json) {
     else if (liquidity > 1e4) confidence = 60;
     else if (liquidity > 1e3) confidence = 45;
     const priceUsd = pair.priceUsd;
-    const price = typeof priceUsd === "string" || typeof priceUsd === "number" ? parseFloat(String(priceUsd)) || 0 : 0;
+    const rawPrice = typeof priceUsd === "string" || typeof priceUsd === "number" ? parseFloat(String(priceUsd)) : NaN;
+    if (!Number.isFinite(rawPrice) || rawPrice <= 0) continue;
+    const price = rawPrice;
     let baseSym = "?";
     let quoteSym = "?";
     if (isRecord(pair.baseToken) && typeof pair.baseToken.symbol === "string") {
@@ -4273,8 +5479,8 @@ function parseJupiterMintEntry(json, mint) {
   if (!isRecord(row)) return null;
   const rawPrice = row.price;
   if (rawPrice === void 0 || rawPrice === null) return null;
-  const price = parseFloat(String(rawPrice)) || 0;
-  if (price <= 0) return null;
+  const price = parseFloat(String(rawPrice));
+  if (!Number.isFinite(price) || price <= 0) return null;
   let mintSymbol = "?";
   if (typeof row.mintSymbol === "string") mintSymbol = row.mintSymbol;
   return { price, mintSymbol };
@@ -4340,10 +5546,17 @@ async function fetchDexSources(mint, signal) {
         headers: { "User-Agent": "percolator/1.0" }
       }
     );
-    if (!resp.ok) return [];
+    if (!resp.ok) {
+      console.debug(`[fetchDexSources] HTTP ${resp.status} for mint ${mint}`);
+      return [];
+    }
     const json = await resp.json();
     return parseDexScreenerPairs(json);
-  } catch {
+  } catch (err) {
+    console.warn(
+      `[fetchDexSources] Error fetching DexScreener data for mint ${mint}:`,
+      err instanceof Error ? err.message : String(err)
+    );
     return [];
   }
 }
@@ -4354,7 +5567,7 @@ function lookupPythSource(mint) {
     type: "pyth",
     address: entry.feedId,
     pairLabel: `${entry.symbol} / USD (Pyth)`,
-    liquidity: Infinity,
+    liquidity: Number.MAX_SAFE_INTEGER,
     // Pyth is considered deep liquidity
     price: 0,
     // We don't fetch live price here; caller can enrich
@@ -4371,10 +5584,16 @@ async function fetchJupiterSource(mint, signal) {
         headers: { "User-Agent": "percolator/1.0" }
       }
     );
-    if (!resp.ok) return null;
+    if (!resp.ok) {
+      console.debug(`[fetchJupiterSource] HTTP ${resp.status} for mint ${mint}`);
+      return null;
+    }
     const json = await resp.json();
     const row = parseJupiterMintEntry(json, mint);
-    if (!row) return null;
+    if (!row) {
+      console.debug(`[fetchJupiterSource] No price data from Jupiter for mint ${mint}`);
+      return null;
+    }
     return {
       type: "jupiter",
       address: mint,
@@ -4385,7 +5604,11 @@ async function fetchJupiterSource(mint, signal) {
       confidence: 40
       // Fallback — lower confidence
     };
-  } catch {
+  } catch (err) {
+    console.warn(
+      `[fetchJupiterSource] Error fetching Jupiter data for mint ${mint}:`,
+      err instanceof Error ? err.message : String(err)
+    );
     return null;
   }
 }
@@ -4400,8 +5623,20 @@ async function resolvePrice(mint, signal, options) {
   const pythSource = lookupPythSource(mint);
   const allSources = [];
   if (pythSource) {
-    const refPrice = dexSources[0]?.price || jupiterSource?.price || 0;
-    pythSource.price = refPrice;
+    const dexPrice = dexSources[0]?.price ?? 0;
+    const jupPrice = jupiterSource?.price ?? 0;
+    if (dexPrice > 0 && jupPrice > 0) {
+      const mid = (dexPrice + jupPrice) / 2;
+      const deviation = Math.abs(dexPrice - jupPrice) / mid;
+      if (deviation > 0.5) {
+        pythSource.price = 0;
+        pythSource.confidence = 20;
+      } else {
+        pythSource.price = mid;
+      }
+    } else {
+      pythSource.price = dexPrice || jupPrice || 0;
+    }
     allSources.push(pythSource);
   }
   allSources.push(...dexSources);
@@ -4426,13 +5661,12 @@ export {
   ACCOUNTS_CLOSE_ACCOUNT,
   ACCOUNTS_CLOSE_SLAB,
   ACCOUNTS_CLOSE_STALE_SLABS,
-  ACCOUNTS_CREATE_INSURANCE_MINT,
   ACCOUNTS_DEPOSIT_COLLATERAL,
-  ACCOUNTS_DEPOSIT_INSURANCE_LP,
   ACCOUNTS_EXECUTE_ADL,
   ACCOUNTS_FUND_MARKET_INSURANCE,
   ACCOUNTS_INIT_LP,
   ACCOUNTS_INIT_MARKET,
+  ACCOUNTS_INIT_MATCHER_CTX,
   ACCOUNTS_INIT_USER,
   ACCOUNTS_KEEPER_CRANK,
   ACCOUNTS_LIQUIDATE_AT_ORACLE,
@@ -4461,20 +5695,26 @@ export {
   ACCOUNTS_UPDATE_CONFIG,
   ACCOUNTS_WITHDRAW_COLLATERAL,
   ACCOUNTS_WITHDRAW_INSURANCE,
-  ACCOUNTS_WITHDRAW_INSURANCE_LP,
   AccountKind,
   CHAINLINK_ANSWER_OFFSET,
   CHAINLINK_DECIMALS_OFFSET,
   CHAINLINK_MIN_SIZE,
+  CHAINLINK_TIMESTAMP_OFFSET,
   CREATOR_LOCK_SEED,
   CTX_VAMM_OFFSET,
   DEFAULT_OI_RAMP_SLOTS,
   ENGINE_MARK_PRICE_OFF,
   ENGINE_OFF,
   IX_TAG,
+  LIGHTHOUSE_CONSTRAINT_ADDRESS,
+  LIGHTHOUSE_ERROR_CODES,
+  LIGHTHOUSE_PROGRAM_ID,
+  LIGHTHOUSE_PROGRAM_ID_STR2 as LIGHTHOUSE_PROGRAM_ID_STR,
+  LIGHTHOUSE_USER_MESSAGE,
   MARK_PRICE_EMA_ALPHA_E6,
   MARK_PRICE_EMA_WINDOW_SLOTS,
   MAX_DECIMALS,
+  MAX_ORACLE_PRICE,
   METEORA_DLMM_PROGRAM_ID,
   ORACLE_PHASE_GROWING,
   ORACLE_PHASE_MATURE,
@@ -4492,9 +5732,11 @@ export {
   RAMP_START_BPS,
   RAYDIUM_CLMM_PROGRAM_ID,
   RENOUNCE_ADMIN_CONFIRMATION,
+  RpcPool,
   SLAB_TIERS,
   SLAB_TIERS_V0,
   SLAB_TIERS_V1,
+  SLAB_TIERS_V12_1,
   SLAB_TIERS_V1D,
   SLAB_TIERS_V1D_LEGACY,
   SLAB_TIERS_V1M,
@@ -4502,6 +5744,7 @@ export {
   SLAB_TIERS_V2,
   SLAB_TIERS_V_ADL,
   SLAB_TIERS_V_ADL_DISCOVERY,
+  SLAB_TIERS_V_SETDEXPOOL,
   STAKE_IX,
   STAKE_POOL_SIZE,
   STAKE_PROGRAM_ID,
@@ -4511,11 +5754,15 @@ export {
   VAMM_MAGIC,
   ValidationError,
   WELL_KNOWN,
+  _internal,
   buildAccountMetas,
   buildAdlInstruction,
   buildAdlTransaction,
   buildIx,
   checkPhaseTransition,
+  checkRpcHealth,
+  classifyLighthouseError,
+  clearStaticMarkets,
   computeDexSpotPriceE6,
   computeDynamicFeeBps,
   computeDynamicTradingFee,
@@ -4527,6 +5774,7 @@ export {
   computeLiqPrice,
   computeMarkPnl,
   computeMaxLeverage,
+  computeMaxWithdrawable,
   computePnlPercent,
   computePreTradeLiqPrice,
   computeRequiredMargin,
@@ -4534,14 +5782,15 @@ export {
   computeVammQuote,
   computeWarmupLeverageCap,
   computeWarmupMaxPositionSize,
+  computeWarmupProgress,
   computeWarmupUnlockedCapital,
   concatBytes,
+  countLighthouseInstructions,
   decodeError,
   decodeStakePool,
   depositAccounts,
   deriveCreatorLockPda,
   deriveDepositPda,
-  deriveInsuranceLpMint,
   deriveKeeperFund,
   deriveLpPda,
   derivePythPriceUpdateAccount,
@@ -4554,6 +5803,8 @@ export {
   detectSlabLayout,
   detectTokenProgram,
   discoverMarkets,
+  discoverMarketsViaApi,
+  discoverMarketsViaStaticBundle,
   encBool,
   encI128,
   encI64,
@@ -4567,26 +5818,33 @@ export {
   encodeAdvanceEpoch,
   encodeAdvanceOraclePhase,
   encodeAllocateMarket,
+  encodeAttestCrossMargin,
   encodeAuditCrank,
   encodeBurnPositionNft,
   encodeCancelQueuedWithdrawal,
+  encodeChallengeSettlement,
   encodeClaimEpochWithdrawal,
   encodeClaimQueuedWithdrawal,
   encodeClearPendingSettlement,
   encodeCloseAccount,
+  encodeCloseOrphanSlab,
   encodeCloseSlab,
   encodeCloseStaleSlabs,
-  encodeCreateInsuranceMint,
+  encodeCreateLpVault,
   encodeDepositCollateral,
-  encodeDepositInsuranceLP,
+  encodeDepositLpCollateral,
   encodeExecuteAdl,
+  encodeForceCloseResolved,
   encodeFundMarketInsurance,
   encodeInitLP,
   encodeInitMarket,
+  encodeInitMatcherCtx,
   encodeInitSharedVault,
   encodeInitUser,
   encodeKeeperCrank,
   encodeLiquidateAtOracle,
+  encodeLpVaultCrankFees,
+  encodeLpVaultDeposit,
   encodeLpVaultWithdraw,
   encodeMintPositionNft,
   encodePauseMarket,
@@ -4595,9 +5853,15 @@ export {
   encodeQueueWithdrawalSV,
   encodeReclaimSlabRent,
   encodeRenounceAdmin,
+  encodeRescueOrphanVault,
+  encodeResolveDispute,
   encodeResolveMarket,
+  encodeResolvePermissionless,
+  encodeSetDexPool,
   encodeSetInsuranceIsolation,
+  encodeSetInsuranceWithdrawPolicy,
   encodeSetMaintenanceFee,
+  encodeSetOffsetPair,
   encodeSetOiImbalanceHardBlock,
   encodeSetOracleAuthority,
   encodeSetOraclePriceCap,
@@ -4638,7 +5902,8 @@ export {
   encodeUpdateRiskParams,
   encodeWithdrawCollateral,
   encodeWithdrawInsurance,
-  encodeWithdrawInsuranceLP,
+  encodeWithdrawInsuranceLimited,
+  encodeWithdrawLpCollateral,
   fetchAdlRankedPositions,
   fetchAdlRankings,
   fetchSlab,
@@ -4650,12 +5915,18 @@ export {
   getCurrentNetwork,
   getErrorHint,
   getErrorName,
+  getMarketsByAddress,
   getMatcherProgramId,
   getProgramId,
   getStakeProgramId,
+  getStaticMarkets,
   initPoolAccounts,
   isAccountUsed,
   isAdlTriggered,
+  isAnchorErrorCode,
+  isLighthouseError,
+  isLighthouseFailureInLogs,
+  isLighthouseInstruction,
   isStandardToken,
   isToken2022,
   isValidChainlinkOracle,
@@ -4674,11 +5945,14 @@ export {
   rankAdlPositions,
   readLastThrUpdateSlot,
   readNonce,
+  registerStaticMarkets,
   resolvePrice,
   safeEnv,
   simulateOrSend,
   slabDataSize,
   slabDataSizeV1,
+  stripLighthouseFromTransaction,
+  stripLighthouseInstructions,
   validateAmount,
   validateBps,
   validateI128,
@@ -4689,6 +5963,7 @@ export {
   validateU128,
   validateU16,
   validateU64,
+  withRetry,
   withdrawAccounts
 };
 //# sourceMappingURL=index.js.map