@valve-tech/tx-tracker 0.6.0 → 0.8.0

package/dist/observations.js

@@ -0,0 +1,287 @@
+/**
+ * Per-record decision functions — the **pure** logic that turns one
+ * upstream observation (a block or a mempool snapshot) plus one
+ * tracked record's current state into the events that should be
+ * emitted and the state patch the orchestrator should apply.
+ *
+ * These functions are extracted from `tracker.ts`'s `onBlock` /
+ * `onMempool` so each branch of the per-record state machine is
+ * testable with literal fixture inputs — no stub source, no async
+ * orchestration, no shared mutable closure. This is the same
+ * primitive-vs-orchestrator split that `oracle.ts` (`reducePollInputs`
+ * pure / poll loop stateful) and `chain-source` (math pure / source
+ * stateful) already follow.
+ *
+ * Inputs are immutable; outputs are immutable. The caller in
+ * `tracker.ts` applies the returned `statusPatch` and `identityPatch`
+ * to its mutable `TrackedRecord`, then emits the returned `events`
+ * via its event-bus + store-audit-log machinery.
+ */
+import { buildLeftMempool, buildReplacedBy, buildSeenInBlock, buildSeenInMempool, buildUnseenForNBlocks, } from './events.js';
+const EMPTY_RESULT = {
+    events: [],
+    statusPatch: {},
+    identityPatch: null,
+    inMempoolPatch: null,
+};
+/**
+ * Per-record decision for one new canonical block. Returns the events
+ * to emit and the state patch to apply. Mutually-exclusive paths,
+ * evaluated in order:
+ *
+ *   1. Hash is in this block → fresh inclusion (emit `seen-in-block`
+ *      with `confirmations: 1`) OR same-block re-observation (no
+ *      emit; `lastSeenInBlock` is already current).
+ *   2. Hash NOT in this block but was previously included → bump
+ *      `confirmations` on the cached observation, emit a fresh
+ *      `seen-in-block` carrying the new count.
+ *   3. Hash NOT in this block, no prior inclusion, but identity is
+ *      cached AND a different hash with the same `(from, nonce)` is
+ *      in this block → emit `replaced-by` with the replacement's
+ *      block number.
+ *   4. Truly unseen → bump the unseen-block streak; emit
+ *      `unseen-for-N-blocks` when the streak crosses the
+ *      subscription's threshold. Does NOT emit on the first block
+ *      after subscription (no `firstObservedAtBlock` yet).
+ */
+export const decideBlockObservation = (input) => {
+    const { record, blockHash, blockNumber, txHashSet, txs, chainId, eventSource, envelope, previousTipNumber, prefetchedReceipts, } = input;
+    const wasSeenInThisBlock = txHashSet.has(record.hash);
+    if (wasSeenInThisBlock) {
+        const tx = txs.find((t) => t.hash === record.hash);
+        if (!tx) {
+            // Defensive: hash was in the set but the find missed. Should
+            // be unreachable since the set is built from the same tx list.
+            return EMPTY_RESULT;
+        }
+        const transactionIndex = txs.indexOf(tx);
+        const isFreshInclusion = record.status.lastSeenInBlock?.blockHash !== blockHash;
+        const confirmations = isFreshInclusion
+            ? 1
+            : record.status.lastSeenInBlock.confirmations;
+        const lastSeenInBlock = {
+            blockHash,
+            blockNumber,
+            transactionIndex,
+            confirmations,
+            source: eventSource,
+        };
+        const receipt = isFreshInclusion
+            ? prefetchedReceipts?.get(record.hash)
+            : undefined;
+        const events = isFreshInclusion
+            ? [
+                buildSeenInBlock({
+                    hash: record.hash,
+                    chainId,
+                    source: eventSource,
+                    at: envelope,
+                    blockHash,
+                    blockNumber,
+                    transactionIndex,
+                    confirmations,
+                    ...(receipt !== undefined ? { receipt } : {}),
+                }),
+            ]
+            : [];
+        return {
+            events,
+            statusPatch: {
+                lastSeenInBlock,
+                unseenStreak: 0,
+                firstObservedAtBlock: record.status.firstObservedAtBlock ?? blockNumber,
+                lastObservedAtBlock: blockNumber,
+            },
+            identityPatch: cacheIdentity(record.identity, tx),
+            inMempoolPatch: null,
+        };
+    }
+    // Path 2: not in this block, but previously observed → confirmation bump
+    if (record.status.lastSeenInBlock && previousTipNumber !== null) {
+        const bumped = record.status.lastSeenInBlock.confirmations + 1;
+        const updated = {
+            ...record.status.lastSeenInBlock,
+            confirmations: bumped,
+        };
+        return {
+            events: [
+                buildSeenInBlock({
+                    hash: record.hash,
+                    chainId,
+                    source: eventSource,
+                    at: envelope,
+                    blockHash: updated.blockHash,
+                    blockNumber: updated.blockNumber,
+                    transactionIndex: updated.transactionIndex,
+                    confirmations: bumped,
+                }),
+            ],
+            statusPatch: {
+                lastSeenInBlock: updated,
+                lastObservedAtBlock: blockNumber,
+            },
+            identityPatch: null,
+            inMempoolPatch: null,
+        };
+    }
+    // Path 3: replacement detection
+    if (record.identity) {
+        const replacement = findReplacementInBlock(record.identity, record.hash, txs);
+        if (replacement && replacement.hash) {
+            return {
+                events: [
+                    buildReplacedBy({
+                        hash: record.hash,
+                        chainId,
+                        source: eventSource,
+                        at: envelope,
+                        replacementHash: replacement.hash,
+                        replacementBlockNumber: blockNumber,
+                    }),
+                ],
+                statusPatch: {
+                    replacedBy: { hash: replacement.hash, blockNumber },
+                    lastObservedAtBlock: blockNumber,
+                },
+                identityPatch: null,
+                inMempoolPatch: null,
+            };
+        }
+    }
+    // Path 4: truly unseen — only counts when there's a prior
+    // observation to count from.
+    if (record.status.firstObservedAtBlock === null) {
+        return EMPTY_RESULT;
+    }
+    const nextStreak = record.status.unseenStreak + 1;
+    const events = nextStreak === record.unseenThresholdBlocks
+        ? [
+            buildUnseenForNBlocks({
+                hash: record.hash,
+                chainId,
+                source: eventSource,
+                at: envelope,
+                blocks: nextStreak,
+            }),
+        ]
+        : [];
+    return {
+        events,
+        statusPatch: { unseenStreak: nextStreak },
+        identityPatch: null,
+        inMempoolPatch: null,
+    };
+};
+/**
+ * Per-record decision for one mempool snapshot. Three independent
+ * outputs that may all fire on the same call:
+ *
+ *   - **Presence transition** — emit `seen-in-mempool` on first
+ *     observation or bucket change; emit `left-mempool` when a
+ *     previously-seen hash is absent from this snapshot.
+ *   - **Replacement** — emit `replaced-by` (with `null` block) when
+ *     the orchestrator's pre-computed `replacementInMempool` is set
+ *     AND the record hasn't already recorded a replacement.
+ */
+export const decideMempoolObservation = (input) => {
+    const { record, presence, replacementInMempool, chainId, eventSource, envelope, tipBlockNumber, } = input;
+    const events = [];
+    let statusPatch = {};
+    let identityPatch = null;
+    let inMempoolPatch = null;
+    if (presence) {
+        identityPatch = cacheIdentity(record.identity, presence.tx);
+        const isFreshOrBucketChange = !record.inLastMempoolSnapshot ||
+            record.status.lastSeenInMempool?.bucket !== presence.bucket;
+        statusPatch = {
+            lastSeenInMempool: {
+                bucket: presence.bucket,
+                tx: presence.tx,
+                at: envelope,
+                source: eventSource,
+            },
+            unseenStreak: 0,
+            firstObservedAtBlock: record.status.firstObservedAtBlock ?? tipBlockNumber,
+            lastObservedAtBlock: tipBlockNumber,
+        };
+        inMempoolPatch = true;
+        if (isFreshOrBucketChange) {
+            events.push(buildSeenInMempool({
+                hash: record.hash,
+                chainId,
+                source: eventSource,
+                at: envelope,
+                bucket: presence.bucket,
+                tx: presence.tx,
+            }));
+        }
+    }
+    else if (record.inLastMempoolSnapshot) {
+        inMempoolPatch = false;
+        events.push(buildLeftMempool({
+            hash: record.hash,
+            chainId,
+            source: eventSource,
+            at: envelope,
+        }));
+    }
+    // Replacement detection runs independently. The orchestrator skips
+    // it when the record already carries a replacement; we mirror that
+    // here so the function is self-contained.
+    if (record.identity &&
+        !record.status.replacedBy &&
+        replacementInMempool &&
+        replacementInMempool.hash &&
+        replacementInMempool.hash !== record.hash) {
+        statusPatch = {
+            ...statusPatch,
+            replacedBy: { hash: replacementInMempool.hash, blockNumber: null },
+        };
+        events.push(buildReplacedBy({
+            hash: record.hash,
+            chainId,
+            source: eventSource,
+            at: envelope,
+            replacementHash: replacementInMempool.hash,
+            replacementBlockNumber: null,
+        }));
+    }
+    return { events, statusPatch, identityPatch, inMempoolPatch };
+};
+// -------------------------------------------------------------
+// Helpers (also pure)
+// -------------------------------------------------------------
+/**
+ * Find a tx in `txs` whose `(from, nonce)` matches `identity` but
+ * whose hash differs from `originalHash` — the replacement candidate
+ * for the original tracked tx. Compares senders case-insensitively
+ * since upstreams disagree on checksum form.
+ */
+export const findReplacementInBlock = (identity, originalHash, txs) => {
+    const targetFrom = identity.from.toLowerCase();
+    for (const tx of txs) {
+        if (tx.from?.toLowerCase() !== targetFrom)
+            continue;
+        if (tx.nonce !== identity.nonce)
+            continue;
+        if (!tx.hash)
+            continue;
+        if (tx.hash === originalHash)
+            continue;
+        return tx;
+    }
+    return null;
+};
+/**
+ * Cache the tx's `(from, nonce)` as the record's identity if it's
+ * not already cached AND the tx carries both fields. Returns the
+ * patch to apply (or `null` when no change).
+ */
+export const cacheIdentity = (current, tx) => {
+    if (current)
+        return null;
+    if (!tx.from || !tx.nonce)
+        return null;
+    return { from: tx.from, nonce: tx.nonce };
+};
+//# sourceMappingURL=observations.js.map

package/dist/observations.js.map

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

package/dist/reorg.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Reorg detector — pure function over a recent-block ring.
+ *
+ * Per `docs/tx-tracker-spec.md` §12. The tracker keeps a small ring
+ * of recently-observed canonical blocks (`BlockSample` below). On
+ * every new tip, it walks the ring backward up to `reorgDepthBlocks`
+ * (default 12) and asks: "is the canonical chain at any of those
+ * heights different from what we recorded?" Any divergence becomes
+ * a `vanished-from-block` candidate the tracker translates per
+ * affected hash.
+ *
+ * Bounded depth (§12.2): a fixed 12-block window keeps the per-tick
+ * work O(depth) regardless of how anomalous the upstream's history
+ * is. Deeper reorgs are vanishingly rare on chains the package
+ * targets; "find the common ancestor" would let one bad reorg make
+ * a tick arbitrarily long.
+ *
+ * Pure: no I/O, no clock, no mutation of input. The tracker (in
+ * `tracker.ts`) calls `appendBlock` to fold each newly-observed
+ * canonical block into the ring, and `detectDivergences` against
+ * a candidate canonical sequence (typically the source's most
+ * recent emit + the on-demand block fetches the tracker did to
+ * walk the chain backward).
+ */
+import type { Hash } from './events.js';
+/**
+ * One canonical-block coordinate the tracker has observed. The
+ * tracker also records the `transactions` it saw on that block
+ * (just the hashes, not the full RawTx) so it can quickly answer
+ * "was tx X in block N?" without a fresh RPC.
+ */
+export interface BlockSample {
+    number: bigint;
+    hash: Hash;
+    parentHash: Hash | null;
+    /** Tx hashes observed in this block at the time it was canonical. */
+    transactionHashes: ReadonlySet<Hash>;
+}
+/**
+ * One divergence the detector found between the tracker's recorded
+ * ring and a freshly-observed canonical chain. The tracker
+ * translates this into per-hash `vanished-from-block` events for
+ * every tracked hash whose `seen-in-block` referenced the previous
+ * (now-stale) hash at this height.
+ */
+export interface BlockDivergence {
+    blockNumber: bigint;
+    /** Hash the ring previously had at this height. */
+    previousBlockHash: Hash;
+    /**
+     * Hash the canonical chain has at this height now. The detector
+     * only emits divergences for heights where the caller passed an
+     * explicit canonical block, so this is always a real hash.
+     */
+    canonicalBlockHash: Hash;
+    /**
+     * Tx hashes the ring saw on the previously-canonical block at
+     * this height. Tracker uses this to scope which tracked hashes
+     * are affected.
+     */
+    vanishedTransactionHashes: ReadonlySet<Hash>;
+}
+/**
+ * Append a freshly-observed canonical block into a bounded ring
+ * keyed by block number, capped at `capacityBlocks` entries. Returns
+ * a new ring (input is not mutated). The newest entry overwrites
+ * any previous entry at the same number — a same-height reorg
+ * replaces the stale block with the new canonical one.
+ */
+export declare const appendBlock: (ring: ReadonlyArray<BlockSample>, block: BlockSample, capacityBlocks: number) => BlockSample[];
+/**
+ * Compare the tracker's `ring` (already-recorded canonical blocks)
+ * against a freshly-observed `canonical` sequence (the tracker's
+ * latest observation, plus any walk-back probes it performed). At
+ * each height present in BOTH sides, if the hashes disagree the
+ * detector returns a `BlockDivergence`.
+ *
+ * **Heights present only in `ring` are skipped** — the detector
+ * treats "no canonical entry at this height" as "no information,"
+ * not "vanished." A real same-height reorg requires the caller to
+ * explicitly pass the new canonical block at that height; gapping
+ * (e.g. caller skipped a height) is not a divergence signal.
+ *
+ * If you need to detect "ring's tip is no longer in canonical" you
+ * pass the canonical chain that explicitly covers that height; with
+ * a partial canonical sequence the detector stays conservative.
+ *
+ * `depthBlocks` caps how far back the comparison runs. The tracker
+ * rarely cares about divergences beyond `reorgDepthBlocks` because
+ * any tracked tx that deep would already be considered finalized by
+ * downstream consumer policy.
+ *
+ * Returns an empty array on a clean chain extension (no divergences).
+ */
+export declare const detectDivergences: (input: {
+    ring: ReadonlyArray<BlockSample>;
+    canonical: ReadonlyArray<BlockSample>;
+    depthBlocks: number;
+}) => BlockDivergence[];
+/**
+ * Default reorg-detection depth in blocks. Conservative — even
+ * Ethereum's worst recent reorgs are under 7 blocks, and unbounded
+ * walks would let a single anomalous reorg make the tick arbitrarily
+ * long (§12.2). Tunable per-tracker via
+ * `CreateTxTrackerOptions.reorgDepthBlocks`.
+ */
+export declare const defaultReorgDepthBlocks = 12;
+//# sourceMappingURL=reorg.d.ts.map

package/dist/reorg.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reorg.d.ts","sourceRoot":"","sources":["../src/reorg.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAA;AAEvC;;;;;GAKG;AACH,MAAM,WAAW,WAAW;IAC1B,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,IAAI,CAAA;IACV,UAAU,EAAE,IAAI,GAAG,IAAI,CAAA;IACvB,qEAAqE;IACrE,iBAAiB,EAAE,WAAW,CAAC,IAAI,CAAC,CAAA;CACrC;AAED;;;;;;GAMG;AACH,MAAM,WAAW,eAAe;IAC9B,WAAW,EAAE,MAAM,CAAA;IACnB,mDAAmD;IACnD,iBAAiB,EAAE,IAAI,CAAA;IACvB;;;;OAIG;IACH,kBAAkB,EAAE,IAAI,CAAA;IACxB;;;;OAIG;IACH,yBAAyB,EAAE,WAAW,CAAC,IAAI,CAAC,CAAA;CAC7C;AAED;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,GACtB,MAAM,aAAa,CAAC,WAAW,CAAC,EAChC,OAAO,WAAW,EAClB,gBAAgB,MAAM,KACrB,WAAW,EAeb,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,iBAAiB,GAAI,OAAO;IACvC,IAAI,EAAE,aAAa,CAAC,WAAW,CAAC,CAAA;IAChC,SAAS,EAAE,aAAa,CAAC,WAAW,CAAC,CAAA;IACrC,WAAW,EAAE,MAAM,CAAA;CACpB,KAAG,eAAe,EA4ClB,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,KAAK,CAAA"}

package/dist/reorg.js

@@ -0,0 +1,125 @@
+/**
+ * Reorg detector — pure function over a recent-block ring.
+ *
+ * Per `docs/tx-tracker-spec.md` §12. The tracker keeps a small ring
+ * of recently-observed canonical blocks (`BlockSample` below). On
+ * every new tip, it walks the ring backward up to `reorgDepthBlocks`
+ * (default 12) and asks: "is the canonical chain at any of those
+ * heights different from what we recorded?" Any divergence becomes
+ * a `vanished-from-block` candidate the tracker translates per
+ * affected hash.
+ *
+ * Bounded depth (§12.2): a fixed 12-block window keeps the per-tick
+ * work O(depth) regardless of how anomalous the upstream's history
+ * is. Deeper reorgs are vanishingly rare on chains the package
+ * targets; "find the common ancestor" would let one bad reorg make
+ * a tick arbitrarily long.
+ *
+ * Pure: no I/O, no clock, no mutation of input. The tracker (in
+ * `tracker.ts`) calls `appendBlock` to fold each newly-observed
+ * canonical block into the ring, and `detectDivergences` against
+ * a candidate canonical sequence (typically the source's most
+ * recent emit + the on-demand block fetches the tracker did to
+ * walk the chain backward).
+ */
+/**
+ * Append a freshly-observed canonical block into a bounded ring
+ * keyed by block number, capped at `capacityBlocks` entries. Returns
+ * a new ring (input is not mutated). The newest entry overwrites
+ * any previous entry at the same number — a same-height reorg
+ * replaces the stale block with the new canonical one.
+ */
+export const appendBlock = (ring, block, capacityBlocks) => {
+    const next = ring.filter((b) => b.number !== block.number);
+    next.push(block);
+    // Sort ascending by block number. The ring is small (~depth + a
+    // few) so the cost is negligible. The same-number case is
+    // unreachable here — `filter` above strips any prior entry at
+    // `block.number` before we push, so the comparator never sees
+    // equal keys; we return -1 in that arm only to satisfy bigint
+    // sort's contract.
+    /* c8 ignore next */
+    next.sort((a, b) => (a.number < b.number ? -1 : 1));
+    if (next.length > capacityBlocks) {
+        next.splice(0, next.length - capacityBlocks);
+    }
+    return next;
+};
+/**
+ * Compare the tracker's `ring` (already-recorded canonical blocks)
+ * against a freshly-observed `canonical` sequence (the tracker's
+ * latest observation, plus any walk-back probes it performed). At
+ * each height present in BOTH sides, if the hashes disagree the
+ * detector returns a `BlockDivergence`.
+ *
+ * **Heights present only in `ring` are skipped** — the detector
+ * treats "no canonical entry at this height" as "no information,"
+ * not "vanished." A real same-height reorg requires the caller to
+ * explicitly pass the new canonical block at that height; gapping
+ * (e.g. caller skipped a height) is not a divergence signal.
+ *
+ * If you need to detect "ring's tip is no longer in canonical" you
+ * pass the canonical chain that explicitly covers that height; with
+ * a partial canonical sequence the detector stays conservative.
+ *
+ * `depthBlocks` caps how far back the comparison runs. The tracker
+ * rarely cares about divergences beyond `reorgDepthBlocks` because
+ * any tracked tx that deep would already be considered finalized by
+ * downstream consumer policy.
+ *
+ * Returns an empty array on a clean chain extension (no divergences).
+ */
+export const detectDivergences = (input) => {
+    const { ring, canonical, depthBlocks } = input;
+    if (ring.length === 0 || canonical.length === 0)
+        return [];
+    // Index the canonical sequence by number for O(1) lookup. The
+    // canonical sequence is small (≤ depthBlocks), so map construction
+    // is cheap.
+    const canonicalByNumber = new Map();
+    for (const block of canonical) {
+        canonicalByNumber.set(block.number, block);
+    }
+    // The "tip" is the highest-numbered block in either side. Compare
+    // back from there for `depthBlocks` heights (inclusive of the tip).
+    // The early `length === 0` guard above means `ring[length-1]` and
+    // `canonical[length-1]` are always defined here — the `!` reflects
+    // that invariant rather than papering over a real nullable.
+    const ringTip = ring[ring.length - 1].number;
+    const canonicalTip = canonical[canonical.length - 1].number;
+    const tip = ringTip > canonicalTip ? ringTip : canonicalTip;
+    const lowestComparedNumber = tip - BigInt(depthBlocks - 1);
+    const divergences = [];
+    for (const sampled of ring) {
+        if (sampled.number < lowestComparedNumber)
+            continue;
+        const canonicalAtHeight = canonicalByNumber.get(sampled.number) ?? null;
+        if (!canonicalAtHeight)
+            continue; // no canonical info at this height
+        if (canonicalAtHeight.hash === sampled.hash)
+            continue; // unchanged
+        divergences.push({
+            blockNumber: sampled.number,
+            previousBlockHash: sampled.hash,
+            canonicalBlockHash: canonicalAtHeight.hash,
+            vanishedTransactionHashes: sampled.transactionHashes,
+        });
+    }
+    // Sort ascending by number so the tracker emits vanished events
+    // in chain order — easier on consumers piping to a single sink.
+    // Divergences are unique by `blockNumber` (one entry per ring
+    // height), so the comparator never sees equal keys; we return -1
+    // in that arm only to satisfy the sort contract.
+    /* c8 ignore next */
+    divergences.sort((a, b) => (a.blockNumber < b.blockNumber ? -1 : 1));
+    return divergences;
+};
+/**
+ * Default reorg-detection depth in blocks. Conservative — even
+ * Ethereum's worst recent reorgs are under 7 blocks, and unbounded
+ * walks would let a single anomalous reorg make the tick arbitrarily
+ * long (§12.2). Tunable per-tracker via
+ * `CreateTxTrackerOptions.reorgDepthBlocks`.
+ */
+export const defaultReorgDepthBlocks = 12;
+//# sourceMappingURL=reorg.js.map

package/dist/reorg.js.map

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

package/dist/replace-transaction.d.ts

@@ -0,0 +1,46 @@
+/**
+ * `replaceTransaction` — same-nonce replacement primitive. Provex
+ * upstream item 5 (memory: upstream-candidates.md#L50). Caller
+ * provides `original` (the previously-submitted request, including
+ * calldata + nonce) and `newGas` (the bumped EIP-1559 fee params,
+ * computed via @valve-tech/gas-oracle's helper or the caller's own
+ * math).
+ *
+ * **tx-tracker MUST NOT import from @valve-tech/gas-oracle.** Sibling
+ * packages, kept independent. The bump-rule helper ships separately
+ * in gas-oracle. See project memory:
+ * transaction-verbs-package-placement.md.
+ */
+import type { Address, Hex, WalletClient } from 'viem';
+export interface ReplaceTransactionOriginal {
+    to: Address;
+    nonce: number;
+    data?: Hex;
+    value?: bigint;
+    chainId?: number;
+}
+export interface ReplaceTransactionNewGas {
+    maxFeePerGas: bigint;
+    maxPriorityFeePerGas: bigint;
+}
+export interface ReplaceTransactionOptions {
+    original: ReplaceTransactionOriginal;
+    walletClient: WalletClient;
+    newGas: ReplaceTransactionNewGas;
+}
+/**
+ * Submit a same-nonce replacement transaction with bumped gas.
+ * Returns the new tx hash. Throws whatever the wallet client throws
+ * (no swallowing — caller decides retry / surface).
+ *
+ * @example
+ *   import { replaceTransaction } from '@valve-tech/tx-tracker'
+ *
+ *   const newHash = await replaceTransaction({
+ *     original: { to: '0xrecipient', nonce: 42, data: '0x...', value: 0n },
+ *     walletClient,
+ *     newGas: bumpForReplacement(currentGas), // from @valve-tech/gas-oracle
+ *   })
+ */
+export declare const replaceTransaction: (options: ReplaceTransactionOptions) => Promise<Hex>;
+//# sourceMappingURL=replace-transaction.d.ts.map

package/dist/replace-transaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"replace-transaction.d.ts","sourceRoot":"","sources":["../src/replace-transaction.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,YAAY,EAAE,MAAM,MAAM,CAAA;AAEtD,MAAM,WAAW,0BAA0B;IACzC,EAAE,EAAE,OAAO,CAAA;IACX,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,CAAC,EAAE,GAAG,CAAA;IACV,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAED,MAAM,WAAW,wBAAwB;IACvC,YAAY,EAAE,MAAM,CAAA;IACpB,oBAAoB,EAAE,MAAM,CAAA;CAC7B;AAED,MAAM,WAAW,yBAAyB;IACxC,QAAQ,EAAE,0BAA0B,CAAA;IACpC,YAAY,EAAE,YAAY,CAAA;IAC1B,MAAM,EAAE,wBAAwB,CAAA;CACjC;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,kBAAkB,GAC7B,SAAS,yBAAyB,KACjC,OAAO,CAAC,GAAG,CAkBb,CAAA"}

package/dist/replace-transaction.js

@@ -0,0 +1,47 @@
+/**
+ * `replaceTransaction` — same-nonce replacement primitive. Provex
+ * upstream item 5 (memory: upstream-candidates.md#L50). Caller
+ * provides `original` (the previously-submitted request, including
+ * calldata + nonce) and `newGas` (the bumped EIP-1559 fee params,
+ * computed via @valve-tech/gas-oracle's helper or the caller's own
+ * math).
+ *
+ * **tx-tracker MUST NOT import from @valve-tech/gas-oracle.** Sibling
+ * packages, kept independent. The bump-rule helper ships separately
+ * in gas-oracle. See project memory:
+ * transaction-verbs-package-placement.md.
+ */
+/**
+ * Submit a same-nonce replacement transaction with bumped gas.
+ * Returns the new tx hash. Throws whatever the wallet client throws
+ * (no swallowing — caller decides retry / surface).
+ *
+ * @example
+ *   import { replaceTransaction } from '@valve-tech/tx-tracker'
+ *
+ *   const newHash = await replaceTransaction({
+ *     original: { to: '0xrecipient', nonce: 42, data: '0x...', value: 0n },
+ *     walletClient,
+ *     newGas: bumpForReplacement(currentGas), // from @valve-tech/gas-oracle
+ *   })
+ */
+export const replaceTransaction = async (options) => {
+    const { original, walletClient, newGas } = options;
+    if (!walletClient.account) {
+        throw new Error('replaceTransaction: walletClient must have an account');
+    }
+    // viem's WalletClient.sendTransaction has multiple overloads with strict
+    // type-narrowing on chain/account. Cast is necessary to thread the request
+    // through the type system without consumers having to specify all generic params.
+    return walletClient.sendTransaction({
+        account: walletClient.account,
+        chain: null,
+        to: original.to,
+        data: original.data,
+        value: original.value,
+        nonce: original.nonce,
+        maxFeePerGas: newGas.maxFeePerGas,
+        maxPriorityFeePerGas: newGas.maxPriorityFeePerGas,
+    });
+};
+//# sourceMappingURL=replace-transaction.js.map

package/dist/replace-transaction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"replace-transaction.js","sourceRoot":"","sources":["../src/replace-transaction.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAuBH;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,KAAK,EACrC,OAAkC,EACpB,EAAE;IAChB,MAAM,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,EAAE,GAAG,OAAO,CAAA;IAClD,IAAI,CAAC,YAAY,CAAC,OAAO,EAAE,CAAC;QAC1B,MAAM,IAAI,KAAK,CAAC,uDAAuD,CAAC,CAAA;IAC1E,CAAC;IACD,yEAAyE;IACzE,2EAA2E;IAC3E,kFAAkF;IAClF,OAAO,YAAY,CAAC,eAAe,CAAC;QAClC,OAAO,EAAE,YAAY,CAAC,OAAO;QAC7B,KAAK,EAAE,IAAI;QACX,EAAE,EAAE,QAAQ,CAAC,EAAE;QACf,IAAI,EAAE,QAAQ,CAAC,IAAI;QACnB,KAAK,EAAE,QAAQ,CAAC,KAAK;QACrB,KAAK,EAAE,QAAQ,CAAC,KAAK;QACrB,YAAY,EAAE,MAAM,CAAC,YAAY;QACjC,oBAAoB,EAAE,MAAM,CAAC,oBAAoB;KACI,CAAC,CAAA;AAC1D,CAAC,CAAA"}