feat: add rules to decide wether an intent is worth fulfilling

Author: fernandomg

typescript/solver/solvers/BaseFiller.ts

@@ -19,17 +19,31 @@ type ParsedArgs = {
   }>;
 };
 
+export type Rule<
+  TMetadata extends Metadata,
+  TParsedArgs extends ParsedArgs,
+  TIntentData extends unknown,
+> = (
+  parsedArgs: TParsedArgs,
+  context: BaseFiller<TMetadata, TParsedArgs, TIntentData>,
+) => Promise<Result<string>>;
+
 export abstract class BaseFiller<
   TMetadata extends Metadata,
   TParsedArgs extends ParsedArgs,
   TIntentData extends unknown,
 > {
+  rules: Array<Rule<TMetadata, TParsedArgs, TIntentData>> = [];
+
   protected constructor(
     readonly multiProvider: MultiProvider,
     readonly allowBlockLists: GenericAllowBlockLists,
     readonly metadata: TMetadata,
     readonly log: Logger,
-  ) {}
+    rules?: Array<Rule<TMetadata, TParsedArgs, TIntentData>>,
+  ) {
+    if (rules) this.rules = rules;
+  }
 
   create() {
     return async (parsedArgs: TParsedArgs, originChainName: string) => {
@@ -84,9 +98,28 @@ export abstract class BaseFiller<
       };
     }
 
+    const result = await this.evaluateRules(parsedArgs);
+
+    if (!result.success) {
+      throw new Error(result.error);
+    }
+
     return { error: "Not implemented", success: false };
   }
 
+  protected async evaluateRules(parsedArgs: TParsedArgs) {
+    let result: Result<string> = { success: true, data: "No rules" };
+
+    for (const rule of this.rules) {
+      result = await rule(parsedArgs, this);
+
+      if (!result.success) {
+        break;
+      }
+    }
+
+    return result;
+  }
 
   protected abstract fill(
     parsedArgs: TParsedArgs,

typescript/solver/solvers/eco/filler.ts

@@ -8,18 +8,27 @@ 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 { retrieveOriginInfo, retrieveTargetInfo } from "../utils.js";
+import {
+  retrieveOriginInfo,
+  retrieveTargetInfo,
+  retrieveTokenBalance,
+} from "../utils.js";
 import { allowBlockLists, metadata } from "./config/index.js";
 import type { EcoMetadata, IntentData, ParsedArgs } from "./types.js";
 import { log, withdrawRewards } from "./utils.js";
 
-type Metadata = {
+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) {
+  constructor(
+    multiProvider: MultiProvider,
+    rules?: BaseFiller<Metadata, ParsedArgs, IntentData>["rules"],
+  ) {
     const { adapters, protocolName } = metadata;
     const ecoFillerMetadata = {
       adapters: adapters.reduce<{
@@ -34,7 +43,7 @@ export class EcoFiller extends BaseFiller<Metadata, ParsedArgs, IntentData> {
       protocolName,
     };
 
-    super(multiProvider, allowBlockLists, ecoFillerMetadata, log);
+    super(multiProvider, allowBlockLists, ecoFillerMetadata, log, rules);
   }
 
   protected retrieveOriginInfo(parsedArgs: ParsedArgs, chainName: string) {
@@ -82,62 +91,8 @@ export class EcoFiller extends BaseFiller<Metadata, ParsedArgs, IntentData> {
       };
     }
 
-    await super.prepareIntent(parsedArgs);
-
     try {
-      const erc20Interface = Erc20__factory.createInterface();
-
-      const requiredAmountsByTarget = parsedArgs._targets.reduce<{
-        [tokenAddress: string]: BigNumber;
-      }>((acc, target, index) => {
-        const [, amount] = erc20Interface.decodeFunctionData(
-          "transfer",
-          parsedArgs._data[index],
-        ) as [unknown, BigNumber];
-
-        acc[target] ||= Zero;
-        acc[target] = acc[target].add(amount);
-
-        return acc;
-      }, {});
-
-      const fillerAddress = await this.multiProvider.getSignerAddress(
-        adapter.chainName,
-      );
-      const signer = this.multiProvider.getSigner(adapter.chainName);
-
-      const areTargetFundsAvailable = await Promise.all(
-        Object.entries(requiredAmountsByTarget).map(
-          async ([target, requiredAmount]) => {
-            const erc20 = Erc20__factory.connect(target, signer);
-
-            const balance = await erc20.balanceOf(fillerAddress);
-            return balance.gte(requiredAmount);
-          },
-        ),
-      );
-
-      if (!areTargetFundsAvailable.every(Boolean)) {
-        return { error: "Not enough tokens", success: false };
-      }
-
-      this.log.debug({
-        msg: "Approving tokens",
-        protocolName: this.metadata.protocolName,
-        intentHash: parsedArgs._hash,
-        adapterAddress: adapter.address,
-      });
-
-      await Promise.all(
-        Object.entries(requiredAmountsByTarget).map(
-          async ([target, requiredAmount]) => {
-            const erc20 = Erc20__factory.connect(target, signer);
-
-            const tx = await erc20.approve(adapter.address, requiredAmount);
-            await tx.wait();
-          },
-        ),
-      );
+      await super.prepareIntent(parsedArgs);
 
       return { data: { adapter }, success: true };
     } catch (error: any) {
@@ -158,6 +113,41 @@ export class EcoFiller extends BaseFiller<Metadata, ParsedArgs, IntentData> {
       intent: `${this.metadata.protocolName}-${parsedArgs._hash}`,
     });
 
+    this.log.debug({
+      msg: "Approving tokens",
+      protocolName: this.metadata.protocolName,
+      intentHash: parsedArgs._hash,
+      adapterAddress: data.adapter.address,
+    });
+
+    const erc20Interface = Erc20__factory.createInterface();
+
+    const requiredAmountsByTarget = parsedArgs._targets.reduce<{
+      [tokenAddress: string]: BigNumber;
+    }>((acc, target, index) => {
+      const [, amount] = erc20Interface.decodeFunctionData(
+        "transfer",
+        parsedArgs._data[index],
+      ) as [unknown, BigNumber];
+
+      acc[target] ||= Zero;
+      acc[target] = acc[target].add(amount);
+
+      return acc;
+    }, {});
+
+    const signer = this.multiProvider.getSigner(data.adapter.chainName);
+    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);
+          await tx.wait();
+        },
+      ),
+    );
+
     const _chainId = parsedArgs._destinationChain.toString();
 
     const filler = this.multiProvider.getSigner(_chainId);
@@ -210,5 +200,54 @@ export class EcoFiller extends BaseFiller<Metadata, ParsedArgs, IntentData> {
   }
 }
 
-export const create = (multiProvider: MultiProvider) =>
-  new EcoFiller(multiProvider).create();
+const enoughBalanceOnDestination: EcoRule = async (parsedArgs, context) => {
+  const erc20Interface = Erc20__factory.createInterface();
+
+  const requiredAmountsByTarget = parsedArgs._targets.reduce<{
+    [tokenAddress: string]: BigNumber;
+  }>((acc, target, index) => {
+    const [, amount] = erc20Interface.decodeFunctionData(
+      "transfer",
+      parsedArgs._data[index],
+    ) as [unknown, BigNumber];
+
+    acc[target] ||= Zero;
+    acc[target] = acc[target].add(amount);
+
+    return acc;
+  }, {});
+
+  const chainId = parsedArgs._destinationChain.toString();
+  const fillerAddress = await context.multiProvider.getSignerAddress(chainId);
+  const provider = context.multiProvider.getProvider(chainId);
+
+  for (const tokenAddress in requiredAmountsByTarget) {
+    const balance = await retrieveTokenBalance(
+      tokenAddress,
+      fillerAddress,
+      provider,
+    );
+
+    if (balance.lt(requiredAmountsByTarget[tokenAddress])) {
+      return {
+        error: `Insufficient balance on destination chain ${chainId} for token ${tokenAddress}`,
+        success: false,
+      };
+    }
+  }
+
+  return { data: "Enough tokens to fulfill the intent", success: true };
+};
+
+export const create = (
+  multiProvider: MultiProvider,
+  rules?: EcoFiller["rules"],
+  keepBaseRules = true,
+) => {
+  const customRules = rules ?? [];
+
+  return new EcoFiller(
+    multiProvider,
+    keepBaseRules ? [enoughBalanceOnDestination, ...customRules] : customRules,
+  ).create();
+};