@rhinestone/service-sdk 0.2.4 → 0.2.6

package/dist/chains.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chains.d.ts","sourceRoot":"","sources":["../src/chains.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,MAAM,CAAA;AAG1D,KAAK,mBAAmB,GAAG,IAAI,CAC7B,YAAY,EACZ,oBAAoB,GAAG,eAAe,CACvC,CAAA;AAKD,wBAAsB,eAAe,CACnC,MAAM,EAAE,mBAAmB,EAC3B,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,gBAAgB,CAAC,CAK3B"}
+{"version":3,"file":"chains.d.ts","sourceRoot":"","sources":["../src/chains.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,MAAM,CAAA;AAG1D,KAAK,mBAAmB,GAAG,IAAI,CAC7B,YAAY,EACZ,oBAAoB,GAAG,eAAe,CACvC,CAAA;AAmFD,wBAAsB,eAAe,CACnC,MAAM,EAAE,mBAAmB,EAC3B,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,gBAAgB,CAAC,CAU3B"}

package/dist/chains.js

@@ -2,24 +2,129 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.estimateGasFees = estimateGasFees;
 const chains_1 = require("viem/chains");
-const SEPOLIA_FEE_HISTORY_BLOCKS = 3;
-const SEPOLIA_REWARD_PERCENTILE = 75;
+// Chains that price fees from a windowed eth_feeHistory instead of viem's
+// default estimator — the volatile-base L1s, where windowing the next-block base
+// fee and pooling tips across the window smooths the single-block noise that
+// made the latest-block-only read jumpy. Other chains stay on viem's default
+// (some with a tip-floor overlay, see TIP_FLOOR_WEI): their base fee is stable
+// or sequencer-pinned, so windowing adds nothing.
+const HISTORICAL_FEE_CHAINS = new Set([chains_1.sepolia.id, chains_1.mainnet.id]);
+const DEFAULT_FEE_CONFIG = {
+    historyBlocks: 20, // Geth FullNodeGPO window
+    baseFeeMultiplier: 2n, // ~6 blocks / ~70s headroom (cap only — free)
+    tipPercentile: 50, // calm-market per-block tip (real mainnet p50 ≈ 0.03 gwei)
+    congestedTipPercentile: 75, // escalate to p75 under load (not p90 — ~45x cost)
+    congestionRatio: 0.5, // "gasUsedRatio trends > 0.5"
+    windowTipPercentile: 50, // nearest-rank p50 across the window's per-block tips
+    // 0.1 gwei. Enough to clear the zero-tip stall (the tip is the only builder
+    // incentive — base fee is burned), without over-buffering: real mainnet p50 is
+    // ~0.03 gwei, so this is ~3x the median, while 1 gwei would be ~30x.
+    tipFloorWei: 100000000n,
+};
+// Per-chain overrides for the windowed feeHistory path; any omitted field falls
+// back to DEFAULT_FEE_CONFIG.
+const FEE_CONFIG_OVERRIDES = {
+    // Testnet — not real money: aggressive percentile, no floor.
+    [chains_1.sepolia.id]: {
+        tipPercentile: 75,
+        congestedTipPercentile: 90,
+        tipFloorWei: 0n,
+    },
+};
+// Chains where viem's default base-fee estimate is fine but its tip oracle
+// (eth_maxPriorityFeePerGas) under-prices the priority fee versus the real
+// on-chain inclusion floor — the oracle reports the chain-min or zero while txs
+// actually clear at a much higher tip. We keep viem's base estimate and lift
+// only the tip to this absolute floor. Values measured live per chain in the
+// RHI-4468 audit.
+const TIP_FLOOR_WEI = {
+    [chains_1.polygon.id]: 45000000000n, // 45 gwei — Bor min 30 gwei x1.5; real p50 tip ~200 gwei
+    [chains_1.gnosis.id]: 1000000000n, // 1.0 gwei — viem oracle ~21 wei; real p90 inclusion ~1.0 gwei (re-probed 2026-06-25)
+    [chains_1.hyperEvm.id]: 150000000n, // 0.15 gwei — oracle returns 0; realized p50 tip ~0.15 gwei
+    [chains_1.monad.id]: 22000000000n, // 22 gwei — oracle 2 gwei; competitive tip p50/mode ~22 gwei
+};
+// Polygon's real tip runs ~6.7x its oracle (Bor min 30 gwei vs real p50 ~200
+// gwei), so a static floor alone lags a busy market — also window the feeHistory
+// tip and take the max with the floor. Its base fee is stable (~5% vol), so the
+// base stays on viem's default.
+const WINDOWED_TIP_CHAINS = new Set([chains_1.polygon.id]);
+const WINDOWED_TIP_HISTORY_BLOCKS = 20;
+const WINDOWED_TIP_PERCENTILE = 50; // p50 per block, nearest-rank across the window
 async function estimateGasFees(client, chainId) {
-    if (chainId === chains_1.sepolia.id) {
-        return estimateSepoliaGasFees(client);
+    if (HISTORICAL_FEE_CHAINS.has(chainId)) {
+        const config = { ...DEFAULT_FEE_CONFIG, ...FEE_CONFIG_OVERRIDES[chainId] };
+        return estimateFeeHistoryGasFees(client, config);
+    }
+    const tipFloorWei = TIP_FLOOR_WEI[chainId];
+    if (tipFloorWei !== undefined) {
+        return estimateViemFeesWithTipFloor(client, chainId, tipFloorWei);
     }
     return client.estimateFeesPerGas();
 }
-async function estimateSepoliaGasFees(client) {
+// viem's default fee estimate (base fee + oracle tip), with the priority fee
+// lifted to an absolute floor — and, for windowed-tip chains, to the windowed
+// feeHistory tip. The maxFeePerGas cap is raised by the same delta so the lifted
+// tip is never clipped. The tip is only ever raised, never lowered, so this
+// preserves viem's estimate whenever it already exceeds the floor.
+async function estimateViemFeesWithTipFloor(client, chainId, tipFloorWei) {
+    const fees = await client.estimateFeesPerGas();
+    const oracleTip = fees.maxPriorityFeePerGas;
+    let tip = oracleTip;
+    if (WINDOWED_TIP_CHAINS.has(chainId)) {
+        const windowedTip = await windowedFeeHistoryTip(client);
+        if (windowedTip > tip)
+            tip = windowedTip;
+    }
+    if (tipFloorWei > tip)
+        tip = tipFloorWei;
+    return {
+        maxFeePerGas: fees.maxFeePerGas + (tip - oracleTip),
+        maxPriorityFeePerGas: tip,
+    };
+}
+// Nearest-rank p50 across the window's per-block p50 tips — used to track a busy
+// market that the static oracle/floor lags.
+async function windowedFeeHistoryTip(client) {
     const feeHistory = await client.getFeeHistory({
-        blockCount: SEPOLIA_FEE_HISTORY_BLOCKS,
-        rewardPercentiles: [SEPOLIA_REWARD_PERCENTILE],
+        blockCount: WINDOWED_TIP_HISTORY_BLOCKS,
+        rewardPercentiles: [WINDOWED_TIP_PERCENTILE],
     });
-    const priorityFee = feeHistory.reward?.at(-1)?.[0] ?? 0n;
+    const perBlockTips = (feeHistory.reward ?? []).map((r) => r?.[0] ?? 0n);
+    return percentileBigInt(perBlockTips, WINDOWED_TIP_PERCENTILE);
+}
+// Windowed eth_feeHistory estimator:
+//   tip          = `windowTipPercentile` across the last N blocks' per-block
+//                  tips, where the per-block tip is read at `tipPercentile`
+//                  (or `congestedTipPercentile` when the window's mean
+//                  gasUsedRatio exceeds `congestionRatio`), floored at
+//                  `tipFloorWei`.
+//   maxFeePerGas = nextBlockBaseFee * baseFeeMultiplier + tip
+async function estimateFeeHistoryGasFees(client, config) {
+    const feeHistory = await client.getFeeHistory({
+        blockCount: config.historyBlocks,
+        rewardPercentiles: [config.tipPercentile, config.congestedTipPercentile],
+    });
+    const ratios = feeHistory.gasUsedRatio ?? [];
+    const meanRatio = ratios.length > 0
+        ? ratios.reduce((sum, r) => sum + r, 0) / ratios.length
+        : 0;
+    // Under load, read the per-block tip from the higher percentile column.
+    const column = meanRatio > config.congestionRatio ? 1 : 0;
+    const perBlockTips = (feeHistory.reward ?? []).map((r) => r?.[column] ?? 0n);
+    const windowedTip = percentileBigInt(perBlockTips, config.windowTipPercentile);
+    const priorityFee = windowedTip > config.tipFloorWei ? windowedTip : config.tipFloorWei;
+    // baseFeePerGas has historyBlocks + 1 entries; the last is the *next* block's
+    // base fee (the one our tx lands in), not the latest mined block's.
     const baseFee = feeHistory.baseFeePerGas.at(-1) ?? 0n;
-    const maxFeePerGas = baseFee * 2n + priorityFee;
-    return {
-        maxFeePerGas,
-        maxPriorityFeePerGas: priorityFee,
-    };
+    const maxFeePerGas = baseFee * config.baseFeeMultiplier + priorityFee;
+    return { maxFeePerGas, maxPriorityFeePerGas: priorityFee };
+}
+// Nearest-rank percentile over a bigint sample. Empty sample → 0n.
+function percentileBigInt(values, percentile) {
+    if (values.length === 0)
+        return 0n;
+    const sorted = [...values].sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+    const rank = Math.ceil((percentile / 100) * sorted.length);
+    const idx = Math.min(Math.max(rank - 1, 0), sorted.length - 1);
+    return sorted[idx];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rhinestone/service-sdk",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "Shared SDK for Rhinestone services",
   "author": {
     "name": "Rhinestone",