@valve-tech/gas-oracle 0.2.0

package/dist/mempool.js

@@ -0,0 +1,108 @@
+/**
+ * Pure mempool-inspection helpers.
+ *
+ * `txpool_content` returns a two-level map: sender → nonce → RawTx,
+ * split into `pending` (next-in-line for inclusion) and `queued` (gap
+ * txs that can't mine yet). These helpers find a specific tx in either
+ * sub-pool.
+ *
+ * **Normalize once.** Upstream clients serialize sender addresses
+ * inconsistently — geth/reth use EIP-55 checksum, others lowercase,
+ * some checksum a few hex chars and not others. Doing the case-fold
+ * (and the hex/decimal nonce coercion) on every lookup wastes work
+ * and invites case-mismatch bugs. Instead, callers run
+ * `normalizeMempool(pool)` ONCE at ingest, then pass the normalized
+ * form to every subsequent lookup. Lookups then become direct O(1)
+ * map accesses with no string-case fallback walks.
+ *
+ * The `NormalizedMempool` type signals that contract structurally —
+ * functionally identical to `TxPoolContent`, but the type alias names
+ * the invariant.
+ */
+const normalizeSubpool = (sub) => {
+    if (!sub)
+        return {};
+    const out = {};
+    for (const [address, byNonce] of Object.entries(sub)) {
+        const normalizedByNonce = {};
+        for (const [nonce, tx] of Object.entries(byNonce)) {
+            normalizedByNonce[BigInt(nonce).toString()] = tx;
+        }
+        out[address.toLowerCase()] = normalizedByNonce;
+    }
+    return out;
+};
+/**
+ * Run the upstream `txpool_content` payload through one normalization
+ * pass: lowercase every sender address, decimal-ify every nonce key.
+ * Idempotent — re-normalizing a NormalizedMempool returns an
+ * equivalent NormalizedMempool. Pass `null`/`undefined` to get an
+ * empty NormalizedMempool back (lookup helpers handle null too, but
+ * always-having-a-shape simplifies callers that store the snapshot).
+ */
+export const normalizeMempool = (pool) => ({
+    pending: normalizeSubpool(pool?.pending),
+    queued: normalizeSubpool(pool?.queued),
+});
+const searchSubpool = (subpool, bucket, predicate) => {
+    if (!subpool)
+        return null;
+    for (const [address, byNonce] of Object.entries(subpool)) {
+        for (const [nonce, tx] of Object.entries(byNonce)) {
+            if (predicate(tx)) {
+                return { tx, bucket, address, nonce };
+            }
+        }
+    }
+    return null;
+};
+const eq = (a, b) => typeof a === 'string' && a.toLowerCase() === b.toLowerCase();
+/**
+ * Find a tx in `pending` or `queued` by hash. Searches `pending` first
+ * — the common "is my tx going to mine?" question is most often
+ * answered there. Hash comparison is case-insensitive (tx.hash on the
+ * stored RawTx may still be checksum-mixed-case from upstream; we
+ * don't rewrite per-tx fields during pool normalization, only the
+ * outer keys).
+ */
+export const findByHash = (pool, hash) => {
+    if (!pool || !hash)
+        return null;
+    const pending = searchSubpool(pool.pending, 'pending', (tx) => eq(tx.hash, hash));
+    if (pending)
+        return pending;
+    return searchSubpool(pool.queued, 'queued', (tx) => eq(tx.hash, hash));
+};
+/**
+ * Find a tx by sender address + nonce. Direct two-key lookup — no
+ * scan, no case-walk, because the pool is normalized at ingest.
+ * `nonce` accepts a number, a decimal string (`'5'`), a hex string
+ * (`'0x5'`), or a bigint. Returns `null` when the pool is null/empty,
+ * the address has no entries, or the address is present but the nonce
+ * isn't.
+ */
+export const findByAddressNonce = (pool, address, nonce) => {
+    if (!pool || !address)
+        return null;
+    const lowerAddr = address.toLowerCase();
+    // BigInt() handles every accepted form: 5, 5n, '5', '0x5'. The .toString()
+    // is the canonical decimal form the normalized pool keys are written in.
+    const decimalNonce = BigInt(nonce).toString();
+    const probe = (subpool, bucket) => {
+        const tx = subpool?.[lowerAddr]?.[decimalNonce];
+        return tx ? { tx, bucket, address: lowerAddr, nonce: decimalNonce } : null;
+    };
+    return probe(pool.pending, 'pending') ?? probe(pool.queued, 'queued');
+};
+/**
+ * Single-call lookup that takes a discriminated `TxIdentifier`. Use
+ * when you don't statically know which dimension you're querying on
+ * (e.g. wiring up a UI that lets the user paste either a hash or an
+ * address + nonce).
+ */
+export const findInMempool = (pool, id) => {
+    if ('hash' in id)
+        return findByHash(pool, id.hash);
+    return findByAddressNonce(pool, id.address, id.nonce);
+};
+//# sourceMappingURL=mempool.js.map

package/dist/mempool.js.map

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

package/dist/oracle.d.ts

@@ -0,0 +1,139 @@
+/**
+ * Gas oracle factory. Owns:
+ *
+ *   - the polling lifecycle (start/stop interval timer)
+ *   - in-memory state for one chain
+ *   - a subscriber list so callers can mirror published state to Redis,
+ *     a websocket, a metrics gauge, etc. — the package itself stays
+ *     transport-agnostic and zero-deps beyond the viem peer.
+ *
+ * One oracle instance per chain. If you need many chains in one
+ * process, instantiate many oracles. They don't share any state.
+ */
+import type { PublicClient } from 'viem';
+import { type OraclePollInputs } from './transport.js';
+import { type NormalizedMempool } from './mempool.js';
+import type { GasOracleState, PollOptions, PriorityModel } from './types.js';
+export interface CreateGasOracleOptions {
+    /** viem PublicClient pointed at the upstream RPC for this chain. */
+    client: PublicClient;
+    /** EVM chain ID. Echoed back in `state.chainId`; not validated. */
+    chainId: number;
+    /** Polling interval in ms. Default 10_000. */
+    pollIntervalMs?: number;
+    /**
+     * Optional error sink. Called for each sub-RPC that fails inside a
+     * poll cycle. Default behavior is to swallow — the oracle keeps running
+     * on partial data. Useful for routing failures into a debug logger or
+     * a metrics counter.
+     */
+    onError?: (method: string, err: unknown) => void;
+    /**
+     * Maximum fraction the published priority-fee tip may drop per block
+     * elapsed since the last publish. Wad-scaled bigint: 1e18 = 100%.
+     * Pass `parseEther('0.125')` for the default 12.5%/block (EIP-1559
+     * parity). `null` disables capping entirely. Validated at construction
+     * to fall in `[0n, WAD]` when not null.
+     */
+    priorityFeeDecayCap?: bigint | null;
+    /**
+     * Where the chain draws its priority cutoff in the EIP-2718 type space.
+     * `'flat'` (default) treats every tx equally — right for extractive
+     * networks. `'eip1559'` derives standard/fast/instant from type-2+
+     * samples only — right for chains that honor 1559 ordering.
+     */
+    priorityModel?: PriorityModel;
+    /**
+     * How many blocks the published recommendation should survive in the
+     * worst case. The buffered base fee underpinning `maxFeePerGas` becomes
+     * `baseFee * (9/8)^N` (the EIP-1559 worst-case rise compounded), so a
+     * tx submitted with the current snapshot still lands within `N` blocks
+     * even if every intervening block is full. Default `1` (one block of
+     * headroom — matches pre-v0.2 behavior). A wallet that wants its
+     * recommendation to last ~1.5 minutes on Ethereum (~6 blocks at 12s)
+     * sets this to `6`. Validated `>= 1`.
+     */
+    baseFeeLivenessBlocks?: number;
+    /**
+     * Producer-side toggles for upstream RPC calls. `feeHistory` and
+     * `mempool` default true; setting either to false skips that RPC
+     * entirely each cycle. `eth_getBlockByNumber` is not toggleable.
+     */
+    poll?: PollOptions;
+    /**
+     * When `true`, the oracle retains the latest normalized mempool
+     * snapshot and exposes it via `getMempoolSnapshot()`. The snapshot
+     * powers `findInMempool` / `tipForBlockPosition({ kind: 'aheadOf' })`-
+     * style lookups without a second RPC roundtrip. Memory cost is the
+     * size of one `txpool_content` payload (5–15MB on busy ETH mainnet);
+     * keep this off in browser/mobile contexts. Default `false`.
+     */
+    keepMempoolSnapshot?: boolean;
+}
+export interface GasOracle {
+    /** Begin the poll loop. Idempotent — calling twice is a no-op. */
+    start: () => void;
+    /** Stop polling and clear in-memory state. */
+    stop: () => void;
+    /** Latest known state, or null if no successful poll has completed yet. */
+    getState: () => GasOracleState | null;
+    /**
+     * Latest normalized mempool snapshot, or `null` if `keepMempoolSnapshot`
+     * is off, no poll has yet succeeded, or the most recent poll's
+     * `txpool_content` failed (provider gated, etc.). Always returns the
+     * normalized form — addresses lowercase, nonces decimalized — so
+     * callers can pass it directly into `findInMempool` /
+     * `tipForBlockPosition`.
+     */
+    getMempoolSnapshot: () => NormalizedMempool | null;
+    /**
+     * Run one poll cycle out-of-band and return the resulting state.
+     * Useful for tests, on-demand refreshes, or running without the
+     * interval timer (e.g., serverless). Resolves to null if the cycle
+     * couldn't produce state (no block fetched).
+     */
+    pollOnce: () => Promise<GasOracleState | null>;
+    /**
+     * Subscribe to state updates. The callback fires after every
+     * successful poll cycle with the new state. Returns an unsubscribe
+     * function. Subscribers fire synchronously; if a subscriber throws,
+     * the error is swallowed so one bad consumer can't take down the
+     * oracle's other listeners.
+     */
+    subscribe: (cb: (state: GasOracleState) => void) => () => void;
+}
+/**
+ * Reduce a poll cycle's RPC outputs into a new oracle state, using the
+ * previous state to anchor the cap-decay and the base-fee history.
+ *
+ * Pure: no I/O, no global state, no time. Test by feeding it fixture
+ * inputs and asserting the returned shape.
+ */
+export declare const reducePollInputs: (input: {
+    inputs: OraclePollInputs;
+    chainId: number;
+    prev: GasOracleState | null;
+    priorityFeeDecayCap?: bigint | null;
+    priorityModel?: PriorityModel;
+    baseFeeLivenessBlocks?: number;
+}) => GasOracleState | null;
+/**
+ * Build a configured oracle. Nothing happens until you call `start()`.
+ *
+ * @example
+ *   import { createPublicClient, http } from 'viem'
+ *   import { mainnet } from 'viem/chains'
+ *   import { createGasOracle } from '@valve-tech/gas-oracle'
+ *
+ *   const client = createPublicClient({ chain: mainnet, transport: http() })
+ *   const oracle = createGasOracle({ client, chainId: 1 })
+ *   oracle.subscribe((state) => publishToRedis(state))
+ *   oracle.start()
+ *
+ *   // Later — sub-ms read, no RPC:
+ *   const tier = oracle.getState()?.tiers.standard
+ */
+export declare const createGasOracle: (options: CreateGasOracleOptions) => GasOracle;
+export type { OraclePollInputs } from './transport.js';
+export type { TierName } from './types.js';
+//# sourceMappingURL=oracle.d.ts.map

package/dist/oracle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"oracle.d.ts","sourceRoot":"","sources":["../src/oracle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,MAAM,CAAA;AAExC,OAAO,EAAqB,KAAK,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AAOzE,OAAO,EAAoB,KAAK,iBAAiB,EAAE,MAAM,cAAc,CAAA;AAEvE,OAAO,KAAK,EAEV,cAAc,EAEd,WAAW,EACX,aAAa,EACd,MAAM,YAAY,CAAA;AAMnB,MAAM,WAAW,sBAAsB;IACrC,oEAAoE;IACpE,MAAM,EAAE,YAAY,CAAA;IACpB,mEAAmE;IACnE,OAAO,EAAE,MAAM,CAAA;IACf,8CAA8C;IAC9C,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,OAAO,KAAK,IAAI,CAAA;IAChD;;;;;;OAMG;IACH,mBAAmB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACnC;;;;;OAKG;IACH,aAAa,CAAC,EAAE,aAAa,CAAA;IAC7B;;;;;;;;;OASG;IACH,qBAAqB,CAAC,EAAE,MAAM,CAAA;IAC9B;;;;OAIG;IACH,IAAI,CAAC,EAAE,WAAW,CAAA;IAClB;;;;;;;OAOG;IACH,mBAAmB,CAAC,EAAE,OAAO,CAAA;CAC9B;AAED,MAAM,WAAW,SAAS;IACxB,kEAAkE;IAClE,KAAK,EAAE,MAAM,IAAI,CAAA;IACjB,8CAA8C;IAC9C,IAAI,EAAE,MAAM,IAAI,CAAA;IAChB,2EAA2E;IAC3E,QAAQ,EAAE,MAAM,cAAc,GAAG,IAAI,CAAA;IACrC;;;;;;;OAOG;IACH,kBAAkB,EAAE,MAAM,iBAAiB,GAAG,IAAI,CAAA;IAClD;;;;;OAKG;IACH,QAAQ,EAAE,MAAM,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CAAA;IAC9C;;;;;;OAMG;IACH,SAAS,EAAE,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,KAAK,MAAM,IAAI,CAAA;CAC/D;AAED;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,GAAI,OAAO;IACtC,MAAM,EAAE,gBAAgB,CAAA;IACxB,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,cAAc,GAAG,IAAI,CAAA;IAC3B,mBAAmB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACnC,aAAa,CAAC,EAAE,aAAa,CAAA;IAC7B,qBAAqB,CAAC,EAAE,MAAM,CAAA;CAC/B,KAAG,cAAc,GAAG,IA6FpB,CAAA;AAED;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,eAAe,GAAI,SAAS,sBAAsB,KAAG,SAsFjE,CAAA;AAID,YAAY,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AACtD,YAAY,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA"}

package/dist/oracle.js

@@ -0,0 +1,208 @@
+/**
+ * Gas oracle factory. Owns:
+ *
+ *   - the polling lifecycle (start/stop interval timer)
+ *   - in-memory state for one chain
+ *   - a subscriber list so callers can mirror published state to Redis,
+ *     a websocket, a metrics gauge, etc. — the package itself stays
+ *     transport-agnostic and zero-deps beyond the viem peer.
+ *
+ * One oracle instance per chain. If you need many chains in one
+ * process, instantiate many oracles. They don't share any state.
+ */
+import { fetchOracleInputs } from './transport.js';
+import { computeBlobBaseFee, computeTiers, detectTrend, flattenTxPool, } from './math.js';
+import { normalizeMempool } from './mempool.js';
+import { blockToSample, mempoolToSamples } from './samples.js';
+const DEFAULT_POLL_INTERVAL_MS = 10000;
+const TREND_WINDOW = 5;
+const WAD = 1000000000000000000n;
+/**
+ * Reduce a poll cycle's RPC outputs into a new oracle state, using the
+ * previous state to anchor the cap-decay and the base-fee history.
+ *
+ * Pure: no I/O, no global state, no time. Test by feeding it fixture
+ * inputs and asserting the returned shape.
+ */
+export const reducePollInputs = (input) => {
+    const { block, feeHistory, txPool } = input.inputs;
+    if (!block)
+        return null;
+    const blockNumber = BigInt(block.number);
+    const timestamp = BigInt(block.timestamp);
+    const baseFee = BigInt(block.baseFeePerGas);
+    const blockGasLimit = BigInt(block.gasLimit);
+    // Base-fee history: prefer feeHistory's window, fall back to a
+    // single-element array so detectTrend has something to chew on.
+    const baseFeeHistory = feeHistory
+        ? feeHistory.baseFeePerGas.map((hex) => BigInt(hex))
+        : [baseFee];
+    const baseFeeTrend = detectTrend(baseFeeHistory.slice(-TREND_WINDOW));
+    // Build the rolling ring. The full 20-block append/bridgeGap/clear
+    // lifecycle is deferred (spec §7-§9); for now we keep window = 1 by
+    // populating ring as a single-element array from the current block.
+    // Forward-compatible: callers can read `state.ring` as a list of
+    // BlockSamples without caring how many entries are in it.
+    const blockSample = blockToSample(block);
+    const ring = [blockSample];
+    const ringSamples = blockSample.tips;
+    // Mempool — best-effort signal.
+    let mempool = {
+        pendingCount: 0,
+        queuedCount: 0,
+        pendingGasDemand: 0n,
+        blockGasLimit,
+    };
+    let mempoolSamples = mempoolToSamples(txPool, baseFee);
+    if (txPool) {
+        const pendingTxs = flattenTxPool(txPool.pending);
+        const queuedTxs = flattenTxPool(txPool.queued);
+        mempool = {
+            pendingCount: pendingTxs.length,
+            queuedCount: queuedTxs.length,
+            pendingGasDemand: pendingTxs.reduce((sum, tx) => sum + (tx.gas ? BigInt(tx.gas) : 0n), 0n),
+            blockGasLimit,
+        };
+    }
+    else {
+        mempoolSamples = [];
+    }
+    // EIP-4844 blob — only on chains that expose excessBlobGas.
+    let blob = null;
+    if (block.excessBlobGas !== undefined) {
+        const excessBlobGas = BigInt(block.excessBlobGas);
+        const blobGasUsed = BigInt(block.blobGasUsed ?? '0x0');
+        const blobBaseFee = computeBlobBaseFee(excessBlobGas);
+        const prevBlobHistory = input.prev?.blob ? [input.prev.blob.blobBaseFee, blobBaseFee] : [blobBaseFee];
+        blob = {
+            blobBaseFee,
+            excessBlobGas,
+            blobGasUsed,
+            blobBaseFeeTrend: detectTrend(prevBlobHistory),
+        };
+    }
+    const blobInput = blob ? { blobBaseFee: blob.blobBaseFee, trend: blob.blobBaseFeeTrend } : null;
+    const { tiers, publishedTips } = computeTiers({
+        ringSamples,
+        mempoolSamples,
+        baseFee,
+        baseFeeTrend,
+        blob: blobInput,
+        blockNumber,
+        lastPublishedTips: input.prev?.lastPublishedTips,
+        lastPublishedBlockNumber: input.prev?.lastPublishedBlockNumber,
+        priorityFeeDecayCap: input.priorityFeeDecayCap,
+        priorityModel: input.priorityModel,
+        baseFeeLivenessBlocks: input.baseFeeLivenessBlocks,
+    });
+    return {
+        chainId: input.chainId,
+        blockNumber,
+        timestamp,
+        baseFee,
+        baseFeeTrend,
+        baseFeeHistory,
+        mempool,
+        blob,
+        tiers,
+        ring,
+        lastPublishedTips: publishedTips,
+        lastPublishedBlockNumber: blockNumber,
+    };
+};
+/**
+ * Build a configured oracle. Nothing happens until you call `start()`.
+ *
+ * @example
+ *   import { createPublicClient, http } from 'viem'
+ *   import { mainnet } from 'viem/chains'
+ *   import { createGasOracle } from '@valve-tech/gas-oracle'
+ *
+ *   const client = createPublicClient({ chain: mainnet, transport: http() })
+ *   const oracle = createGasOracle({ client, chainId: 1 })
+ *   oracle.subscribe((state) => publishToRedis(state))
+ *   oracle.start()
+ *
+ *   // Later — sub-ms read, no RPC:
+ *   const tier = oracle.getState()?.tiers.standard
+ */
+export const createGasOracle = (options) => {
+    // Validate at the boundary so misconfigured callers fail fast rather
+    // than producing silently-wrong tier numbers later.
+    if (options.priorityFeeDecayCap !== undefined &&
+        options.priorityFeeDecayCap !== null) {
+        const cap = options.priorityFeeDecayCap;
+        if (cap < 0n || cap > WAD) {
+            throw new Error(`priorityFeeDecayCap must be in [0n, ${WAD}] (wad-scale; null = uncapped); got ${cap}`);
+        }
+    }
+    if (options.baseFeeLivenessBlocks !== undefined &&
+        (!Number.isInteger(options.baseFeeLivenessBlocks) || options.baseFeeLivenessBlocks < 1)) {
+        throw new Error(`baseFeeLivenessBlocks must be a positive integer; got ${options.baseFeeLivenessBlocks}`);
+    }
+    const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+    const retainMempool = options.keepMempoolSnapshot === true;
+    let state = null;
+    let mempoolSnapshot = null;
+    let timer = null;
+    const subscribers = new Set();
+    const notify = (next) => {
+        for (const cb of subscribers) {
+            try {
+                cb(next);
+            }
+            catch { /* swallow per-subscriber errors */ }
+        }
+    };
+    const cycle = async () => {
+        const inputs = await fetchOracleInputs(options.client, {
+            onError: options.onError,
+            poll: options.poll,
+        });
+        const next = reducePollInputs({
+            inputs,
+            chainId: options.chainId,
+            prev: state,
+            priorityFeeDecayCap: options.priorityFeeDecayCap,
+            priorityModel: options.priorityModel,
+            baseFeeLivenessBlocks: options.baseFeeLivenessBlocks,
+        });
+        if (next) {
+            state = next;
+            if (retainMempool) {
+                // Re-normalize each cycle. `inputs.txPool` is null when the
+                // mempool RPC is gated/disabled — store an empty snapshot
+                // rather than leaving stale data from a prior cycle around.
+                mempoolSnapshot = normalizeMempool(inputs.txPool);
+            }
+            notify(next);
+        }
+        return next;
+    };
+    return {
+        start: () => {
+            if (timer !== null)
+                return;
+            // Fire-and-forget the first cycle so callers don't block on RPC
+            // latency. The interval picks up from there.
+            void cycle();
+            timer = setInterval(() => { void cycle(); }, pollIntervalMs);
+        },
+        stop: () => {
+            if (timer !== null) {
+                clearInterval(timer);
+                timer = null;
+            }
+            state = null;
+            mempoolSnapshot = null;
+        },
+        getState: () => state,
+        getMempoolSnapshot: () => mempoolSnapshot,
+        pollOnce: () => cycle(),
+        subscribe: (cb) => {
+            subscribers.add(cb);
+            return () => { subscribers.delete(cb); };
+        },
+    };
+};
+//# sourceMappingURL=oracle.js.map

package/dist/oracle.js.map

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

package/dist/samples.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Adapters from upstream RPC result shapes to the gas-oracle sample
+ * model. Pure functions: take a typed RPC payload and emit either a
+ * `BlockSample` (one block of state for the ring buffer) or an array
+ * of `{ tip, gas }` mempool samples.
+ *
+ * Kept separate from `math.ts` (which stays numeric) and from
+ * `transport.ts` (which stays I/O) so tests can fixture the RPC
+ * shapes without touching either neighbor.
+ */
+import type { BlockResult, TxPoolContent } from './transport.js';
+import type { BlockSample, TipSample } from './types.js';
+/**
+ * Convert a full block (from `eth_getBlockByNumber(_, true)`) into a
+ * `BlockSample`. Per-tx tips + gas are computed once at ingest and
+ * never re-derived. Identifier fields (hash/from/nonce) ride along so
+ * the block-position helpers can locate a specific tx in the
+ * distribution. Txs missing the `gas` field are filtered out — we
+ * can't gas-weight a sample without the weight.
+ */
+export declare const blockToSample: (block: BlockResult) => BlockSample;
+/**
+ * Flatten the `pending` half of a `txpool_content` payload into the
+ * sample shape. Queued txs are excluded (consistent with existing
+ * behavior — they can't be mined at current nonce).
+ *
+ * The pool's outer key is the canonical sender address (lowercased
+ * here, since the pool may not yet be normalized). Outer key is
+ * preferred over `tx.from` because some upstream serializers omit
+ * the per-tx `from` for mempool entries to save bytes.
+ *
+ * Txs missing `gas` are filtered out for the same reason as in
+ * `blockToSample`: gas-weighting requires the weight.
+ */
+export declare const mempoolToSamples: (pool: TxPoolContent | null | undefined, currentBaseFee: bigint) => TipSample[];
+//# sourceMappingURL=samples.d.ts.map

package/dist/samples.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"samples.d.ts","sourceRoot":"","sources":["../src/samples.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAChE,OAAO,KAAK,EAAE,WAAW,EAAS,SAAS,EAAE,MAAM,YAAY,CAAA;AA8B/D;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa,GAAI,OAAO,WAAW,KAAG,WAsBlD,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,gBAAgB,GAC3B,MAAM,aAAa,GAAG,IAAI,GAAG,SAAS,EACtC,gBAAgB,MAAM,KACrB,SAAS,EAkBX,CAAA"}

package/dist/samples.js

@@ -0,0 +1,107 @@
+/**
+ * Adapters from upstream RPC result shapes to the gas-oracle sample
+ * model. Pure functions: take a typed RPC payload and emit either a
+ * `BlockSample` (one block of state for the ring buffer) or an array
+ * of `{ tip, gas }` mempool samples.
+ *
+ * Kept separate from `math.ts` (which stays numeric) and from
+ * `transport.ts` (which stays I/O) so tests can fixture the RPC
+ * shapes without touching either neighbor.
+ */
+import { effectiveTip } from './math.js';
+/**
+ * Decode the EIP-2718 type byte from its hex-string wire form.
+ * Returns `undefined` for missing or malformed inputs so the
+ * `priorityModel: 'eip1559'` filter under-counts rather than mis-buckets
+ * a malformed tx into the priority lane. `Number()` correctly handles
+ * the `0x`-prefixed forms most clients emit (`'0x'`, `'0x0'`, `'0x2'`).
+ */
+const decodeTxType = (raw) => {
+    if (raw === undefined)
+        return undefined;
+    // Empty string and `'0x'` both coerce to 0 via Number — that's the
+    // legacy/type-0 case and the right answer.
+    const n = raw === '0x' || raw === '' ? 0 : Number(raw);
+    return Number.isFinite(n) ? n : undefined;
+};
+/**
+ * Decimalize a hex-or-decimal nonce, when present. Returns undefined
+ * for missing input so the field stays optional through to consumers.
+ */
+const decodeNonce = (raw) => {
+    if (raw === undefined)
+        return undefined;
+    try {
+        return BigInt(raw).toString();
+    }
+    catch {
+        return undefined;
+    }
+};
+/**
+ * Convert a full block (from `eth_getBlockByNumber(_, true)`) into a
+ * `BlockSample`. Per-tx tips + gas are computed once at ingest and
+ * never re-derived. Identifier fields (hash/from/nonce) ride along so
+ * the block-position helpers can locate a specific tx in the
+ * distribution. Txs missing the `gas` field are filtered out — we
+ * can't gas-weight a sample without the weight.
+ */
+export const blockToSample = (block) => {
+    const baseFee = BigInt(block.baseFeePerGas);
+    const tips = [];
+    for (const tx of block.transactions) {
+        if (tx.gas === undefined)
+            continue;
+        tips.push({
+            tip: effectiveTip(tx, baseFee),
+            gas: BigInt(tx.gas),
+            txType: decodeTxType(tx.type),
+            hash: tx.hash,
+            address: tx.from?.toLowerCase(),
+            nonce: decodeNonce(tx.nonce),
+        });
+    }
+    return {
+        number: BigInt(block.number),
+        hash: block.hash ?? '',
+        parentHash: block.parentHash ?? '',
+        baseFee,
+        gasUsed: BigInt(block.gasUsed),
+        tips,
+    };
+};
+/**
+ * Flatten the `pending` half of a `txpool_content` payload into the
+ * sample shape. Queued txs are excluded (consistent with existing
+ * behavior — they can't be mined at current nonce).
+ *
+ * The pool's outer key is the canonical sender address (lowercased
+ * here, since the pool may not yet be normalized). Outer key is
+ * preferred over `tx.from` because some upstream serializers omit
+ * the per-tx `from` for mempool entries to save bytes.
+ *
+ * Txs missing `gas` are filtered out for the same reason as in
+ * `blockToSample`: gas-weighting requires the weight.
+ */
+export const mempoolToSamples = (pool, currentBaseFee) => {
+    if (!pool)
+        return [];
+    const samples = [];
+    for (const [address, byNonce] of Object.entries(pool.pending ?? {})) {
+        const lowerAddr = address.toLowerCase();
+        for (const [nonce, tx] of Object.entries(byNonce)) {
+            if (tx.gas === undefined)
+                continue;
+            samples.push({
+                tip: effectiveTip(tx, currentBaseFee),
+                gas: BigInt(tx.gas),
+                txType: decodeTxType(tx.type),
+                hash: tx.hash,
+                address: lowerAddr,
+                nonce: decodeNonce(nonce) ?? decodeNonce(tx.nonce),
+            });
+        }
+    }
+    return samples;
+};
+//# sourceMappingURL=samples.js.map

package/dist/samples.js.map

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