@feelyourprotocol/vm 8141.0.0

package/src/constructors.ts

@@ -0,0 +1,91 @@
+import { Common, Mainnet } from '@feelyourprotocol/common'
+import { EVMMockBlockchain, createEVM, getActivePrecompiles } from '@feelyourprotocol/evm'
+import { MerkleStateManager } from '@feelyourprotocol/statemanager'
+import {
+  Account,
+  Address,
+  EthereumJSErrorWithoutCode,
+  createAccount,
+  unprefixedHexToBytes,
+} from '@feelyourprotocol/util'
+
+import { VM } from './vm.ts'
+
+import type { VMOpts } from './types.ts'
+
+/**
+ * VM async constructor. Creates engine instance and initializes it.
+ *
+ * @param opts VM engine constructor options
+ */
+export async function createVM(opts: VMOpts = {}): Promise<VM> {
+  // Save if a `StateManager` was passed (for activatePrecompiles)
+  const didPassStateManager = opts.stateManager !== undefined
+
+  // Add common, SM, blockchain, EVM here
+  if (opts.common === undefined) {
+    opts.common = new Common({ chain: Mainnet })
+  }
+
+  if (opts.stateManager === undefined) {
+    opts.stateManager = new MerkleStateManager({
+      common: opts.common,
+    })
+  }
+
+  if (opts.blockchain === undefined) {
+    opts.blockchain = new EVMMockBlockchain()
+  }
+
+  if (opts.profilerOpts !== undefined) {
+    const profilerOpts = opts.profilerOpts
+    if (profilerOpts.reportAfterBlock === true && profilerOpts.reportAfterTx === true) {
+      throw EthereumJSErrorWithoutCode(
+        'Cannot have `reportProfilerAfterBlock` and `reportProfilerAfterTx` set to `true` at the same time',
+      )
+    }
+  }
+
+  if (opts.evm !== undefined && opts.evmOpts !== undefined) {
+    throw EthereumJSErrorWithoutCode('the evm and evmOpts options cannot be used in conjunction')
+  }
+
+  if (opts.evm === undefined) {
+    let enableProfiler = false
+    if (opts.profilerOpts?.reportAfterBlock === true || opts.profilerOpts?.reportAfterTx === true) {
+      enableProfiler = true
+    }
+    const evmOpts = opts.evmOpts ?? {}
+    opts.evm = await createEVM({
+      common: opts.common,
+      stateManager: opts.stateManager,
+      blockchain: opts.blockchain,
+      profiler: {
+        enabled: enableProfiler,
+      },
+      ...evmOpts,
+    })
+  }
+
+  if (opts.activatePrecompiles === true && !didPassStateManager) {
+    await opts.evm.journal.checkpoint()
+    // put 1 wei in each of the precompiles in order to make the accounts non-empty and thus not have them deduct `callNewAccount` gas.
+    for (const [addressStr] of getActivePrecompiles(opts.common)) {
+      const address = new Address(unprefixedHexToBytes(addressStr))
+      let account = await opts.evm.stateManager.getAccount(address)
+      // Only do this if it is not overridden in genesis
+      // Note: in the case that custom genesis has storage fields, this is preserved
+      if (account === undefined) {
+        account = new Account()
+        const newAccount = createAccount({
+          balance: 1,
+          storageRoot: account.storageRoot,
+        })
+        await opts.evm.stateManager.putAccount(address, newAccount)
+      }
+    }
+    await opts.evm.journal.commit()
+  }
+
+  return new VM(opts)
+}

package/src/emitEVMProfile.ts

@@ -0,0 +1,151 @@
+import type { EVMPerformanceLogOutput } from '@feelyourprotocol/evm'
+
+/**
+ * Emit EVM profile logs
+ * @param logs
+ * @param profileTitle
+ * @hidden
+ */
+export function emitEVMProfile(logs: EVMPerformanceLogOutput[], profileTitle: string) {
+  if (logs.length === 0) {
+    return
+  }
+
+  // Track total calls / time (ms) / gas
+
+  let calls = 0
+  let totalMs = 0
+  let totalGas = 0
+
+  // Order of columns to report (see `EVMPerformanceLogOutput` type)
+
+  const colOrder: (keyof EVMPerformanceLogOutput)[] = [
+    'tag',
+    'calls',
+    'avgTimePerCall',
+    'totalTime',
+    'staticGasUsed',
+    'dynamicGasUsed',
+    'gasUsed',
+    'staticGas',
+    'millionGasPerSecond',
+    'blocksPerSlot',
+  ]
+
+  // The name of this column to report (saves space)
+  const colNames = [
+    'tag',
+    'calls',
+    'ms/call',
+    'total (ms)',
+    'sgas',
+    'dgas',
+    'total (s+d)',
+    'static fee',
+    'Mgas/s',
+    'BpS',
+  ]
+
+  // Special padStr method which inserts whitespace left and right
+  // This ensures that there is at least one whitespace between the columns (denoted by pipe `|` chars)
+  function padStr(str: string | number, leftpad: number) {
+    return ' ' + str.toString().padStart(leftpad, ' ') + ' '
+  }
+  // Returns the string length of this column. Used to calculate how big the header / footer should be
+  function strLen(str: string | number) {
+    return padStr(str, 0).length - 2
+  }
+
+  // Step one: calculate the length of each column
+  const colLength: number[] = []
+
+  for (const entry of logs) {
+    let ins = 0
+    colLength[ins] = Math.max(colLength[ins] ?? 0, strLen(colNames[ins]))
+    for (const key of colOrder) {
+      if (entry[key] !== undefined) {
+        // If entry is available, max out the current column length (this will be the longest string of this column)
+        colLength[ins] = Math.max(colLength[ins] ?? 0, strLen(entry[key]!))
+        ins++
+        // In this switch statement update the total calls / time / gas used
+        switch (key) {
+          case 'calls':
+            calls += entry[key]
+            break
+          case 'totalTime':
+            totalMs += entry[key]
+            break
+          case 'gasUsed':
+            totalGas += entry[key]
+            break
+        }
+      }
+    }
+  }
+
+  // Ensure that the column names also fit on the column length
+  for (const i in colLength) {
+    colLength[i] = Math.max(colLength[i] ?? 0, strLen(colNames[i]))
+  }
+
+  // Calculate the total header length
+  // This is done by summing all columns together, plus adding three extra chars per column (two whitespace, one pipe)
+  // Remove the final pipe character since this is included in the header string (so subtract one)
+  const headerLength = colLength.reduce((pv, cv) => pv + cv, 0) + colLength.length * 3 - 1
+
+  const blockGasLimit = 30_000_000 // Block gas limit
+  const slotTime = 12000 // Time in milliseconds (!) per slot
+
+  // Normalize constant to check if execution time is above one block per slot (>=1) or not (<1)
+  const bpsNormalizer = blockGasLimit / slotTime
+
+  const avgGas = totalGas / totalMs // Gas per millisecond
+  const mGasSAvg = Math.round(avgGas) / 1e3
+  const bpSAvg = Math.round((avgGas / bpsNormalizer) * 1e3) / 1e3
+
+  // Write the profile title
+  // eslint-disable-next-line
+  console.log('+== ' + profileTitle + ' ==+')
+  // Write the summary of this profile
+  // eslint-disable-next-line
+  console.log(
+    `+== Calls: ${calls}, Total time: ${
+      Math.round(totalMs * 1e3) / 1e3
+    }ms, Total gas: ${totalGas}, MGas/s: ${mGasSAvg}, Blocks per Slot (BpS): ${bpSAvg} ==+`,
+  )
+
+  // Generate and write the header
+  const header = '|' + '-'.repeat(headerLength) + '|'
+  // eslint-disable-next-line
+  console.log(header)
+
+  // Write the columns
+  let str = ''
+  for (const i in colLength) {
+    str += '|' + padStr(colNames[i], colLength[i])
+  }
+  str += '|'
+
+  // eslint-disable-next-line
+  console.log(str)
+
+  // Write each profile entry
+  for (const entry of logs) {
+    let str = ''
+    let i = 0
+    for (const key of colOrder) {
+      if (entry[key] !== undefined) {
+        str += '|' + padStr(entry[key]!, colLength[i])
+        i++
+      }
+    }
+    str += '|'
+    // eslint-disable-next-line
+    console.log(str)
+  }
+
+  // Finally, write the footer
+  const footer = '+' + '-'.repeat(headerLength) + '+'
+  // eslint-disable-next-line
+  console.log(footer)
+}

package/src/index.ts

@@ -0,0 +1,10 @@
+export { Bloom } from './bloom/index.ts'
+export { BlockBuilder, BuildStatus } from './buildBlock.ts'
+export { buildBlock } from './buildBlock.ts'
+export * from './constructors.ts'
+export * from './params.ts'
+export { encodeReceipt } from './runBlock.ts'
+export { runBlock } from './runBlock.ts'
+export { runTx } from './runTx.ts'
+export * from './types.ts'
+export { VM } from './vm.ts'

package/src/params.ts

@@ -0,0 +1,104 @@
+import type { ParamsDict } from '@feelyourprotocol/common'
+import { SYSTEM_ADDRESS } from '@feelyourprotocol/util'
+
+export const paramsVM: ParamsDict = {
+  /**
+   * Frontier/Chainstart
+   */
+  1: {
+    // gasConfig
+    maxRefundQuotient: 2, // Maximum refund quotient; max tx refund is min(tx.gasUsed/maxRefundQuotient, tx.gasRefund)
+    blobGasPerBlob: 0,
+    maxBlobGasPerBlock: 0,
+    targetBlobGasPerBlock: 0,
+    // pow
+    minerReward: '5000000000000000000', // the amount a miner get rewarded for mining a block
+  },
+  /**
+.  * Byzantium HF Meta EIP
+.  */
+  609: {
+    // pow
+    minerReward: '3000000000000000000', // the amount a miner get rewarded for mining a block
+  },
+  /**
+.  * Constantinople HF Meta EIP
+.  */
+  1013: {
+    // pow
+    minerReward: '2000000000000000000', // The amount a miner gets rewarded for mining a block
+  },
+  /**
+.  * Fee market change for ETH 1.0 chain
+.  */
+  1559: {
+    // gasConfig
+    elasticityMultiplier: 2, // Maximum block gas target elasticity
+    initialBaseFee: 1000000000, // Initial base fee on first EIP1559 block
+  },
+  /**
+   * Save historical block hashes in state (Verkle related usage, UNSTABLE)
+   */
+  2935: {
+    // config
+    historyStorageAddress: '0x0000F90827F1C53A10CB7A02335B175320002935', // The address where the historical blockhashes are stored
+    historyServeWindow: 8191, // The amount of blocks to be served by the historical blockhash contract
+    systemAddress: SYSTEM_ADDRESS, // The system address
+  },
+  /**
+.  * Reduction in refunds
+.  */
+  3529: {
+    // gasConfig
+    maxRefundQuotient: 5, // Maximum refund quotient; max tx refund is min(tx.gasUsed/maxRefundQuotient, tx.gasRefund)
+  },
+  /**
+.  * Shard Blob Transactions
+.  */
+  4844: {
+    // gasConfig
+    targetBlobGasPerBlock: 393216, // The target blob gas consumed per block
+    blobGasPerBlob: 131072, // The base fee for blob gas per blob
+    maxBlobGasPerBlock: 786432, // The max blob gas allowable per block
+    blobGasPriceUpdateFraction: 3338477, // The denominator used in the exponential when calculating a blob gas price
+    // gasPrices
+    minBlobGas: 1, // The minimum fee per blob gas
+  },
+  /**
+.  * Beacon block root in the EVM
+.  */
+  4788: {
+    // config
+    historicalRootsLength: 8191, // The modulo parameter of the beaconroot ring buffer in the beaconroot stateful precompile
+  },
+  /**
+   * Execution layer triggerable withdrawals (experimental)
+   */
+  7002: {
+    // config
+    systemAddress: SYSTEM_ADDRESS, // The system address to perform operations on the withdrawal requests predeploy address
+    // See: https://github.com/ethereum/EIPs/pull/8934/files
+    withdrawalRequestPredeployAddress: '0x00000961EF480EB55E80D19AD83579A64C007002', // Address of the validator excess address
+    systemCallGasLimit: 30_000_000, // EIP-7002 system call gas limit
+  },
+
+  /**
+   * Increase the MAX_EFFECTIVE_BALANCE -> Execution layer triggered consolidations (experimental)
+   */
+  7251: {
+    // config
+    systemAddress: SYSTEM_ADDRESS, // The system address to perform operations on the consolidation requests predeploy address
+    // See: https://github.com/ethereum/EIPs/pull/8934/files
+    consolidationRequestPredeployAddress: '0x0000BBDDC7CE488642FB579F8B00F3A590007251', // Address of the consolidations contract
+    systemCallGasLimit: 30_000_000, // EIP-7251 system call gas limit
+  },
+  /**
+.  * Shard Blob Transactions
+.  */
+  7691: {
+    // gasConfig
+    targetBlobGasPerBlock: 786432, // The target blob gas consumed per block
+    maxBlobGasPerBlock: 1179648, // The max blob gas allowable per block
+    blobGasPriceUpdateFraction: 5007716, // The denominator used in the exponential when calculating a blob gas price
+  },
+}

package/src/requests.ts

@@ -0,0 +1,293 @@
+import { Mainnet } from '@feelyourprotocol/common'
+import type { BlockLevelAccessList, PrefixedHexString } from '@feelyourprotocol/util'
+import {
+  CLRequest,
+  CLRequestType,
+  EthereumJSErrorWithoutCode,
+  bigIntToAddressBytes,
+  bigIntToBytes,
+  bytesToBigInt,
+  bytesToHex,
+  concatBytes,
+  createAddressFromString,
+  setLengthLeft,
+} from '@feelyourprotocol/util'
+
+import type { RunTxResult } from './types.ts'
+import type { VM } from './vm.ts'
+
+const DEPOSIT_TOPIC = '0x649bbc62d0e31342afea4e5cd82d4049e7e1ee912fc0889aa790803be39038c5'
+const PUBKEY_OFFSET = BigInt(160)
+const WITHDRAWAL_CREDENTIALS_OFFSET = BigInt(256)
+const AMOUNT_OFFSET = BigInt(320)
+const SIGNATURE_OFFSET = BigInt(384)
+const INDEX_OFFSET = BigInt(512)
+const PUBKEY_SIZE = BigInt(48)
+const WITHDRAWAL_CREDENTIALS_SIZE = BigInt(32)
+const AMOUNT_SIZE = BigInt(8)
+const SIGNATURE_SIZE = BigInt(96)
+const INDEX_SIZE = BigInt(8)
+const LOG_SIZE = 576
+const LOG_LAYOUT_MISMATCH = 'invalid deposit log: unsupported data layout'
+
+function cloneSystemAccessEntry(vm: VM, systemAddressHex: PrefixedHexString) {
+  const access = vm.evm.blockLevelAccessList?.accesses[systemAddressHex]
+  if (access === undefined) {
+    return undefined
+  }
+
+  const storageChanges: typeof access.storageChanges = {}
+  for (const [slot, changes] of Object.entries(access.storageChanges)) {
+    storageChanges[slot as PrefixedHexString] = changes.map(
+      ([index, value]) => [index, value] as const,
+    )
+  }
+
+  return {
+    nonceChanges: new Map(access.nonceChanges),
+    balanceChanges: new Map(access.balanceChanges),
+    codeChanges: access.codeChanges.map(([index, code]) => [index, code] as const),
+    storageChanges,
+    storageReads: new Set(access.storageReads),
+  }
+}
+
+function restoreSystemAccessEntry(
+  vm: VM,
+  systemAddressHex: PrefixedHexString,
+  snapshot: ReturnType<typeof cloneSystemAccessEntry>,
+) {
+  const bal = vm.evm.blockLevelAccessList
+  if (bal === undefined) {
+    return
+  }
+
+  if (snapshot === undefined) {
+    delete bal.accesses[systemAddressHex]
+    return
+  }
+
+  bal.accesses[systemAddressHex] = snapshot as BlockLevelAccessList['accesses'][PrefixedHexString]
+}
+
+/**
+ * This helper method generates a list of all CL requests that can be included in a pending block
+ * @param vm VM instance (used in deriving partial withdrawal requests)
+ * @param txResults (used in deriving deposit requests)
+ * @returns a list of CL requests in ascending order by type
+ */
+export const accumulateRequests = async (
+  vm: VM,
+  txResults: RunTxResult[],
+): Promise<CLRequest<CLRequestType>[]> => {
+  const requests: CLRequest<CLRequestType>[] = []
+  const common = vm.common
+
+  if (common.isActivatedEIP(6110)) {
+    const depositContractAddress =
+      vm.common['_chainParams'].depositContractAddress ?? Mainnet.depositContractAddress
+    if (depositContractAddress === undefined)
+      throw EthereumJSErrorWithoutCode('deposit contract address required with EIP 6110')
+    const depositsRequest = accumulateDepositsRequest(depositContractAddress, txResults)
+    requests.push(depositsRequest)
+  }
+
+  if (common.isActivatedEIP(7002)) {
+    const withdrawalsRequest = await accumulateWithdrawalsRequest(vm)
+    requests.push(withdrawalsRequest)
+  }
+
+  if (common.isActivatedEIP(7251)) {
+    const consolidationsRequest = await accumulateConsolidationsRequest(vm)
+    requests.push(consolidationsRequest)
+  }
+
+  // requests are already type byte ordered by construction
+  return requests
+}
+
+const accumulateWithdrawalsRequest = async (
+  vm: VM,
+): Promise<CLRequest<typeof CLRequestType.Withdrawal>> => {
+  // Partial withdrawals logic
+  const addressBytes = setLengthLeft(
+    bigIntToBytes(vm.common.param('withdrawalRequestPredeployAddress')),
+    20,
+  )
+  const withdrawalsAddress = createAddressFromString(bytesToHex(addressBytes))
+
+  const systemAddressBytes = bigIntToAddressBytes(vm.common.param('systemAddress'))
+  const systemAddress = createAddressFromString(bytesToHex(systemAddressBytes))
+  const systemAccount = await vm.stateManager.getAccount(systemAddress)
+
+  const originalAccount = await vm.stateManager.getAccount(withdrawalsAddress)
+
+  if (originalAccount === undefined) {
+    return new CLRequest(CLRequestType.Withdrawal, new Uint8Array())
+  }
+
+  const systemAddressHex = systemAddress.toString()
+  const balSnapshot = cloneSystemAccessEntry(vm, systemAddressHex)
+  const results = await vm.evm.runCall({
+    caller: systemAddress,
+    gasLimit: vm.common.param('systemCallGasLimit'),
+    to: withdrawalsAddress,
+  })
+  restoreSystemAccessEntry(vm, systemAddressHex, balSnapshot)
+
+  if (systemAccount === undefined) {
+    await vm.stateManager.deleteAccount(systemAddress)
+  } else {
+    await vm.stateManager.putAccount(systemAddress, systemAccount)
+  }
+
+  const resultsBytes = results.execResult.returnValue
+  return new CLRequest(CLRequestType.Withdrawal, resultsBytes)
+}
+
+const accumulateConsolidationsRequest = async (
+  vm: VM,
+): Promise<CLRequest<typeof CLRequestType.Consolidation>> => {
+  // Partial withdrawals logic
+  const addressBytes = setLengthLeft(
+    bigIntToBytes(vm.common.param('consolidationRequestPredeployAddress')),
+    20,
+  )
+  const consolidationsAddress = createAddressFromString(bytesToHex(addressBytes))
+
+  const systemAddressBytes = bigIntToAddressBytes(vm.common.param('systemAddress'))
+  const systemAddress = createAddressFromString(bytesToHex(systemAddressBytes))
+  const systemAccount = await vm.stateManager.getAccount(systemAddress)
+
+  const originalAccount = await vm.stateManager.getAccount(consolidationsAddress)
+
+  if (originalAccount === undefined) {
+    return new CLRequest(CLRequestType.Consolidation, new Uint8Array(0))
+  }
+
+  const systemAddressHex = systemAddress.toString()
+  const balSnapshot = cloneSystemAccessEntry(vm, systemAddressHex)
+  const results = await vm.evm.runCall({
+    caller: systemAddress,
+    gasLimit: vm.common.param('systemCallGasLimit'),
+    to: consolidationsAddress,
+  })
+  restoreSystemAccessEntry(vm, systemAddressHex, balSnapshot)
+
+  if (systemAccount === undefined) {
+    await vm.stateManager.deleteAccount(systemAddress)
+  } else {
+    await vm.stateManager.putAccount(systemAddress, systemAccount)
+  }
+
+  const resultsBytes = results.execResult.returnValue
+  return new CLRequest(CLRequestType.Consolidation, resultsBytes)
+}
+
+const accumulateDepositsRequest = (
+  depositContractAddress: string,
+  txResults: RunTxResult[],
+): CLRequest<typeof CLRequestType.Deposit> => {
+  let resultsBytes = new Uint8Array(0)
+  const depositContractAddressLowerCase = depositContractAddress.toLowerCase()
+  for (const [_, tx] of txResults.entries()) {
+    for (let i = 0; i < tx.receipt.logs.length; i++) {
+      const log = tx.receipt.logs[i]
+      const [address, topics, data] = log
+      if (
+        topics.length > 0 &&
+        bytesToHex(topics[0]) === DEPOSIT_TOPIC &&
+        depositContractAddressLowerCase === bytesToHex(address).toLowerCase()
+      ) {
+        const { pubkey, withdrawalCredentials, amount, signature, index } = parseDepositLog(data)
+        const depositRequestBytes = concatBytes(
+          pubkey,
+          withdrawalCredentials,
+          amount,
+          signature,
+          index,
+        )
+
+        resultsBytes = concatBytes(resultsBytes, depositRequestBytes)
+      }
+    }
+  }
+
+  return new CLRequest(CLRequestType.Deposit, resultsBytes)
+}
+
+function parseDepositLog(requestData: Uint8Array) {
+  if (requestData.length !== LOG_SIZE) {
+    throw EthereumJSErrorWithoutCode(LOG_LAYOUT_MISMATCH)
+  }
+  // Extracts validator pubkey, withdrawal credential, deposit amount, signature,
+  // and validator index from Deposit Event log.
+  // The event fields are non-indexed so contained in one byte array (log[2]) so parsing is as follows:
+  // 1. Read the first 32 bytes to get the starting position of the first field.
+  // 2. Continue reading the byte array in 32 byte increments to get all the field starting positions
+  // 3. Read 32 bytes starting with the first field position to get the size of the first field
+  // 4. Read the bytes from first field position + 32 + the size of the first field to get the first field value
+  // 5. Repeat steps 3-4 for each field
+  const pubKeyIdxBigInt = bytesToBigInt(requestData.slice(0, 32))
+  const withdrawalCreditsIdxBigInt = bytesToBigInt(requestData.slice(32, 64))
+  const amountIdxBigInt = bytesToBigInt(requestData.slice(64, 96))
+  const sigIdxBigInt = bytesToBigInt(requestData.slice(96, 128))
+  const indexIdxBigInt = bytesToBigInt(requestData.slice(128, 160))
+
+  if (
+    pubKeyIdxBigInt !== PUBKEY_OFFSET ||
+    withdrawalCreditsIdxBigInt !== WITHDRAWAL_CREDENTIALS_OFFSET ||
+    amountIdxBigInt !== AMOUNT_OFFSET ||
+    sigIdxBigInt !== SIGNATURE_OFFSET ||
+    indexIdxBigInt !== INDEX_OFFSET
+  ) {
+    throw EthereumJSErrorWithoutCode(LOG_LAYOUT_MISMATCH)
+  }
+
+  const pubKeyIdx = Number(pubKeyIdxBigInt)
+  const withdrawalCreditsIdx = Number(withdrawalCreditsIdxBigInt)
+  const amountIdx = Number(amountIdxBigInt)
+  const sigIdx = Number(sigIdxBigInt)
+  const indexIdx = Number(indexIdxBigInt)
+
+  const pubKeySizeBigInt = bytesToBigInt(requestData.slice(pubKeyIdx, pubKeyIdx + 32))
+  const withdrawalCreditsSizeBigInt = bytesToBigInt(
+    requestData.slice(withdrawalCreditsIdx, withdrawalCreditsIdx + 32),
+  )
+  const amountSizeBigInt = bytesToBigInt(requestData.slice(amountIdx, amountIdx + 32))
+  const sigSizeBigInt = bytesToBigInt(requestData.slice(sigIdx, sigIdx + 32))
+  const indexSizeBigInt = bytesToBigInt(requestData.slice(indexIdx, indexIdx + 32))
+
+  if (
+    pubKeySizeBigInt !== PUBKEY_SIZE ||
+    withdrawalCreditsSizeBigInt !== WITHDRAWAL_CREDENTIALS_SIZE ||
+    amountSizeBigInt !== AMOUNT_SIZE ||
+    sigSizeBigInt !== SIGNATURE_SIZE ||
+    indexSizeBigInt !== INDEX_SIZE
+  ) {
+    throw EthereumJSErrorWithoutCode(LOG_LAYOUT_MISMATCH)
+  }
+
+  const pubKeySize = Number(pubKeySizeBigInt)
+  const withdrawalCreditsSize = Number(withdrawalCreditsSizeBigInt)
+  const amountSize = Number(amountSizeBigInt)
+  const sigSize = Number(sigSizeBigInt)
+  const indexSize = Number(indexSizeBigInt)
+
+  const pubkey = requestData.slice(pubKeyIdx + 32, pubKeyIdx + 32 + pubKeySize)
+  const withdrawalCredentials = requestData.slice(
+    withdrawalCreditsIdx + 32,
+    withdrawalCreditsIdx + 32 + withdrawalCreditsSize,
+  )
+  const amount = requestData.slice(amountIdx + 32, amountIdx + 32 + amountSize)
+  const signature = requestData.slice(sigIdx + 32, sigIdx + 32 + sigSize)
+  const index = requestData.slice(indexIdx + 32, indexIdx + 32 + indexSize)
+
+  return {
+    pubkey,
+    withdrawalCredentials,
+    amount,
+    signature,
+    index,
+  }
+}