@valve-tech/gas-oracle 0.2.0

package/dist/transport.d.ts

@@ -0,0 +1,75 @@
+/**
+ * viem-native RPC transport. The oracle needs three calls per cycle:
+ *
+ *   1. eth_feeHistory(20, 'latest', [10, 25, 50, 75, 90])
+ *      — base-fee history + percentile rewards, for trend detection
+ *      and as a fallback when a block has zero txs of our own to
+ *      percentile.
+ *   2. eth_getBlockByNumber('latest', true)
+ *      — full block (header + all txs) so we can compute the same
+ *      effectiveTip miners themselves maximize.
+ *   3. txpool_content
+ *      — pending + queued txs by sender. Best-effort: many public
+ *      RPC providers gate this method (returns 405/method-not-found),
+ *      and a missing mempool just degrades the oracle to block-only
+ *      signal — it does NOT fail the cycle.
+ *
+ * Why not viem's getBlock/getFeeHistory directly? `txpool_content` is
+ * a non-standard RPC, so we'd reach for `client.request` for that one
+ * anyway. Doing all three through `client.request` keeps the call shapes
+ * symmetric and avoids viem's type narrowing where we want raw fields
+ * (excessBlobGas, blobGasUsed) that viem currently doesn't surface in
+ * its decoded Block type uniformly across versions.
+ */
+import type { PublicClient } from 'viem';
+import type { PollOptions, RawTx } from './types.js';
+/** Result shape returned by `eth_feeHistory`. */
+export interface FeeHistoryResult {
+    baseFeePerGas: string[];
+    reward?: string[][];
+    gasUsedRatio: number[];
+    oldestBlock: string;
+}
+/**
+ * Result shape returned by `eth_getBlockByNumber` with `fullTransactions=true`.
+ * Hex-encoded numbers are kept as strings — the oracle decodes them at the
+ * point of use to keep transport boundary-typed and the math layer pure.
+ */
+export interface BlockResult {
+    number: string;
+    hash?: string;
+    parentHash?: string;
+    timestamp: string;
+    baseFeePerGas: string;
+    gasLimit: string;
+    gasUsed: string;
+    transactions: RawTx[];
+    excessBlobGas?: string;
+    blobGasUsed?: string;
+}
+export interface TxPoolContent {
+    pending: Record<string, Record<string, RawTx>>;
+    queued: Record<string, Record<string, RawTx>>;
+}
+export interface OraclePollInputs {
+    feeHistory: FeeHistoryResult | null;
+    block: BlockResult | null;
+    txPool: TxPoolContent | null;
+}
+/**
+ * One poll cycle's RPC fan-out. Returns whatever could be fetched —
+ * `null` for any sub-call that failed OR was disabled by `poll`. The
+ * caller (`oracle.ts`) handles the case where `block` is null (cycle
+ * aborts) and where `feeHistory`/`txPool` is null (those signals are
+ * dropped, see reducePollInputs).
+ *
+ * `poll.feeHistory` and `poll.mempool` default to `true`. When `false`,
+ * the corresponding RPC is skipped entirely (not even attempted) — this
+ * is for callers who know upstream gates the method or who want to
+ * minimize their RPC budget. `eth_getBlockByNumber` is non-toggleable.
+ */
+export declare const fetchOracleInputs: (client: PublicClient, options?: {
+    onError?: (method: string, err: unknown) => void;
+    poll?: PollOptions;
+}) => Promise<OraclePollInputs>;
+//# sourceMappingURL=transport.d.ts.map

package/dist/transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../src/transport.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,MAAM,CAAA;AAExC,OAAO,KAAK,EAAE,WAAW,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAEpD,iDAAiD;AACjD,MAAM,WAAW,gBAAgB;IAC/B,aAAa,EAAE,MAAM,EAAE,CAAA;IACvB,MAAM,CAAC,EAAE,MAAM,EAAE,EAAE,CAAA;IACnB,YAAY,EAAE,MAAM,EAAE,CAAA;IACtB,WAAW,EAAE,MAAM,CAAA;CACpB;AAED;;;;GAIG;AACH,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,SAAS,EAAE,MAAM,CAAA;IACjB,aAAa,EAAE,MAAM,CAAA;IACrB,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,YAAY,EAAE,KAAK,EAAE,CAAA;IACrB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB;AAED,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAA;IAC9C,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC,CAAA;CAC9C;AAED,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,gBAAgB,GAAG,IAAI,CAAA;IACnC,KAAK,EAAE,WAAW,GAAG,IAAI,CAAA;IACzB,MAAM,EAAE,aAAa,GAAG,IAAI,CAAA;CAC7B;AA2BD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,iBAAiB,GAC5B,QAAQ,YAAY,EACpB,UAAS;IACP,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,KAAK,IAAI,CAAA;IAChD,IAAI,CAAC,EAAE,WAAW,CAAA;CACd,KACL,OAAO,CAAC,gBAAgB,CAiC1B,CAAA"}

package/dist/transport.js

@@ -0,0 +1,72 @@
+/**
+ * viem-native RPC transport. The oracle needs three calls per cycle:
+ *
+ *   1. eth_feeHistory(20, 'latest', [10, 25, 50, 75, 90])
+ *      — base-fee history + percentile rewards, for trend detection
+ *      and as a fallback when a block has zero txs of our own to
+ *      percentile.
+ *   2. eth_getBlockByNumber('latest', true)
+ *      — full block (header + all txs) so we can compute the same
+ *      effectiveTip miners themselves maximize.
+ *   3. txpool_content
+ *      — pending + queued txs by sender. Best-effort: many public
+ *      RPC providers gate this method (returns 405/method-not-found),
+ *      and a missing mempool just degrades the oracle to block-only
+ *      signal — it does NOT fail the cycle.
+ *
+ * Why not viem's getBlock/getFeeHistory directly? `txpool_content` is
+ * a non-standard RPC, so we'd reach for `client.request` for that one
+ * anyway. Doing all three through `client.request` keeps the call shapes
+ * symmetric and avoids viem's type narrowing where we want raw fields
+ * (excessBlobGas, blobGasUsed) that viem currently doesn't surface in
+ * its decoded Block type uniformly across versions.
+ */
+/**
+ * Issue an arbitrary JSON-RPC method through the client. Wraps
+ * `client.request` so a single failure (method-not-found, transport
+ * error, malformed response) becomes `null` rather than a thrown
+ * exception — the caller decides how to interpret missing data. This
+ * matches the original oracle's behavior where a missing `txpool_content`
+ * gracefully falls through to block-only signal.
+ */
+const safeRequest = async (client, method, params, onError) => {
+    try {
+        // viem's request typing is parameterized over a known method union;
+        // for non-standard methods (txpool_content) we cast through unknown.
+        const result = (await client.request({ method, params }));
+        return result ?? null;
+    }
+    catch (err) {
+        if (onError)
+            onError(err);
+        return null;
+    }
+};
+/**
+ * One poll cycle's RPC fan-out. Returns whatever could be fetched —
+ * `null` for any sub-call that failed OR was disabled by `poll`. The
+ * caller (`oracle.ts`) handles the case where `block` is null (cycle
+ * aborts) and where `feeHistory`/`txPool` is null (those signals are
+ * dropped, see reducePollInputs).
+ *
+ * `poll.feeHistory` and `poll.mempool` default to `true`. When `false`,
+ * the corresponding RPC is skipped entirely (not even attempted) — this
+ * is for callers who know upstream gates the method or who want to
+ * minimize their RPC budget. `eth_getBlockByNumber` is non-toggleable.
+ */
+export const fetchOracleInputs = async (client, options = {}) => {
+    const onErr = (method) => options.onError ? (err) => options.onError(method, err) : undefined;
+    const fetchFeeHistory = options.poll?.feeHistory !== false;
+    const fetchMempool = options.poll?.mempool !== false;
+    const [feeHistory, block, txPool] = await Promise.all([
+        fetchFeeHistory
+            ? safeRequest(client, 'eth_feeHistory', ['0x14', 'latest', [10, 25, 50, 75, 90]], onErr('eth_feeHistory'))
+            : Promise.resolve(null),
+        safeRequest(client, 'eth_getBlockByNumber', ['latest', true], onErr('eth_getBlockByNumber')),
+        fetchMempool
+            ? safeRequest(client, 'txpool_content', [], onErr('txpool_content'))
+            : Promise.resolve(null),
+    ]);
+    return { feeHistory, block, txPool };
+};
+//# sourceMappingURL=transport.js.map

package/dist/transport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.js","sourceRoot":"","sources":["../src/transport.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AA2CH;;;;;;;GAOG;AACH,MAAM,WAAW,GAAG,KAAK,EACvB,MAAoB,EACpB,MAAc,EACd,MAAiB,EACjB,OAAgC,EACb,EAAE;IACrB,IAAI,CAAC;QACH,oEAAoE;QACpE,qEAAqE;QACrE,MAAM,MAAM,GAAG,CAAC,MAAM,MAAM,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,MAAM,EAAW,CAAC,CAAM,CAAA;QACvE,OAAO,MAAM,IAAI,IAAI,CAAA;IACvB,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,IAAI,OAAO;YAAE,OAAO,CAAC,GAAG,CAAC,CAAA;QACzB,OAAO,IAAI,CAAA;IACb,CAAC;AACH,CAAC,CAAA;AAED;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,KAAK,EACpC,MAAoB,EACpB,UAGI,EAAE,EACqB,EAAE;IAC7B,MAAM,KAAK,GAAG,CAAC,MAAc,EAAE,EAAE,CAC/B,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,GAAY,EAAE,EAAE,CAAC,OAAO,CAAC,OAAQ,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAA;IAE/E,MAAM,eAAe,GAAG,OAAO,CAAC,IAAI,EAAE,UAAU,KAAK,KAAK,CAAA;IAC1D,MAAM,YAAY,GAAG,OAAO,CAAC,IAAI,EAAE,OAAO,KAAK,KAAK,CAAA;IAEpD,MAAM,CAAC,UAAU,EAAE,KAAK,EAAE,MAAM,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC;QACpD,eAAe;YACb,CAAC,CAAC,WAAW,CACT,MAAM,EACN,gBAAgB,EAChB,CAAC,MAAM,EAAE,QAAQ,EAAE,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EACxC,KAAK,CAAC,gBAAgB,CAAC,CACxB;YACH,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC;QACzB,WAAW,CACT,MAAM,EACN,sBAAsB,EACtB,CAAC,QAAQ,EAAE,IAAI,CAAC,EAChB,KAAK,CAAC,sBAAsB,CAAC,CAC9B;QACD,YAAY;YACV,CAAC,CAAC,WAAW,CACT,MAAM,EACN,gBAAgB,EAChB,EAAE,EACF,KAAK,CAAC,gBAAgB,CAAC,CACxB;YACH,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC;KAC1B,CAAC,CAAA;IAEF,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,EAAE,CAAA;AACtC,CAAC,CAAA"}

package/dist/types.d.ts

@@ -0,0 +1,168 @@
+/**
+ * Shared types for the gas oracle. Pure data shapes — no deps.
+ *
+ * Wire format note: every fee field is a `bigint`. Callers serializing
+ * across HTTP / Redis / WebSocket should hex-encode (`'0x' + n.toString(16)`)
+ * since JSON has no native bigint and `JSON.stringify` will throw on raw
+ * bigint values. The caller owns that encoding — this package keeps the
+ * canonical numeric form internally.
+ */
+/**
+ * Minimal tx shape extracted from `eth_getBlockByNumber(latest, true)` or
+ * `txpool_content`. Fee fields drive tip math; `hash`, `from`, `nonce`
+ * support mempool lookups (`findByHash` / `findByAddressNonce`). Other
+ * tx fields (to/value/data/etc.) are ignored.
+ *
+ * `hash`, `from`, `nonce` are nominally optional because `eth_get-
+ * BlockByNumber(_, true)` blocks always carry them but we want callers
+ * to be able to construct `RawTx` from minimal fixtures in tests.
+ * geth/reth `txpool_content` includes all three.
+ */
+export interface RawTx {
+    maxPriorityFeePerGas?: string;
+    maxFeePerGas?: string;
+    gasPrice?: string;
+    gas?: string;
+    type?: string;
+    hash?: string;
+    from?: string;
+    nonce?: string;
+}
+export interface TipPercentiles {
+    p10: bigint;
+    p25: bigint;
+    p50: bigint;
+    p75: bigint;
+    p90: bigint;
+}
+/**
+ * One fee-tier recommendation. `gasPrice` is included for legacy callers
+ * (type-0/1 txs) and is computed as `baseFee + maxPriorityFeePerGas`.
+ * `maxFeePerBlobGas` is null on chains without EIP-4844 support.
+ */
+export interface TierRecommendation {
+    maxPriorityFeePerGas: bigint;
+    maxFeePerGas: bigint;
+    gasPrice: bigint;
+    maxFeePerBlobGas: bigint | null;
+}
+export type Trend = 'rising' | 'falling' | 'stable';
+export type TierName = 'slow' | 'standard' | 'fast' | 'instant';
+export interface MempoolStats {
+    pendingCount: number;
+    queuedCount: number;
+    /** Sum of `tx.gas` across all pending txs — congestion proxy. */
+    pendingGasDemand: bigint;
+    /** Latest block's gas limit, useful for "pending demand vs. block capacity". */
+    blockGasLimit: bigint;
+}
+export interface BlobStats {
+    blobBaseFee: bigint;
+    excessBlobGas: bigint;
+    blobGasUsed: bigint;
+    blobBaseFeeTrend: Trend;
+}
+/**
+ * One per-tx contribution to the priority-fee distribution.
+ *
+ * - `tip`     — effective per-gas tip miners maximize for inclusion.
+ * - `gas`     — declared gas; the gas-weighting denominator for percentile math.
+ * - `txType`  — EIP-2718 type byte (0 legacy, 1 EIP-2930, 2 EIP-1559, 3
+ *               EIP-4844, 4 EIP-7702, …). Used by `priorityModel: 'eip1559'`
+ *               filtering to keep paying-lane tiers honest on chains that
+ *               honor the cutoff.
+ * - `hash`    — the tx hash, for `tipForBlockPosition({ kind: 'aheadOf' })`-
+ *               style relative targeting. Optional because tests construct
+ *               minimal samples by hand.
+ * - `address` — sender address, lowercased. Pairs with `nonce` to identify
+ *               a tx without needing its hash.
+ * - `nonce`   — decimal-string normalized.
+ */
+export interface TipSample {
+    tip: bigint;
+    gas: bigint;
+    txType?: number;
+    hash?: string;
+    address?: string;
+    nonce?: string;
+}
+/**
+ * Where the chain's inclusion logic draws its priority cutoff in the
+ * tx-type space.
+ *
+ * - `'flat'`     — chain ignores the EIP-2718 type byte for ordering.
+ *                  Tiers derive from a single gas-weighted distribution
+ *                  across all txs. Right for extractive validators
+ *                  (PulseChain et al.) where the only signal that matters
+ *                  is fee per gas, regardless of tx envelope.
+ * - `'eip1559'`  — type 2+ txs get priority. Paying-lane tiers
+ *                  (standard/fast/instant) derive from type-2+ samples
+ *                  only; `slow` still draws from the full distribution
+ *                  so legacy senders find their lane. Right for chains
+ *                  that honor the 1559 fee-market shape.
+ *
+ * Future cutoffs can be added (e.g. `'eip4844'` for blob-only priority)
+ * without re-interpreting existing values.
+ */
+export type PriorityModel = 'flat' | 'eip1559';
+/**
+ * Producer-side toggles: which RPCs the oracle calls upstream each cycle.
+ *
+ * Fields default to true. `eth_getBlockByNumber` is intentionally not
+ * toggleable — without a block we can't compute anything.
+ *
+ * - `feeHistory: false` — drops `eth_feeHistory`. Trend detection falls
+ *                          back to a single-element history (always
+ *                          reports `'stable'`); percentile fallback
+ *                          becomes block-only.
+ * - `mempool: false`    — drops `txpool_content`. Tiers reflect block
+ *                          inclusion only, not pending pressure. Useful
+ *                          when the upstream provider gates the
+ *                          method (many public RPCs return 405).
+ */
+export interface PollOptions {
+    feeHistory?: boolean;
+    mempool?: boolean;
+}
+/**
+ * One block's worth of state retained in the rolling ring. Per-tx tips
+ * + gas are kept so we can re-percentile on each poll without re-fetching
+ * historical blocks. Header fields support the reorg/missed-poll detector
+ * (see spec §7).
+ */
+export interface BlockSample {
+    number: bigint;
+    hash: string;
+    parentHash: string;
+    baseFee: bigint;
+    gasUsed: bigint;
+    tips: TipSample[];
+}
+/**
+ * Snapshot of a single chain's gas-oracle state. Re-published on every
+ * poll cycle. `lastPublishedTips`, `lastPublishedBlockNumber`, and `ring`
+ * are the producer-local cap anchor + sample buffer used by `cappedTip`
+ * and tier construction; consumers receiving a serialized snapshot can
+ * ignore them (the relay's `toPublishable` strips them before publish).
+ */
+export interface GasOracleState {
+    chainId: number;
+    blockNumber: bigint;
+    timestamp: bigint;
+    baseFee: bigint;
+    baseFeeTrend: Trend;
+    baseFeeHistory: bigint[];
+    mempool: MempoolStats;
+    blob: BlobStats | null;
+    tiers: Record<TierName, TierRecommendation>;
+    /**
+     * Rolling ring of recent blocks (oldest → newest). Producer-only.
+     * Currently always single-element; the 20-block lifecycle (append /
+     * bridgeGap / clearAndBackfill) is deferred to a follow-up per spec
+     * §7-§9.
+     */
+    ring: BlockSample[];
+    lastPublishedTips?: Record<TierName, bigint>;
+    lastPublishedBlockNumber?: bigint;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/dist/types.js

@@ -0,0 +1,11 @@
+/**
+ * Shared types for the gas oracle. Pure data shapes — no deps.
+ *
+ * Wire format note: every fee field is a `bigint`. Callers serializing
+ * across HTTP / Redis / WebSocket should hex-encode (`'0x' + n.toString(16)`)
+ * since JSON has no native bigint and `JSON.stringify` will throw on raw
+ * bigint values. The caller owns that encoding — this package keeps the
+ * canonical numeric form internally.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG"}

package/dist/viem-actions.d.ts

@@ -0,0 +1,77 @@
+/**
+ * @valve-tech/gas-oracle/viem-actions — viem client extension.
+ *
+ * Use when callers want explicit access to the structured tier shape:
+ *
+ *   const client = createPublicClient({ chain, transport: http() })
+ *     .extend(gasOracleActions({
+ *       chainId: 1,
+ *       priorityFeeDecayCap: parseEther('0.125'),
+ *       priorityModel: 'eip1559',
+ *     }))
+ *
+ *   await client.getGasTiers()        // full snapshot
+ *   await client.getGasTier('fast')   // one tier
+ *
+ * The actions own a per-extension `GasOracle` keyed off the supplied
+ * chainId. The poll loop starts eagerly by default so the first read is
+ * served from a populated cache; pass `lifecycle: 'lazy'` to defer
+ * polling to the first read instead. Either way the underlying client
+ * is what drives the upstream RPC (the same transport viem already
+ * uses for everything else), so callers don't have to wire a second
+ * URL just to feed the oracle.
+ *
+ * Stopping the poller is the caller's responsibility — viem clients
+ * have no explicit lifecycle, so `stopGasOracle()` is exposed on the
+ * extended client for shutdown hooks (Next.js HMR, test teardown,
+ * one-shot scripts) that need to drop the interval timer cleanly.
+ */
+import type { PublicClient } from 'viem';
+import { type BlockPositionQuery, type BlockPositionResult } from './block-position.js';
+import { type MempoolHit, type TxIdentifier } from './mempool.js';
+import { type CreateGasOracleOptions } from './oracle.js';
+import type { GasOracleState, TierName, TierRecommendation } from './types.js';
+export interface GasOracleActionsOptions extends Omit<CreateGasOracleOptions, 'client'> {
+    /**
+     * When the oracle starts polling.
+     * - `'eager'` (default): poll loop begins as soon as the extension is
+     *   attached — first read is served from cache.
+     * - `'lazy'`:            poll loop starts on the first `getGasTiers`
+     *                        / `getGasTier` call. Trades a small first-read
+     *                        latency for not running background RPCs the
+     *                        caller never asked for.
+     */
+    lifecycle?: 'eager' | 'lazy';
+}
+export interface GasOracleActions {
+    /**
+     * Latest tier snapshot. When state hasn't been populated yet (cold
+     * start), runs an out-of-band poll to seed it before returning.
+     */
+    getGasTiers: () => Promise<GasOracleState>;
+    /** One specific tier's recommendation. Same backing state as getGasTiers. */
+    getGasTier: (name: TierName) => Promise<TierRecommendation>;
+    /**
+     * Look up a tx in the mempool by hash or by sender address + nonce.
+     * When `keepMempoolSnapshot: true` is set on the actions options,
+     * served from the oracle's cached snapshot (no extra RPC); otherwise
+     * issues an on-demand `txpool_content` request.
+     */
+    findTxInMempool: (id: TxIdentifier) => Promise<MempoolHit | null>;
+    /**
+     * Compute the tip required to land at a target position in the next
+     * block. Distribution = ring (last block) ∪ pending mempool, the
+     * same union `computeTiers` reads. When mempool data isn't available
+     * (gated upstream / `keepMempoolSnapshot: false` / first cold-start
+     * read), falls back to ring-only.
+     */
+    tipForBlockPosition: (query: BlockPositionQuery) => Promise<BlockPositionResult>;
+    /**
+     * Stop the underlying poller. Idempotent. After stop, subsequent
+     * reads will throw — there's no auto-restart, since restart timing
+     * is the caller's concern (HMR vs. test teardown vs. real shutdown).
+     */
+    stopGasOracle: () => void;
+}
+export declare const gasOracleActions: (options: GasOracleActionsOptions) => (client: PublicClient) => GasOracleActions;
+//# sourceMappingURL=viem-actions.d.ts.map

package/dist/viem-actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"viem-actions.d.ts","sourceRoot":"","sources":["../src/viem-actions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,MAAM,CAAA;AAExC,OAAO,EAEL,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,EACzB,MAAM,qBAAqB,CAAA;AAC5B,OAAO,EAGL,KAAK,UAAU,EAEf,KAAK,YAAY,EAClB,MAAM,cAAc,CAAA;AACrB,OAAO,EAAmB,KAAK,sBAAsB,EAAkB,MAAM,aAAa,CAAA;AAE1F,OAAO,KAAK,EAAE,cAAc,EAAE,QAAQ,EAAE,kBAAkB,EAAa,MAAM,YAAY,CAAA;AAEzF,MAAM,WAAW,uBAAwB,SAAQ,IAAI,CAAC,sBAAsB,EAAE,QAAQ,CAAC;IACrF;;;;;;;;OAQG;IACH,SAAS,CAAC,EAAE,OAAO,GAAG,MAAM,CAAA;CAC7B;AAED,MAAM,WAAW,gBAAgB;IAC/B;;;OAGG;IACH,WAAW,EAAE,MAAM,OAAO,CAAC,cAAc,CAAC,CAAA;IAC1C,6EAA6E;IAC7E,UAAU,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,OAAO,CAAC,kBAAkB,CAAC,CAAA;IAC3D;;;;;OAKG;IACH,eAAe,EAAE,CAAC,EAAE,EAAE,YAAY,KAAK,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CAAA;IACjE;;;;;;OAMG;IACH,mBAAmB,EAAE,CAAC,KAAK,EAAE,kBAAkB,KAAK,OAAO,CAAC,mBAAmB,CAAC,CAAA;IAChF;;;;OAIG;IACH,aAAa,EAAE,MAAM,IAAI,CAAA;CAC1B;AAED,eAAO,MAAM,gBAAgB,GAAI,SAAS,uBAAuB,MAC9D,QAAQ,YAAY,KAAG,gBAuFvB,CAAA"}

package/dist/viem-actions.js

@@ -0,0 +1,118 @@
+/**
+ * @valve-tech/gas-oracle/viem-actions — viem client extension.
+ *
+ * Use when callers want explicit access to the structured tier shape:
+ *
+ *   const client = createPublicClient({ chain, transport: http() })
+ *     .extend(gasOracleActions({
+ *       chainId: 1,
+ *       priorityFeeDecayCap: parseEther('0.125'),
+ *       priorityModel: 'eip1559',
+ *     }))
+ *
+ *   await client.getGasTiers()        // full snapshot
+ *   await client.getGasTier('fast')   // one tier
+ *
+ * The actions own a per-extension `GasOracle` keyed off the supplied
+ * chainId. The poll loop starts eagerly by default so the first read is
+ * served from a populated cache; pass `lifecycle: 'lazy'` to defer
+ * polling to the first read instead. Either way the underlying client
+ * is what drives the upstream RPC (the same transport viem already
+ * uses for everything else), so callers don't have to wire a second
+ * URL just to feed the oracle.
+ *
+ * Stopping the poller is the caller's responsibility — viem clients
+ * have no explicit lifecycle, so `stopGasOracle()` is exposed on the
+ * extended client for shutdown hooks (Next.js HMR, test teardown,
+ * one-shot scripts) that need to drop the interval timer cleanly.
+ */
+import { tipForBlockPosition, } from './block-position.js';
+import { findInMempool, normalizeMempool, } from './mempool.js';
+import { createGasOracle } from './oracle.js';
+export const gasOracleActions = (options) => (client) => {
+    const oracle = createGasOracle({ ...options, client });
+    const lifecycle = options.lifecycle ?? 'eager';
+    let started = false;
+    if (lifecycle === 'eager') {
+        oracle.start();
+        started = true;
+    }
+    const ensureState = async () => {
+        if (!started) {
+            oracle.start();
+            started = true;
+        }
+        const cached = oracle.getState();
+        if (cached)
+            return cached;
+        const polled = await oracle.pollOnce();
+        if (!polled) {
+            throw new Error(`[gas-oracle] poll cycle returned no state — upstream block fetch failed for chain ${options.chainId}`);
+        }
+        return polled;
+    };
+    /**
+     * Pull a fresh mempool snapshot — from the oracle's cache when
+     * `keepMempoolSnapshot: true`, otherwise via an on-demand RPC.
+     * Falls back to `null` when the upstream gates `txpool_content`.
+     */
+    const fetchMempool = async () => {
+        const cached = oracle.getMempoolSnapshot();
+        if (cached)
+            return cached;
+        try {
+            const raw = (await client.request({
+                method: 'txpool_content',
+                params: [],
+            }));
+            return raw ? normalizeMempool(raw) : null;
+        }
+        catch {
+            return null;
+        }
+    };
+    return {
+        getGasTiers: ensureState,
+        getGasTier: async (name) => (await ensureState()).tiers[name],
+        findTxInMempool: async (id) => findInMempool(await fetchMempool(), id),
+        tipForBlockPosition: async (query) => {
+            const state = await ensureState();
+            const ringSamples = state.ring.flatMap((b) => b.tips);
+            const mempool = await fetchMempool();
+            const mempoolSamples = mempool
+                ? Object.entries(mempool.pending).flatMap(([address, byNonce]) => Object.entries(byNonce).flatMap(([nonce, tx]) => {
+                    if (tx.gas === undefined)
+                        return [];
+                    const tip = (() => {
+                        if (tx.maxFeePerGas && tx.maxPriorityFeePerGas) {
+                            const maxFee = BigInt(tx.maxFeePerGas);
+                            const maxPriority = BigInt(tx.maxPriorityFeePerGas);
+                            const headroom = maxFee - state.baseFee;
+                            if (headroom <= 0n)
+                                return 0n;
+                            return maxPriority < headroom ? maxPriority : headroom;
+                        }
+                        if (tx.gasPrice) {
+                            const price = BigInt(tx.gasPrice);
+                            return price > state.baseFee ? price - state.baseFee : 0n;
+                        }
+                        return 0n;
+                    })();
+                    return [
+                        {
+                            tip,
+                            gas: BigInt(tx.gas),
+                            txType: tx.type !== undefined ? Number(tx.type) : undefined,
+                            hash: tx.hash,
+                            address,
+                            nonce,
+                        },
+                    ];
+                }))
+                : [];
+            return tipForBlockPosition([...ringSamples, ...mempoolSamples], query);
+        },
+        stopGasOracle: () => oracle.stop(),
+    };
+};
+//# sourceMappingURL=viem-actions.js.map

package/dist/viem-actions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"viem-actions.js","sourceRoot":"","sources":["../src/viem-actions.ts"],"names":[],"mappings":"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"}

package/dist/viem-transport.d.ts

@@ -0,0 +1,85 @@
+/**
+ * @valve-tech/gas-oracle/viem-transport — viem Transport wrapper.
+ *
+ * Use when callers want viem's existing API to *just work better*
+ * without changing call-site code:
+ *
+ *   const transport = withGasOracle(http(rpcUrl), {
+ *     chainId: 1,
+ *     priorityFeeDecayCap: parseEther('0.125'),
+ *     priorityModel: 'eip1559',
+ *     intercept: { eth_maxPriorityFeePerGas: 'fast' },
+ *   })
+ *   const client = createPublicClient({ chain: mainnet, transport })
+ *
+ *   // Standard viem APIs now reach the oracle cache instead of upstream:
+ *   await client.estimateMaxPriorityFeePerGas()
+ *   await walletClient.sendTransaction({ ... })  // gas auto-fill is corrected
+ *
+ * Default `intercept` is `{ eth_gasFeeEstimate: true }` only — the
+ * additive method that returns the full tier shape. Standard methods
+ * (`eth_gasPrice`, `eth_maxPriorityFeePerGas`) pass through to upstream
+ * unless the caller opts in AND specifies which tier to map them to.
+ * Forcing the tier choice keeps the package out of the silently-pick-a-
+ * percentile foot-gun the relay's gas-intercept caught earlier (one
+ * customer's eth_gasPrice and another's eth_maxPriorityFeePerGas
+ * returning numbers 5x apart because each defaulted to a different
+ * percentile).
+ *
+ * `eth_feeHistory` is intentionally NOT in the intercept options.
+ * Synthesizing the historical-percentile array from oracle state is
+ * its own design problem; passthrough is the only honest answer in v0.2.
+ */
+import { type Transport } from 'viem';
+import { type CreateGasOracleOptions } from './oracle.js';
+import type { TierName } from './types.js';
+export interface InterceptOptions {
+    /**
+     * Additive multi-tier read. Returns `{ baseFee, tiers: { slow, standard,
+     * fast, instant }, mempoolPendingCount, ... }`. Default `true`.
+     */
+    eth_gasFeeEstimate?: boolean;
+    /**
+     * Map `eth_gasPrice` to a tier's `gasPrice` (legacy field = baseFee + tip).
+     * Required tier choice — boolean is intentionally not accepted because
+     * a default tier would silently make this method's number depend on the
+     * package version.
+     */
+    eth_gasPrice?: TierName | false;
+    /**
+     * Map `eth_maxPriorityFeePerGas` to a tier's `maxPriorityFeePerGas`.
+     * Required tier choice. Same reasoning as `eth_gasPrice`.
+     */
+    eth_maxPriorityFeePerGas?: TierName | false;
+}
+export interface WithGasOracleOptions extends Omit<CreateGasOracleOptions, 'client'> {
+    /**
+     * Per-method intercept config. Methods not listed pass through to the
+     * inner transport. See `InterceptOptions` field docs for defaults and
+     * the rationale for tier-required opt-in on standard methods.
+     */
+    intercept?: InterceptOptions;
+    /**
+     * When the oracle starts polling. `'eager'` (default) starts on
+     * construction; `'lazy'` waits for the first intercepted RPC. Lazy
+     * mode trades a small first-read latency for not running background
+     * RPCs when the wrapped client is constructed but never used.
+     */
+    lifecycle?: 'eager' | 'lazy';
+}
+export type GasOracleTransport = Transport & {
+    stopGasOracle: () => void;
+};
+/**
+ * Wrap an existing viem Transport with gas-oracle interception.
+ *
+ * The returned value is a Transport (drops into `createPublicClient({
+ * transport })` directly) plus a `stopGasOracle()` handle for shutdown
+ * hooks (HMR, test teardown). The oracle is constructed once per
+ * `withGasOracle` call — a single Transport instance is shared with
+ * the oracle's poll loop, so wrapping `http(url)` once produces one
+ * oracle and one stream of upstream RPC, regardless of how many
+ * clients consume the transport downstream.
+ */
+export declare const withGasOracle: (innerTransport: Transport, options: WithGasOracleOptions) => GasOracleTransport;
+//# sourceMappingURL=viem-transport.d.ts.map

package/dist/viem-transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"viem-transport.d.ts","sourceRoot":"","sources":["../src/viem-transport.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AAEH,OAAO,EAAU,KAAK,SAAS,EAAE,MAAM,MAAM,CAAA;AAE7C,OAAO,EAAmB,KAAK,sBAAsB,EAAkB,MAAM,aAAa,CAAA;AAC1F,OAAO,KAAK,EAAkB,QAAQ,EAAsB,MAAM,YAAY,CAAA;AAE9E,MAAM,WAAW,gBAAgB;IAC/B;;;OAGG;IACH,kBAAkB,CAAC,EAAE,OAAO,CAAA;IAC5B;;;;;OAKG;IACH,YAAY,CAAC,EAAE,QAAQ,GAAG,KAAK,CAAA;IAC/B;;;OAGG;IACH,wBAAwB,CAAC,EAAE,QAAQ,GAAG,KAAK,CAAA;CAC5C;AAED,MAAM,WAAW,oBAAqB,SAAQ,IAAI,CAAC,sBAAsB,EAAE,QAAQ,CAAC;IAClF;;;;OAIG;IACH,SAAS,CAAC,EAAE,gBAAgB,CAAA;IAC5B;;;;;OAKG;IACH,SAAS,CAAC,EAAE,OAAO,GAAG,MAAM,CAAA;CAC7B;AAED,MAAM,MAAM,kBAAkB,GAAG,SAAS,GAAG;IAAE,aAAa,EAAE,MAAM,IAAI,CAAA;CAAE,CAAA;AA8G1E;;;;;;;;;;GAUG;AACH,eAAO,MAAM,aAAa,GACxB,gBAAgB,SAAS,EACzB,SAAS,oBAAoB,KAC5B,kBAyBF,CAAA"}