@jinn-network/client 0.1.6 → 0.1.7

package/dist/tasks/sources.js

@@ -13,22 +13,50 @@ export class StaticConfiguredTaskSource {
         }));
     }
 }
+/**
+ * Filter a config-level tasks[] array to only entries that can be posted via
+ * the production adapter (i.e. those with a solverNetManifestCid).
+ *
+ * This is the guard for issue #415: a tasks[] entry without a manifest CID
+ * will always throw PermanentError in signTaskDocument, causing the creator loop
+ * to backoff and retry indefinitely. Filtering here prevents the entry from ever
+ * entering the posting cycle and emits a one-time warning per dropped entry at
+ * startup.
+ *
+ * Only call this on the config-level tasks[] array (the production path). Do not
+ * apply it to Task objects created in tests or via other in-memory sources.
+ */
+export function filterBindableTasks(tasks) {
+    return tasks.filter((task) => {
+        if (!task.solverNetManifestCid) {
+            console.warn(`[creator] Skipping configured task "${task.id}": missing solverNetManifestCid. ` +
+                `Legacy tasks[] entries without a SolverNet manifest binding can never be posted ` +
+                `(spec §14 BINDING rule). Remove this entry from your config or add a solverNetManifestCid.`);
+            return false;
+        }
+        return true;
+    });
+}
 export class GeneratedTaskSource {
     sourceKey;
     generator;
-    constructor(sourceKey, generator) {
+    opts;
+    constructor(sourceKey, generator, opts = {}) {
         this.sourceKey = sourceKey;
         this.generator = generator;
+        this.opts = opts;
     }
     async collect(_now) {
         const generated = await this.generator();
         if (!generated)
             return [];
         const tasks = Array.isArray(generated) ? generated : [generated];
-        return tasks.map((task) => {
-            const bucketKey = task.window
-                ? `${task.window.startTs}:${task.window.endTs}`
-                : task.id;
+        return tasks.map((task, index) => {
+            const overrideBucketKey = this.opts.bucketKeyForTask?.(task, index);
+            const bucketKey = overrideBucketKey
+                ?? (task.window
+                    ? `${task.window.startTs}:${task.window.endTs}`
+                    : task.id);
             return {
                 task,
                 sourceKey: this.sourceKey,

package/dist/tasks/sources.js.map

@@ -1 +1 @@
-{"version":3,"file":"sources.js","sourceRoot":"","sources":["../../src/tasks/sources.ts"],"names":[],"mappings":"AAiCA,MAAM,OAAO,0BAA0B;IAGR;IAFpB,SAAS,GAAG,YAAY,CAAC;IAElC,YAA6B,KAAa;QAAb,UAAK,GAAL,KAAK,CAAQ;IAAG,CAAC;IAE9C,KAAK,CAAC,OAAO,CAAC,IAAU;QACtB,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;YAC/B,IAAI;YACJ,SAAS,EAAE,GAAG,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,EAAE,EAAE;YACzC,aAAa,EAAE,EAAE,IAAI,EAAE,eAAe,EAAE;YACxC,UAAU,EAAE,EAAE,UAAU,EAAE,IAAI,CAAC,UAAU,EAAE,IAAI,EAAE,YAAY,EAAE;SAChE,CAAC,CAAC,CAAC;IACN,CAAC;CACF;AAED,MAAM,OAAO,mBAAmB;IAEnB;IACQ;IAFnB,YACW,SAAiB,EACT,SAAwB;QADhC,cAAS,GAAT,SAAS,CAAQ;QACT,cAAS,GAAT,SAAS,CAAe;IACxC,CAAC;IAEJ,KAAK,CAAC,OAAO,CAAC,IAAU;QACtB,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,SAAS,EAAE,CAAC;QACzC,IAAI,CAAC,SAAS;YAAE,OAAO,EAAE,CAAC;QAC1B,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;QACjE,OAAO,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE;YACxB,MAAM,SAAS,GAAG,IAAI,CAAC,MAAM;gBAC3B,CAAC,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,IAAI,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE;gBAC/C,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC;YACZ,OAAO;gBACL,IAAI;gBACJ,SAAS,EAAE,IAAI,CAAC,SAAS;gBACzB,aAAa,EAAE,EAAE,IAAI,EAAE,iBAA0B,EAAE,SAAS,EAAE;gBAC9D,UAAU,EAAE;oBACV,UAAU,EAAE,IAAI,CAAC,UAAU;oBAC3B,SAAS;oBACT,IAAI,EAAE,WAAW;iBAClB;aACF,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,CAAC;CACF"}
+{"version":3,"file":"sources.js","sourceRoot":"","sources":["../../src/tasks/sources.ts"],"names":[],"mappings":"AAiCA,MAAM,OAAO,0BAA0B;IAGR;IAFpB,SAAS,GAAG,YAAY,CAAC;IAElC,YAA6B,KAAa;QAAb,UAAK,GAAL,KAAK,CAAQ;IAAG,CAAC;IAE9C,KAAK,CAAC,OAAO,CAAC,IAAU;QACtB,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;YAC/B,IAAI;YACJ,SAAS,EAAE,GAAG,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,EAAE,EAAE;YACzC,aAAa,EAAE,EAAE,IAAI,EAAE,eAAe,EAAE;YACxC,UAAU,EAAE,EAAE,UAAU,EAAE,IAAI,CAAC,UAAU,EAAE,IAAI,EAAE,YAAY,EAAE;SAChE,CAAC,CAAC,CAAC;IACN,CAAC;CACF;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,mBAAmB,CAAC,KAAa;IAC/C,OAAO,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE;QAC3B,IAAI,CAAC,IAAI,CAAC,oBAAoB,EAAE,CAAC;YAC/B,OAAO,CAAC,IAAI,CACV,uCAAuC,IAAI,CAAC,EAAE,mCAAmC;gBACjF,kFAAkF;gBAClF,4FAA4F,CAC7F,CAAC;YACF,OAAO,KAAK,CAAC;QACf,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC,CAAC,CAAC;AACL,CAAC;AAED,MAAM,OAAO,mBAAmB;IAEnB;IACQ;IACA;IAHnB,YACW,SAAiB,EACT,SAAwB,EACxB,OAEb,EAAE;QAJG,cAAS,GAAT,SAAS,CAAQ;QACT,cAAS,GAAT,SAAS,CAAe;QACxB,SAAI,GAAJ,IAAI,CAEf;IACL,CAAC;IAEJ,KAAK,CAAC,OAAO,CAAC,IAAU;QACtB,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,SAAS,EAAE,CAAC;QACzC,IAAI,CAAC,SAAS;YAAE,OAAO,EAAE,CAAC;QAC1B,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;QACjE,OAAO,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE;YAC/B,MAAM,iBAAiB,GAAG,IAAI,CAAC,IAAI,CAAC,gBAAgB,EAAE,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;YACpE,MAAM,SAAS,GAAG,iBAAiB;mBAC9B,CAAC,IAAI,CAAC,MAAM;oBACb,CAAC,CAAC,GAAG,IAAI,CAAC,MAAM,CAAC,OAAO,IAAI,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE;oBAC/C,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YACf,OAAO;gBACL,IAAI;gBACJ,SAAS,EAAE,IAAI,CAAC,SAAS;gBACzB,aAAa,EAAE,EAAE,IAAI,EAAE,iBAA0B,EAAE,SAAS,EAAE;gBAC9D,UAAU,EAAE;oBACV,UAAU,EAAE,IAAI,CAAC,UAAU;oBAC3B,SAAS;oBACT,IAAI,EAAE,WAAW;iBAClB;aACF,CAAC;QACJ,CAAC,CAAC,CAAC;IACL,CAAC;CACF"}

package/dist/tx-retry.d.ts

@@ -8,6 +8,9 @@ export declare const TX_RETRY_DEFAULTS: {
     readonly maxDelayMs: 12000;
     /** Extra fee bump per retry attempt after the first (basis points, 1500 = +15%) */
     readonly feeBumpBpsPerAttempt: 1500;
+    /** Minimum bump over the previously submitted fee for same-sender nonce replacement. */
+    readonly replacementBumpBps: 1500;
+    readonly stuckNonceAfterMs: 120000;
 };
 export declare function flattenErrorMessage(error: unknown): string;
 /**
@@ -21,6 +24,9 @@ export interface TxRetryOptions {
     maxAttempts?: number;
     baseDelayMs?: number;
     maxDelayMs?: number;
+    ledger?: TxSubmissionLedger;
+    logicalTx?: string;
+    stuckNonceAfterMs?: number;
     /** If set, invoked before each retry (attempt >= 1) for logging/metrics */
     onRetry?: (info: {
         attempt: number;
@@ -28,6 +34,119 @@ export interface TxRetryOptions {
         message: string;
     }) => void;
 }
+export interface TxFeeSnapshot {
+    maxFeePerGas?: bigint;
+    maxPriorityFeePerGas?: bigint;
+    gasPrice?: bigint;
+}
+export type Eip1559FeeOverrides = {
+    maxFeePerGas: bigint;
+    maxPriorityFeePerGas: bigint;
+    gasPrice?: undefined;
+};
+export type LegacyFeeOverrides = {
+    gasPrice: bigint;
+    maxFeePerGas?: undefined;
+    maxPriorityFeePerGas?: undefined;
+};
+export type EmptyFeeOverrides = {
+    maxFeePerGas?: undefined;
+    maxPriorityFeePerGas?: undefined;
+    gasPrice?: undefined;
+};
+export type TxFeeOverrides = Eip1559FeeOverrides | LegacyFeeOverrides | EmptyFeeOverrides;
+export type TxFeeOverrideResult = {
+    kind: 'eip1559';
+    overrides: Eip1559FeeOverrides;
+    snapshot: TxFeeSnapshot;
+} | {
+    kind: 'legacy';
+    overrides: LegacyFeeOverrides;
+    snapshot: TxFeeSnapshot;
+} | {
+    kind: 'none';
+    overrides: EmptyFeeOverrides;
+    snapshot: TxFeeSnapshot;
+};
+export type TxRecoveryTransactionRequest = TxFeeOverrides & {
+    account?: unknown;
+    to: Address;
+    value: bigint;
+    nonce: number;
+};
+export interface TxRecoveryWalletClient {
+    account?: unknown;
+    sendTransaction(tx: TxRecoveryTransactionRequest): Promise<Hex>;
+}
+export type TxRetryTransactionRequest = TxFeeOverrides & {
+    account?: unknown;
+    to?: Address;
+    data?: Hex;
+    value?: bigint;
+    gas?: bigint;
+    nonce?: number;
+    [key: string]: unknown;
+};
+export interface TxRetryWalletClient {
+    account?: unknown;
+    sendTransaction(tx: TxRetryTransactionRequest): Promise<Hex>;
+}
+export interface TxSubmissionKey {
+    chainId: number;
+    from: Address;
+    nonce: number;
+}
+export interface TxSubmissionLedgerEntry extends TxSubmissionKey {
+    hash?: Hex;
+    logicalTx?: string;
+    submittedAtMs: number;
+    fees: TxFeeSnapshot;
+    to?: Address;
+    value?: bigint;
+    data?: Hex;
+    resolvedAtMs?: number | null;
+}
+type MaybePromise<T> = T | Promise<T>;
+export interface TxSubmissionLedger {
+    getTxSubmission(key: TxSubmissionKey): MaybePromise<TxSubmissionLedgerEntry | null>;
+    recordTxSubmission(entry: TxSubmissionLedgerEntry): MaybePromise<void>;
+    markTxSubmissionResolved(key: TxSubmissionKey & {
+        resolvedAtMs: number;
+    }): MaybePromise<void>;
+}
+export interface NonceLedgerSubmission {
+    hash?: Hex;
+    logicalTx?: string;
+    submittedAtMs?: number;
+    fees: TxFeeSnapshot;
+    to?: Address;
+    value?: bigint;
+    data?: Hex;
+}
+export interface NonceLedgerContext {
+    ledger: TxSubmissionLedger;
+    chainId: number;
+    from: Address;
+    nonce: number;
+    feeResultForAttempt(attemptIndex: number, options?: {
+        forceEstimate?: boolean;
+    }): Promise<TxFeeOverrideResult>;
+    recordSubmitted(entry: NonceLedgerSubmission): Promise<void>;
+    markResolved(resolvedAtMs?: number): Promise<void>;
+}
+export interface WithNonceLedgerArgs {
+    publicClient: PublicClient;
+    walletClient?: TxRecoveryWalletClient;
+    ledger?: TxSubmissionLedger;
+    from: Address;
+    nonce?: number;
+    chainId?: number;
+    recoverStuckNonce?: boolean;
+    staleAfterMs?: number;
+}
+export declare function createMemoryTxSubmissionLedger(): TxSubmissionLedger;
+export declare function setDefaultTxSubmissionLedger(ledger: TxSubmissionLedger): void;
+export declare function getDefaultTxSubmissionLedger(): TxSubmissionLedger;
 export declare function withRecoverableRetry<T>(fn: (attemptIndex: number) => Promise<T>, options?: TxRetryOptions): Promise<T>;
 /**
  * Poll publicClient.getCode until bytecode is present at `address`, or give up.
@@ -42,27 +161,40 @@ export declare function waitForContractCode(publicClient: PublicClient, address:
     baseDelayMs?: number;
     maxDelayMs?: number;
 }): Promise<Hex>;
+export declare function mergeFeeEstimateWithPrevious(current: TxFeeSnapshot, previous?: TxFeeSnapshot | null, attemptIndex?: number): TxFeeSnapshot;
+/**
+ * EIP-1559 or legacy gas overrides for viem, increasingly aggressive on later attempts.
+ *
+ * The result carries both the spreadable viem transaction overrides and the
+ * ledger snapshot, keeping call sites from recasting the override object.
+ */
+export declare function viemFeeOverrideResultForAttempt(publicClient: PublicClient, attemptIndex: number, options?: {
+    previousFees?: TxFeeSnapshot | null;
+    forceEstimate?: boolean;
+}): Promise<TxFeeOverrideResult>;
 /** EIP-1559 or legacy gas overrides for viem, increasingly aggressive on later attempts. */
-export declare function viemFeeOverridesForAttempt(publicClient: PublicClient, attemptIndex: number): Promise<{
-    maxFeePerGas: bigint;
-    maxPriorityFeePerGas: bigint;
-} | {
-    gasPrice: bigint;
-} | Record<string, never>>;
+export declare function viemFeeOverridesForAttempt(publicClient: PublicClient, attemptIndex: number, options?: {
+    previousFees?: TxFeeSnapshot | null;
+    forceEstimate?: boolean;
+}): Promise<TxFeeOverrides>;
 export declare function waitForTransactionReceiptWithRetry(publicClient: PublicClient, hash: Hex, options?: TxRetryOptions & {
     pollingInterval?: number;
     confirmations?: number;
 }): Promise<TransactionReceipt>;
-export declare function viemSendTransactionWithRetry(walletClient: {
-    sendTransaction: (tx: any) => Promise<Hex>;
-}, publicClient: PublicClient, txRequest: {
-    account: any;
-    to?: Address;
-    data?: Hex;
-    value?: bigint;
-    gas?: bigint;
-    maxFeePerGas?: bigint;
-    maxPriorityFeePerGas?: bigint;
-    gasPrice?: bigint;
-    [key: string]: any;
-}, options?: TxRetryOptions): Promise<Hex>;
+export declare function removeConflictingLegacyGasPrice<T extends TxFeeSnapshot>(tx: T): void;
+export declare function withNonceLedger<T>(args: WithNonceLedgerArgs, fn: (context: NonceLedgerContext) => Promise<T>): Promise<T>;
+export declare function recoverStuckNonceIfNeeded(args: {
+    publicClient: PublicClient;
+    walletClient: TxRecoveryWalletClient;
+    ledger?: TxSubmissionLedger;
+    from: Address;
+    chainId?: number;
+    staleAfterMs?: number;
+    nowMs?: number;
+}): Promise<{
+    nonce: number;
+    previousHash?: Hex;
+    recoveryHash: Hex;
+} | null>;
+export declare function viemSendTransactionWithRetry(walletClient: TxRetryWalletClient, publicClient: PublicClient, txRequest: TxRetryTransactionRequest, options?: TxRetryOptions): Promise<Hex>;
+export {};

package/dist/tx-retry.js

@@ -7,6 +7,9 @@ export const TX_RETRY_DEFAULTS = {
     maxDelayMs: 12_000,
     /** Extra fee bump per retry attempt after the first (basis points, 1500 = +15%) */
     feeBumpBpsPerAttempt: 1500,
+    /** Minimum bump over the previously submitted fee for same-sender nonce replacement. */
+    replacementBumpBps: 1500,
+    stuckNonceAfterMs: 120_000,
 };
 export function flattenErrorMessage(error) {
     if (error === null || error === undefined)
@@ -194,6 +197,30 @@ export async function backoffDelay(attemptIndex, baseMs, maxMs) {
     const jitter = Math.floor(Math.random() * Math.min(250, baseMs));
     await sleep(exp + jitter);
 }
+export function createMemoryTxSubmissionLedger() {
+    const entries = new Map();
+    const keyFor = (key) => `${key.chainId}:${key.from.toLowerCase()}:${key.nonce}`;
+    return {
+        getTxSubmission(key) {
+            return entries.get(keyFor(key)) ?? null;
+        },
+        recordTxSubmission(entry) {
+            entries.set(keyFor(entry), { ...entry, resolvedAtMs: entry.resolvedAtMs ?? null });
+        },
+        markTxSubmissionResolved(key) {
+            const existing = entries.get(keyFor(key));
+            if (existing)
+                entries.set(keyFor(key), { ...existing, resolvedAtMs: key.resolvedAtMs });
+        },
+    };
+}
+let defaultTxSubmissionLedger = createMemoryTxSubmissionLedger();
+export function setDefaultTxSubmissionLedger(ledger) {
+    defaultTxSubmissionLedger = ledger;
+}
+export function getDefaultTxSubmissionLedger() {
+    return defaultTxSubmissionLedger;
+}
 export async function withRecoverableRetry(fn, options = {}) {
     const maxAttempts = options.maxAttempts ?? TX_RETRY_DEFAULTS.maxAttempts;
     const baseDelayMs = options.baseDelayMs ?? TX_RETRY_DEFAULTS.baseDelayMs;
@@ -237,20 +264,71 @@ export async function waitForContractCode(publicClient, address, options = {}) {
     }
     throw new Error(`No contract code at ${address} after ${maxAttempts} getCode attempts`);
 }
-/** EIP-1559 or legacy gas overrides for viem, increasingly aggressive on later attempts. */
-export async function viemFeeOverridesForAttempt(publicClient, attemptIndex) {
+function mulDivCeil(value, numerator, denominator) {
+    return (value * numerator + denominator - 1n) / denominator;
+}
+function maxBigInt(...values) {
+    const present = values.filter((value) => value !== undefined);
+    if (present.length === 0)
+        return undefined;
+    return present.reduce((max, value) => (value > max ? value : max), present[0]);
+}
+function replacementBump(value) {
+    return mulDivCeil(value, 10000n + BigInt(TX_RETRY_DEFAULTS.replacementBumpBps), 10000n);
+}
+function attemptBump(value, attemptIndex) {
     if (attemptIndex <= 0)
-        return {};
+        return value;
     const bps = BigInt(TX_RETRY_DEFAULTS.feeBumpBpsPerAttempt) * BigInt(attemptIndex);
-    const mult = 10000n + bps;
-    const apply = (v) => (v * mult) / 10000n;
+    return mulDivCeil(value, 10000n + bps, 10000n);
+}
+export function mergeFeeEstimateWithPrevious(current, previous, attemptIndex = 0) {
+    if (current.gasPrice !== undefined || previous?.gasPrice !== undefined) {
+        const gasPrice = maxBigInt(current.gasPrice === undefined ? undefined : attemptBump(current.gasPrice, attemptIndex), previous?.gasPrice === undefined ? undefined : replacementBump(previous.gasPrice));
+        return gasPrice === undefined ? {} : { gasPrice };
+    }
+    const maxFeePerGas = maxBigInt(current.maxFeePerGas === undefined ? undefined : attemptBump(current.maxFeePerGas, attemptIndex), previous?.maxFeePerGas === undefined ? undefined : replacementBump(previous.maxFeePerGas));
+    const maxPriorityFeePerGas = maxBigInt(current.maxPriorityFeePerGas === undefined
+        ? undefined
+        : attemptBump(current.maxPriorityFeePerGas, attemptIndex), previous?.maxPriorityFeePerGas === undefined
+        ? undefined
+        : replacementBump(previous.maxPriorityFeePerGas));
+    if (maxFeePerGas !== undefined && maxPriorityFeePerGas !== undefined) {
+        return { maxFeePerGas, maxPriorityFeePerGas };
+    }
+    return {};
+}
+function feeOverrideResultFromSnapshot(snapshot) {
+    if (snapshot.maxFeePerGas !== undefined && snapshot.maxPriorityFeePerGas !== undefined) {
+        const overrides = {
+            maxFeePerGas: snapshot.maxFeePerGas,
+            maxPriorityFeePerGas: snapshot.maxPriorityFeePerGas,
+        };
+        return { kind: 'eip1559', overrides, snapshot: overrides };
+    }
+    if (snapshot.gasPrice !== undefined) {
+        const overrides = { gasPrice: snapshot.gasPrice };
+        return { kind: 'legacy', overrides, snapshot: overrides };
+    }
+    return { kind: 'none', overrides: {}, snapshot: {} };
+}
+/**
+ * EIP-1559 or legacy gas overrides for viem, increasingly aggressive on later attempts.
+ *
+ * The result carries both the spreadable viem transaction overrides and the
+ * ledger snapshot, keeping call sites from recasting the override object.
+ */
+export async function viemFeeOverrideResultForAttempt(publicClient, attemptIndex, options = {}) {
+    if (attemptIndex <= 0 && !options.previousFees && !options.forceEstimate) {
+        return feeOverrideResultFromSnapshot({});
+    }
     try {
         const fees = await publicClient.estimateFeesPerGas();
         if (fees.maxFeePerGas !== undefined && fees.maxPriorityFeePerGas !== undefined) {
-            return {
-                maxFeePerGas: apply(fees.maxFeePerGas),
-                maxPriorityFeePerGas: apply(fees.maxPriorityFeePerGas),
-            };
+            return feeOverrideResultFromSnapshot(mergeFeeEstimateWithPrevious({
+                maxFeePerGas: fees.maxFeePerGas,
+                maxPriorityFeePerGas: fees.maxPriorityFeePerGas,
+            }, options.previousFees, attemptIndex));
         }
     }
     catch {
@@ -258,12 +336,18 @@ export async function viemFeeOverridesForAttempt(publicClient, attemptIndex) {
     }
     try {
         const gasPrice = await publicClient.getGasPrice();
-        return { gasPrice: apply(gasPrice) };
+        return feeOverrideResultFromSnapshot(mergeFeeEstimateWithPrevious({ gasPrice }, options.previousFees, attemptIndex));
     }
     catch {
-        return {};
+        return options.previousFees
+            ? feeOverrideResultFromSnapshot(mergeFeeEstimateWithPrevious({}, options.previousFees, attemptIndex))
+            : feeOverrideResultFromSnapshot({});
     }
 }
+/** EIP-1559 or legacy gas overrides for viem, increasingly aggressive on later attempts. */
+export async function viemFeeOverridesForAttempt(publicClient, attemptIndex, options = {}) {
+    return (await viemFeeOverrideResultForAttempt(publicClient, attemptIndex, options)).overrides;
+}
 export async function waitForTransactionReceiptWithRetry(publicClient, hash, options = {}) {
     const maxAttempts = options.maxAttempts ?? TX_RETRY_DEFAULTS.maxAttempts;
     const baseDelayMs = options.baseDelayMs ?? TX_RETRY_DEFAULTS.baseDelayMs;
@@ -294,34 +378,204 @@ export async function waitForTransactionReceiptWithRetry(publicClient, hash, opt
     }
     throw lastError instanceof Error ? lastError : new Error(String(lastError));
 }
+async function resolveTxChainId(publicClient) {
+    return Number(await publicClient.getChainId());
+}
+async function resolvePendingNonce(publicClient, from) {
+    return Number(await publicClient.getTransactionCount({ address: from, blockTag: 'pending' }));
+}
+async function resolveLatestNonce(publicClient, from) {
+    return Number(await publicClient.getTransactionCount({ address: from, blockTag: 'latest' }));
+}
+function accountAddress(account) {
+    if (account && typeof account === 'object' && typeof account.address === 'string') {
+        return account.address;
+    }
+    return undefined;
+}
+function supportsNonceTracking(publicClient) {
+    const client = publicClient;
+    return typeof client.getChainId === 'function' && typeof client.getTransactionCount === 'function';
+}
+function isEmptyFees(fees) {
+    return fees.maxFeePerGas === undefined
+        && fees.maxPriorityFeePerGas === undefined
+        && fees.gasPrice === undefined;
+}
+export function removeConflictingLegacyGasPrice(tx) {
+    if (tx.maxFeePerGas !== undefined && tx.maxPriorityFeePerGas !== undefined) {
+        delete tx.gasPrice;
+    }
+}
+function withoutFeeOverrides(tx) {
+    const { maxFeePerGas: _maxFeePerGas, maxPriorityFeePerGas: _maxPriorityFeePerGas, gasPrice: _gasPrice, ...baseRequest } = tx;
+    return baseRequest;
+}
+export async function withNonceLedger(args, fn) {
+    const ledger = args.ledger ?? defaultTxSubmissionLedger;
+    const chainId = args.chainId ?? await resolveTxChainId(args.publicClient);
+    if (args.recoverStuckNonce) {
+        if (!args.walletClient) {
+            throw new Error('withNonceLedger recovery requested without a wallet client');
+        }
+        await recoverStuckNonceIfNeeded({
+            publicClient: args.publicClient,
+            walletClient: args.walletClient,
+            ledger,
+            chainId,
+            from: args.from,
+            staleAfterMs: args.staleAfterMs,
+        });
+    }
+    const nonce = args.nonce ?? await resolvePendingNonce(args.publicClient, args.from);
+    const key = { chainId, from: args.from, nonce };
+    const context = {
+        ledger,
+        chainId,
+        from: args.from,
+        nonce,
+        async feeResultForAttempt(attemptIndex, options = {}) {
+            const previous = await ledger.getTxSubmission(key);
+            return viemFeeOverrideResultForAttempt(args.publicClient, attemptIndex, {
+                previousFees: previous?.resolvedAtMs == null ? previous?.fees : undefined,
+                forceEstimate: options.forceEstimate,
+            });
+        },
+        async recordSubmitted(entry) {
+            await ledger.recordTxSubmission({
+                chainId,
+                from: args.from,
+                nonce,
+                hash: entry.hash,
+                logicalTx: entry.logicalTx,
+                submittedAtMs: entry.submittedAtMs ?? Date.now(),
+                fees: entry.fees,
+                to: entry.to,
+                value: entry.value,
+                data: entry.data,
+            });
+        },
+        async markResolved(resolvedAtMs = Date.now()) {
+            await ledger.markTxSubmissionResolved({ chainId, from: args.from, nonce, resolvedAtMs });
+        },
+    };
+    return fn(context);
+}
+export async function recoverStuckNonceIfNeeded(args) {
+    const ledger = args.ledger ?? defaultTxSubmissionLedger;
+    const [chainId, pendingNonce, latestNonce] = await Promise.all([
+        args.chainId ?? resolveTxChainId(args.publicClient),
+        resolvePendingNonce(args.publicClient, args.from),
+        resolveLatestNonce(args.publicClient, args.from),
+    ]);
+    if (pendingNonce <= latestNonce)
+        return null;
+    const nowMs = args.nowMs ?? Date.now();
+    const staleAfterMs = args.staleAfterMs ?? TX_RETRY_DEFAULTS.stuckNonceAfterMs;
+    for (let nonce = latestNonce; nonce < pendingNonce; nonce++) {
+        const entry = await ledger.getTxSubmission({ chainId, from: args.from, nonce });
+        if (!entry || entry.resolvedAtMs != null)
+            continue;
+        if (nowMs - entry.submittedAtMs < staleAfterMs)
+            continue;
+        const feeOverrides = await viemFeeOverridesForAttempt(args.publicClient, 1, {
+            previousFees: entry.fees,
+            forceEstimate: true,
+        });
+        const account = args.walletClient.account;
+        const tx = {
+            account,
+            to: args.from,
+            value: 0n,
+            nonce,
+            ...feeOverrides,
+        };
+        removeConflictingLegacyGasPrice(tx);
+        const recoveryHash = await args.walletClient.sendTransaction(tx);
+        await ledger.recordTxSubmission({
+            chainId,
+            from: args.from,
+            nonce,
+            hash: recoveryHash,
+            logicalTx: 'stuck-nonce-recovery',
+            submittedAtMs: nowMs,
+            fees: feeOverrides,
+            to: args.from,
+            value: 0n,
+        });
+        await args.publicClient.waitForTransactionReceipt({ hash: recoveryHash });
+        await ledger.markTxSubmissionResolved({ chainId, from: args.from, nonce, resolvedAtMs: nowMs });
+        return { nonce, previousHash: entry.hash, recoveryHash };
+    }
+    return null;
+}
 export async function viemSendTransactionWithRetry(walletClient, publicClient, txRequest, options = {}) {
     const maxAttempts = options.maxAttempts ?? TX_RETRY_DEFAULTS.maxAttempts;
     const baseDelayMs = options.baseDelayMs ?? TX_RETRY_DEFAULTS.baseDelayMs;
     const maxDelayMs = options.maxDelayMs ?? TX_RETRY_DEFAULTS.maxDelayMs;
-    let lastError;
-    for (let attempt = 0; attempt < maxAttempts; attempt++) {
-        try {
-            const overrides = await viemFeeOverridesForAttempt(publicClient, attempt);
-            const req = { ...txRequest, ...overrides };
-            // If we provided maxFeePerGas, ensure gasPrice is not somehow inherited
-            if ('maxFeePerGas' in req && 'maxPriorityFeePerGas' in req) {
-                delete req.gasPrice;
+    const ledger = options.ledger ?? defaultTxSubmissionLedger;
+    const from = accountAddress(txRequest.account);
+    const shouldTrackNonce = from !== undefined && supportsNonceTracking(publicClient);
+    const requestedNonce = txRequest.nonce === undefined ? undefined : Number(txRequest.nonce);
+    const sendWithRetry = async (nonceLedger) => {
+        const pinnedNonce = nonceLedger?.nonce ?? requestedNonce;
+        let lastError;
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
+            try {
+                const feeResult = nonceLedger
+                    ? await nonceLedger.feeResultForAttempt(attempt, { forceEstimate: true })
+                    : await viemFeeOverrideResultForAttempt(publicClient, attempt);
+                const nonceOverride = pinnedNonce !== undefined ? { nonce: pinnedNonce } : {};
+                const req = feeResult.kind === 'none'
+                    ? {
+                        ...txRequest,
+                        ...nonceOverride,
+                    }
+                    : {
+                        ...withoutFeeOverrides(txRequest),
+                        ...nonceOverride,
+                        ...feeResult.overrides,
+                    };
+                removeConflictingLegacyGasPrice(req);
+                const hash = await walletClient.sendTransaction(req);
+                if (nonceLedger && !isEmptyFees(feeResult.snapshot)) {
+                    await nonceLedger.recordSubmitted({
+                        hash,
+                        logicalTx: options.logicalTx,
+                        fees: feeResult.snapshot,
+                        to: txRequest.to,
+                        value: txRequest.value,
+                        data: txRequest.data,
+                    });
+                }
+                return hash;
             }
-            return await walletClient.sendTransaction(req);
-        }
-        catch (err) {
-            lastError = err;
-            if (!isRecoverableTransactionError(err) || attempt >= maxAttempts - 1) {
-                throw err;
+            catch (err) {
+                lastError = err;
+                if (!isRecoverableTransactionError(err) || attempt >= maxAttempts - 1) {
+                    throw err;
+                }
+                options.onRetry?.({
+                    attempt: attempt + 1,
+                    error: err,
+                    message: flattenErrorMessage(err),
+                });
+                await backoffDelay(attempt, baseDelayMs, maxDelayMs);
             }
-            options.onRetry?.({
-                attempt: attempt + 1,
-                error: err,
-                message: flattenErrorMessage(err),
-            });
-            await backoffDelay(attempt, baseDelayMs, maxDelayMs);
         }
+        throw lastError instanceof Error ? lastError : new Error(String(lastError));
+    };
+    if (from && shouldTrackNonce) {
+        return withNonceLedger({
+            publicClient,
+            walletClient,
+            ledger,
+            from,
+            nonce: requestedNonce,
+            recoverStuckNonce: true,
+            staleAfterMs: options.stuckNonceAfterMs,
+        }, sendWithRetry);
     }
-    throw lastError instanceof Error ? lastError : new Error(String(lastError));
+    return sendWithRetry();
 }
 //# sourceMappingURL=tx-retry.js.map