Add CompactX solver

typescript/solver/NonceKeeperWallet.ts

@@ -1,3 +1,4 @@
+import type { BigNumber } from "@ethersproject/bignumber";
 import { defaultPath, HDNode } from "@ethersproject/hdnode";
 import type { Deferrable } from "@ethersproject/properties";
 import type {
@@ -36,7 +37,7 @@ export class NonceKeeperWallet extends Wallet {
       // this check is necessary in order to not generate new nonces when a tx is going to fail
       await super.estimateGas(transaction);
     } catch (error) {
-      checkError(error, {transaction});
+      checkError(error, { transaction });
     }
 
     if (transaction.nonce == null) {
@@ -48,6 +49,14 @@ export class NonceKeeperWallet extends Wallet {
     return super.sendTransaction(transaction);
   }
 
+  async estimateGas(
+    transaction: Deferrable<TransactionRequest>,
+  ): Promise<BigNumber> {
+    return super
+      .estimateGas(transaction)
+      .catch((error) => checkError(error, { transaction }));
+  }
+
   static override fromMnemonic(
     mnemonic: string,
     path?: string,
@@ -67,47 +76,84 @@ function checkError(error: any, params: any): any {
   const transaction = params.transaction || params.signedTransaction;
 
   let message = error.message;
-  if (error.code === Logger.errors.SERVER_ERROR && error.error && typeof(error.error.message) === "string") {
-      message = error.error.message;
-  } else if (typeof(error.body) === "string") {
-      message = error.body;
-  } else if (typeof(error.responseText) === "string") {
-      message = error.responseText;
+  if (
+    error.code === Logger.errors.SERVER_ERROR &&
+    error.error &&
+    typeof error.error.message === "string"
+  ) {
+    message = error.error.message;
+  } else if (typeof error.body === "string") {
+    message = error.body;
+  } else if (typeof error.responseText === "string") {
+    message = error.responseText;
   }
   message = (message || "").toLowerCase();
 
   // "insufficient funds for gas * price + value + cost(data)"
   if (message.match(/insufficient funds|base fee exceeds gas limit/i)) {
-      ethersLogger.throwError("insufficient funds for intrinsic transaction cost", Logger.errors.INSUFFICIENT_FUNDS, {
-          error, transaction
-      });
+    ethersLogger.throwError(
+      "insufficient funds for intrinsic transaction cost",
+      Logger.errors.INSUFFICIENT_FUNDS,
+      {
+        error,
+        transaction,
+      },
+    );
   }
 
   // "nonce too low"
   if (message.match(/nonce (is )?too low/i)) {
-      ethersLogger.throwError("nonce has already been used", Logger.errors.NONCE_EXPIRED, {
-          error, transaction
-      });
+    ethersLogger.throwError(
+      "nonce has already been used",
+      Logger.errors.NONCE_EXPIRED,
+      {
+        error,
+        transaction,
+      },
+    );
   }
 
   // "replacement transaction underpriced"
-  if (message.match(/replacement transaction underpriced|transaction gas price.*too low/i)) {
-      ethersLogger.throwError("replacement fee too low", Logger.errors.REPLACEMENT_UNDERPRICED, {
-          error, transaction
-      });
+  if (
+    message.match(
+      /replacement transaction underpriced|transaction gas price.*too low/i,
+    )
+  ) {
+    ethersLogger.throwError(
+      "replacement fee too low",
+      Logger.errors.REPLACEMENT_UNDERPRICED,
+      {
+        error,
+        transaction,
+      },
+    );
   }
 
   // "replacement transaction underpriced"
   if (message.match(/only replay-protected/i)) {
-      ethersLogger.throwError("legacy pre-eip-155 transactions not supported", Logger.errors.UNSUPPORTED_OPERATION, {
-          error, transaction
-      });
+    ethersLogger.throwError(
+      "legacy pre-eip-155 transactions not supported",
+      Logger.errors.UNSUPPORTED_OPERATION,
+      {
+        error,
+        transaction,
+      },
+    );
   }
 
-  if (message.match(/gas required exceeds allowance|always failing transaction|execution reverted/)) {
-      ethersLogger.throwError("cannot estimate gas; transaction may fail or may require manual gas limit", Logger.errors.UNPREDICTABLE_GAS_LIMIT, {
-          error, transaction
-      });
+  if (
+    message.match(
+      /gas required exceeds allowance|always failing transaction|execution reverted/,
+    )
+  ) {
+    ethersLogger.throwError(
+      "cannot estimate gas; transaction may fail or may require manual gas limit",
+      Logger.errors.UNPREDICTABLE_GAS_LIMIT,
+      {
+        error,
+        transaction,
+      },
+    );
   }
 
   throw error;

typescript/solver/config/solvers.json

@@ -4,5 +4,8 @@
   },
   "hyperlane7683": {
     "enabled": true
+  },
+  "compactX": {
+    "enabled": true
   }
 }

typescript/solver/index.ts

@@ -9,7 +9,7 @@ import { getMultiProvider } from "./solvers/utils.js";
 
 const main = async () => {
   const multiProvider = await getMultiProvider(chainMetadata).catch(
-    (error) => (log.error(error.reason ?? error.message), process.exit(1))
+    (error) => (log.error(error.reason ?? error.message), process.exit(1)),
   );
 
   log.info("🙍 Intent Solver 📝");

typescript/solver/package.json

@@ -26,6 +26,7 @@
     "@inquirer/prompts": "^7.2.0",
     "@typechain/ethers-v5": "^11.1.2",
     "@types/copyfiles": "^2",
+    "@types/ws": "^8",
     "copyfiles": "^2.4.1",
     "prettier": "^3.3.3",
     "tsx": "^4.19.2",
@@ -45,6 +46,7 @@
     "pino": "^9.5.0",
     "pino-pretty": "^13.0.0",
     "pino-socket": "^7.4.0",
-    "uniqolor": "^1.1.1"
+    "uniqolor": "^1.1.1",
+    "ws": "^8.18.1"
   }
 }

typescript/solver/solvers/BaseFiller.ts

@@ -1,3 +1,4 @@
+import { BigNumber } from "@ethersproject/bignumber";
 import type { MultiProvider } from "@hyperlane-xyz/sdk";
 import type { Result } from "@hyperlane-xyz/utils";
 import {
@@ -82,11 +83,19 @@ export abstract class BaseFiller<
         await this.fill(parsedArgs, data, originChainName, blockNumber);
 
         await this.settleOrder(parsedArgs, data, originChainName);
-      } catch (error) {
+      } catch (error: any) {
         this.log.error({
           msg: `Failed processing intent`,
           intent: `${this.metadata.protocolName}-${parsedArgs.orderId}`,
-          error: JSON.stringify(error),
+          error: {
+            stack: error.stack,
+            details: JSON.stringify(error, (_, value) => {
+              if (value instanceof BigNumber || typeof value === "bigint") {
+                return value.toString();
+              }
+              return value;
+            }),
+          },
         });
       }
     };

typescript/solver/solvers/BaseListener.ts

@@ -97,7 +97,7 @@ export abstract class BaseListener<
                   confirmationBlocks,
                 ),
               pollInterval ?? this.defaultPollInterval,
-            )
+            ),
           );
 
           contract.provider.getNetwork().then((network) => {
@@ -118,9 +118,8 @@ export abstract class BaseListener<
           clearInterval(this.pollIntervals[i]);
         }
         this.pollIntervals = [];
-      }
+      };
     };
-
   }
 
   protected async pollEvents(

typescript/solver/solvers/SolverManager.ts

@@ -8,32 +8,29 @@ type SolverModule = {
     create: () => Promise<ListenerFn>;
   };
   filler: {
-    create: (
-      multiProvider: MultiProvider,
-      rules?: any
-    ) => FillerFn;
+    create: (multiProvider: MultiProvider, rules?: any) => FillerFn;
   };
   rules?: any;
 };
 
 type ListenerFn = <T>(
-  handler: (args: T, originChainName: string, blockNumber: number) => void
+  handler: (args: T, originChainName: string, blockNumber: number) => void,
 ) => ShutdownFn;
 
 type ShutdownFn = () => void;
 
 type FillerFn = <T>(
   args: T,
   originChainName: string,
-  blockNumber: number
+  blockNumber: number,
 ) => Promise<void>;
 
 export class SolverManager {
   private activeListeners: Array<() => void> = [];
 
   constructor(
     private readonly multiProvider: MultiProvider,
-    private readonly log: Logger
+    private readonly log: Logger,
   ) {}
 
   async initializeSolvers() {
@@ -47,7 +44,7 @@ export class SolverManager {
         await this.initializeSolver(solverName as SolverName);
       } catch (error: any) {
         this.log.error(
-          `Failed to initialize solver ${solverName}: ${error.message}`
+          `Failed to initialize solver ${solverName}: ${error.message}`,
         );
         throw error;
       }