@towns-labs/relayer 3.3.1 → 3.4.0

package/dist/index.js

@@ -12198,7 +12198,7 @@ var cors = /* @__PURE__ */ __name((options) => {
   }, "cors2");
 }, "cors");
 
-// ../deployments/dist/addresses.json
+// ../contracts/dist/addresses.json
 var addresses_default = {
   dev: {
     "84532": {
@@ -12292,7 +12292,7 @@ var addresses_default = {
   }
 };
 
-// ../deployments/dist/index.js
+// ../contracts/dist/index.js
 var requiredAddressKeys = [
   "orchestrator",
   "simpleFunder",
@@ -21741,7 +21741,7 @@ function errorDetails(error48) {
 __name(errorDetails, "errorDetails");
 var logger = createLogger("eip7702-relayer");
 
-// ../deployments/dist/abis/index.js
+// ../contracts/dist/abis/index.js
 var orchestratorAbi = [
   { type: "receive", stateMutability: "payable" },
   {
@@ -44780,6 +44780,76 @@ function isPendingTransactionIdUniqueConstraintError(errorMessage) {
 }
 __name(isPendingTransactionIdUniqueConstraintError, "isPendingTransactionIdUniqueConstraintError");
 
+// src/durable-objects/signer-replacement-policy.ts
+function ceilMultiplyByBps(value, bps) {
+  if (bps < 0) {
+    throw new Error("bumpBps must be non-negative");
+  }
+  const multiplier = BigInt(1e4 + bps);
+  const numerator = value * multiplier;
+  return (numerator + 9999n) / 10000n;
+}
+__name(ceilMultiplyByBps, "ceilMultiplyByBps");
+function mapStoredTxStatusToPublicStatus(storedStatus) {
+  if (storedStatus === "confirmed") return "confirmed";
+  if (storedStatus === "failed" || storedStatus === "stuck" || storedStatus === "abandoned") {
+    return "failed";
+  }
+  return "pending";
+}
+__name(mapStoredTxStatusToPublicStatus, "mapStoredTxStatusToPublicStatus");
+function shouldTriggerReplacementByFee(input) {
+  return input.requiredMaxFeePerGas > input.currentMaxFeePerGas + input.staleThresholdPerGas;
+}
+__name(shouldTriggerReplacementByFee, "shouldTriggerReplacementByFee");
+function computeReplacementFees(input) {
+  const bumpedMaxFee = ceilMultiplyByBps(input.currentMaxFeePerGas, input.bumpBps);
+  const bumpedMaxPriorityFee = ceilMultiplyByBps(input.currentMaxPriorityFeePerGas, input.bumpBps);
+  const maxFeePerGas = bumpedMaxFee > input.requiredMaxFeePerGas ? bumpedMaxFee : input.requiredMaxFeePerGas;
+  const maxPriorityFeePerGas = bumpedMaxPriorityFee > input.requiredMaxPriorityFeePerGas ? bumpedMaxPriorityFee : input.requiredMaxPriorityFeePerGas;
+  if (input.maxFeePerGasCap !== void 0 && (maxFeePerGas > input.maxFeePerGasCap || maxPriorityFeePerGas > input.maxFeePerGasCap)) {
+    return null;
+  }
+  return {
+    maxFeePerGas,
+    maxPriorityFeePerGas
+  };
+}
+__name(computeReplacementFees, "computeReplacementFees");
+function shouldApplyFinalization(input) {
+  if (!input.eventTxHash) return true;
+  if (input.status === "confirmed") return true;
+  return input.activeTxHash.toLowerCase() === input.eventTxHash.toLowerCase();
+}
+__name(shouldApplyFinalization, "shouldApplyFinalization");
+function shouldAttemptReplacementNow(input) {
+  if (input.maxAttempts <= 0) return false;
+  if (input.attempts >= input.maxAttempts) return false;
+  if (input.attempts === 0) return true;
+  const exponent = input.attempts - 1;
+  const backoffMs = input.baseBackoffMs * Math.pow(2, exponent);
+  return input.nowMs >= input.lastReplacementAtMs + backoffMs;
+}
+__name(shouldAttemptReplacementNow, "shouldAttemptReplacementNow");
+async function withCleanupOnError(operation, cleanup) {
+  try {
+    return await operation();
+  } catch (error48) {
+    await cleanup();
+    throw error48;
+  }
+}
+__name(withCleanupOnError, "withCleanupOnError");
+async function withRecoveryOnError(operation, recovery, fallback) {
+  try {
+    return await operation();
+  } catch {
+    await recovery();
+    return fallback;
+  }
+}
+__name(withRecoveryOnError, "withRecoveryOnError");
+
 // src/durable-objects/signer.do.ts
 var DEFAULT_MAX_PENDING = 16;
 var BALANCE_CHECK_INTERVAL_MS = 3e5;
@@ -44787,12 +44857,14 @@ var STALE_TX_THRESHOLD_MS = 5 * 60 * 1e3;
 var DEFAULT_INTENT_EXPIRY_BUFFER_SECONDS = 30;
 var DUPLICATE_TX_WAIT_MS = 2e3;
 var DUPLICATE_TX_WAIT_POLL_MS = 100;
-function mapStoredTxStatusToPublicStatus(storedStatus) {
-  if (storedStatus === "confirmed") return "confirmed";
-  if (storedStatus === "failed" || storedStatus === "stuck") return "failed";
-  return "pending";
-}
-__name(mapStoredTxStatusToPublicStatus, "mapStoredTxStatusToPublicStatus");
+var DEFAULT_REPLACEMENT_BUMP_BPS = 1250;
+var DEFAULT_REPLACEMENT_TRIGGER_WEI = 0n;
+var DEFAULT_REPLACEMENT_MAX_ATTEMPTS = 3;
+var DEFAULT_REPLACEMENT_BACKOFF_MS = 3e4;
+function mapStoredTxStatusToPublicStatus2(storedStatus) {
+  return mapStoredTxStatusToPublicStatus(storedStatus);
+}
+__name(mapStoredTxStatusToPublicStatus2, "mapStoredTxStatusToPublicStatus");
 function isIntentExpired(expiryTimestamp, bufferSeconds = DEFAULT_INTENT_EXPIRY_BUFFER_SECONDS) {
   const expiry = typeof expiryTimestamp === "string" ? BigInt(expiryTimestamp) : expiryTimestamp;
   const currentTime = BigInt(Math.floor(Date.now() / 1e3));
@@ -44851,8 +44923,8 @@ var SignerDO = class extends DurableObject {
           if (request.method !== "POST") {
             return new Response("Method not allowed", { status: 405 });
           }
-          const { txId, status } = await request.json();
-          await this.handleFinalized(txId, status);
+          const { txId, status, txHash } = await request.json();
+          await this.handleFinalized(txId, status, txHash);
           return Response.json({ ok: true });
         }
         case "/maintenance": {
@@ -44934,6 +45006,20 @@ var SignerDO = class extends DurableObject {
         UPDATE schema_version SET version = 2 WHERE id = 1;
       `);
     }
+    if (currentVersion < 3) {
+      this.sql.exec(`
+        ALTER TABLE pending_transactions ADD COLUMN tx_to TEXT;
+        ALTER TABLE pending_transactions ADD COLUMN tx_data TEXT;
+        ALTER TABLE pending_transactions ADD COLUMN tx_value TEXT;
+        ALTER TABLE pending_transactions ADD COLUMN tx_authorization_list TEXT;
+        ALTER TABLE pending_transactions ADD COLUMN max_fee_per_gas TEXT;
+        ALTER TABLE pending_transactions ADD COLUMN max_priority_fee_per_gas TEXT;
+        ALTER TABLE pending_transactions ADD COLUMN replacement_attempts INTEGER NOT NULL DEFAULT 0;
+        ALTER TABLE pending_transactions ADD COLUMN last_replacement_at INTEGER NOT NULL DEFAULT 0;
+        CREATE INDEX IF NOT EXISTS idx_pending_replacement ON pending_transactions(status, sent_at);
+        UPDATE schema_version SET version = 3 WHERE id = 1;
+      `);
+    }
   }
   /**
    * Self-initialize on first request
@@ -45097,7 +45183,7 @@ var SignerDO = class extends DurableObject {
         this.sql.exec("DELETE FROM pending_transactions WHERE id = ?", txId);
       }
       const pendingMaxRows = this.sql.exec(
-        "SELECT MAX(nonce) as max_nonce FROM pending_transactions WHERE status = 'pending'"
+        "SELECT MAX(nonce) as max_nonce FROM pending_transactions WHERE status IN ('pending', 'replacing')"
       ).toArray();
       const pendingMax = pendingMaxRows[0]?.max_nonce;
       const nextNonce = Math.max(onChainNonce, (pendingMax ?? -1) + 1);
@@ -45202,7 +45288,7 @@ var SignerDO = class extends DurableObject {
     try {
       const receipt = await this.getTransactionReceipt(txHash, chainId);
       if (receipt) {
-        if (status === "pending") {
+        if (status === "pending" || status === "replacing") {
           const finalStatus = receipt.status === "0x1" ? "confirmed" : "failed";
           this.sql.exec(
             "UPDATE pending_transactions SET status = ? WHERE id = ?",
@@ -45227,7 +45313,7 @@ var SignerDO = class extends DurableObject {
       }
     } catch {
     }
-    const fallbackStatus = mapStoredTxStatusToPublicStatus(status);
+    const fallbackStatus = mapStoredTxStatusToPublicStatus2(status);
     return {
       txId,
       txHash,
@@ -45333,7 +45419,9 @@ var SignerDO = class extends DurableObject {
     }
     const minBalance = this.parseBalance(this.env.MIN_SIGNER_BALANCE, 10000000000000000n);
     const isPaused = !!state.paused || balanceWei < minBalance;
-    const pendingCount = this.sql.exec("SELECT COUNT(*) as c FROM pending_transactions WHERE status = 'pending'").toArray()[0]?.c ?? 0;
+    const pendingCount = this.sql.exec(
+      "SELECT COUNT(*) as c FROM pending_transactions WHERE status IN ('pending', 'replacing')"
+    ).toArray()[0]?.c ?? 0;
     const maxPending = parseInt(
       this.env.MAX_PENDING_PER_SIGNER ?? String(DEFAULT_MAX_PENDING),
       10
@@ -45372,7 +45460,7 @@ var SignerDO = class extends DurableObject {
           return { error: "Signer is paused", code: "PAUSED" };
         }
         const pending = this.sql.exec(
-          "SELECT COUNT(*) as c FROM pending_transactions WHERE status = 'pending'"
+          "SELECT COUNT(*) as c FROM pending_transactions WHERE status IN ('pending', 'replacing')"
         ).toArray()[0]?.c ?? 0;
         if (pending >= maxPending) {
           return {
@@ -45415,13 +45503,34 @@ var SignerDO = class extends DurableObject {
       throw new SignerDOError(errorResult.error, errorResult.code ?? "BROADCAST_FAILED");
     }
     const successResult = result;
+    const { txParams, initialFeeParams } = await withCleanupOnError(
+      async () => {
+        const preparedTxParams = await this.buildTxParams(
+          tx,
+          successResult.chainId,
+          successResult.address
+        );
+        const recommendedFeeParams = await this.getRecommendedFeeParams(
+          successResult.chainId
+        );
+        return {
+          txParams: preparedTxParams,
+          initialFeeParams: recommendedFeeParams
+        };
+      },
+      async () => {
+        await this.syncNonceFromChainAtomic(tx.id);
+      }
+    );
     let txHash;
+    let usedFeeParams = initialFeeParams;
+    let usedNonce = successResult.nonce;
     try {
-      txHash = await this.signAndBroadcast(
-        tx,
+      txHash = await this.signAndBroadcastPrepared(
+        txParams,
         successResult.nonce,
-        successResult.address,
-        successResult.chainId
+        successResult.chainId,
+        initialFeeParams
       );
     } catch (error48) {
       const errorMessage = getErrorMessage(error48);
@@ -45448,12 +45557,15 @@ var SignerDO = class extends DurableObject {
           `[SignerDO] Retrying with synced nonce: ${retryNonce} (synced base: ${syncedNonce})`
         );
         try {
-          txHash = await this.signAndBroadcast(
-            tx,
+          const retryFeeParams = await this.getRecommendedFeeParams(successResult.chainId);
+          txHash = await this.signAndBroadcastPrepared(
+            txParams,
             retryNonce,
-            successResult.address,
-            successResult.chainId
+            successResult.chainId,
+            retryFeeParams
           );
+          usedFeeParams = retryFeeParams;
+          usedNonce = retryNonce;
         } catch (retryError) {
           await this.syncNonceFromChainAtomic(tx.id);
           throw retryError;
@@ -45463,7 +45575,22 @@ var SignerDO = class extends DurableObject {
         throw error48;
       }
     }
-    this.sql.exec("UPDATE pending_transactions SET tx_hash = ? WHERE id = ?", txHash, tx.id);
+    this.sql.exec(
+      `
+          UPDATE pending_transactions
+          SET tx_hash = ?, tx_to = ?, tx_data = ?, tx_value = ?, tx_authorization_list = ?,
+              max_fee_per_gas = ?, max_priority_fee_per_gas = ?
+          WHERE id = ?
+        `,
+      txHash,
+      txParams.to,
+      txParams.data,
+      txParams.value.toString(),
+      this.serializeAuthorizationList(txParams.authorizationList),
+      usedFeeParams.maxFeePerGas.toString(),
+      usedFeeParams.maxPriorityFeePerGas.toString(),
+      tx.id
+    );
     const signerName = this.getSignerName();
     if (!signerName) {
       throw new SignerDOError(
@@ -45471,18 +45598,10 @@ var SignerDO = class extends DurableObject {
         "NOT_INITIALIZED"
       );
     }
-    await this.env.MONITOR_QUEUE.send({
-      type: "monitor",
-      txId: tx.id,
-      txHash,
-      signerName,
-      chainId: successResult.chainId,
-      attempt: 0
-    });
-    this.sql.exec("UPDATE pending_transactions SET queued = 1 WHERE id = ?", tx.id);
+    await this.enqueueMonitorJob(tx.id, txHash, signerName, successResult.chainId);
     return {
       txHash,
-      nonce: successResult.nonce,
+      nonce: usedNonce,
       signer: successResult.address,
       signerName
     };
@@ -45550,16 +45669,76 @@ var SignerDO = class extends DurableObject {
     }
     return "";
   }
-  /**
-   * Sign and broadcast a transaction
-   */
-  async signAndBroadcast(tx, nonce, _signerAddress, chainId) {
-    const { walletClient, account } = this.ensureClients(chainId);
+  async enqueueMonitorJob(txId, txHash, signerName, chainId) {
+    try {
+      await this.env.MONITOR_QUEUE.send({
+        type: "monitor",
+        txId,
+        txHash,
+        signerName,
+        chainId,
+        attempt: 0
+      });
+      this.sql.exec("UPDATE pending_transactions SET queued = 1 WHERE id = ?", txId);
+      return true;
+    } catch {
+      this.sql.exec("UPDATE pending_transactions SET queued = 0 WHERE id = ?", txId);
+      return false;
+    }
+  }
+  parseOptionalBigInt(value) {
+    if (!value) return void 0;
+    const trimmed = value.trim();
+    if (!trimmed) return void 0;
+    return BigInt(trimmed);
+  }
+  serializeAuthorizationList(authorizationList) {
+    if (!authorizationList || authorizationList.length === 0) return null;
+    return JSON.stringify(
+      authorizationList,
+      (_key, value) => typeof value === "bigint" ? value.toString() : value
+    );
+  }
+  deserializeAuthorizationList(value) {
+    if (!value) return void 0;
+    const parsed = JSON.parse(value);
+    return parsed.map((item) => {
+      const copy = { ...item };
+      if (typeof copy.chainId === "string") copy.chainId = BigInt(copy.chainId);
+      if (typeof copy.nonce === "string") copy.nonce = BigInt(copy.nonce);
+      return copy;
+    });
+  }
+  getRecommendedFeeParams(chainId) {
+    const { publicClient } = this.ensureClients(chainId);
+    return publicClient.estimateFeesPerGas({
+      type: "eip1559",
+      chain: publicClient.chain
+    });
+  }
+  parseReplacementConfig() {
+    return {
+      bumpBps: parseInt(
+        this.env.REPLACEMENT_BUMP_BPS ?? String(DEFAULT_REPLACEMENT_BUMP_BPS),
+        10
+      ),
+      triggerThresholdWei: this.parseOptionalBigInt(this.env.REPLACEMENT_TRIGGER_THRESHOLD_WEI) ?? DEFAULT_REPLACEMENT_TRIGGER_WEI,
+      maxAttempts: parseInt(
+        this.env.REPLACEMENT_MAX_ATTEMPTS ?? String(DEFAULT_REPLACEMENT_MAX_ATTEMPTS),
+        10
+      ),
+      baseBackoffMs: parseInt(
+        this.env.REPLACEMENT_BACKOFF_BASE_MS ?? String(DEFAULT_REPLACEMENT_BACKOFF_MS),
+        10
+      ),
+      maxFeeCapWei: this.parseOptionalBigInt(this.env.REPLACEMENT_MAX_FEE_PER_GAS_WEI)
+    };
+  }
+  async buildTxParams(tx, chainId, signerAddress) {
     const contracts = getContractAddresses(
       this.env,
       chainId
     );
-    let txParams;
     switch (tx.type) {
       case "create-account": {
         if (tx.preCall && tx.preCall.executionData !== "0x") {
@@ -45569,23 +45748,23 @@ var SignerDO = class extends DurableObject {
             nonce: BigInt(tx.preCall.nonce),
             signature: tx.preCall.signature
           };
-          txParams = {
+          return {
             to: contracts.orchestrator,
             data: encodeFunctionData({
               abi: orchestratorAbi,
               functionName: "executePreCalls",
               args: [tx.accountAddress, [signedCall]]
             }),
-            authorizationList: [tx.authorization]
-          };
-        } else {
-          txParams = {
-            to: tx.accountAddress,
-            data: "0x",
+            value: 0n,
             authorizationList: [tx.authorization]
           };
         }
-        break;
+        return {
+          to: tx.accountAddress,
+          data: "0x",
+          value: 0n,
+          authorizationList: [tx.authorization]
+        };
       }
       case "execute-intent": {
         const bufferSeconds = parseInt(
@@ -45600,18 +45779,18 @@ var SignerDO = class extends DurableObject {
         }
         const intentWithRecipient = {
           ...tx.intent,
-          paymentRecipient: getPaymentRecipient(this.env.FEE_RECIPIENT, account.address)
+          paymentRecipient: getPaymentRecipient(this.env.FEE_RECIPIENT, signerAddress)
         };
         const encodedIntent = this.encodeIntentToBytes(intentWithRecipient);
-        txParams = {
+        return {
           to: contracts.orchestrator,
           data: encodeFunctionData({
             abi: orchestratorAbi,
             functionName: "execute",
             args: [encodedIntent]
-          })
+          }),
+          value: 0n
         };
-        break;
       }
       case "batch-execute-intent": {
         const batchBufferSeconds = parseInt(
@@ -45628,35 +45807,34 @@ var SignerDO = class extends DurableObject {
         }
         const intentsWithRecipient = tx.intents.map((intent) => ({
           ...intent,
-          paymentRecipient: getPaymentRecipient(this.env.FEE_RECIPIENT, account.address)
+          paymentRecipient: getPaymentRecipient(this.env.FEE_RECIPIENT, signerAddress)
         }));
         const encodedIntents = intentsWithRecipient.map(
           (intent) => this.encodeIntentToBytes(intent)
         );
-        txParams = {
+        return {
           to: contracts.orchestrator,
           data: encodeFunctionData({
             abi: orchestratorAbi,
             functionName: "execute",
             args: [encodedIntents]
-          })
+          }),
+          value: 0n
         };
-        break;
       }
-      default:
-        throw new SignerDOError(
-          `Unknown transaction type: ${tx.type}`,
-          "BROADCAST_FAILED"
-        );
     }
+  }
+  async signAndBroadcastPrepared(txParams, nonce, chainId, feeParams) {
+    const { walletClient, account } = this.ensureClients(chainId);
     try {
-      const txHash = await walletClient.sendTransaction({
+      return await walletClient.sendTransaction({
         ...txParams,
         nonce,
         account,
-        chain: { id: chainId }
+        chain: { id: chainId },
+        maxFeePerGas: feeParams.maxFeePerGas,
+        maxPriorityFeePerGas: feeParams.maxPriorityFeePerGas
       });
-      return txHash;
     } catch (error48) {
       const message = getErrorMessage(error48);
       throw new SignerDOError(
@@ -45745,9 +45923,187 @@ var SignerDO = class extends DurableObject {
   /**
    * Handle transaction finalization (called by queue consumer)
    */
-  async handleFinalized(txId, status) {
+  async handleFinalized(txId, status, txHash) {
+    if (txHash) {
+      const rows = this.sql.exec("SELECT tx_hash FROM pending_transactions WHERE id = ?", txId).toArray();
+      if (rows.length === 0) return;
+      const activeTxHash = rows[0].tx_hash ?? "";
+      if (!shouldApplyFinalization({ activeTxHash, eventTxHash: txHash, status })) {
+        return;
+      }
+    }
     this.sql.exec("UPDATE pending_transactions SET status = ? WHERE id = ?", status, txId);
   }
+  async tryReplaceStaleTransaction(txId, chainId, signerName) {
+    const config2 = this.parseReplacementConfig();
+    const nowMs = Date.now();
+    const claimedRows = this.sql.exec(
+      `
+          UPDATE pending_transactions
+          SET status = 'replacing'
+          WHERE id = ? AND status = 'pending'
+          RETURNING
+            nonce,
+            tx_to,
+            tx_data,
+            tx_value,
+            tx_authorization_list,
+            max_fee_per_gas,
+            max_priority_fee_per_gas,
+            replacement_attempts,
+            last_replacement_at
+        `,
+      txId
+    ).toArray();
+    if (claimedRows.length === 0) return "skipped";
+    return withRecoveryOnError(
+      async () => {
+        const claimed = claimedRows[0];
+        const attempts = claimed.replacement_attempts ?? 0;
+        const lastReplacementAtMs = claimed.last_replacement_at ?? 0;
+        if (attempts >= config2.maxAttempts) {
+          this.sql.exec(
+            "UPDATE pending_transactions SET status = ? WHERE id = ?",
+            "abandoned",
+            txId
+          );
+          return "abandoned";
+        }
+        if (!shouldAttemptReplacementNow({
+          nowMs,
+          attempts,
+          maxAttempts: config2.maxAttempts,
+          lastReplacementAtMs,
+          baseBackoffMs: config2.baseBackoffMs
+        })) {
+          this.sql.exec(
+            "UPDATE pending_transactions SET status = ? WHERE id = ?",
+            "pending",
+            txId
+          );
+          return "skipped";
+        }
+        const currentMaxFee = this.parseOptionalBigInt(
+          claimed.max_fee_per_gas
+        );
+        const currentMaxPriority = this.parseOptionalBigInt(
+          claimed.max_priority_fee_per_gas
+        );
+        const txTo = claimed.tx_to ?? "";
+        const txData = claimed.tx_data ?? "";
+        const txValue = this.parseOptionalBigInt(claimed.tx_value);
+        if (!currentMaxFee || !currentMaxPriority || !txTo || !txData || txValue === void 0) {
+          this.sql.exec(
+            "UPDATE pending_transactions SET status = ? WHERE id = ?",
+            "stuck",
+            txId
+          );
+          return "skipped";
+        }
+        const requiredFees = await this.getRecommendedFeeParams(chainId);
+        const triggerReplacement = shouldTriggerReplacementByFee({
+          requiredMaxFeePerGas: requiredFees.maxFeePerGas,
+          currentMaxFeePerGas: currentMaxFee,
+          staleThresholdPerGas: config2.triggerThresholdWei
+        });
+        if (!triggerReplacement) {
+          this.sql.exec(
+            "UPDATE pending_transactions SET status = ? WHERE id = ?",
+            "pending",
+            txId
+          );
+          return "skipped";
+        }
+        const nextFeeParams = computeReplacementFees({
+          currentMaxFeePerGas: currentMaxFee,
+          currentMaxPriorityFeePerGas: currentMaxPriority,
+          requiredMaxFeePerGas: requiredFees.maxFeePerGas,
+          requiredMaxPriorityFeePerGas: requiredFees.maxPriorityFeePerGas,
+          bumpBps: config2.bumpBps,
+          maxFeePerGasCap: config2.maxFeeCapWei
+        });
+        const nextAttempts = attempts + 1;
+        if (!nextFeeParams) {
+          this.sql.exec(
+            `
+                      UPDATE pending_transactions
+                      SET status = 'abandoned',
+                          replacement_attempts = ?,
+                          last_replacement_at = ?
+                      WHERE id = ?
+                    `,
+            nextAttempts,
+            nowMs,
+            txId
+          );
+          return "abandoned";
+        }
+        const txParams = {
+          to: txTo,
+          data: txData,
+          value: txValue,
+          authorizationList: this.deserializeAuthorizationList(
+            claimed.tx_authorization_list
+          )
+        };
+        try {
+          const nonce = claimed.nonce;
+          const replacementHash = await this.signAndBroadcastPrepared(
+            txParams,
+            nonce,
+            chainId,
+            nextFeeParams
+          );
+          this.sql.exec(
+            `
+                      UPDATE pending_transactions
+                      SET tx_hash = ?,
+                          status = 'pending',
+                          queued = 0,
+                          max_fee_per_gas = ?,
+                          max_priority_fee_per_gas = ?,
+                          replacement_attempts = ?,
+                          last_replacement_at = ?,
+                          sent_at = ?
+                      WHERE id = ?
+                    `,
+            replacementHash,
+            nextFeeParams.maxFeePerGas.toString(),
+            nextFeeParams.maxPriorityFeePerGas.toString(),
+            nextAttempts,
+            nowMs,
+            nowMs,
+            txId
+          );
+          await this.enqueueMonitorJob(txId, replacementHash, signerName, chainId);
+          return "replaced";
+        } catch {
+          const terminal = nextAttempts >= config2.maxAttempts;
+          this.sql.exec(
+            `
+                      UPDATE pending_transactions
+                      SET status = ?,
+                          replacement_attempts = ?,
+                          last_replacement_at = ?
+                      WHERE id = ?
+                    `,
+            terminal ? "abandoned" : "pending",
+            nextAttempts,
+            nowMs,
+            txId
+          );
+          return terminal ? "abandoned" : "skipped";
+        }
+      },
+      async () => {
+        this.sql.exec(
+          "UPDATE pending_transactions SET status = 'pending' WHERE id = ? AND status = 'replacing'",
+          txId
+        );
+      },
+      "skipped"
+    );
+  }
   /**
    * Maintenance: clean up stale transactions, check balance
    */
@@ -45783,11 +46139,25 @@ var SignerDO = class extends DurableObject {
         if (newStatus === "confirmed") confirmed++;
         else failed++;
       } else {
-        this.sql.exec(
-          "UPDATE pending_transactions SET status = 'stuck' WHERE id = ?",
-          tx.id
+        const signerName2 = this.getSignerName();
+        if (!signerName2) {
+          this.sql.exec(
+            "UPDATE pending_transactions SET status = 'stuck' WHERE id = ?",
+            tx.id
+          );
+          stuck++;
+          continue;
+        }
+        const replacementResult = await this.tryReplaceStaleTransaction(
+          tx.id,
+          chainId,
+          signerName2
         );
-        stuck++;
+        if (replacementResult === "abandoned") {
+          failed++;
+        } else if (replacementResult === "skipped") {
+          stuck++;
+        }
       }
     }
     let requeued = 0;
@@ -45800,18 +46170,14 @@ var SignerDO = class extends DurableObject {
         `
       ).toArray();
       for (const tx of orphaned) {
-        try {
-          await this.env.MONITOR_QUEUE.send({
-            type: "monitor",
-            txId: tx.id,
-            txHash: tx.tx_hash,
-            signerName,
-            chainId,
-            attempt: 0
-          });
-          this.sql.exec("UPDATE pending_transactions SET queued = 1 WHERE id = ?", tx.id);
+        const queued = await this.enqueueMonitorJob(
+          tx.id,
+          tx.tx_hash,
+          signerName,
+          chainId
+        );
+        if (queued) {
           requeued++;
-        } catch {
         }
       }
     }
@@ -45861,7 +46227,9 @@ var SignerDO = class extends DurableObject {
   async getStatus() {
     await this.ensureInitialized();
     const stateRows = this.sql.exec("SELECT * FROM signer_state WHERE id = 1").toArray();
-    const pendingCount = this.sql.exec("SELECT COUNT(*) as c FROM pending_transactions WHERE status = 'pending'").toArray()[0]?.c ?? 0;
+    const pendingCount = this.sql.exec(
+      "SELECT COUNT(*) as c FROM pending_transactions WHERE status IN ('pending', 'replacing')"
+    ).toArray()[0]?.c ?? 0;
     const recentTransactions = this.sql.exec("SELECT * FROM pending_transactions ORDER BY sent_at DESC LIMIT 10").toArray();
     return {
       state: stateRows.length > 0 ? stateRows[0] : null,
@@ -47229,6 +47597,7 @@ async function handleMonitorJob(msg, env) {
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({
         txId,
+        txHash,
         status: receipt.status === "0x1" ? "confirmed" : "failed"
       })
     });