feat: update oval node to support oval factory deployments

.github/workflows/ci.yml

@@ -0,0 +1,43 @@
+name: "CI"
+
+on:
+  workflow_dispatch:
+  pull_request:
+  push:
+    branches:
+      - "master"
+
+jobs:
+  test:
+    runs-on: "ubuntu-latest"
+    steps:
+      - name: "Check out the repo"
+        uses: "actions/checkout@v4"
+
+      - name: "Install Node.js"
+        uses: "actions/setup-node@v3"
+        with:
+          node-version: "20"
+
+      - name: "Install Yarn"
+        run: "npm install --global yarn"
+
+      - name: "Install Node.js dependencies"
+        run: "yarn install"
+
+      - name: "Create .env file"
+        run: |
+          echo 'PROVIDER_URL="https://mainnet.infura.io/v3/00000000000000000000000000000000"' > .env
+          echo 'PROVIDER_WSS="wss://mainnet.infura.io/ws/v3/00000000000000000000000000000000"' >> .env
+          echo 'FORWARD_URL="https://relay.flashbots.net"' >> .env
+          echo 'OVAL_CONFIGS="{"0x000000000000000000000000000000000000beef":{"unlockerKey":"0x000000000000000000000000000000000000000000000000000000000000beef","refundAddress":"0x000000000000000000000000000000000000beef","refundPercent":90}}"' >> .env
+          echo 'AUTH_PRIVATE_KEY="0x0000000000000000000000000000000000000000000000000000000000000000"' >> .env
+          echo 'MAINNET_BLOCK_OFFSET=5' >> .env
+
+      - name: "Run the tests"
+        run: "yarn test"
+
+      - name: "Add test summary"
+        run: |
+          echo "## Tests result" >> $GITHUB_STEP_SUMMARY
+          echo "✅ Passed" >> $GITHUB_STEP_SUMMARY

.mocharc.json

@@ -0,0 +1,11 @@
+{
+    "require": "ts-node/register",
+    "extension": [
+        "ts"
+    ],
+    "spec": "test/**/*.ts",
+    "watch-files": [
+        "src/**/*.ts",
+        "test/**/*.ts"
+    ]
+}

README.md

@@ -34,6 +34,7 @@ Define a `.env` file and define, at minimum, the following (see [here](./src/lib
 
 ```
 OVAL_CONFIGS=<oval_configs_json>              # JSON string that maps Oval contract addresses to their specific configurations (see below).
+OVAL_CONFIGS_SHARED=<oval_configs_shared_json># JSON string for shared unlocker configurations (see below).
 OVAL_ADDRESS=0x420                            # (Only if not using OVAL_CONFIGS) The address of the Oval contract you want to target with the Oval Node.
 REFUND_ADDRESS=0x42069                        # (Only if not using OVAL_CONFIGS) The refund address you want to send the OEV kickback to.
 REFUND_PERCENT=0.5                            # (Only if not using OVAL_CONFIGS) The percentage of the OEV kickback to send to the refund address.
@@ -48,7 +49,6 @@ CHAIN_ID=<network_chain_id>                   # Chain ID of the Ethereum network
 
 `OVAL_CONFIGS` is a JSON string that maps Oval contract addresses to their specific configurations. Each entry in this JSON object should have the following format:
 
-
 ```json
 {
   "<Oval_Contract_Address>": {
@@ -66,6 +66,19 @@ CHAIN_ID=<network_chain_id>                   # Chain ID of the Ethereum network
 - `Refund_Address`: The Ethereum address where refunds will be sent.
 - `Refund_Percentage`: The percentage of the OEV kickback to send to the refund address.
 
+`OVAL_CONFIGS_SHARED` is a JSON string that specifies the shared unlocker configurations for all Oval contracts. Each entry in this JSON object should have the following format:
+
+```json
+[
+  {
+    "unlockerKey": "<Unlocker_Private_Key>", // Optional: Use either this or gckmsKeyId, not both.
+    "gckmsKeyId": "<GCKMS_Key_ID>", // Optional: Use either this or unlockerKey, not both.
+  },...
+]
+```
+
+Note: If an Oval instance has an instance specific configuration, it will take precedence over the shared configuration.
+
 ### 2. Build & run the Oval Node:
 
 Build the JS with:

package.json

@@ -14,6 +14,7 @@
     "@types/uuid": "^9.0.8",
     "@uma/logger": "^1.1.0",
     "axios": "^1.5.1",
+    "bluebird": "^3.7.2",
     "body-parser": "^1.20.2",
     "ethers": "^6.8.0",
     "express": "^4.18.2",
@@ -26,16 +27,27 @@
     "typescript": "^5.2.2"
   },
   "devDependencies": {
+    "@typechain/ethers-v6": "^0.5.1",
+    "@types/bluebird": "^3.5.42",
+    "@types/chai": "^4.3.16",
     "@types/eventsource": "^1.1.11",
+    "@types/mocha": "^10.0.7",
     "@types/node": "^18.14.4",
+    "@types/sinon": "^17.0.3",
     "@typescript-eslint/eslint-plugin": "^5.56.0",
     "@typescript-eslint/parser": "^5.56.0",
-    "dotenv": "^16.3.1"
+    "chai": "^4.4.1",
+    "dotenv": "^16.3.1",
+    "mocha": "^10.6.0",
+    "sinon": "^18.0.0",
+    "typechain": "^8.3.2"
   },
   "scripts": {
     "dev": "nodemon",
     "build": "tsc",
+    "test": " mocha",
     "start": "node ./out/index.js",
-    "lint": "prettier './**/*.ts' --write"
+    "lint": "prettier './**/*.ts' --write",
+    "generate-contract-types": "rm -rf src/contract-types && mkdir -p src/contract-types && typechain --target ethers-v6 --out-dir src/contract-types 'src/abi/*.json'"
   }
 }

src/contract-types/PermissionProxy.ts

@@ -0,0 +1,249 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BytesLike,
+  FunctionFragment,
+  Result,
+  Interface,
+  EventFragment,
+  AddressLike,
+  ContractRunner,
+  ContractMethod,
+  Listener,
+} from "ethers";
+import type {
+  TypedContractEvent,
+  TypedDeferredTopicFilter,
+  TypedEventLog,
+  TypedLogDescription,
+  TypedListener,
+  TypedContractMethod,
+} from "./common";
+
+export interface PermissionProxyInterface extends Interface {
+  getFunction(
+    nameOrSignature:
+      | "execute"
+      | "multicall"
+      | "owner"
+      | "renounceOwnership"
+      | "senders"
+      | "setSender"
+      | "transferOwnership"
+  ): FunctionFragment;
+
+  getEvent(
+    nameOrSignatureOrTopic: "OwnershipTransferred" | "SenderSet"
+  ): EventFragment;
+
+  encodeFunctionData(
+    functionFragment: "execute",
+    values: [AddressLike, BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "multicall",
+    values: [BytesLike[]]
+  ): string;
+  encodeFunctionData(functionFragment: "owner", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "renounceOwnership",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "senders",
+    values: [AddressLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "setSender",
+    values: [AddressLike, boolean]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "transferOwnership",
+    values: [AddressLike]
+  ): string;
+
+  decodeFunctionResult(functionFragment: "execute", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "multicall", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "renounceOwnership",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "senders", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "setSender", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "transferOwnership",
+    data: BytesLike
+  ): Result;
+}
+
+export namespace OwnershipTransferredEvent {
+  export type InputTuple = [previousOwner: AddressLike, newOwner: AddressLike];
+  export type OutputTuple = [previousOwner: string, newOwner: string];
+  export interface OutputObject {
+    previousOwner: string;
+    newOwner: string;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export namespace SenderSetEvent {
+  export type InputTuple = [sender: AddressLike, allowed: boolean];
+  export type OutputTuple = [sender: string, allowed: boolean];
+  export interface OutputObject {
+    sender: string;
+    allowed: boolean;
+  }
+  export type Event = TypedContractEvent<InputTuple, OutputTuple, OutputObject>;
+  export type Filter = TypedDeferredTopicFilter<Event>;
+  export type Log = TypedEventLog<Event>;
+  export type LogDescription = TypedLogDescription<Event>;
+}
+
+export interface PermissionProxy extends BaseContract {
+  connect(runner?: ContractRunner | null): PermissionProxy;
+  waitForDeployment(): Promise<this>;
+
+  interface: PermissionProxyInterface;
+
+  queryFilter<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+  queryFilter<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TypedEventLog<TCEvent>>>;
+
+  on<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  on<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  once<TCEvent extends TypedContractEvent>(
+    event: TCEvent,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+  once<TCEvent extends TypedContractEvent>(
+    filter: TypedDeferredTopicFilter<TCEvent>,
+    listener: TypedListener<TCEvent>
+  ): Promise<this>;
+
+  listeners<TCEvent extends TypedContractEvent>(
+    event: TCEvent
+  ): Promise<Array<TypedListener<TCEvent>>>;
+  listeners(eventName?: string): Promise<Array<Listener>>;
+  removeAllListeners<TCEvent extends TypedContractEvent>(
+    event?: TCEvent
+  ): Promise<this>;
+
+  execute: TypedContractMethod<
+    [target: AddressLike, callData: BytesLike],
+    [string],
+    "nonpayable"
+  >;
+
+  multicall: TypedContractMethod<[data: BytesLike[]], [string[]], "nonpayable">;
+
+  owner: TypedContractMethod<[], [string], "view">;
+
+  renounceOwnership: TypedContractMethod<[], [void], "nonpayable">;
+
+  senders: TypedContractMethod<[arg0: AddressLike], [boolean], "view">;
+
+  setSender: TypedContractMethod<
+    [sender: AddressLike, allowed: boolean],
+    [void],
+    "nonpayable"
+  >;
+
+  transferOwnership: TypedContractMethod<
+    [newOwner: AddressLike],
+    [void],
+    "nonpayable"
+  >;
+
+  getFunction<T extends ContractMethod = ContractMethod>(
+    key: string | FunctionFragment
+  ): T;
+
+  getFunction(
+    nameOrSignature: "execute"
+  ): TypedContractMethod<
+    [target: AddressLike, callData: BytesLike],
+    [string],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "multicall"
+  ): TypedContractMethod<[data: BytesLike[]], [string[]], "nonpayable">;
+  getFunction(
+    nameOrSignature: "owner"
+  ): TypedContractMethod<[], [string], "view">;
+  getFunction(
+    nameOrSignature: "renounceOwnership"
+  ): TypedContractMethod<[], [void], "nonpayable">;
+  getFunction(
+    nameOrSignature: "senders"
+  ): TypedContractMethod<[arg0: AddressLike], [boolean], "view">;
+  getFunction(
+    nameOrSignature: "setSender"
+  ): TypedContractMethod<
+    [sender: AddressLike, allowed: boolean],
+    [void],
+    "nonpayable"
+  >;
+  getFunction(
+    nameOrSignature: "transferOwnership"
+  ): TypedContractMethod<[newOwner: AddressLike], [void], "nonpayable">;
+
+  getEvent(
+    key: "OwnershipTransferred"
+  ): TypedContractEvent<
+    OwnershipTransferredEvent.InputTuple,
+    OwnershipTransferredEvent.OutputTuple,
+    OwnershipTransferredEvent.OutputObject
+  >;
+  getEvent(
+    key: "SenderSet"
+  ): TypedContractEvent<
+    SenderSetEvent.InputTuple,
+    SenderSetEvent.OutputTuple,
+    SenderSetEvent.OutputObject
+  >;
+
+  filters: {
+    "OwnershipTransferred(address,address)": TypedContractEvent<
+      OwnershipTransferredEvent.InputTuple,
+      OwnershipTransferredEvent.OutputTuple,
+      OwnershipTransferredEvent.OutputObject
+    >;
+    OwnershipTransferred: TypedContractEvent<
+      OwnershipTransferredEvent.InputTuple,
+      OwnershipTransferredEvent.OutputTuple,
+      OwnershipTransferredEvent.OutputObject
+    >;
+
+    "SenderSet(address,bool)": TypedContractEvent<
+      SenderSetEvent.InputTuple,
+      SenderSetEvent.OutputTuple,
+      SenderSetEvent.OutputObject
+    >;
+    SenderSet: TypedContractEvent<
+      SenderSetEvent.InputTuple,
+      SenderSetEvent.OutputTuple,
+      SenderSetEvent.OutputObject
+    >;
+  };
+}