@feelyourprotocol/block 8141.0.0

package/src/block/constructors.ts

@@ -0,0 +1,407 @@
+import { MerklePatriciaTrie } from '@feelyourprotocol/mpt'
+import { RLP } from '@feelyourprotocol/rlp'
+import type { TxOptions, TypedTransaction } from '@feelyourprotocol/tx'
+import {
+  createTx,
+  createTxFromBlockBodyData,
+  createTxFromRLP,
+  normalizeTxParams,
+} from '@feelyourprotocol/tx'
+import {
+  EthereumJSErrorWithoutCode,
+  bigIntToHex,
+  bytesToHex,
+  createWithdrawal,
+  equalsBytes,
+  fetchFromProvider,
+  getProvider,
+  hexToBytes,
+  intToHex,
+  isHexString,
+} from '@feelyourprotocol/util'
+
+import { generateCliqueBlockExtraData } from '../consensus/clique.ts'
+import { genTransactionsTrieRoot, genWithdrawalsTrieRoot } from '../helpers.ts'
+import {
+  Block,
+  createBlockHeader,
+  createBlockHeaderFromBytesArray,
+  createBlockHeaderFromRPC,
+  executionPayloadFromBeaconPayload,
+} from '../index.ts'
+
+import type { EthersProvider, WithdrawalBytes } from '@feelyourprotocol/util'
+import type { BeaconPayloadJSON } from '../from-beacon-payload.ts'
+import type {
+  BlockBytes,
+  BlockData,
+  BlockOptions,
+  ExecutionPayload,
+  HeaderData,
+  JSONRPCBlock,
+  WithdrawalsBytes,
+} from '../types.ts'
+
+/**
+ * Static constructor to create a block from a block data dictionary
+ *
+ * @param blockData
+ * @param opts
+ * @returns a new {@link Block} object
+ */
+export function createBlock(blockData: BlockData = {}, opts?: BlockOptions): Block {
+  const {
+    header: headerData,
+    transactions: txsData,
+    uncleHeaders: uhsData,
+    withdrawals: withdrawalsData,
+  } = blockData
+
+  const header = createBlockHeader(headerData, opts)
+
+  // parse transactions
+  const transactions = []
+  for (const txData of txsData ?? []) {
+    const tx = createTx(txData, {
+      ...opts,
+      // Use header common in case of setHardfork being activated
+      common: header.common,
+    } as TxOptions)
+    transactions.push(tx)
+  }
+
+  // parse uncle headers
+  const uncleHeaders = []
+  const uncleOpts: BlockOptions = {
+    ...opts,
+    // Use header common in case of setHardfork being activated
+    common: header.common,
+    // Disable this option here (all other options carried over), since this overwrites the provided Difficulty to an incorrect value
+    calcDifficultyFromHeader: undefined,
+  }
+  // Uncles are obsolete post-merge, any hardfork by option implies setHardfork
+  if (opts?.setHardfork !== undefined) {
+    uncleOpts.setHardfork = true
+  }
+  for (const uhData of uhsData ?? []) {
+    const uh = createBlockHeader(uhData, uncleOpts)
+    uncleHeaders.push(uh)
+  }
+
+  const withdrawals = withdrawalsData?.map(createWithdrawal)
+
+  return new Block(header, transactions, uncleHeaders, withdrawals, opts)
+}
+
+/**
+ * Simple static constructor if only an empty block is needed
+ * (tree shaking advantages since it does not draw all the tx constructors in)
+ *
+ * @param headerData
+ * @param opts
+ * @returns a new {@link Block} object
+ */
+export function createEmptyBlock(headerData: HeaderData, opts?: BlockOptions): Block {
+  const header = createBlockHeader(headerData, opts)
+  return new Block(header)
+}
+
+/**
+ * Static constructor to create a block from an array of Bytes values
+ *
+ * @param values
+ * @param opts
+ * @returns a new {@link Block} object
+ */
+export function createBlockFromBytesArray(values: BlockBytes, opts?: BlockOptions): Block {
+  if (values.length > 5) {
+    throw EthereumJSErrorWithoutCode(
+      `invalid  More values=${values.length} than expected were received (at most 5)`,
+    )
+  }
+
+  // First try to load header so that we can use its common (in case of setHardfork being activated)
+  // to correctly make checks on the hardforks
+  const [headerData, txsData, uhsData, ...valuesTail] = values
+  const header = createBlockHeaderFromBytesArray(headerData, opts)
+
+  // conditional assignment of rest of values and splicing them out from the valuesTail
+  const withdrawalBytes = header.common.isActivatedEIP(4895)
+    ? (valuesTail.splice(0, 1)[0] as WithdrawalsBytes)
+    : undefined
+
+  if (
+    header.common.isActivatedEIP(4895) &&
+    (withdrawalBytes === undefined || !Array.isArray(withdrawalBytes))
+  ) {
+    throw EthereumJSErrorWithoutCode(
+      'Invalid serialized block input: EIP-4895 is active, and no withdrawals were provided as array',
+    )
+  }
+
+  // parse transactions
+  const transactions = []
+  for (const txData of txsData ?? []) {
+    transactions.push(
+      createTxFromBlockBodyData(txData, {
+        ...opts,
+        // Use header common in case of setHardfork being activated
+        common: header.common,
+      }),
+    )
+  }
+
+  // parse uncle headers
+  const uncleHeaders = []
+  const uncleOpts: BlockOptions = {
+    ...opts,
+    // Use header common in case of setHardfork being activated
+    common: header.common,
+    // Disable this option here (all other options carried over), since this overwrites the provided Difficulty to an incorrect value
+    calcDifficultyFromHeader: undefined,
+  }
+  // Uncles are obsolete post-merge, any hardfork by option implies setHardfork
+  if (opts?.setHardfork !== undefined) {
+    uncleOpts.setHardfork = true
+  }
+  for (const uncleHeaderData of uhsData ?? []) {
+    uncleHeaders.push(createBlockHeaderFromBytesArray(uncleHeaderData, uncleOpts))
+  }
+
+  const withdrawals = (withdrawalBytes as WithdrawalBytes[])
+    ?.map(([index, validatorIndex, address, amount]) => ({
+      index,
+      validatorIndex,
+      address,
+      amount,
+    }))
+    ?.map(createWithdrawal)
+
+  return new Block(header, transactions, uncleHeaders, withdrawals, opts)
+}
+
+/**
+ * Static constructor to create a block from a RLP-serialized block
+ *
+ * @param serialized
+ * @param opts
+ * @returns a new {@link Block} object
+ */
+export function createBlockFromRLP(serialized: Uint8Array, opts?: BlockOptions): Block {
+  if (opts?.common?.isActivatedEIP(7934) === true) {
+    const maxRlpBlockSize = opts.common.param('maxRlpBlockSize')
+    if (serialized.length > maxRlpBlockSize) {
+      throw EthereumJSErrorWithoutCode(
+        `Block size exceeds limit: ${serialized.length} > ${maxRlpBlockSize}`,
+      )
+    }
+  }
+  const values = RLP.decode(Uint8Array.from(serialized)) as BlockBytes
+
+  if (!Array.isArray(values)) {
+    throw EthereumJSErrorWithoutCode('Invalid serialized block input. Must be array')
+  }
+
+  return createBlockFromBytesArray(values, opts)
+}
+
+/**
+ * Creates a new block object from Ethereum JSON RPC.
+ *
+ * @param blockParams - Ethereum JSON RPC of block (eth_getBlockByNumber)
+ * @param uncles - Optional list of Ethereum JSON RPC of uncles (eth_getUncleByBlockHashAndIndex)
+ * @param opts - An object describing the blockchain
+ * @returns a new {@link Block} object
+ */
+export function createBlockFromRPC(
+  blockParams: JSONRPCBlock,
+  uncles: any[] = [],
+  options?: BlockOptions,
+): Block {
+  const header = createBlockHeaderFromRPC(blockParams, options)
+
+  const transactions: TypedTransaction[] = []
+  const opts = { common: header.common }
+  for (const _txParams of blockParams.transactions ?? []) {
+    const txParams = normalizeTxParams(_txParams)
+    const tx = createTx(txParams, opts)
+    transactions.push(tx)
+  }
+
+  const uncleHeaders = uncles.map((uh) => createBlockHeaderFromRPC(uh, options))
+
+  return createBlock(
+    { header, transactions, uncleHeaders, withdrawals: blockParams.withdrawals },
+    options,
+  )
+}
+
+/**
+ *  Method to retrieve a block from a JSON-RPC provider and format as a {@link Block}
+ * @param provider either a url for a remote provider or an Ethers JSONRPCProvider object
+ * @param blockTag block hash or block number to be run
+ * @param opts {@link BlockOptions}
+ * @returns a new {@link Block} object specified by `blockTag`
+ */
+export const createBlockFromJSONRPCProvider = async (
+  provider: string | EthersProvider,
+  blockTag: string | bigint,
+  opts: BlockOptions,
+): Promise<Block> => {
+  let blockData
+  const providerUrl = getProvider(provider)
+
+  if (typeof blockTag === 'string' && blockTag.length === 66) {
+    blockData = await fetchFromProvider(providerUrl, {
+      method: 'eth_getBlockByHash',
+      params: [blockTag, true],
+    })
+  } else if (typeof blockTag === 'bigint') {
+    blockData = await fetchFromProvider(providerUrl, {
+      method: 'eth_getBlockByNumber',
+      params: [bigIntToHex(blockTag), true],
+    })
+  } else if (
+    isHexString(blockTag) ||
+    blockTag === 'latest' ||
+    blockTag === 'earliest' ||
+    blockTag === 'pending' ||
+    blockTag === 'finalized' ||
+    blockTag === 'safe'
+  ) {
+    blockData = await fetchFromProvider(providerUrl, {
+      method: 'eth_getBlockByNumber',
+      params: [blockTag, true],
+    })
+  } else {
+    throw EthereumJSErrorWithoutCode(
+      `expected blockTag to be block hash, bigint, hex prefixed string, or earliest/latest/pending; got ${blockTag}`,
+    )
+  }
+
+  if (blockData === null) {
+    throw EthereumJSErrorWithoutCode('No block data returned from provider')
+  }
+
+  const uncleHeaders = []
+  if (blockData.uncles.length > 0) {
+    for (let x = 0; x < blockData.uncles.length; x++) {
+      const headerData = await fetchFromProvider(providerUrl, {
+        method: 'eth_getUncleByBlockHashAndIndex',
+        params: [blockData.hash, intToHex(x)],
+      })
+      uncleHeaders.push(headerData)
+    }
+  }
+
+  return createBlockFromRPC(blockData, uncleHeaders, opts)
+}
+
+/**
+ *  Method to retrieve a block from an execution payload
+ * @param payload Execution payload constructed from beacon payload data
+ * @param opts {@link BlockOptions}
+ * @returns The constructed {@link Block} object
+ */
+export async function createBlockFromExecutionPayload(
+  payload: ExecutionPayload,
+  opts?: BlockOptions,
+): Promise<Block> {
+  const {
+    blockNumber: number,
+    receiptsRoot: receiptTrie,
+    prevRandao: mixHash,
+    feeRecipient: coinbase,
+    transactions,
+    withdrawals: withdrawalsData,
+  } = payload
+
+  const txs = []
+  for (const [index, serializedTx] of transactions.entries()) {
+    try {
+      const tx = createTxFromRLP(hexToBytes(serializedTx), {
+        common: opts?.common,
+      })
+      txs.push(tx)
+    } catch (error) {
+      const validationError = `Invalid tx at index ${index}: ${error}`
+      throw validationError
+    }
+  }
+
+  const transactionsTrie = await genTransactionsTrieRoot(
+    txs,
+    new MerklePatriciaTrie({ common: opts?.common }),
+  )
+  const withdrawals = withdrawalsData?.map((wData) => createWithdrawal(wData))
+  const withdrawalsRoot = withdrawals
+    ? await genWithdrawalsTrieRoot(withdrawals, new MerklePatriciaTrie({ common: opts?.common }))
+    : undefined
+
+  const header: HeaderData = {
+    ...payload,
+    number,
+    receiptTrie,
+    transactionsTrie,
+    withdrawalsRoot,
+    mixHash,
+    coinbase,
+  }
+
+  // we are not setting setHardfork as common is already set to the correct hf
+  const block = createBlock({ header, transactions: txs, withdrawals }, opts)
+  // Verify blockHash matches payload
+  if (!equalsBytes(block.hash(), hexToBytes(payload.blockHash))) {
+    const validationError = `Invalid blockHash, expected: ${
+      payload.blockHash
+    }, received: ${bytesToHex(block.hash())}`
+    throw Error(validationError)
+  }
+
+  return block
+}
+
+/**
+ *  Method to retrieve a block from a beacon payload JSON
+ * @param payload JSON of a beacon block fetched from beacon APIs
+ * @param opts {@link BlockOptions}
+ * @returns The constructed {@link Block} object
+ */
+export async function createBlockFromBeaconPayloadJSON(
+  payload: BeaconPayloadJSON,
+  opts?: BlockOptions,
+): Promise<Block> {
+  const executionPayload = executionPayloadFromBeaconPayload(payload)
+  return createBlockFromExecutionPayload(executionPayload, opts)
+}
+
+/**
+ * Creates a block for Clique networks with the seal applied during instantiation.
+ * @param blockData Block fields used to build the block
+ * @param cliqueSigner Private key bytes used to sign the header
+ * @param opts {@link BlockOptions}
+ * @returns A sealed Clique {@link Block} object
+ */
+export function createSealedCliqueBlock(
+  blockData: BlockData = {},
+  cliqueSigner: Uint8Array,
+  opts: BlockOptions = {},
+): Block {
+  const sealedCliqueBlock = createBlock(blockData, {
+    ...opts,
+    ...{ freeze: false, skipConsensusFormatValidation: true },
+  })
+  ;(sealedCliqueBlock.header.extraData as any) = generateCliqueBlockExtraData(
+    sealedCliqueBlock.header,
+    cliqueSigner,
+  )
+  if (opts?.freeze === true) {
+    // We have to freeze here since we can't freeze the block when constructing it since we are overwriting `extraData`
+    Object.freeze(sealedCliqueBlock)
+  }
+  if (opts?.skipConsensusFormatValidation === false) {
+    // We need to validate the consensus format here since we skipped it when constructing the block
+    sealedCliqueBlock.header['_consensusFormatValidation']()
+  }
+  return sealedCliqueBlock
+}

package/src/block/index.ts

@@ -0,0 +1,2 @@
+export * from './block.ts'
+export * from './constructors.ts'

package/src/consensus/clique.ts

@@ -0,0 +1,171 @@
+import { ConsensusAlgorithm } from '@feelyourprotocol/common'
+import { RLP } from '@feelyourprotocol/rlp'
+import {
+  Address,
+  BIGINT_0,
+  BIGINT_27,
+  EthereumJSErrorWithoutCode,
+  bytesToBigInt,
+  concatBytes,
+  createAddressFromPublicKey,
+  createZeroAddress,
+  ecrecover,
+  equalsBytes,
+} from '@feelyourprotocol/util'
+import { secp256k1 } from '@noble/curves/secp256k1.js'
+
+import type { CliqueConfig } from '@feelyourprotocol/common'
+import type { BlockHeader } from '../index.ts'
+
+// Fixed number of extra-data prefix bytes reserved for signer vanity
+export const CLIQUE_EXTRA_VANITY = 32
+// Fixed number of extra-data suffix bytes reserved for signer seal
+export const CLIQUE_EXTRA_SEAL = 65
+
+// This function is not exported in the index file to keep it internal
+export function requireClique(header: BlockHeader, name: string) {
+  if (header.common.consensusAlgorithm() !== ConsensusAlgorithm.Clique) {
+    const msg = header['_errorMsg'](
+      `BlockHeader.${name}() call only supported for clique PoA networks`,
+    )
+    throw EthereumJSErrorWithoutCode(msg)
+  }
+}
+
+/**
+ * PoA clique signature hash without the seal.
+ */
+export function cliqueSigHash(header: BlockHeader) {
+  requireClique(header, 'cliqueSigHash')
+  const raw = header.raw()
+  raw[12] = header.extraData.subarray(0, header.extraData.length - CLIQUE_EXTRA_SEAL)
+  return header['keccakFunction'](RLP.encode(raw))
+}
+
+/**
+ * Checks if the block header is an epoch transition
+ * header (only clique PoA, throws otherwise)
+ */
+export function cliqueIsEpochTransition(header: BlockHeader): boolean {
+  requireClique(header, 'cliqueIsEpochTransition')
+  const epoch = BigInt((header.common.consensusConfig() as CliqueConfig).epoch)
+  // Epoch transition block if the block number has no
+  // remainder on the division by the epoch length
+  return header.number % epoch === BIGINT_0
+}
+
+/**
+ * Returns extra vanity data
+ * (only clique PoA, throws otherwise)
+ */
+export function cliqueExtraVanity(header: BlockHeader): Uint8Array {
+  requireClique(header, 'cliqueExtraVanity')
+  return header.extraData.subarray(0, CLIQUE_EXTRA_VANITY)
+}
+
+/**
+ * Returns extra seal data
+ * (only clique PoA, throws otherwise)
+ */
+export function cliqueExtraSeal(header: BlockHeader): Uint8Array {
+  requireClique(header, 'cliqueExtraSeal')
+  return header.extraData.subarray(-CLIQUE_EXTRA_SEAL)
+}
+
+/**
+ * Returns a list of signers
+ * (only clique PoA, throws otherwise)
+ *
+ * This function throws if not called on an epoch
+ * transition block and should therefore be used
+ * in conjunction with {@link cliqueIsEpochTransition}
+ */
+export function cliqueEpochTransitionSigners(header: BlockHeader): Address[] {
+  requireClique(header, 'cliqueEpochTransitionSigners')
+  if (!cliqueIsEpochTransition(header)) {
+    const msg = header['_errorMsg']('Signers are only included in epoch transition blocks (clique)')
+    throw EthereumJSErrorWithoutCode(msg)
+  }
+
+  const start = CLIQUE_EXTRA_VANITY
+  const end = header.extraData.length - CLIQUE_EXTRA_SEAL
+  const signerBytes = header.extraData.subarray(start, end)
+
+  const signerList: Uint8Array[] = []
+  const signerLength = 20
+  for (let start = 0; start <= signerBytes.length - signerLength; start += signerLength) {
+    signerList.push(signerBytes.subarray(start, start + signerLength))
+  }
+  return signerList.map((buf) => new Address(buf))
+}
+
+/**
+ * Returns the signer address
+ */
+export function cliqueSigner(header: BlockHeader): Address {
+  requireClique(header, 'cliqueSigner')
+  const extraSeal = cliqueExtraSeal(header)
+  // Reasonable default for default blocks
+  if (extraSeal.length === 0 || equalsBytes(extraSeal, new Uint8Array(65))) {
+    return createZeroAddress()
+  }
+  const r = extraSeal.subarray(0, 32)
+  const s = extraSeal.subarray(32, 64)
+  const v = bytesToBigInt(extraSeal.subarray(64, 65)) + BIGINT_27
+  const pubKey = ecrecover(cliqueSigHash(header), v, r, s)
+  return createAddressFromPublicKey(pubKey)
+}
+
+/**
+ * Verifies the signature of the block (last 65 bytes of extraData field)
+ * (only clique PoA, throws otherwise)
+ *
+ *  Method throws if signature is invalid
+ */
+export function cliqueVerifySignature(header: BlockHeader, signerList: Address[]): boolean {
+  requireClique(header, 'cliqueVerifySignature')
+  const signerAddress = cliqueSigner(header)
+  const signerFound = signerList.find((signer) => {
+    return signer.equals(signerAddress)
+  })
+  return !!signerFound
+}
+
+/**
+ * Generates the extraData from a sealed block header
+ * @param header block header from which to retrieve extraData
+ * @param cliqueSigner clique signer key used for creating sealed block
+ * @returns clique seal (i.e. extradata) for the block
+ */
+export function generateCliqueBlockExtraData(
+  header: BlockHeader,
+  cliqueSigner: Uint8Array,
+): Uint8Array {
+  // Ensure extraData is at least length CLIQUE_EXTRA_VANITY + CLIQUE_EXTRA_SEAL
+  const minExtraDataLength = CLIQUE_EXTRA_VANITY + CLIQUE_EXTRA_SEAL
+  if (header.extraData.length < minExtraDataLength) {
+    const remainingLength = minExtraDataLength - header.extraData.length
+    ;(header.extraData as any) = concatBytes(header.extraData, new Uint8Array(remainingLength))
+  }
+
+  requireClique(header, 'generateCliqueBlockExtraData')
+
+  const msgHash = cliqueSigHash(header)
+
+  // Use custom ecsign if provided, otherwise use secp256k1.sign
+  const ecSignFunction = header.common.customCrypto?.ecsign ?? secp256k1.sign
+
+  // Use noble/curves secp256k1.sign with recovered format (returns 65-byte Uint8Array)
+  // sigBytes format: [recovery (1 byte) | r (32 bytes) | s (32 bytes)]
+  const sigBytes = ecSignFunction(msgHash, cliqueSigner, { prehash: false, format: 'recovered' })
+
+  // clique format: [r (32 bytes) | s (32 bytes) | recovery (1 byte)]
+  const cliqueSignature = concatBytes(sigBytes.subarray(1), sigBytes.subarray(0, 1))
+
+  const extraDataWithoutSeal = header.extraData.subarray(
+    0,
+    header.extraData.length - CLIQUE_EXTRA_SEAL,
+  )
+  const extraData = concatBytes(extraDataWithoutSeal, cliqueSignature)
+  return extraData
+}

package/src/consensus/ethash.ts

@@ -0,0 +1,11 @@
+import type { Block } from '../index.ts'
+
+/**
+ * Returns the canonical difficulty for this block.
+ *
+ * @param block - the block whose difficulty should be calculated
+ * @param parentBlock - the parent of this `Block`
+ */
+export function ethashCanonicalDifficulty(block: Block, parentBlock: Block): bigint {
+  return block.header.ethashCanonicalDifficulty(parentBlock.header)
+}

package/src/consensus/index.ts

@@ -0,0 +1,12 @@
+export {
+  CLIQUE_EXTRA_SEAL,
+  CLIQUE_EXTRA_VANITY,
+  cliqueEpochTransitionSigners,
+  cliqueExtraSeal,
+  cliqueExtraVanity,
+  cliqueIsEpochTransition,
+  cliqueSigHash,
+  cliqueSigner,
+  cliqueVerifySignature,
+} from './clique.ts'
+export * from './ethash.ts'

package/src/from-beacon-payload.ts

@@ -0,0 +1,82 @@
+import { bigIntToHex } from '@feelyourprotocol/util'
+
+import type { NumericString, PrefixedHexString } from '@feelyourprotocol/util'
+import type { ExecutionPayload } from './types.ts'
+
+type BeaconWithdrawal = {
+  index: PrefixedHexString
+  validator_index: PrefixedHexString
+  address: PrefixedHexString
+  amount: PrefixedHexString
+}
+
+// Payload JSON that one gets using the beacon apis
+// curl localhost:5052/eth/v2/beacon/blocks/56610 | jq .data.message.body.execution_payload
+export type BeaconPayloadJSON = {
+  parent_hash: PrefixedHexString
+  fee_recipient: PrefixedHexString
+  state_root: PrefixedHexString
+  receipts_root: PrefixedHexString
+  logs_bloom: PrefixedHexString
+  prev_randao: PrefixedHexString
+  block_number: NumericString
+  gas_limit: NumericString
+  gas_used: NumericString
+  timestamp: NumericString
+  extra_data: PrefixedHexString
+  base_fee_per_gas: NumericString
+  block_hash: PrefixedHexString
+  transactions: PrefixedHexString[]
+  withdrawals?: BeaconWithdrawal[]
+  blob_gas_used?: NumericString
+  excess_blob_gas?: NumericString
+  parent_beacon_block_root?: PrefixedHexString
+  requests_hash?: PrefixedHexString
+}
+
+/**
+ * Converts a beacon block execution payload JSON object {@link BeaconPayloadJSON} to the {@link ExecutionPayload} data needed to construct a {@link Block}.
+ * The JSON data can be retrieved from a consensus layer (CL) client on this Beacon API `/eth/v2/beacon/blocks/[block number]`
+ */
+export function executionPayloadFromBeaconPayload(payload: BeaconPayloadJSON): ExecutionPayload {
+  const executionPayload: ExecutionPayload = {
+    parentHash: payload.parent_hash,
+    feeRecipient: payload.fee_recipient,
+    stateRoot: payload.state_root,
+    receiptsRoot: payload.receipts_root,
+    logsBloom: payload.logs_bloom,
+    prevRandao: payload.prev_randao,
+    blockNumber: bigIntToHex(BigInt(payload.block_number)),
+    gasLimit: bigIntToHex(BigInt(payload.gas_limit)),
+    gasUsed: bigIntToHex(BigInt(payload.gas_used)),
+    timestamp: bigIntToHex(BigInt(payload.timestamp)),
+    extraData: payload.extra_data,
+    baseFeePerGas: bigIntToHex(BigInt(payload.base_fee_per_gas)),
+    blockHash: payload.block_hash,
+    transactions: payload.transactions,
+  }
+
+  if (payload.withdrawals !== undefined && payload.withdrawals !== null) {
+    executionPayload.withdrawals = payload.withdrawals.map((wd) => ({
+      index: bigIntToHex(BigInt(wd.index)),
+      validatorIndex: bigIntToHex(BigInt(wd.validator_index)),
+      address: wd.address,
+      amount: bigIntToHex(BigInt(wd.amount)),
+    }))
+  }
+
+  if (payload.blob_gas_used !== undefined && payload.blob_gas_used !== null) {
+    executionPayload.blobGasUsed = bigIntToHex(BigInt(payload.blob_gas_used))
+  }
+  if (payload.excess_blob_gas !== undefined && payload.excess_blob_gas !== null) {
+    executionPayload.excessBlobGas = bigIntToHex(BigInt(payload.excess_blob_gas))
+  }
+  if (payload.parent_beacon_block_root !== undefined && payload.parent_beacon_block_root !== null) {
+    executionPayload.parentBeaconBlockRoot = payload.parent_beacon_block_root
+  }
+  if (payload.requests_hash !== undefined && payload.requests_hash !== null) {
+    executionPayload.requestsHash = payload.requests_hash
+  }
+
+  return executionPayload
+}