@lodestar/prover 1.35.0-dev.f80d2d52da → 1.35.0-dev.fcf8d024ea

package/src/proof_provider/payload_store.ts

@@ -0,0 +1,223 @@
+import {ApiClient} from "@lodestar/api";
+import {ForkName} from "@lodestar/params";
+import {ExecutionPayload, LightClientHeader} from "@lodestar/types";
+import {Logger} from "@lodestar/utils";
+import {MAX_PAYLOAD_HISTORY} from "../constants.js";
+import {fetchBlock, getExecutionPayloadForBlockNumber} from "../utils/consensus.js";
+import {bufferToHex, hexToNumber} from "../utils/conversion.js";
+import {OrderedMap} from "./ordered_map.js";
+
+type BlockELRoot = string;
+type BlockELRootAndSlot = {
+  blockELRoot: BlockELRoot;
+  slot: number;
+};
+type BlockCLRoot = string;
+
+/**
+ * The in-memory store for the execution payloads to be used to verify the proofs
+ */
+export class PayloadStore {
+  // We store the block root from execution for finalized blocks
+  // As these blocks are finalized, so not to be worried about conflicting roots
+  private finalizedRoots = new OrderedMap<BlockELRootAndSlot>();
+
+  // Unfinalized blocks may change over time and may have conflicting roots
+  // We can receive multiple light-client headers for the same block of execution
+  // So we why store unfinalized payloads by their CL root, which is only used
+  // in processing the light-client headers
+  private unfinalizedRoots = new Map<BlockCLRoot, BlockELRoot>();
+
+  // Payloads store with BlockELRoot as key
+  private payloads = new Map<BlockELRoot, ExecutionPayload>();
+
+  private latestBlockRoot: BlockELRoot | null = null;
+
+  constructor(private opts: {api: ApiClient; logger: Logger}) {}
+
+  get finalized(): ExecutionPayload | undefined {
+    const maxBlockNumberForFinalized = this.finalizedRoots.max;
+
+    if (maxBlockNumberForFinalized === undefined) {
+      return undefined;
+    }
+
+    const finalizedMaxRoot = this.finalizedRoots.get(maxBlockNumberForFinalized);
+    if (finalizedMaxRoot) {
+      return this.payloads.get(finalizedMaxRoot.blockELRoot);
+    }
+
+    return undefined;
+  }
+
+  get latest(): ExecutionPayload | undefined {
+    if (this.latestBlockRoot) {
+      return this.payloads.get(this.latestBlockRoot);
+    }
+
+    return undefined;
+  }
+
+  async get(blockId: number | string): Promise<ExecutionPayload | undefined> {
+    // Given block id is a block hash in hex (32 bytes root takes 64 hex chars + 2 for 0x prefix)
+    if (typeof blockId === "string" && blockId.startsWith("0x") && blockId.length === 64 + 2) {
+      return this.payloads.get(blockId);
+    }
+
+    // Given block id is a block number in hex
+    if (typeof blockId === "string" && blockId.startsWith("0x")) {
+      return this.getOrFetchFinalizedPayload(hexToNumber(blockId));
+    }
+
+    // Given block id is a block number in decimal string
+    if (typeof blockId === "string" && !blockId.startsWith("0x")) {
+      return this.getOrFetchFinalizedPayload(parseInt(blockId, 10));
+    }
+
+    // Given block id is a block number in decimal
+    if (typeof blockId === "number") {
+      return this.getOrFetchFinalizedPayload(blockId);
+    }
+
+    return undefined;
+  }
+
+  protected async getOrFetchFinalizedPayload(blockNumber: number): Promise<ExecutionPayload | undefined> {
+    const maxBlockNumberForFinalized = this.finalizedRoots.max;
+    const minBlockNumberForFinalized = this.finalizedRoots.min;
+
+    if (maxBlockNumberForFinalized === undefined || minBlockNumberForFinalized === undefined) {
+      return;
+    }
+
+    if (blockNumber > maxBlockNumberForFinalized) {
+      throw new Error(
+        `Block number ${blockNumber} is higher than the latest finalized block number. We recommend to use block hash for unfinalized blocks.`
+      );
+    }
+
+    let blockELRoot = this.finalizedRoots.get(blockNumber);
+    // check if we have payload cached locally else fetch from api
+    if (!blockELRoot) {
+      const finalizedMaxRoot = this.finalizedRoots.get(maxBlockNumberForFinalized);
+      const slot = finalizedMaxRoot?.slot;
+      if (slot !== undefined) {
+        const payloads = await getExecutionPayloadForBlockNumber(this.opts.api, slot, blockNumber);
+        for (const [slot, payload] of payloads.entries()) {
+          this.set(payload, slot, true);
+        }
+      }
+    }
+
+    blockELRoot = this.finalizedRoots.get(blockNumber);
+    if (blockELRoot) {
+      return this.payloads.get(blockELRoot.blockELRoot);
+    }
+
+    return undefined;
+  }
+
+  set(payload: ExecutionPayload, slot: number, finalized: boolean): void {
+    const blockELRoot = bufferToHex(payload.blockHash);
+    this.payloads.set(blockELRoot, payload);
+
+    if (this.latestBlockRoot) {
+      const latestPayload = this.payloads.get(this.latestBlockRoot);
+      if (latestPayload && latestPayload.blockNumber < payload.blockNumber) {
+        this.latestBlockRoot = blockELRoot;
+      }
+    } else {
+      this.latestBlockRoot = blockELRoot;
+    }
+
+    if (finalized) {
+      this.finalizedRoots.set(payload.blockNumber, {blockELRoot, slot});
+    }
+  }
+
+  async processLCHeader(header: LightClientHeader<ForkName.capella>, finalized = false): Promise<void> {
+    const blockSlot = header.beacon.slot;
+    const blockNumber = header.execution.blockNumber;
+    const blockELRoot = bufferToHex(header.execution.blockHash);
+    const blockCLRoot = bufferToHex(header.beacon.stateRoot);
+    const existingELRoot = this.unfinalizedRoots.get(blockCLRoot);
+
+    // ==== Finalized blocks ====
+    // if the block is finalized, we need to update the finalizedRoots map
+    if (finalized) {
+      this.finalizedRoots.set(blockNumber, {blockELRoot, slot: blockSlot});
+
+      // If the block is finalized and we already have the payload
+      // We can remove it from the unfinalizedRoots map and do nothing else
+      if (existingELRoot) {
+        this.unfinalizedRoots.delete(blockCLRoot);
+      }
+
+      // If the block is finalized and we do not have the payload
+      // We need to fetch and set the payload
+      else {
+        const block = await fetchBlock(this.opts.api, blockSlot);
+        if (block) {
+          this.payloads.set(blockELRoot, block.message.body.executionPayload);
+        } else {
+          this.opts.logger.error("Failed to fetch block", blockSlot);
+        }
+      }
+
+      return;
+    }
+
+    // ==== Unfinalized blocks ====
+    // We already have the payload for this block
+    if (existingELRoot && existingELRoot === blockELRoot) {
+      return;
+    }
+
+    // Re-org happened, we need to update the payload
+    if (existingELRoot && existingELRoot !== blockELRoot) {
+      this.payloads.delete(existingELRoot);
+    }
+
+    // This is unfinalized header we need to store it's root related to cl root
+    this.unfinalizedRoots.set(blockCLRoot, blockELRoot);
+
+    // We do not have the payload for this block, we need to fetch it
+    const block = await fetchBlock(this.opts.api, blockSlot);
+    if (block) {
+      this.set(block.message.body.executionPayload, blockSlot, false);
+    } else {
+      this.opts.logger.error("Failed to fetch finalized block", blockSlot);
+    }
+    this.prune();
+  }
+
+  prune(): void {
+    if (this.finalizedRoots.size <= MAX_PAYLOAD_HISTORY) return;
+    // Store doe not have any finalized blocks means it's recently initialized
+    if (this.finalizedRoots.max === undefined || this.finalizedRoots.min === undefined) return;
+
+    for (
+      let blockNumber = this.finalizedRoots.max - MAX_PAYLOAD_HISTORY;
+      blockNumber >= this.finalizedRoots.min;
+      blockNumber--
+    ) {
+      const blockELRoot = this.finalizedRoots.get(blockNumber);
+      if (blockELRoot) {
+        this.payloads.delete(blockELRoot.blockELRoot);
+        this.finalizedRoots.delete(blockNumber);
+      }
+    }
+
+    for (const [clRoot, elRoot] of this.unfinalizedRoots) {
+      const payload = this.payloads.get(elRoot);
+      if (!payload) {
+        this.unfinalizedRoots.delete(clRoot);
+        continue;
+      }
+
+      if (payload.blockNumber < this.finalizedRoots.min) {
+        this.unfinalizedRoots.delete(clRoot);
+      }
+    }
+  }
+}

package/src/proof_provider/proof_provider.ts

@@ -0,0 +1,210 @@
+import {ApiClient, getClient} from "@lodestar/api/beacon";
+import {ChainForkConfig, createChainForkConfig} from "@lodestar/config";
+import {NetworkName, networksChainConfig} from "@lodestar/config/networks";
+import {Lightclient, LightclientEvent, RunStatusCode} from "@lodestar/light-client";
+import {LightClientRestTransport} from "@lodestar/light-client/transport";
+import {ForkName, isForkPostCapella} from "@lodestar/params";
+import {ExecutionPayload, LightClientHeader} from "@lodestar/types";
+import {Logger} from "@lodestar/utils";
+import {LCTransport, RootProviderInitOptions} from "../interfaces.js";
+import {assertLightClient} from "../utils/assertion.js";
+import {
+  fetchBlock,
+  getExecutionPayloads,
+  getGenesisData,
+  getSyncCheckpoint,
+  getUnFinalizedRangeForPayloads,
+} from "../utils/consensus.js";
+import {bufferToHex} from "../utils/conversion.js";
+import {PayloadStore} from "./payload_store.js";
+
+type RootProviderOptions = Omit<RootProviderInitOptions, "transport"> & {
+  transport: LightClientRestTransport;
+  api: ApiClient;
+  config: ChainForkConfig;
+};
+
+export class ProofProvider {
+  private store: PayloadStore;
+  private logger: Logger;
+  // Make sure readyPromise doesn't throw unhandled exceptions
+  private readyPromise?: Promise<void>;
+
+  readonly config: ChainForkConfig;
+  readonly network: NetworkName;
+  readonly api: ApiClient;
+
+  lightClient?: Lightclient;
+
+  constructor(readonly opts: RootProviderOptions) {
+    this.store = new PayloadStore({api: opts.api, logger: opts.logger});
+    this.logger = opts.logger;
+    this.config = opts.config;
+    this.api = opts.api;
+    this.network = opts.config.PRESET_BASE as NetworkName;
+  }
+
+  async waitToBeReady(): Promise<void> {
+    return this.readyPromise;
+  }
+
+  static init(opts: RootProviderInitOptions): ProofProvider {
+    if (opts.transport === LCTransport.P2P) {
+      throw new Error("P2P mode not supported yet");
+    }
+    opts.logger.info("Creating ProofProvider instance with REST APIs", {
+      network: opts.network,
+      urls: opts.urls.join(","),
+    });
+
+    const config = opts.network
+      ? createChainForkConfig(networksChainConfig[opts.network])
+      : createChainForkConfig(opts.config);
+
+    const api = getClient({urls: opts.urls}, {config});
+    const transport = new LightClientRestTransport(api);
+
+    const provider = new ProofProvider({
+      ...opts,
+      config,
+      api,
+      transport,
+    });
+
+    provider.readyPromise = provider.sync(opts.wsCheckpoint).catch((e) => {
+      opts.logger.error("Error while syncing", e);
+      return Promise.reject(e);
+    });
+
+    return provider;
+  }
+
+  private async sync(wsCheckpoint?: string): Promise<void> {
+    if (this.lightClient !== undefined) {
+      throw Error("Light client already initialized and syncing.");
+    }
+    this.logger.info("Starting sync for proof provider");
+    const {api, config, transport} = this.opts;
+    const checkpointRoot = await getSyncCheckpoint(api, wsCheckpoint);
+    const genesisData = await getGenesisData(api);
+
+    this.logger.info("Initializing lightclient", {checkpointRoot: bufferToHex(checkpointRoot)});
+    this.lightClient = await Lightclient.initializeFromCheckpointRoot({
+      checkpointRoot,
+      config,
+      transport,
+      genesisData,
+    });
+
+    assertLightClient(this.lightClient);
+
+    this.logger.info("Initiating lightclient");
+    // Wait for the lightclient to start
+    await this.lightClient?.start();
+    this.logger.info("Lightclient synced", this.getStatus());
+    this.registerEvents();
+
+    // Load the payloads from the CL
+    this.logger.info("Building EL payload history");
+    const {start, end} = await getUnFinalizedRangeForPayloads(this.lightClient);
+    const payloads = await getExecutionPayloads({
+      api: this.opts.api,
+      startSlot: start,
+      endSlot: end,
+      logger: this.logger,
+    });
+    for (const [slot, payload] of payloads.entries()) {
+      this.store.set(payload, slot, false);
+    }
+
+    // Load the finalized payload from the CL
+    const finalizedSlot = this.lightClient.getFinalized().beacon.slot;
+    this.logger.debug("Getting finalized slot from lightclient", {finalizedSlot});
+    const block = await fetchBlock(this.opts.api, finalizedSlot);
+    if (block) {
+      this.store.set(block.message.body.executionPayload, finalizedSlot, true);
+    } else {
+      this.logger.error("Failed to fetch finalized block", finalizedSlot);
+    }
+
+    this.logger.info("Proof provider ready");
+  }
+
+  getStatus(): {latest: number; finalized: number; status: RunStatusCode} {
+    if (!this.lightClient) {
+      return {
+        latest: 0,
+        finalized: 0,
+        status: RunStatusCode.uninitialized,
+      };
+    }
+
+    return {
+      latest: this.lightClient.getHead().beacon.slot,
+      finalized: this.lightClient.getFinalized().beacon.slot,
+      status: this.lightClient.status,
+    };
+  }
+
+  async getExecutionPayload(blockNumber: number | string | "finalized" | "latest"): Promise<ExecutionPayload> {
+    assertLightClient(this.lightClient);
+
+    if (typeof blockNumber === "string" && blockNumber === "finalized") {
+      const payload = this.store.finalized;
+      if (!payload) throw new Error("No finalized payload");
+      return payload;
+    }
+
+    if (typeof blockNumber === "string" && blockNumber === "latest") {
+      const payload = this.store.latest;
+      if (!payload) throw new Error("No latest payload");
+      return payload;
+    }
+
+    if ((typeof blockNumber === "string" && blockNumber.startsWith("0x")) || typeof blockNumber === "number") {
+      const payload = await this.store.get(blockNumber);
+      if (!payload) throw new Error(`No payload for blockNumber ${blockNumber}`);
+      return payload;
+    }
+
+    throw new Error(`Invalid blockNumber "${blockNumber}"`);
+  }
+
+  async processLCHeader(lcHeader: LightClientHeader, finalized = false): Promise<void> {
+    const fork = this.opts.config.getForkName(lcHeader.beacon.slot);
+
+    if (!isForkPostCapella(fork)) {
+      return;
+    }
+
+    const sszType = this.opts.config.getPostBellatrixForkTypes(lcHeader.beacon.slot).ExecutionPayloadHeader;
+    if (
+      isForkPostCapella(fork) &&
+      (!("execution" in lcHeader) || sszType.equals(lcHeader.execution, sszType.defaultValue()))
+    ) {
+      throw new Error("Execution payload is required for execution fork");
+    }
+
+    await this.store.processLCHeader(lcHeader as LightClientHeader<ForkName.capella>, finalized);
+  }
+
+  private registerEvents(): void {
+    assertLightClient(this.lightClient);
+
+    this.opts.signal.addEventListener("abort", () => {
+      this.lightClient?.stop();
+    });
+
+    this.lightClient.emitter.on(LightclientEvent.lightClientFinalityHeader, async (data) => {
+      await this.processLCHeader(data, true).catch((e) => {
+        this.logger.error("Error processing finality update", null, e);
+      });
+    });
+
+    this.lightClient.emitter.on(LightclientEvent.lightClientOptimisticHeader, async (data) => {
+      await this.processLCHeader(data).catch((e) => {
+        this.logger.error("Error processing optimistic update", null, e);
+      });
+    });
+  }
+}

package/src/provider_types/eip1193_provider_type.ts

@@ -0,0 +1,32 @@
+import {Web3ProviderType} from "../interfaces.js";
+import {JsonRpcRequestOrBatch, JsonRpcResponseOrBatch} from "../types.js";
+
+// Modern providers uses this structure e.g. Web3 4.x
+export interface EIP1193Provider {
+  request: (payload: JsonRpcRequestOrBatch) => Promise<JsonRpcResponseOrBatch>;
+}
+export default {
+  name: "eip1193",
+  matched(provider): provider is EIP1193Provider {
+    return (
+      "request" in provider &&
+      typeof provider.request === "function" &&
+      provider.request.constructor.name === "AsyncFunction"
+    );
+  },
+  handler(provider) {
+    const request = provider.request.bind(provider);
+
+    return async (payload: JsonRpcRequestOrBatch): Promise<JsonRpcResponseOrBatch | undefined> => {
+      const response = await request(payload);
+      return response;
+    };
+  },
+  mutateProvider(provider, newHandler) {
+    Object.assign(provider, {
+      request: async function newRequest(payload: JsonRpcRequestOrBatch): Promise<JsonRpcResponseOrBatch | undefined> {
+        return newHandler(payload);
+      },
+    });
+  },
+} as Web3ProviderType<EIP1193Provider>;

package/src/provider_types/ethers_provider_type.ts

@@ -0,0 +1,44 @@
+import {Web3ProviderType} from "../interfaces.js";
+import {JsonRpcRequestOrBatch, JsonRpcResponse, JsonRpcResponseOrBatch} from "../types.js";
+import {isBatchRequest} from "../utils/json_rpc.js";
+import web3JsProviderType from "./web3_js_provider_type.js";
+
+export interface EthersProvider {
+  // Ethers provider does not have a public interface for batch requests
+  send(method: string, params: Array<unknown>): Promise<JsonRpcResponse>;
+}
+export default {
+  name: "ethers",
+  matched(provider): provider is EthersProvider {
+    return (
+      !web3JsProviderType.matched(provider) &&
+      "send" in provider &&
+      typeof provider.send === "function" &&
+      provider.send.length > 1 &&
+      provider.send.constructor.name === "AsyncFunction"
+    );
+  },
+  handler(provider) {
+    const send = provider.send.bind(provider);
+
+    return async (payload: JsonRpcRequestOrBatch): Promise<JsonRpcResponseOrBatch | undefined> => {
+      // Because ethers provider public interface does not support batch requests
+      // so we need to handle it manually
+      if (isBatchRequest(payload)) {
+        const responses = [];
+        for (const request of payload) {
+          responses.push(await send(request.method, request.params));
+        }
+        return responses;
+      }
+      return send(payload.method, payload.params);
+    };
+  },
+  mutateProvider(provider, newHandler) {
+    Object.assign(provider, {
+      send: function newSend(method: string, params: Array<unknown>): Promise<JsonRpcResponseOrBatch | undefined> {
+        return newHandler({jsonrpc: "2.0", id: 0, method, params});
+      },
+    });
+  },
+} as Web3ProviderType<EthersProvider>;

package/src/provider_types/legacy_provider_type.ts

@@ -0,0 +1,123 @@
+import {AnyWeb3Provider, Web3ProviderType} from "../interfaces.js";
+import {JsonRpcRequest, JsonRpcRequestOrBatch, JsonRpcResponse, JsonRpcResponseOrBatch} from "../types.js";
+import web3JsProviderType from "./web3_js_provider_type.js";
+
+// Some providers uses `request` instead of the `send`. e.g. Ganache
+interface RequestProvider {
+  request(
+    payload: JsonRpcRequestOrBatch,
+    callback: (err: Error | undefined, response: JsonRpcResponseOrBatch) => void
+  ): void;
+}
+// The legacy Web3 1.x use this structure
+interface SendProvider {
+  send(payload: JsonRpcRequest, callback: (err?: Error | null, response?: JsonRpcResponse) => void): void;
+}
+// Some legacy providers use this very old structure
+interface SendAsyncProvider {
+  sendAsync(payload: JsonRpcRequestOrBatch): Promise<JsonRpcResponseOrBatch>;
+}
+
+type LegacyProvider = RequestProvider | SendProvider | SendAsyncProvider;
+
+export default {
+  name: "legacy",
+  matched(provider): provider is LegacyProvider {
+    return isRequestProvider(provider) || isSendProvider(provider) || isSendAsyncProvider(provider);
+  },
+  handler(provider) {
+    if (isRequestProvider(provider)) {
+      const request = provider.request.bind(provider);
+      return function newHandler(payload: JsonRpcRequestOrBatch): Promise<JsonRpcResponseOrBatch | undefined> {
+        return new Promise((resolve, reject) => {
+          request(payload, (err, response) => {
+            if (err) {
+              reject(err);
+            } else {
+              resolve(response);
+            }
+          });
+        });
+      };
+    }
+    if (isSendProvider(provider)) {
+      const send = provider.send.bind(provider);
+      return function newHandler(payload: JsonRpcRequestOrBatch): Promise<JsonRpcResponseOrBatch | undefined> {
+        return new Promise((resolve, reject) => {
+          // web3 providers supports batch requests but don't have valid types
+          send(payload as JsonRpcRequest, (err, response) => {
+            if (err) {
+              reject(err);
+            } else {
+              resolve(response);
+            }
+          });
+        });
+      };
+    }
+
+    // sendAsync provider
+    const sendAsync = provider.sendAsync.bind(provider);
+    return async function newHandler(payload: JsonRpcRequestOrBatch): Promise<JsonRpcResponseOrBatch | undefined> {
+      const response = await sendAsync(payload);
+      return response;
+    };
+  },
+  mutateProvider(provider, newHandler) {
+    if (isRequestProvider(provider)) {
+      const newRequest = function newRequest(
+        payload: JsonRpcRequestOrBatch,
+        callback: (err?: Error | null, response?: JsonRpcResponseOrBatch) => void
+      ): void {
+        newHandler(payload)
+          .then((response) => callback(undefined, response))
+          .catch((err) => callback(err, undefined));
+      };
+
+      Object.assign(provider, {request: newRequest});
+    }
+
+    if (isSendProvider(provider)) {
+      const newSend = function newSend(
+        payload: JsonRpcRequestOrBatch,
+        callback: (err?: Error | null, response?: JsonRpcResponseOrBatch) => void
+      ): void {
+        newHandler(payload)
+          .then((response) => callback(undefined, response))
+          .catch((err) => callback(err, undefined));
+      };
+
+      Object.assign(provider, {send: newSend});
+    }
+
+    // sendAsync provider
+    Object.assign(provider, {sendAsync: newHandler});
+  },
+} as Web3ProviderType<LegacyProvider>;
+
+function isSendProvider(provider: AnyWeb3Provider): provider is SendProvider {
+  return (
+    !web3JsProviderType.matched(provider) &&
+    "send" in provider &&
+    typeof provider.send === "function" &&
+    provider.send.length > 1 &&
+    provider.send.constructor.name !== "AsyncFunction"
+  );
+}
+
+function isRequestProvider(provider: AnyWeb3Provider): provider is RequestProvider {
+  return (
+    !web3JsProviderType.matched(provider) &&
+    "request" in provider &&
+    typeof provider.request === "function" &&
+    provider.request.length > 1
+  );
+}
+
+function isSendAsyncProvider(provider: AnyWeb3Provider): provider is SendAsyncProvider {
+  return (
+    "sendAsync" in provider &&
+    typeof provider.sendAsync === "function" &&
+    provider.sendAsync.constructor.name === "AsyncFunction"
+  );
+}

package/src/provider_types/web3_js_provider_type.ts

@@ -0,0 +1,35 @@
+import {AnyWeb3Provider, Web3ProviderType} from "../interfaces.js";
+import {JsonRpcRequest, JsonRpcRequestOrBatch, JsonRpcResponse, JsonRpcResponseOrBatch} from "../types.js";
+import {isBatchRequest} from "../utils/json_rpc.js";
+
+export interface Web3jsProvider {
+  request: (payload: JsonRpcRequest) => Promise<JsonRpcResponse>;
+}
+
+export default {
+  name: "web3js",
+  matched(provider): provider is Web3jsProvider {
+    return (
+      "isWeb3Provider" in provider.constructor &&
+      (provider.constructor as {isWeb3Provider: (provider: AnyWeb3Provider) => boolean}).isWeb3Provider(provider)
+    );
+  },
+  handler(provider) {
+    const request = provider.request.bind(provider);
+
+    return async (payload: JsonRpcRequestOrBatch): Promise<JsonRpcResponseOrBatch | undefined> => {
+      if (isBatchRequest(payload)) {
+        return Promise.all(payload.map((p) => request(p)));
+      }
+
+      return request(payload);
+    };
+  },
+  mutateProvider(provider, newHandler) {
+    Object.assign(provider, {
+      request: async function newRequest(payload: JsonRpcRequestOrBatch): Promise<JsonRpcResponseOrBatch | undefined> {
+        return newHandler(payload);
+      },
+    });
+  },
+} as Web3ProviderType<Web3jsProvider>;