@towns-labs/relayer 3.4.1 → 4.1.0

package/dist/index.js

@@ -24114,6 +24114,13 @@ function getSeqKeyForDraftMark(intentNonce, seqKeyFromContext) {
   }
 }
 __name(getSeqKeyForDraftMark, "getSeqKeyForDraftMark");
+function buildBundleTrackingUnavailableError() {
+  return new RpcError2(
+    SERVICE_UNAVAILABLE,
+    "Intent submitted but bundle tracking unavailable; retry status lookup later"
+  );
+}
+__name(buildBundleTrackingUnavailableError, "buildBundleTrackingUnavailableError");
 async function handleSendPreparedCalls(params, ctx) {
   const env = ctx.env;
   const typedParams = unwrapParams(params);
@@ -24201,7 +24208,7 @@ async function handleSendPreparedCalls(params, ctx) {
     try {
       const bundleStatusId = env.BUNDLE_STATUS_DO.idFromName(`bundle-status-${chainId}`);
       const bundleStatus = env.BUNDLE_STATUS_DO.get(bundleStatusId);
-      await bundleStatus.fetch("http://do/add_bundle_tx", {
+      const addBundleResponse = await bundleStatus.fetch("http://do/add_bundle_tx", {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({
@@ -24210,30 +24217,87 @@ async function handleSendPreparedCalls(params, ctx) {
           signerName: result.signerName
         })
       });
+      if (!addBundleResponse.ok) {
+        logger.error(
+          {
+            category: "bundle_tracking_persist_failed",
+            bundleId,
+            chainId,
+            txId: tx.id,
+            signerName: result.signerName,
+            status: addBundleResponse.status,
+            statusText: addBundleResponse.statusText
+          },
+          "bundle tracking persistence failed"
+        );
+        throw buildBundleTrackingUnavailableError();
+      }
       if ("quote" in context && context.quote?.quotes?.length) {
         const quote = context.quote.quotes[0];
         const telemetry = quote?.telemetry;
         if (telemetry?.combinedGas || telemetry?.simulationGas || telemetry?.txGas) {
-          await bundleStatus.fetch("http://do/upsert_bundle_telemetry", {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({
-              bundleId,
-              chainId,
-              eoa: intent.eoa,
-              paymentEnabled: telemetry.paymentEnabled ?? false,
-              simulationGas: telemetry.simulationGas,
-              combinedGas: telemetry.combinedGas,
-              txGas: telemetry.txGas
-            })
-          });
+          try {
+            const telemetryResponse = await bundleStatus.fetch(
+              "http://do/upsert_bundle_telemetry",
+              {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                  bundleId,
+                  chainId,
+                  eoa: intent.eoa,
+                  paymentEnabled: telemetry.paymentEnabled ?? false,
+                  simulationGas: telemetry.simulationGas,
+                  combinedGas: telemetry.combinedGas,
+                  txGas: telemetry.txGas
+                })
+              }
+            );
+            if (!telemetryResponse.ok) {
+              logger.warn(
+                {
+                  category: "bundle_telemetry_persist_failed",
+                  bundleId,
+                  chainId,
+                  txId: tx.id,
+                  signerName: result.signerName,
+                  status: telemetryResponse.status,
+                  statusText: telemetryResponse.statusText
+                },
+                "bundle telemetry persistence failed"
+              );
+            }
+          } catch (error48) {
+            logger.warn(
+              {
+                category: "bundle_telemetry_persist_failed",
+                error: getErrorMessage(error48),
+                bundleId,
+                chainId,
+                txId: tx.id,
+                signerName: result.signerName
+              },
+              "failed to persist bundle telemetry"
+            );
+          }
         }
       }
     } catch (error48) {
+      if (error48 instanceof RpcError2) {
+        throw error48;
+      }
       logger.warn(
-        { error: getErrorMessage(error48), bundleId },
-        "Failed to store bundle status"
+        {
+          category: "bundle_tracking_persist_failed",
+          error: getErrorMessage(error48),
+          bundleId,
+          chainId,
+          txId: tx.id,
+          signerName: result.signerName
+        },
+        "failed to persist bundle tracking"
       );
+      throw buildBundleTrackingUnavailableError();
     }
   }
   return { id: bundleId };
@@ -24369,12 +24433,13 @@ async function handleBatchSendPreparedCalls(requests, ctx) {
       );
     }
   }
+  const bundleTrackingErrors = /* @__PURE__ */ new Map();
   if (env.BUNDLE_STATUS_DO) {
     const bundleStatusId = env.BUNDLE_STATUS_DO.idFromName(`bundle-status-${batchChainId}`);
     const bundleStatus = env.BUNDLE_STATUS_DO.get(bundleStatusId);
     for (const req of parsedRequests) {
       try {
-        await bundleStatus.fetch("http://do/add_bundle_tx", {
+        const addBundleResponse = await bundleStatus.fetch("http://do/add_bundle_tx", {
           method: "POST",
           headers: { "Content-Type": "application/json" },
           body: JSON.stringify({
@@ -24383,14 +24448,34 @@ async function handleBatchSendPreparedCalls(requests, ctx) {
             signerName: result.signerName
           })
         });
+        if (!addBundleResponse.ok) {
+          logger.error(
+            {
+              category: "bundle_tracking_persist_failed",
+              bundleId: req.bundleId,
+              chainId: batchChainId,
+              txId: batchTx.id,
+              signerName: result.signerName,
+              status: addBundleResponse.status,
+              statusText: addBundleResponse.statusText
+            },
+            "bundle tracking persistence failed for batch request"
+          );
+          bundleTrackingErrors.set(req.id, buildBundleTrackingUnavailableError());
+        }
       } catch (error48) {
         logger.warn(
           {
+            category: "bundle_tracking_persist_failed",
             error: getErrorMessage(error48),
-            bundleId: req.bundleId
+            bundleId: req.bundleId,
+            chainId: batchChainId,
+            txId: batchTx.id,
+            signerName: result.signerName
           },
-          "Failed to store bundle status for batch request"
+          "failed to persist bundle tracking for batch request"
         );
+        bundleTrackingErrors.set(req.id, buildBundleTrackingUnavailableError());
       }
     }
   }
@@ -24399,6 +24484,10 @@ async function handleBatchSendPreparedCalls(requests, ctx) {
     if (validationError) {
       return { id: req.id, error: validationError };
     }
+    const bundleTrackingError = bundleTrackingErrors.get(req.id);
+    if (bundleTrackingError) {
+      return { id: req.id, error: bundleTrackingError };
+    }
     const successResult = parsedRequests.find((r) => r.id === req.id);
     if (successResult) {
       return { id: req.id, result: { id: successResult.bundleId } };
@@ -24613,7 +24702,7 @@ __name(checkRpc, "checkRpc");
 async function checkSignerPool(env, chainId) {
   const poolId = env.SIGNER_POOL.idFromName(`pool-${chainId}`);
   const pool = env.SIGNER_POOL.get(poolId);
-  const response = await pool.fetch("http://do/status");
+  const response = await pool.fetch(`http://do/status?poolName=pool-${chainId}`);
   if (!response.ok) {
     throw new Error(`SignerPool status check failed: ${response.status} ${response.statusText}`);
   }
@@ -44831,6 +44920,14 @@ function shouldAttemptReplacementNow(input) {
   return input.nowMs >= input.lastReplacementAtMs + backoffMs;
 }
 __name(shouldAttemptReplacementNow, "shouldAttemptReplacementNow");
+function resolveNonTriggeredReplacement(attempts, maxAttempts) {
+  const nextAttempts = attempts + 1;
+  return {
+    nextAttempts,
+    status: nextAttempts >= maxAttempts ? "stuck" : "pending"
+  };
+}
+__name(resolveNonTriggeredReplacement, "resolveNonTriggeredReplacement");
 async function withCleanupOnError(operation, cleanup) {
   try {
     return await operation();
@@ -44872,6 +44969,25 @@ function isIntentExpired(expiryTimestamp, bufferSeconds = DEFAULT_INTENT_EXPIRY_
   return currentTime + buffer2 >= expiry;
 }
 __name(isIntentExpired, "isIntentExpired");
+function isFillTransactionUnsupportedError(message) {
+  const lower = message.toLowerCase();
+  const mentionsMethod = lower.includes("eth_filltransaction");
+  if (!mentionsMethod) return false;
+  return lower.includes("not available") || lower.includes("does not exist") || lower.includes("method not found");
+}
+__name(isFillTransactionUnsupportedError, "isFillTransactionUnsupportedError");
+function buildRawFallbackBroadcastRequest(input) {
+  return {
+    ...input.txParams,
+    nonce: input.nonce,
+    account: input.account,
+    chain: { id: input.chainId },
+    gas: input.gas,
+    maxFeePerGas: input.feeParams.maxFeePerGas,
+    maxPriorityFeePerGas: input.feeParams.maxPriorityFeePerGas
+  };
+}
+__name(buildRawFallbackBroadcastRequest, "buildRawFallbackBroadcastRequest");
 var SignerDO = class extends DurableObject {
   static {
     __name(this, "SignerDO");
@@ -45825,23 +45941,92 @@ var SignerDO = class extends DurableObject {
     }
   }
   async signAndBroadcastPrepared(txParams, nonce, chainId, feeParams) {
-    const { walletClient, account } = this.ensureClients(chainId);
+    const { publicClient, walletClient, account } = this.ensureClients(chainId);
     try {
-      return await walletClient.sendTransaction({
-        ...txParams,
+      return await this.sendWithPrimaryPath(
+        txParams,
         nonce,
-        account,
-        chain: { id: chainId },
-        maxFeePerGas: feeParams.maxFeePerGas,
-        maxPriorityFeePerGas: feeParams.maxPriorityFeePerGas
-      });
+        chainId,
+        feeParams,
+        walletClient,
+        account
+      );
     } catch (error48) {
-      const message = getErrorMessage(error48);
+      const primaryMessage = getErrorMessage(error48);
+      if (!isFillTransactionUnsupportedError(primaryMessage)) {
+        throw new SignerDOError(
+          `Failed to broadcast transaction: ${primaryMessage}`,
+          "BROADCAST_FAILED"
+        );
+      }
+      console.warn("[SignerDO] broadcast fallback activated", {
+        reason: "eth_filltransaction_unsupported",
+        chainId
+      });
+      try {
+        const txHash = await this.sendWithRawFallback(
+          txParams,
+          nonce,
+          chainId,
+          feeParams,
+          publicClient,
+          walletClient,
+          account
+        );
+        console.info("[SignerDO] broadcast fallback success", { chainId, txHash });
+        return txHash;
+      } catch (fallbackError) {
+        const fallbackMessage = getErrorMessage(fallbackError);
+        const message = `${primaryMessage}; fallback failed: ${fallbackMessage}`;
+        console.error("[SignerDO] broadcast fallback failed", {
+          chainId,
+          primaryError: primaryMessage,
+          fallbackError: fallbackMessage
+        });
+        throw new SignerDOError(
+          `Failed to broadcast transaction: ${message}`,
+          "BROADCAST_FAILED"
+        );
+      }
+    }
+  }
+  async sendWithPrimaryPath(txParams, nonce, chainId, feeParams, walletClient, account) {
+    return walletClient.sendTransaction({
+      ...txParams,
+      nonce,
+      account,
+      chain: { id: chainId },
+      maxFeePerGas: feeParams.maxFeePerGas,
+      maxPriorityFeePerGas: feeParams.maxPriorityFeePerGas
+    });
+  }
+  async sendWithRawFallback(txParams, nonce, chainId, feeParams, publicClient, walletClient, account) {
+    const gas = await publicClient.estimateGas({
+      account: account.address,
+      to: txParams.to,
+      data: txParams.data,
+      value: txParams.value,
+      nonce,
+      maxFeePerGas: feeParams.maxFeePerGas,
+      maxPriorityFeePerGas: feeParams.maxPriorityFeePerGas,
+      authorizationList: txParams.authorizationList
+    });
+    const request = buildRawFallbackBroadcastRequest({
+      txParams,
+      nonce,
+      chainId,
+      account,
+      gas,
+      feeParams
+    });
+    const serializedTransaction = await walletClient.signTransaction(request);
+    if (!serializedTransaction) {
       throw new SignerDOError(
-        `Failed to broadcast transaction: ${message}`,
+        "Fallback signing returned empty serialized transaction",
         "BROADCAST_FAILED"
       );
     }
+    return publicClient.sendRawTransaction({ serializedTransaction });
   }
   /**
    * Encode an intent to bytes for the Orchestrator.execute() call
@@ -46007,9 +46192,18 @@ var SignerDO = class extends DurableObject {
           staleThresholdPerGas: config2.triggerThresholdWei
         });
         if (!triggerReplacement) {
+          const resolution = resolveNonTriggeredReplacement(attempts, config2.maxAttempts);
           this.sql.exec(
-            "UPDATE pending_transactions SET status = ? WHERE id = ?",
-            "pending",
+            `
+                      UPDATE pending_transactions
+                      SET status = ?,
+                          replacement_attempts = ?,
+                          last_replacement_at = ?
+                      WHERE id = ?
+                    `,
+            resolution.status,
+            resolution.nextAttempts,
+            nowMs,
             txId
           );
           return "skipped";
@@ -46522,6 +46716,7 @@ var SignerPoolDO = class extends DurableObject2 {
 
 // src/durable-objects/bundle-status.do.ts
 import { DurableObject as DurableObject3 } from "cloudflare:workers";
+var DEFAULT_BUNDLE_UNRESOLVED_SLA_MS = 3e5;
 var BundleStatusDO = class extends DurableObject3 {
   static {
     __name(this, "BundleStatusDO");
@@ -46546,6 +46741,7 @@ var BundleStatusDO = class extends DurableObject3 {
             CREATE INDEX IF NOT EXISTS idx_bundle_transactions_tx_id ON bundle_transactions(tx_id);
             CREATE INDEX IF NOT EXISTS idx_bundle_transactions_signer ON bundle_transactions(signer_name);
         `);
+    this.ensureBundleTransactionsSchema();
     this.sql.exec(`
             CREATE TABLE IF NOT EXISTS pending_bundles (
                 bundle_id TEXT PRIMARY KEY,
@@ -46664,6 +46860,73 @@ var BundleStatusDO = class extends DurableObject3 {
       }
     }
   }
+  /**
+   * Backward-compatible migration for bundle_transactions metadata.
+   * Adds created_at for unresolved-bundle SLA tracking.
+   */
+  ensureBundleTransactionsSchema() {
+    const columns = new Set(
+      this.sql.exec("PRAGMA table_info(bundle_transactions)").toArray().map((row) => String(row.name ?? ""))
+    );
+    if (!columns.has("created_at")) {
+      this.sql.exec(
+        "ALTER TABLE bundle_transactions ADD COLUMN created_at INTEGER NOT NULL DEFAULT 0"
+      );
+    }
+    const now = Date.now();
+    this.sql.exec(
+      "UPDATE bundle_transactions SET created_at = ? WHERE created_at IS NULL OR created_at <= 0",
+      now
+    );
+  }
+  getChainIdFromName() {
+    const name = this.ctx.id.name;
+    if (!name) return 0;
+    const parts = name.split("-");
+    if (parts.length !== 3 || parts[0] !== "bundle" || parts[1] !== "status") return 0;
+    const chainId = Number.parseInt(parts[2], 10);
+    return Number.isFinite(chainId) ? chainId : 0;
+  }
+  getBundleUnresolvedSlaMs() {
+    const parsed = Number.parseInt(
+      this.env.BUNDLE_UNRESOLVED_SLA_MS ?? String(DEFAULT_BUNDLE_UNRESOLVED_SLA_MS),
+      10
+    );
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_BUNDLE_UNRESOLVED_SLA_MS;
+  }
+  async fetchTxStatusFromSigner(txId, signerName) {
+    try {
+      const signerId = this.env.SIGNER.idFromName(signerName);
+      const signer = this.env.SIGNER.get(signerId);
+      const response = await signer.fetch(`http://do/get_tx_status?txId=${txId}`);
+      if (!response.ok) return null;
+      return await response.json();
+    } catch (error48) {
+      logger.warn(
+        {
+          event: "bundle_status_signer_fetch_failed",
+          txId,
+          signerName,
+          error: getErrorMessage(error48)
+        },
+        "failed to fetch transaction status from signer"
+      );
+      return null;
+    }
+  }
+  async probeSignerForTxStatus(txId, chainId, skipSignerName) {
+    const signerCount = Number.parseInt(this.env.RELAYER_COUNT ?? "1", 10);
+    const maxSigners = Number.isFinite(signerCount) && signerCount > 0 ? signerCount : 1;
+    for (let index2 = 0; index2 < maxSigners; index2 += 1) {
+      const signerName = `signer-${chainId}-${index2}`;
+      if (skipSignerName && signerName === skipSignerName) continue;
+      const txStatus = await this.fetchTxStatusFromSigner(txId, signerName);
+      if (txStatus) {
+        return { txStatus, signerName };
+      }
+    }
+    return { txStatus: null, signerName: null };
+  }
   /**
    * HTTP handler for BundleStatusDO endpoints
    */
@@ -46716,10 +46979,11 @@ var BundleStatusDO = class extends DurableObject3 {
    */
   async add_bundle_tx(bundleId, txId, signerName) {
     this.sql.exec(
-      "INSERT OR IGNORE INTO bundle_transactions (bundle_id, tx_id, signer_name) VALUES (?, ?, ?)",
+      "INSERT OR IGNORE INTO bundle_transactions (bundle_id, tx_id, signer_name, created_at) VALUES (?, ?, ?, ?)",
       bundleId,
       txId,
-      signerName ?? null
+      signerName ?? null,
+      Date.now()
     );
   }
   /**
@@ -46727,7 +46991,7 @@ var BundleStatusDO = class extends DurableObject3 {
    */
   async get_bundle_status(bundleId) {
     const txRows = this.sql.exec(
-      "SELECT tx_id, signer_name FROM bundle_transactions WHERE bundle_id = ?",
+      "SELECT tx_id, signer_name, created_at FROM bundle_transactions WHERE bundle_id = ?",
       bundleId
     ).toArray();
     if (txRows.length === 0) {
@@ -46749,26 +47013,113 @@ var BundleStatusDO = class extends DurableObject3 {
       };
     }
     const transactions = [];
+    const chainId = this.getChainIdFromName();
     for (const row of txRows) {
       const txId = row.tx_id;
       const signerName = row.signer_name;
       if (!signerName) {
-        continue;
+        logger.warn(
+          {
+            event: "bundle_status_missing_signer_name",
+            bundleId,
+            txId
+          },
+          "bundle transaction missing signer_name; probing signers"
+        );
       }
       try {
-        const signerId = this.env.SIGNER.idFromName(signerName);
-        const signer = this.env.SIGNER.get(signerId);
-        const response = await signer.fetch(`http://do/get_tx_status?txId=${txId}`);
-        if (!response.ok) {
+        let txStatus = signerName ? await this.fetchTxStatusFromSigner(txId, signerName) : null;
+        let resolvedSignerName = signerName;
+        if (!txStatus && chainId > 0) {
+          const probed = await this.probeSignerForTxStatus(
+            txId,
+            chainId,
+            signerName ?? void 0
+          );
+          txStatus = probed.txStatus;
+          resolvedSignerName = probed.signerName;
+        }
+        if (!txStatus) {
+          logger.warn(
+            {
+              event: "bundle_status_signer_probe_failed",
+              bundleId,
+              txId,
+              signerName,
+              chainId
+            },
+            "failed to resolve signer tx status for bundle transaction"
+          );
           continue;
         }
-        const txStatus = await response.json();
+        if (resolvedSignerName && resolvedSignerName !== signerName) {
+          try {
+            this.sql.exec(
+              "UPDATE bundle_transactions SET signer_name = ? WHERE bundle_id = ? AND tx_id = ?",
+              resolvedSignerName,
+              bundleId,
+              txId
+            );
+          } catch (error48) {
+            logger.warn(
+              {
+                event: "bundle_status_signer_cache_update_failed",
+                bundleId,
+                txId,
+                signerName,
+                resolvedSignerName,
+                chainId,
+                error: getErrorMessage(error48)
+              },
+              "failed to cache resolved signer name for bundle transaction"
+            );
+          }
+        }
         transactions.push(txStatus);
-      } catch {
+      } catch (error48) {
+        logger.warn(
+          {
+            event: "bundle_status_tx_resolution_failed",
+            bundleId,
+            txId,
+            signerName,
+            chainId,
+            error: getErrorMessage(error48)
+          },
+          "failed during bundle transaction status resolution"
+        );
         continue;
       }
     }
     if (transactions.length === 0) {
+      const oldestCreatedAt = txRows.reduce((oldest, row) => {
+        const createdAt = Number(row.created_at ?? 0);
+        if (!Number.isFinite(createdAt) || createdAt <= 0) return oldest;
+        return Math.min(oldest, createdAt);
+      }, Number.MAX_SAFE_INTEGER);
+      const safeOldestCreatedAt = oldestCreatedAt === Number.MAX_SAFE_INTEGER ? Date.now() : oldestCreatedAt;
+      const ageMs = Date.now() - safeOldestCreatedAt;
+      const unresolvedSlaMs = this.getBundleUnresolvedSlaMs();
+      if (ageMs >= unresolvedSlaMs) {
+        logger.error(
+          {
+            event: "bundle_unresolvable_sla_failed",
+            reason: "unresolvable_bundle_tracking_timeout",
+            bundleId,
+            ageMs,
+            unresolvedSlaMs,
+            txCount: txRows.length,
+            chainId
+          },
+          "bundle unresolved beyond SLA; terminalizing as failed"
+        );
+        return {
+          bundleId,
+          status: "failed",
+          statusCode: 300,
+          receipts: []
+        };
+      }
       return {
         bundleId,
         status: "pending",
@@ -47478,6 +47829,7 @@ var HttpAuthNonceDO = class extends DurableObject5 {
 };
 
 // src/index.ts
+var MAX_MONITOR_ATTEMPTS = 30;
 var app = new Hono2();
 app.use("*", async (c2, next) => {
   const allowedOrigins = c2.env.CORS_ALLOWED_ORIGINS;
@@ -47562,24 +47914,70 @@ async function handleQueue(batch, env) {
   for (const msg of batch.messages) {
     const job = msg.body;
     try {
-      const jobType = "type" in job ? job.type : "monitor";
+      const jobType = resolveQueueJobType(job);
       switch (jobType) {
         case "monitor":
           await handleMonitorJob(msg, env);
           break;
         default:
-          logger.warn({ job }, "unknown job type");
+          logger.warn({ job, attempts: msg.attempts }, "queue invalid job payload");
           msg.ack();
       }
     } catch (error48) {
-      logger.error({ job, error: getErrorMessage(error48) }, "queue processing error");
+      logger.error(
+        { job, attempts: msg.attempts, error: getErrorMessage(error48) },
+        "queue processing error"
+      );
       msg.retry({ delaySeconds: 30 });
     }
   }
 }
 __name(handleQueue, "handleQueue");
+function resolveQueueJobType(job) {
+  if (!job || typeof job !== "object") return "unknown";
+  if (!("type" in job)) return "monitor";
+  return job.type === "monitor" ? "monitor" : "unknown";
+}
+__name(resolveQueueJobType, "resolveQueueJobType");
+function getMonitorAttempt(msg) {
+  return msg.attempts ?? msg.body.attempt ?? 0;
+}
+__name(getMonitorAttempt, "getMonitorAttempt");
+async function notifySignerFinalization(env, signerName, txId, txHash, status) {
+  try {
+    const signerId = env.SIGNER.idFromName(signerName);
+    const signer = env.SIGNER.get(signerId);
+    const response = await signer.fetch(`http://do/finalized?signerName=${signerName}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ txId, txHash, status })
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+__name(notifySignerFinalization, "notifySignerFinalization");
+async function finalizeMonitorAsFailed(msg, env, reason) {
+  const { txId, txHash, signerName } = msg.body;
+  const finalized = await notifySignerFinalization(env, signerName, txId, txHash, "failed");
+  if (finalized) {
+    logger.error(
+      { txId, txHash, signerName, attempts: getMonitorAttempt(msg), reason },
+      "monitor job finalized as failed"
+    );
+    return true;
+  }
+  logger.error(
+    { txId, txHash, signerName, attempts: getMonitorAttempt(msg), reason },
+    "failed to finalize monitor job as failed"
+  );
+  return false;
+}
+__name(finalizeMonitorAsFailed, "finalizeMonitorAsFailed");
 async function handleMonitorJob(msg, env) {
-  const { txId, txHash, signerName, attempt } = msg.body;
+  const { txId, txHash, signerName } = msg.body;
+  const attempt = getMonitorAttempt(msg);
   const fallbackChainIds = getChainIds(env);
   const chainId = msg.body.chainId ?? (fallbackChainIds.length === 1 ? fallbackChainIds[0] : void 0);
   if (!chainId) {
@@ -47590,24 +47988,33 @@ async function handleMonitorJob(msg, env) {
   const receipt = await getTransactionReceipt2(getChainRpcUrl(chainId, env), txHash);
   if (receipt) {
     await logBundleGasTelemetry(env, txId, chainId, txHash, receipt.gasUsed);
-    const signerId = env.SIGNER.idFromName(signerName);
-    const signer = env.SIGNER.get(signerId);
-    await signer.fetch(`http://do/finalized?signerName=${signerName}`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        txId,
-        txHash,
-        status: receipt.status === "0x1" ? "confirmed" : "failed"
-      })
-    });
+    const finalStatus = receipt.status === "0x1" ? "confirmed" : "failed";
+    const finalized = await notifySignerFinalization(env, signerName, txId, txHash, finalStatus);
+    if (!finalized) {
+      msg.retry({ delaySeconds: 30 });
+      logger.error(
+        { txId, txHash, signerName, attempt },
+        "failed to notify signer finalization, retrying"
+      );
+      return;
+    }
     msg.ack();
-    logger.info(
-      { txId, txHash, status: receipt.status === "0x1" ? "confirmed" : "failed" },
-      "transaction finalized"
-    );
+    logger.info({ txId, txHash, status: finalStatus }, "transaction finalized");
   } else {
-    const delaySeconds = Math.min(Math.pow(2, attempt + 1), 60);
+    if (attempt >= MAX_MONITOR_ATTEMPTS) {
+      const finalized = await finalizeMonitorAsFailed(
+        msg,
+        env,
+        "monitor retries exhausted without receipt"
+      );
+      if (finalized) {
+        msg.ack();
+      } else {
+        msg.retry({ delaySeconds: 30 });
+      }
+      return;
+    }
+    const delaySeconds = Math.min(Math.pow(2, attempt), 60);
     msg.retry({ delaySeconds });
     logger.debug({ txId, txHash, attempt, delaySeconds }, "transaction pending, retrying");
   }