Merge pull request #117 from BootNodeDev/custom-rules

Custom rules configuration

Author: fernandomg

typescript/solver/config/chainMetadata.ts

@@ -2,16 +2,15 @@ import { z } from "zod";
 
 import { chainMetadata as defaultChainMetadata } from "@hyperlane-xyz/registry";
 
-import { ChainMetadataSchema } from "@hyperlane-xyz/sdk";
 import type { ChainMap, ChainMetadata } from "@hyperlane-xyz/sdk";
+import { ChainMetadataSchema } from "@hyperlane-xyz/sdk";
 
 import { objMerge } from "@hyperlane-xyz/utils";
 
 const customChainMetadata = {
   // Example custom configuration
   // basesepolia: {
   //   rpcUrls: [
-  // ,
   //     {
   //       http: "https://base-sepolia-rpc.publicnode.com",
   //       pagination: {

typescript/solver/index.ts

@@ -23,8 +23,10 @@ const main = async () => {
 
   const hyperlane7683Listener =
     await solvers["hyperlane7683"].listener.create();
-  const hyperlane7683Filler =
-    solvers["hyperlane7683"].filler.create(multiProvider);
+  const hyperlane7683Filler = solvers["hyperlane7683"].filler.create(
+    multiProvider,
+    solvers["hyperlane7683"].rules,
+  );
 
   hyperlane7683Listener(hyperlane7683Filler);
 };

typescript/solver/solvers/BaseFiller.ts

@@ -5,10 +5,7 @@ import {
   isAllowedIntent,
 } from "../config/index.js";
 import type { Logger } from "../logger.js";
-
-type Metadata = {
-  protocolName: string;
-};
+import type { BaseMetadata, BuildRules } from "./types.js";
 
 export type ParsedArgs = {
   orderId: string;
@@ -19,8 +16,8 @@ export type ParsedArgs = {
   }>;
 };
 
-export type Rule<
-  TMetadata extends Metadata,
+export type BaseRule<
+  TMetadata extends BaseMetadata,
   TParsedArgs extends ParsedArgs,
   TIntentData extends unknown,
 > = (
@@ -29,20 +26,20 @@ export type Rule<
 ) => Promise<Result<string>>;
 
 export abstract class BaseFiller<
-  TMetadata extends Metadata,
+  TMetadata extends BaseMetadata,
   TParsedArgs extends ParsedArgs,
   TIntentData extends unknown,
 > {
-  rules: Array<Rule<TMetadata, TParsedArgs, TIntentData>> = [];
+  rules: Array<BaseRule<TMetadata, TParsedArgs, TIntentData>> = [];
 
   protected constructor(
     readonly multiProvider: MultiProvider,
     readonly allowBlockLists: GenericAllowBlockLists,
     readonly metadata: TMetadata,
     readonly log: Logger,
-    rules?: Array<Rule<TMetadata, TParsedArgs, TIntentData>>,
+    rulesConfig?: BuildRules<BaseRule<TMetadata, TParsedArgs, TIntentData>>,
   ) {
-    if (rules) this.rules = rules;
+    if (rulesConfig) this.rules = this.buildRules(rulesConfig);
   }
 
   create() {
@@ -51,15 +48,26 @@ export abstract class BaseFiller<
       originChainName: string,
       blockNumber: number,
     ) => {
-      const origin = await this.retrieveOriginInfo(parsedArgs, originChainName);
-      const target = await this.retrieveTargetInfo(parsedArgs);
-
-      this.log.info({
-        msg: "Intent Indexed",
-        intent: `${this.metadata.protocolName}-${parsedArgs.orderId}`,
-        origin: origin.join(", "),
-        target: target.join(", "),
-      });
+      try {
+        const origin = await this.retrieveOriginInfo(
+          parsedArgs,
+          originChainName,
+        );
+        const target = await this.retrieveTargetInfo(parsedArgs);
+
+        this.log.info({
+          msg: "Intent Indexed",
+          intent: `${this.metadata.protocolName}-${parsedArgs.orderId}`,
+          origin: origin.join(", "),
+          target: target.join(", "),
+        });
+      } catch (error) {
+        this.log.error({
+          msg: "Failed retrieving origin and target info",
+          intent: `${this.metadata.protocolName}-${parsedArgs.orderId}`,
+          error: JSON.stringify(error),
+        });
+      }
 
       const intent = await this.prepareIntent(parsedArgs);
 
@@ -73,7 +81,7 @@ export abstract class BaseFiller<
       try {
         await this.fill(parsedArgs, data, originChainName, blockNumber);
 
-        await this.settleOrder(parsedArgs, data);
+        await this.settleOrder(parsedArgs, data, originChainName);
       } catch (error) {
         this.log.error({
           msg: `Failed processing intent`,
@@ -137,7 +145,11 @@ export abstract class BaseFiller<
     blockNumber: number,
   ): Promise<void>;
 
-  protected async settleOrder(parsedArgs: TParsedArgs, data: TIntentData) {
+  protected async settleOrder(
+    parsedArgs: TParsedArgs,
+    data: TIntentData,
+    originChainName: string,
+  ) {
     return;
   }
 
@@ -159,4 +171,38 @@ export abstract class BaseFiller<
       }),
     );
   }
+
+  private buildRules({
+    base = [],
+    custom,
+  }: BuildRules<BaseRule<TMetadata, TParsedArgs, TIntentData>>): Array<
+    BaseRule<TMetadata, TParsedArgs, TIntentData>
+  > {
+    const customRules = [];
+
+    if (this.metadata.customRules?.rules.length) {
+      if (!custom) {
+        throw new Error(
+          "Custom rules are specified in metadata, but no corresponding rule functions were provided.",
+        );
+      }
+
+      for (let i = 0; i < this.metadata.customRules.rules.length; i++) {
+        const rule = this.metadata.customRules.rules[i];
+        const ruleFn = custom[rule.name];
+
+        if (!ruleFn) {
+          throw new Error(
+            `Custom rule "${rule.name}" is specified in metadata but is not provided in the custom rules configuration.`,
+          );
+        }
+
+        customRules.push(ruleFn(rule.args));
+      }
+    }
+
+    const keepBaseRules = this.metadata.customRules?.keepBaseRules ?? true;
+
+    return keepBaseRules ? [...base, ...customRules] : customRules;
+  }
 }

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

@@ -8,12 +8,9 @@ const metadata: EcoMetadata = {
       chainName: "optimismsepolia",
     },
   ],
-  adapters: [
-    {
-      address: "0x218FB5210d4eE248f046F3EC8B5Dd1c7Bc0756e5",
-      chainName: "basesepolia",
-    },
-  ],
+  adapters: {
+    basesepolia: "0x218FB5210d4eE248f046F3EC8B5Dd1c7Bc0756e5",
+  },
 };
 
 EcoMetadataSchema.parse(metadata);

typescript/solver/solvers/eco/filler.ts

@@ -8,6 +8,7 @@ import { chainIds, chainIdsToName } from "../../config/index.js";
 import { Erc20__factory } from "../../typechain/factories/contracts/Erc20__factory.js";
 import { EcoAdapter__factory } from "../../typechain/factories/eco/contracts/EcoAdapter__factory.js";
 import { BaseFiller } from "../BaseFiller.js";
+import { BuildRules, RulesMap } from "../types.js";
 import {
   retrieveOriginInfo,
   retrieveTargetInfo,
@@ -17,33 +18,11 @@ import { allowBlockLists, metadata } from "./config/index.js";
 import type { EcoMetadata, IntentData, ParsedArgs } from "./types.js";
 import { log, withdrawRewards } from "./utils.js";
 
-export type Metadata = {
-  adapters: { [chainId: string]: EcoMetadata["adapters"][number] };
-  protocolName: EcoMetadata["protocolName"];
-};
-
 export type EcoRule = EcoFiller["rules"][number];
 
-export class EcoFiller extends BaseFiller<Metadata, ParsedArgs, IntentData> {
-  constructor(
-    multiProvider: MultiProvider,
-    rules?: BaseFiller<Metadata, ParsedArgs, IntentData>["rules"],
-  ) {
-    const { adapters, protocolName } = metadata;
-    const ecoFillerMetadata = {
-      adapters: adapters.reduce<{
-        [chainId: string]: EcoMetadata["adapters"][number];
-      }>(
-        (acc, adapter) => ({
-          ...acc,
-          [chainIds[adapter.chainName]]: adapter,
-        }),
-        {},
-      ),
-      protocolName,
-    };
-
-    super(multiProvider, allowBlockLists, ecoFillerMetadata, log, rules);
+export class EcoFiller extends BaseFiller<EcoMetadata, ParsedArgs, IntentData> {
+  constructor(multiProvider: MultiProvider, rules?: BuildRules<EcoRule>) {
+    super(multiProvider, allowBlockLists, metadata, log, rules);
   }
 
   protected retrieveOriginInfo(parsedArgs: ParsedArgs, chainName: string) {
@@ -81,10 +60,12 @@ export class EcoFiller extends BaseFiller<Metadata, ParsedArgs, IntentData> {
   protected async prepareIntent(
     parsedArgs: ParsedArgs,
   ): Promise<Result<IntentData>> {
-    const adapter =
-      this.metadata.adapters[parsedArgs._destinationChain.toString()];
+    const chainName = this.multiProvider.getChainName(
+      parsedArgs._destinationChain.toString(),
+    );
+    const adapterAddress = this.metadata.adapters[chainName];
 
-    if (!adapter) {
+    if (!adapterAddress) {
       return {
         error: "No adapter found for destination chain",
         success: false,
@@ -94,7 +75,7 @@ export class EcoFiller extends BaseFiller<Metadata, ParsedArgs, IntentData> {
     try {
       await super.prepareIntent(parsedArgs);
 
-      return { data: { adapter }, success: true };
+      return { data: { adapterAddress }, success: true };
     } catch (error: any) {
       return {
         error: error.message ?? "Failed to prepare Eco Intent.",
@@ -117,7 +98,7 @@ export class EcoFiller extends BaseFiller<Metadata, ParsedArgs, IntentData> {
       msg: "Approving tokens",
       protocolName: this.metadata.protocolName,
       intentHash: parsedArgs._hash,
-      adapterAddress: data.adapter.address,
+      adapterAddress: data.adapterAddress,
     });
 
     const erc20Interface = Erc20__factory.createInterface();
@@ -136,25 +117,21 @@ export class EcoFiller extends BaseFiller<Metadata, ParsedArgs, IntentData> {
       return acc;
     }, {});
 
-    const signer = this.multiProvider.getSigner(data.adapter.chainName);
+    const destinationChainId = parsedArgs._destinationChain.toString();
+    const signer = this.multiProvider.getSigner(destinationChainId);
+
     await Promise.all(
       Object.entries(requiredAmountsByTarget).map(
         async ([target, requiredAmount]) => {
           const erc20 = Erc20__factory.connect(target, signer);
 
-          const tx = await erc20.approve(data.adapter.address, requiredAmount);
+          const tx = await erc20.approve(data.adapterAddress, requiredAmount);
           await tx.wait();
         },
       ),
     );
 
-    const _chainId = parsedArgs._destinationChain.toString();
-
-    const filler = this.multiProvider.getSigner(_chainId);
-    const ecoAdapter = EcoAdapter__factory.connect(
-      data.adapter.address,
-      filler,
-    );
+    const ecoAdapter = EcoAdapter__factory.connect(data.adapterAddress, signer);
 
     const claimantAddress =
       await this.multiProvider.getSignerAddress(originChainName);
@@ -190,10 +167,14 @@ export class EcoFiller extends BaseFiller<Metadata, ParsedArgs, IntentData> {
     });
   }
 
-  settleOrder(parsedArgs: ParsedArgs, data: IntentData) {
+  settleOrder(
+    parsedArgs: ParsedArgs,
+    data: IntentData,
+    originChainName: string,
+  ) {
     return withdrawRewards(
       parsedArgs,
-      data.adapter.chainName,
+      originChainName,
       this.multiProvider,
       this.metadata.protocolName,
     );
@@ -241,13 +222,10 @@ const enoughBalanceOnDestination: EcoRule = async (parsedArgs, context) => {
 
 export const create = (
   multiProvider: MultiProvider,
-  rules?: EcoFiller["rules"],
-  keepBaseRules = true,
+  customRules?: RulesMap<EcoRule>,
 ) => {
-  const customRules = rules ?? [];
-
-  return new EcoFiller(
-    multiProvider,
-    keepBaseRules ? [enoughBalanceOnDestination, ...customRules] : customRules,
-  ).create();
+  return new EcoFiller(multiProvider, {
+    base: [enoughBalanceOnDestination],
+    custom: customRules,
+  }).create();
 };

typescript/solver/solvers/eco/index.ts

@@ -1,2 +1,3 @@
 export * as filler from "./filler.js";
 export * as listener from "./listener.js";
+export * as rules from "./rules/index.js";

typescript/solver/solvers/eco/rules/index.ts

@@ -0,0 +1 @@
+export {};

typescript/solver/solvers/eco/types.ts

@@ -2,30 +2,20 @@ import z from "zod";
 import { chainNames } from "../../config/index.js";
 import { addressSchema } from "../../config/types.js";
 import type { IntentCreatedEventObject } from "../../typechain/eco/contracts/IntentSource.js";
+import { BaseMetadataSchema } from "../types.js";
 
-export const EcoMetadataSchema = z.object({
-  protocolName: z.string(),
-  intentSources: z.array(
-    z.object({
-      address: addressSchema,
-      chainName: z.string().refine((name) => chainNames.includes(name), {
-        message: "Invalid chainName",
-      }),
-    }),
-  ),
-  adapters: z.array(
-    z.object({
-      address: addressSchema,
-      chainName: z.string().refine((name) => chainNames.includes(name), {
-        message: "Invalid chainName",
-      }),
+export const EcoMetadataSchema = BaseMetadataSchema.extend({
+  adapters: z.record(
+    z.string().refine((name) => chainNames.includes(name), {
+      message: "Invalid chainName",
     }),
+    addressSchema,
   ),
 });
 
 export type EcoMetadata = z.infer<typeof EcoMetadataSchema>;
 
-export type IntentData = { adapter: EcoMetadata["adapters"][number] };
+export type IntentData = { adapterAddress: z.infer<typeof addressSchema> };
 
 export type ParsedArgs = IntentCreatedEventObject & {
   orderId: string;