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

package/src/types.ts

@@ -0,0 +1,163 @@
+export type JsonRpcId = number | string;
+export type JsonRpcVersion = string & ("2.0" | "1.0");
+
+export interface JsonRpcRequestPayload<T = unknown[]> {
+  readonly jsonrpc: JsonRpcVersion;
+  readonly id: JsonRpcId;
+  readonly method: string;
+  readonly params: T;
+  readonly requestOptions?: unknown;
+}
+
+export interface JsonRpcNotificationPayload<T = unknown[]> {
+  readonly jsonrpc: JsonRpcVersion;
+  readonly method: string;
+  readonly params: T;
+  readonly requestOptions?: unknown;
+}
+
+export type JsonRpcRequest<T = unknown[]> = JsonRpcRequestPayload<T> | JsonRpcNotificationPayload<T>;
+export type JsonRpcBatchRequest<T = unknown[]> = JsonRpcRequest<T>[];
+
+// The request can be a single request, a notification
+// or an array of requests and notifications as batch request
+export type JsonRpcRequestOrBatch<T = unknown[]> = JsonRpcRequest<T> | JsonRpcBatchRequest<T>;
+
+// Make the response compatible with different libraries, we don't use the readonly modifier
+export interface JsonRpcResponseWithResultPayload<T> {
+  readonly id?: JsonRpcId;
+  jsonrpc: JsonRpcVersion;
+  result: T;
+  error?: never;
+}
+
+export interface JsonRpcErrorPayload<T> {
+  readonly code?: number;
+  readonly data?: T;
+  readonly message: string;
+}
+
+export interface JsonRpcResponseWithErrorPayload<T> {
+  readonly id?: JsonRpcId;
+  jsonrpc: JsonRpcVersion;
+  result?: never;
+  error: JsonRpcErrorPayload<T>;
+}
+
+// Make the very flexible el response type to match different libraries easily
+// biome-ignore lint/suspicious/noExplicitAny: We need to use `any` type here
+export type JsonRpcResponse<T = any, E = any> =
+  | JsonRpcResponseWithResultPayload<T>
+  | JsonRpcResponseWithErrorPayload<E>;
+
+// biome-ignore lint/suspicious/noExplicitAny: We need to use `any` type here
+export type JsonRpcBatchResponse<T = any, E = any> = JsonRpcResponse<T, E>[];
+
+// Response can be a single response or an array of responses in case of batch request
+// Make the very flexible el response type to match different libraries easily
+// biome-ignore lint/suspicious/noExplicitAny: We need to use `any` type here
+export type JsonRpcResponseOrBatch<T = any, E = any> = JsonRpcResponse<T, E> | JsonRpcBatchResponse<T, E>;
+
+export type HexString = string;
+
+export type ELBlockNumberOrTag = number | string | "latest" | "earliest" | "pending";
+
+export interface ELProof {
+  readonly address: string;
+  readonly balance: string;
+  readonly codeHash: string;
+  readonly nonce: string;
+  readonly storageHash: string;
+  readonly accountProof: string[];
+  readonly storageProof: {
+    readonly key: string;
+    readonly value: string;
+    readonly proof: string[];
+  }[];
+}
+
+export interface ELTransaction {
+  readonly type: string;
+  readonly nonce: string;
+  readonly to: string | null;
+  readonly chainId?: string;
+  readonly input: string;
+  readonly value: string;
+  readonly gasPrice?: string;
+  readonly gas: string;
+  readonly maxFeePerGas?: string;
+  readonly maxPriorityFeePerGas?: string;
+  readonly blockHash: string;
+  readonly blockNumber: string;
+  readonly from: string;
+  readonly hash: string;
+  readonly r: string;
+  readonly s: string;
+  readonly v: string;
+  readonly transactionIndex: string;
+  readonly accessList?: {address: string; storageKeys: string[]}[];
+  readonly data?: string;
+}
+
+export interface ELWithdrawal {
+  readonly index: string;
+  readonly validatorIndex: string;
+  readonly address: string;
+  readonly amount: string;
+}
+
+export interface ELBlock {
+  readonly parentHash: string;
+  readonly stateRoot: string;
+  readonly receiptsRoot: string;
+  readonly logsBloom: string;
+  readonly nonce: string;
+  readonly difficulty: string;
+  readonly totalDifficulty: string;
+  readonly number: string;
+  readonly gasLimit: string;
+  readonly gasUsed: string;
+  readonly timestamp: string;
+  readonly extraData?: Buffer | string;
+  readonly mixHash: string;
+  readonly hash: string;
+  readonly baseFeePerGas: string;
+  readonly miner: string;
+  readonly sha3Uncles: string;
+  readonly size: string;
+  readonly uncles: ELBlock[];
+  readonly transactions: ELTransaction[];
+  readonly transactionsRoot: string;
+  readonly withdrawals?: ELWithdrawal[];
+  readonly withdrawalsRoot?: string;
+}
+
+export interface ELAccessList {
+  readonly address: HexString;
+  readonly storageKeys: HexString[];
+}
+
+export interface ELAccessListResponse {
+  readonly error: string;
+  readonly gasUsed: HexString;
+  readonly accessList: ELAccessList[];
+}
+
+export type ELStorageProof = Pick<ELProof, "storageHash" | "storageProof">;
+
+export type ELApi = {
+  eth_getBalance: (address: string, block?: number | string) => string;
+  eth_createAccessList: (transaction: ELTransaction, block?: ELBlockNumberOrTag) => ELAccessListResponse;
+  eth_call: (transaction: ELTransaction, block?: ELBlockNumberOrTag) => HexString;
+  eth_estimateGas: (transaction: ELTransaction, block?: ELBlockNumberOrTag) => HexString;
+  eth_getCode: (address: string, block?: ELBlockNumberOrTag) => HexString;
+  eth_getProof: (address: string, storageKeys: string[], block?: ELBlockNumberOrTag) => ELProof;
+  eth_getBlockByNumber: (block: ELBlockNumberOrTag, hydrated?: boolean) => ELBlock | undefined;
+  eth_getBlockByHash: (block: string, hydrated?: boolean) => ELBlock | undefined;
+};
+export type ELApiParams = {
+  [K in keyof ELApi]: Parameters<ELApi[K]>;
+};
+export type ELApiReturn = {
+  [K in keyof ELApi]: ReturnType<ELApi[K]>;
+};

package/src/utils/assertion.ts

@@ -0,0 +1,11 @@
+import {Lightclient} from "@lodestar/light-client";
+
+export function assertLightClient(client?: Lightclient): asserts client is Lightclient {
+  if (!client) {
+    throw new Error("Light client is not initialized yet.");
+  }
+}
+
+export function isTruthy<T = unknown>(value: T): value is Exclude<T, undefined | null> {
+  return value !== undefined && value !== null && value !== false;
+}

package/src/utils/consensus.ts

@@ -0,0 +1,122 @@
+import {ApiClient} from "@lodestar/api/beacon";
+import {GenesisData, Lightclient} from "@lodestar/light-client";
+import {Bytes32, ExecutionPayload, capella} from "@lodestar/types";
+import {Logger} from "@lodestar/utils";
+import {MAX_PAYLOAD_HISTORY} from "../constants.js";
+import {hexToBuffer} from "./conversion.js";
+
+export async function fetchBlock(api: ApiClient, slot: number): Promise<capella.SignedBeaconBlock | undefined> {
+  const res = await api.beacon.getBlockV2({blockId: slot});
+
+  if (res.ok) return res.value() as capella.SignedBeaconBlock;
+  return;
+}
+
+export async function fetchNearestBlock(
+  api: ApiClient,
+  slot: number,
+  direction: "up" | "down" = "down"
+): Promise<capella.SignedBeaconBlock> {
+  const res = await api.beacon.getBlockV2({blockId: slot});
+
+  if (res.ok) return res.value() as capella.SignedBeaconBlock;
+
+  if (!res.ok && res.status === 404) {
+    return fetchNearestBlock(api, direction === "down" ? slot - 1 : slot + 1);
+  }
+
+  throw new Error(`Can not fetch nearest block for slot=${slot}`);
+}
+
+export async function getUnFinalizedRangeForPayloads(lightClient: Lightclient): Promise<{start: number; end: number}> {
+  const headSlot = lightClient.getHead().beacon.slot;
+  const finalizeSlot = lightClient.getFinalized().beacon.slot;
+  const endSlot = headSlot - MAX_PAYLOAD_HISTORY;
+
+  return {
+    start: headSlot,
+    end: endSlot < finalizeSlot ? finalizeSlot : endSlot,
+  };
+}
+
+export async function getExecutionPayloads({
+  api,
+  startSlot,
+  endSlot,
+  logger,
+}: {
+  api: ApiClient;
+  startSlot: number;
+  endSlot: number;
+  logger: Logger;
+}): Promise<Map<number, ExecutionPayload>> {
+  [startSlot, endSlot] = [Math.min(startSlot, endSlot), Math.max(startSlot, endSlot)];
+  if (startSlot === endSlot) {
+    logger.debug("Fetching EL payload", {slot: startSlot});
+  } else {
+    logger.debug("Fetching EL payloads", {startSlot, endSlot});
+  }
+
+  const payloads = new Map<number, ExecutionPayload>();
+
+  let slot = endSlot;
+  let block = await fetchNearestBlock(api, slot);
+  payloads.set(block.message.slot, block.message.body.executionPayload);
+  slot = block.message.slot - 1;
+
+  while (slot >= startSlot) {
+    const previousBlock = await fetchNearestBlock(api, block.message.slot - 1);
+
+    if (block.message.body.executionPayload.parentHash === previousBlock.message.body.executionPayload.blockHash) {
+      payloads.set(block.message.slot, block.message.body.executionPayload);
+    }
+
+    slot = block.message.slot - 1;
+    block = previousBlock;
+  }
+
+  return payloads;
+}
+
+export async function getExecutionPayloadForBlockNumber(
+  api: ApiClient,
+  startSlot: number,
+  blockNumber: number
+): Promise<Map<number, ExecutionPayload>> {
+  const payloads = new Map<number, ExecutionPayload>();
+
+  let block = await fetchNearestBlock(api, startSlot);
+  payloads.set(block.message.slot, block.message.body.executionPayload);
+
+  while (payloads.get(block.message.slot)?.blockNumber !== blockNumber) {
+    const previousBlock = await fetchNearestBlock(api, block.message.slot - 1);
+    block = previousBlock;
+    payloads.set(block.message.slot, block.message.body.executionPayload);
+  }
+
+  return payloads;
+}
+
+export async function getGenesisData(api: Pick<ApiClient, "beacon">): Promise<GenesisData> {
+  const {genesisTime, genesisValidatorsRoot} = (await api.beacon.getGenesis()).value();
+
+  return {
+    genesisTime,
+    genesisValidatorsRoot,
+  };
+}
+
+export async function getSyncCheckpoint(api: Pick<ApiClient, "beacon">, checkpoint?: string): Promise<Bytes32> {
+  let syncCheckpoint: Bytes32 | undefined = checkpoint ? hexToBuffer(checkpoint) : undefined;
+
+  if (syncCheckpoint && syncCheckpoint.byteLength !== 32) {
+    throw Error(`Checkpoint root must be 32 bytes. length=${syncCheckpoint.byteLength}`);
+  }
+
+  if (!syncCheckpoint) {
+    const res = await api.beacon.getStateFinalityCheckpoints({stateId: "head"});
+    syncCheckpoint = res.value().finalized.root;
+  }
+
+  return syncCheckpoint;
+}

package/src/utils/conversion.ts

@@ -0,0 +1,107 @@
+import {BlockData, HeaderData} from "@ethereumjs/block";
+import {ELBlock, ELTransaction} from "../types.js";
+import {isTruthy} from "./assertion.js";
+
+export function numberToHex(num: number | bigint): string {
+  return "0x" + num.toString(16);
+}
+
+export function hexToNumber(num: string): number {
+  return num.startsWith("0x") ? parseInt(num.slice(2), 16) : parseInt(num, 16);
+}
+
+export function hexToBigInt(num: string): bigint {
+  return num.startsWith("0x") ? BigInt(num) : BigInt(`0x${num}`);
+}
+
+export function bigIntToHex(num: bigint): string {
+  return `0x${num.toString(16)}`;
+}
+
+export function bufferToHex(buffer: Buffer | Uint8Array): string {
+  return "0x" + Buffer.from(buffer).toString("hex");
+}
+
+export function hexToBuffer(val: string): Buffer {
+  const hexWithEvenLength = val.length % 2 ? `0${val}` : val;
+  return Buffer.from(hexWithEvenLength.replace("0x", ""), "hex");
+}
+
+export function padLeft<T extends Buffer | Uint8Array>(v: T, length: number): T {
+  const buf = Buffer.alloc(length);
+  Buffer.from(v).copy(buf, length - v.length);
+
+  if (Buffer.isBuffer(v)) return buf as T;
+
+  return Uint8Array.from(buf) as T;
+}
+
+export function headerDataFromELBlock(blockInfo: ELBlock): HeaderData {
+  return {
+    parentHash: blockInfo.parentHash,
+    uncleHash: blockInfo.sha3Uncles,
+    coinbase: blockInfo.miner,
+    stateRoot: blockInfo.stateRoot,
+    transactionsTrie: blockInfo.transactionsRoot,
+    receiptTrie: blockInfo.receiptsRoot,
+    logsBloom: blockInfo.logsBloom,
+    difficulty: BigInt(blockInfo.difficulty),
+    number: BigInt(blockInfo.number),
+    gasLimit: BigInt(blockInfo.gasLimit),
+    gasUsed: BigInt(blockInfo.gasUsed),
+    timestamp: BigInt(blockInfo.timestamp),
+    extraData: blockInfo.extraData,
+    mixHash: blockInfo.mixHash, // some reason the types are not up to date :(
+    nonce: blockInfo.nonce,
+    baseFeePerGas: blockInfo.baseFeePerGas ? BigInt(blockInfo.baseFeePerGas) : undefined,
+    withdrawalsRoot: blockInfo.withdrawalsRoot ?? undefined,
+  };
+}
+
+export function txDataFromELBlock(txInfo: ELTransaction) {
+  return {
+    ...txInfo,
+    data: txInfo.input,
+    gasPrice: isTruthy(txInfo.gasPrice) ? BigInt(txInfo.gasPrice) : null,
+    gasLimit: txInfo.gas,
+    to: isTruthy(txInfo.to) ? padLeft(hexToBuffer(txInfo.to), 20) : undefined,
+    value: txInfo.value ? BigInt(txInfo.value) : undefined,
+    maxFeePerGas: isTruthy(txInfo.maxFeePerGas) ? BigInt(txInfo.maxFeePerGas) : undefined,
+    maxPriorityFeePerGas: isTruthy(txInfo.maxPriorityFeePerGas) ? BigInt(txInfo.maxPriorityFeePerGas) : undefined,
+  };
+}
+
+export function blockDataFromELBlock(blockInfo: ELBlock): BlockData {
+  return {
+    header: headerDataFromELBlock(blockInfo),
+    transactions: blockInfo.transactions.map(txDataFromELBlock) as BlockData["transactions"],
+  };
+}
+
+export function cleanObject<T extends Record<string, unknown> | unknown[]>(obj: T): T {
+  const isNullify = (v: unknown): boolean => v === undefined || v === null;
+
+  if (Array.isArray(obj)) return obj.filter((v) => isNullify(v)) as T;
+
+  if (typeof obj === "object") {
+    for (const key of Object.keys(obj)) {
+      if (isNullify(obj[key])) {
+        delete obj[key];
+      } else if (typeof obj[key] === "object") {
+        cleanObject(obj[key] as Record<string, unknown>);
+      }
+    }
+  }
+
+  return obj;
+}
+
+/**
+ * Convert an array to array of chunks of length N
+ * @example
+ * chunkIntoN([1,2,3,4,5,6], 2)
+ * => [[1,2], [3,4], [5,6]]
+ */
+export function chunkIntoN<T extends unknown[]>(arr: T, n: number): T[] {
+  return Array.from({length: Math.ceil(arr.length / n)}, (_, i) => arr.slice(i * n, i * n + n)) as T[];
+}

package/src/utils/errors.ts

@@ -0,0 +1,4 @@
+/**
+ * Expected error that shouldn't print a stack trace
+ */
+export class YargsError extends Error {}

package/src/utils/evm.ts

@@ -0,0 +1,284 @@
+import {Block, BlockHeader} from "@ethereumjs/block";
+import {Blockchain} from "@ethereumjs/blockchain";
+import {TransactionFactory} from "@ethereumjs/tx";
+import {Account, Address} from "@ethereumjs/util";
+import {RunTxResult, VM} from "@ethereumjs/vm";
+import {NetworkName} from "@lodestar/config/networks";
+import {ExecutionPayload} from "@lodestar/types";
+import {Logger} from "@lodestar/utils";
+import {ZERO_ADDRESS} from "../constants.js";
+import {ProofProvider} from "../proof_provider/proof_provider.js";
+import {ELBlock, ELProof, ELTransaction, JsonRpcVersion} from "../types.js";
+import {bufferToHex, chunkIntoN, cleanObject, hexToBigInt, hexToBuffer, numberToHex, padLeft} from "./conversion.js";
+import {getChainCommon, getTxType} from "./execution.js";
+import {isValidResponse} from "./json_rpc.js";
+import {ELRpcProvider} from "./rpc_provider.js";
+import {isNullish, isValidAccount, isValidCodeHash, isValidStorageKeys} from "./validation.js";
+
+export async function createVM({proofProvider}: {proofProvider: ProofProvider}): Promise<VM> {
+  const common = getChainCommon(proofProvider.config.PRESET_BASE as string);
+  const blockchain = await Blockchain.create({common});
+
+  // Connect blockchain object with existing proof provider for block history
+  // biome-ignore lint/suspicious/noExplicitAny: We need to use `any` type here
+  (blockchain as any).getBlock = async (blockId: number) => {
+    const payload = await proofProvider.getExecutionPayload(blockId);
+    return {
+      hash: () => payload.blockHash,
+    };
+  };
+  const vm = await VM.create({common, blockchain});
+
+  return vm;
+}
+
+export async function getVMWithState({
+  rpc,
+  executionPayload,
+  tx,
+  vm,
+  logger,
+}: {
+  rpc: ELRpcProvider;
+  vm: VM;
+  executionPayload: ExecutionPayload;
+  tx: ELTransaction;
+  logger: Logger;
+}): Promise<VM> {
+  const {stateRoot, blockHash, gasLimit} = executionPayload;
+  const blockHashHex = bufferToHex(blockHash);
+
+  // If tx does not have a from address then it must be initiated via zero address
+  const from = tx.from ?? ZERO_ADDRESS;
+  const to = tx.to;
+
+  // Create Access List for the contract call
+  const accessListTx = cleanObject({
+    to,
+    from,
+    data: tx.input ? tx.input : tx.data,
+    value: tx.value,
+    gas: tx.gas ? tx.gas : numberToHex(gasLimit),
+    gasPrice: "0x0",
+  }) as ELTransaction;
+  const response = await rpc.request("eth_createAccessList", [accessListTx, blockHashHex], {raiseError: false});
+
+  if (!isValidResponse(response) || response.result.error) {
+    throw new Error(`Invalid response from RPC. method: eth_createAccessList, params: ${JSON.stringify(tx)}`);
+  }
+
+  const storageKeysMap: Record<string, string[]> = {};
+  for (const {address, storageKeys} of response.result.accessList) {
+    storageKeysMap[address] = storageKeys;
+  }
+
+  // If from address is not present then we have to fetch it for all keys
+  if (isNullish(storageKeysMap[from])) {
+    storageKeysMap[from] = [];
+  }
+
+  // If to address is not present then we have to fetch it with for all keys
+  if (to && isNullish(storageKeysMap[to])) {
+    storageKeysMap[to] = [];
+  }
+
+  const batchRequests = [];
+  for (const [address, storageKeys] of Object.entries(storageKeysMap)) {
+    batchRequests.push({
+      jsonrpc: "2.0" as JsonRpcVersion,
+      id: rpc.getRequestId(),
+      method: "eth_getProof",
+      params: [address, storageKeys, blockHashHex],
+    });
+
+    batchRequests.push({
+      jsonrpc: "2.0" as JsonRpcVersion,
+      id: rpc.getRequestId(),
+      method: "eth_getCode",
+      params: [address, blockHashHex],
+    });
+  }
+
+  // If all responses are valid then we will have even number of responses
+  // For each address, one response for eth_getProof and one for eth_getCode
+  const batchResponse = await rpc.batchRequest(batchRequests, {raiseError: true});
+  const batchResponseInChunks = chunkIntoN(batchResponse, 2);
+
+  const vmState: VMState = {};
+  for (const [proofResponse, codeResponse] of batchResponseInChunks) {
+    const addressHex = proofResponse.request.params[0] as string;
+    if (!isNullish(vmState[addressHex])) continue;
+
+    const proof = proofResponse.response.result as ELProof;
+    const storageKeys = proofResponse.request.params[1] as string[];
+    const code = codeResponse.response.result as string;
+
+    const validAccount = await isValidAccount({address: addressHex, proof, logger, stateRoot});
+    const validStorage = validAccount && (await isValidStorageKeys({storageKeys, proof, logger}));
+    if (!validAccount || !validStorage) {
+      throw new Error(`Invalid account: ${addressHex}`);
+    }
+
+    if (!(await isValidCodeHash({codeResponse: code, logger, codeHash: proof.codeHash}))) {
+      throw new Error(`Invalid code hash: ${addressHex}`);
+    }
+
+    vmState[addressHex] = {code, proof};
+  }
+
+  return updateVMWithState({vm, state: vmState, logger});
+}
+type VMState = Record<string, {code: string; proof: ELProof}>;
+export async function updateVMWithState({vm, state}: {logger: Logger; state: VMState; vm: VM}): Promise<VM> {
+  await vm.stateManager.checkpoint();
+  for (const [addressHex, {proof, code}] of Object.entries(state)) {
+    const address = Address.fromString(addressHex);
+    const codeBuffer = hexToBuffer(code);
+
+    const account = Account.fromAccountData({
+      nonce: BigInt(proof.nonce),
+      balance: BigInt(proof.balance),
+      codeHash: proof.codeHash,
+    });
+
+    await vm.stateManager.putAccount(address, account);
+
+    for (const {key, value} of proof.storageProof) {
+      await vm.stateManager.putContractStorage(address, padLeft(hexToBuffer(key), 32), padLeft(hexToBuffer(value), 32));
+    }
+    if (codeBuffer.byteLength !== 0) await vm.stateManager.putContractCode(address, codeBuffer);
+  }
+
+  await vm.stateManager.commit();
+  return vm;
+}
+
+export async function executeVMCall({
+  rpc,
+  tx,
+  vm,
+  executionPayload,
+  network,
+}: {
+  rpc: ELRpcProvider;
+  tx: ELTransaction;
+  vm: VM;
+  executionPayload: ExecutionPayload;
+  network: NetworkName;
+}): Promise<RunTxResult["execResult"]> {
+  const {from, to, gas, gasPrice, maxPriorityFeePerGas, value, data, input} = tx;
+  const blockHash = bufferToHex(executionPayload.blockHash);
+  const {result: block} = await rpc.request("eth_getBlockByHash", [blockHash, true], {
+    raiseError: true,
+  });
+
+  if (!block) {
+    throw new Error(`Block not found: ${blockHash}`);
+  }
+
+  const {execResult} = await vm.evm.runCall({
+    caller: from ? Address.fromString(from) : undefined,
+    to: to ? Address.fromString(to) : undefined,
+    gasLimit: hexToBigInt(gas ?? block.gasLimit),
+    gasPrice: hexToBigInt(gasPrice ?? maxPriorityFeePerGas ?? "0x0"),
+    value: hexToBigInt(value ?? "0x0"),
+    data: input ? hexToBuffer(input) : data ? hexToBuffer(data) : undefined,
+    block: {
+      header: getVMBlockHeaderFromELBlock(block, executionPayload, network),
+    },
+  });
+
+  if (execResult.exceptionError) {
+    throw new Error(execResult.exceptionError.error);
+  }
+
+  return execResult;
+}
+
+export async function executeVMTx({
+  rpc,
+  tx,
+  vm,
+  executionPayload,
+  network,
+}: {
+  rpc: ELRpcProvider;
+  tx: ELTransaction;
+  vm: VM;
+  executionPayload: ExecutionPayload;
+  network: NetworkName;
+}): Promise<RunTxResult> {
+  const {result: block} = await rpc.request("eth_getBlockByHash", [bufferToHex(executionPayload.blockHash), true], {
+    raiseError: true,
+  });
+
+  if (!block) {
+    throw new Error(`Block not found: ${bufferToHex(executionPayload.blockHash)}`);
+  }
+  const txType = getTxType(tx);
+  const from = tx.from ? Address.fromString(tx.from) : Address.zero();
+  const to = tx.to ? Address.fromString(tx.to) : undefined;
+
+  const txData = {
+    ...tx,
+    from,
+    to,
+    type: txType,
+    // If no gas limit is specified use the last block gas limit as an upper bound.
+    gasLimit: hexToBigInt(tx.gas ?? block.gasLimit),
+  };
+
+  if (txType === 2) {
+    // Handle EIP-1559 transactions
+    // To fix the vm error: Transaction's maxFeePerGas (0) is less than the block's baseFeePerGas
+    txData.maxFeePerGas = txData.maxFeePerGas ?? block.baseFeePerGas;
+  } else {
+    // Legacy transaction
+    txData.gasPrice = isNullish(txData.gasPrice) || txData.gasPrice === "0x0" ? block.baseFeePerGas : txData.gasPrice;
+  }
+
+  const txObject = TransactionFactory.fromTxData(txData, {common: getChainCommon(network), freeze: false});
+
+  // Override to avoid tx signature verification
+  txObject.getSenderAddress = () => (tx.from ? Address.fromString(tx.from) : Address.zero());
+
+  const result = await vm.runTx({
+    tx: txObject,
+    skipNonce: true,
+    skipBalance: true,
+    skipBlockGasLimitValidation: true,
+    skipHardForkValidation: true,
+    block: {
+      header: getVMBlockHeaderFromELBlock(block, executionPayload, network),
+    } as Block,
+  });
+
+  return result;
+}
+
+export function getVMBlockHeaderFromELBlock(
+  block: ELBlock,
+  executionPayload: ExecutionPayload,
+  network: NetworkName
+): BlockHeader {
+  const blockHeaderData = {
+    number: hexToBigInt(block.number),
+    cliqueSigner: () => Address.fromString(block.miner),
+    timestamp: hexToBigInt(block.timestamp),
+    difficulty: hexToBigInt(block.difficulty),
+    gasLimit: hexToBigInt(block.gasLimit),
+    baseFeePerGas: block.baseFeePerGas ? hexToBigInt(block.baseFeePerGas) : undefined,
+
+    // Use these values from the execution payload
+    // instead of the block values to ensure that
+    // the VM is using the verified values from the lightclient
+    prevRandao: Buffer.from(executionPayload.prevRandao),
+    stateRoot: Buffer.from(executionPayload.stateRoot),
+    parentHash: Buffer.from(executionPayload.parentHash),
+
+    // TODO: Fix the coinbase address
+    coinbase: Address.fromString(block.miner),
+  };
+
+  return BlockHeader.fromHeaderData(blockHeaderData, {common: getChainCommon(network)});
+}