Merge pull request #57 from BootNodeDev/multichain-listeners

feat: add support for listening on multiple chains

Author: tmsrjs

typescript/solver/solvers/BaseListener.ts

@@ -17,47 +17,38 @@ export abstract class BaseListener<
     },
     private readonly eventName: Extract<keyof TContract["filters"], string>,
     private readonly metadata: {
-      address: string;
-      chainName: string;
+      contracts: Array<{
+        address: string;
+        chainName: string;
+      }>;
       protocolName: string;
     },
     private readonly log: Logger,
   ) {}
 
-  protected setup(): TContract {
-    if (!this.metadata.address || !this.metadata.chainName) {
-      throw new Error("Origin contract information must be provided");
-    }
-
-    if (!this.metadata.protocolName) {
-      throw new Error("Solver name must be provided");
-    }
-
-    const multiProvider = new MultiProvider(chainMetadata);
-    const provider = multiProvider.getProvider(this.metadata.chainName);
-
-    return this.contractFactory.connect(this.metadata.address, provider);
-  }
-
   create() {
-    const contract = this.setup();
-
-    return (handler: (args: TParsedArgs) => void) => {
-      const filter = contract.filters[this.eventName]();
-
-      const listener: TypedListener<TEvent> = (...args) => {
-        handler(this.parseEventArgs(args));
-      };
-
-      contract.on(filter, listener);
-
-      contract.provider.getNetwork().then((network) => {
-        this.log.info({
-          msg: "Listener started",
-          event: this.eventName,
-          protocol: this.metadata.protocolName,
-          chainId: network.chainId,
-          chainName: this.metadata.chainName,
+    return (handler: (args: TParsedArgs, originChainName: string) => void) => {
+      const multiProvider = new MultiProvider(chainMetadata);
+
+      this.metadata.contracts.forEach(({ address, chainName }) => {
+        const provider = multiProvider.getProvider(chainName);
+        const contract = this.contractFactory.connect(address, provider);
+        const filter = contract.filters[this.eventName]();
+
+        const listener: TypedListener<TEvent> = (...args) => {
+          handler(this.parseEventArgs(args), chainName);
+        };
+
+        contract.on(filter, listener);
+
+        contract.provider.getNetwork().then((network) => {
+          this.log.info({
+            msg: "Listener started",
+            event: this.eventName,
+            protocol: this.metadata.protocolName,
+            chainId: network.chainId,
+            chainName: chainName,
+          });
         });
       });
     };

typescript/solver/solvers/eco/config/metadata.ts

@@ -2,10 +2,12 @@ import { type EcoMetadata, EcoMetadataSchema } from "../types.js";
 
 const metadata: EcoMetadata = {
   protocolName: "Eco",
-  intentSource: {
-    address: "0x734a3d5a8D691d9b9,11674E682De5f06517c79ec",
-    chainName: "optimismsepolia",
-  },
+  intentSources: [
+    {
+      address: "0x734a3d5a8D691d9b9,11674E682De5f06517c79ec",
+      chainName: "optimismsepolia",
+    },
+  ],
   adapters: [
     {
       address: "0x218FB5210d4eE248f046F3EC8B5Dd1c7Bc0756e5",

typescript/solver/solvers/eco/filler.ts

@@ -22,12 +22,15 @@ import {
 } from "../../config/index.js";
 
 export const create = (multiProvider: MultiProvider) => {
-  const { adapters, intentSource, protocolName } = setup();
+  const { adapters, protocolName } = setup();
 
-  return async function eco(intent: IntentCreatedEventObject) {
+  return async function eco(
+    intent: IntentCreatedEventObject,
+    originChainName: string,
+  ) {
     const origin = await retrieveOriginInfo(
       intent,
-      intentSource,
+      originChainName,
       multiProvider,
     );
     const target = await retrieveTargetInfo(intent, adapters, multiProvider);
@@ -56,12 +59,12 @@ export const create = (multiProvider: MultiProvider) => {
     await fill(
       intent,
       result.data.adapter,
-      intentSource,
+      originChainName,
       multiProvider,
       protocolName,
     );
 
-    await withdrawRewards(intent, intentSource, multiProvider, protocolName);
+    await withdrawRewards(intent, originChainName, multiProvider, protocolName);
   };
 };
 
@@ -181,7 +184,7 @@ async function prepareIntent(
 async function fill(
   intent: IntentCreatedEventObject,
   adapter: EcoMetadata["adapters"][number],
-  intentSource: EcoMetadata["intentSource"],
+  originChainName: string,
   multiProvider: MultiProvider,
   protocolName: string,
 ): Promise<void> {
@@ -195,19 +198,17 @@ async function fill(
   const filler = multiProvider.getSigner(_chainId);
   const ecoAdapter = EcoAdapter__factory.connect(adapter.address, filler);
 
-  const claimantAddress = await multiProvider.getSignerAddress(
-    intentSource.chainName,
-  );
+  const claimantAddress = await multiProvider.getSignerAddress(originChainName);
 
   const { _targets, _data, _expiryTime, nonce, _hash, _prover } = intent;
   const value = await ecoAdapter.fetchFee(
-    chainIds[intentSource.chainName],
+    chainIds[originChainName],
     [_hash],
     [claimantAddress],
     _prover,
   );
   const tx = await ecoAdapter.fulfillHyperInstant(
-    chainIds[intentSource.chainName],
+    chainIds[originChainName],
     _targets,
     _data,
     _expiryTime,

typescript/solver/solvers/eco/listener.ts

@@ -15,11 +15,8 @@ export class EcoListener extends BaseListener<
   IntentCreatedEventObject
 > {
   constructor() {
-    const {
-      intentSource: { address, chainName },
-      protocolName,
-    } = metadata;
-    const ecoMetadata = { address, chainName, protocolName };
+    const { intentSources, protocolName } = metadata;
+    const ecoMetadata = { contracts: intentSources, protocolName };
 
     super(IntentSource__factory, "IntentCreated", ecoMetadata, log);
   }

typescript/solver/solvers/eco/types.ts

@@ -3,12 +3,14 @@ import { chainNames } from "../../config/index.js";
 
 export const EcoMetadataSchema = z.object({
   protocolName: z.string(),
-  intentSource: z.object({
-    address: z.string(),
-    chainName: z.string().refine((name) => chainNames.includes(name), {
-      message: "Invalid chainName",
+  intentSources: z.array(
+    z.object({
+      address: z.string(),
+      chainName: z.string().refine((name) => chainNames.includes(name), {
+        message: "Invalid chainName",
+      }),
     }),
-  }),
+  ),
   adapters: z.array(
     z.object({
       address: z.string(),

typescript/solver/solvers/eco/utils.ts

@@ -15,7 +15,7 @@ export const log = createLogger(metadata.protocolName);
 
 export async function withdrawRewards(
   intent: IntentCreatedEventObject,
-  intentSource: EcoMetadata["intentSource"],
+  originChainName: string,
   multiProvider: MultiProvider,
   protocolName: string,
 ) {
@@ -25,7 +25,7 @@ export async function withdrawRewards(
   });
 
   const { _hash, _prover } = intent;
-  const signer = multiProvider.getSigner(intentSource.chainName);
+  const signer = multiProvider.getSigner(originChainName);
   const claimantAddress = await signer.getAddress();
   const prover = HyperProver__factory.connect(_prover, signer);
 
@@ -36,13 +36,16 @@ export async function withdrawRewards(
         log.debug(`${protocolName} - Intent proven: ${_hash}`);
 
         const settler = IntentSource__factory.connect(
-          intentSource.address,
+          metadata.intentSources.find(
+            (source) => source.chainName == originChainName,
+          )!.address,
           signer,
         );
         const tx = await settler.withdrawRewards(_hash);
         const receipt = await tx.wait();
-        const baseUrl = multiProvider.getChainMetadata(intentSource.chainName)
-          .blockExplorers?.[0].url;
+        const baseUrl =
+          multiProvider.getChainMetadata(originChainName).blockExplorers?.[0]
+            .url;
 
         const txInfo = baseUrl
           ? `${baseUrl}/tx/${receipt.transactionHash}`
@@ -63,14 +66,14 @@ export async function withdrawRewards(
 
 export async function retrieveOriginInfo(
   intent: IntentCreatedEventObject,
-  intentSource: EcoMetadata["intentSource"],
+  originChainName: string,
   multiProvider: MultiProvider,
 ): Promise<Array<string>> {
   const originInfo = await Promise.all(
     intent._rewardTokens.map(async (tokenAddress, index) => {
       const erc20 = Erc20__factory.connect(
         tokenAddress,
-        multiProvider.getProvider(intentSource.chainName),
+        multiProvider.getProvider(originChainName),
       );
       const [decimals, symbol] = await Promise.all([
         erc20.decimals(),
@@ -84,7 +87,7 @@ export async function retrieveOriginInfo(
 
   return originInfo.map(
     ({ amount, decimals, symbol }) =>
-      `${formatUnits(amount, decimals)} ${symbol} in on ${intentSource.chainName}`,
+      `${formatUnits(amount, decimals)} ${symbol} in on ${originChainName}`,
   );
 }
 

typescript/solver/solvers/hyperlane7683/config/metadata.ts

@@ -5,10 +5,24 @@ import {
 
 const metadata: Hyperlane7683Metadata = {
   protocolName: "Hyperlane7683",
-  originSettler: {
-    address: "0x376dc8E71A223Af488D885ce04A7021f32C2D1e0",
-    chainName: "optimismsepolia",
-  },
+  originSettlers: [
+    {
+      address: "0xe0c8f83bA0686FDF1a76AF0cC202181AEaA25a03",
+      chainName: "optimismsepolia",
+    },
+    {
+      address: "0xe0c8f83bA0686FDF1a76AF0cC202181AEaA25a03",
+      chainName: "arbitrumsepolia",
+    },
+    {
+      address: "0xe0c8f83bA0686FDF1a76AF0cC202181AEaA25a03",
+      chainName: "sepolia",
+    },
+    {
+      address: "0xe0c8f83bA0686FDF1a76AF0cC202181AEaA25a03",
+      chainName: "basesepolia",
+    },
+  ],
 };
 
 Hyperlane7683MetadataSchema.parse(metadata);

typescript/solver/solvers/hyperlane7683/filler.ts

@@ -24,17 +24,13 @@ import { allowBlockLists, metadata } from "./config/index.js";
 import { chainIdsToName, isAllowedIntent } from "../../config/index.js";
 
 export const create = (multiProvider: MultiProvider) => {
-  const { originSettler, protocolName } = setup();
+  const { protocolName } = setup();
 
-  return async function hyperlane7683({
-    orderId,
-    resolvedOrder,
-  }: OpenEventArgs) {
-    const origin = await retrieveOriginInfo(
-      resolvedOrder,
-      originSettler,
-      multiProvider,
-    );
+  return async function hyperlane7683(
+    { orderId, resolvedOrder }: OpenEventArgs,
+    _originChainName: string,
+  ) {
+    const origin = await retrieveOriginInfo(resolvedOrder, multiProvider);
     const target = await retrieveTargetInfo(resolvedOrder, multiProvider);
 
     log.info({

typescript/solver/solvers/hyperlane7683/listener.ts

@@ -15,11 +15,8 @@ export class Hyperlane7683Listener extends BaseListener<
   OpenEventArgs
 > {
   constructor() {
-    const {
-      originSettler: { address, chainName },
-      protocolName,
-    } = metadata;
-    const hyperlane7683Metadata = { address, chainName, protocolName };
+    const { originSettlers, protocolName } = metadata;
+    const hyperlane7683Metadata = { contracts: originSettlers, protocolName };
 
     super(Hyperlane7683__factory, "Open", hyperlane7683Metadata, log);
   }

typescript/solver/solvers/hyperlane7683/types.ts

@@ -37,12 +37,14 @@ export type IntentData = {
 
 export const Hyperlane7683MetadataSchema = z.object({
   protocolName: z.string(),
-  originSettler: z.object({
-    address: z.string(),
-    chainName: z.string().refine((name) => chainNames.includes(name), {
-      message: "Invalid chainName",
+  originSettlers: z.array(
+    z.object({
+      address: z.string(),
+      chainName: z.string().refine((name) => chainNames.includes(name), {
+        message: "Invalid chainName",
+      }),
     }),
-  }),
+  ),
 });
 
 export type Hyperlane7683Metadata = z.infer<typeof Hyperlane7683MetadataSchema>;