EIP-6110: Supply Validator Deposits on Chain

packages/block/src/block.ts

@@ -4,6 +4,8 @@ import { Trie } from '@ethereumjs/trie'
 import { BlobEIP4844Transaction, Capability, TransactionFactory } from '@ethereumjs/tx'
 import {
   BIGINT_0,
+  Deposit,
+  CLRequest,
   KECCAK256_RLP,
   KECCAK256_RLP_ARRAY,
   Withdrawal,
@@ -41,7 +43,14 @@ import type {
   TxOptions,
   TypedTransaction,
 } from '@ethereumjs/tx'
-import type { EthersProvider, WithdrawalBytes } from '@ethereumjs/util'
+import type {
+  DepositBytes,
+  EthersProvider,
+  WithdrawalBytes,
+  CLRequestType,
+  PrefixedHexString,
+  RequestBytes,
+} from '@ethereumjs/util'
 
 /**
  * An object that represents the block.
@@ -51,6 +60,8 @@ export class Block {
   public readonly transactions: TypedTransaction[] = []
   public readonly uncleHeaders: BlockHeader[] = []
   public readonly withdrawals?: Withdrawal[]
+  public readonly deposits?: Deposit[]
+  public readonly requests?: CLRequestType[]
   public readonly common: Common
   protected keccakFunction: (msg: Uint8Array) => Uint8Array
 
@@ -64,8 +75,17 @@ export class Block {
   protected cache: {
     txTrieRoot?: Uint8Array
     withdrawalsTrieRoot?: Uint8Array
+    requestsRoot?: Uint8Array
   } = {}
 
+  public static async genDepositsTrieRoot(deposits: Deposit[], emptyTrie?: Trie) {
+    const trie = emptyTrie ?? new Trie()
+    for (const [i, deposit] of deposits.entries()) {
+      await trie.put(RLP.encode(i), RLP.encode(deposit.raw()))
+    }
+    return trie.root()
+  }
+
   /**
    * Returns the withdrawals trie root for array of Withdrawal.
    * @param wts array of Withdrawal to compute the root of
@@ -92,6 +112,28 @@ export class Block {
     return trie.root()
   }
 
+  /**
+   * Returns the requests trie root for an array of CLRequests
+   * @param requests - an array of CLRequests
+   * @param emptyTrie optional empty trie used to generate the root
+   * @returns a 32 byte Uint8Array representing the requests trie root
+   */
+  public static async genRequestsTrieRoot(requests: CLRequest[], emptyTrie?: Trie) {
+    // Requests should be sorted in monotonically ascending order based on type
+    // and whatever internal sorting logic is defined by each request type
+    if (requests.length > 1) {
+      for (let x = 1; x < requests.length; x++) {
+        if (requests[x].type < requests[x - 1].type)
+          throw new Error('requests are not sorted in ascending order')
+      }
+    }
+    const trie = emptyTrie ?? new Trie()
+    for (const [i, req] of requests.entries()) {
+      await trie.put(RLP.encode(i), req.serialize())
+    }
+    return trie.root()
+  }
+
   /**
    * Static constructor to create a block from a block data dictionary
    *
@@ -105,6 +147,8 @@ export class Block {
       uncleHeaders: uhsData,
       withdrawals: withdrawalsData,
       executionWitness: executionWitnessData,
+      deposits: depositData,
+      requests: clRequests,
     } = blockData
 
     const header = BlockHeader.fromHeaderData(headerData, opts)
@@ -143,7 +187,18 @@ export class Block {
     // stub till that time
     const executionWitness = executionWitnessData
 
-    return new Block(header, transactions, uncleHeaders, withdrawals, opts, executionWitness)
+    const deposits = depositData?.map(Deposit.fromDepositData)
+
+    return new Block(
+      header,
+      transactions,
+      uncleHeaders,
+      withdrawals,
+      opts,
+      deposits,
+      clRequests,
+      executionWitness
+    )
   }
 
   /**
@@ -177,7 +232,15 @@ export class Block {
 
     // 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, withdrawalBytes, executionWitnessBytes] = values
+    const [
+      headerData,
+      txsData,
+      uhsData,
+      withdrawalBytes,
+      depositBytes,
+      requestBytes,
+      executionWitnessBytes,
+    ] = values
     const header = BlockHeader.fromValuesArray(headerData, opts)
 
     if (
@@ -189,6 +252,15 @@ export class Block {
       )
     }
 
+    if (
+      header.common.isActivatedEIP(6110) &&
+      (depositBytes === undefined || !Array.isArray(depositBytes))
+    ) {
+      throw new Error(
+        'Invalid serialized block input: EIP-6110 is active, and no deposits were provided as array'
+      )
+    }
+
     // parse transactions
     const transactions = []
     for (const txData of txsData ?? []) {
@@ -227,6 +299,24 @@ export class Block {
       }))
       ?.map(Withdrawal.fromWithdrawalData)
 
+    const deposits = header.common.isActivatedEIP(6110)
+      ? (depositBytes as DepositBytes[])
+          ?.map(([pubkey, withdrawalCredentials, amount, signature, index]) => ({
+            pubkey,
+            withdrawalCredentials,
+            amount,
+            signature,
+            index,
+          }))
+          ?.map(Deposit.fromDepositData)
+      : undefined
+
+    let requests
+    if (header.common.isActivatedEIP(7685)) {
+      requests = (requestBytes as RequestBytes[]).map(
+        (bytes) => new CLRequest(bytes[0], bytes.slice(1))
+      )
+    }
     // executionWitness are not part of the EL fetched blocks via eth_ bodies method
     // they are currently only available via the engine api constructed blocks
     let executionWitness
@@ -242,7 +332,16 @@ export class Block {
       }
     }
 
-    return new Block(header, transactions, uncleHeaders, withdrawals, opts, executionWitness)
+    return new Block(
+      header,
+      transactions,
+      uncleHeaders,
+      withdrawals,
+      opts,
+      deposits,
+      requests,
+      executionWitness
+    )
   }
 
   /**
@@ -334,22 +433,27 @@ export class Block {
       feeRecipient: coinbase,
       transactions,
       withdrawals: withdrawalsData,
+      requestsRoot,
       executionWitness,
     } = payload
 
     const txs = []
     for (const [index, serializedTx] of transactions.entries()) {
       try {
-        const tx = TransactionFactory.fromSerializedData(hexToBytes(serializedTx), {
-          common: opts?.common,
-        })
+        const tx = TransactionFactory.fromSerializedData(
+          hexToBytes(serializedTx as PrefixedHexString),
+          {
+            common: opts?.common,
+          }
+        )
         txs.push(tx)
       } catch (error) {
         const validationError = `Invalid tx at index ${index}: ${error}`
         throw validationError
       }
     }
 
+    const reqRoot = requestsRoot === null ? undefined : requestsRoot
     const transactionsTrie = await Block.genTransactionsTrieRoot(
       txs,
       new Trie({ common: opts?.common })
@@ -360,12 +464,17 @@ export class Block {
       : undefined
     const header: HeaderData = {
       ...payload,
+      //@ts-ignore
       number,
+      //@ts-ignore
       receiptTrie,
       transactionsTrie,
       withdrawalsRoot,
+      //@ts-ignore
       mixHash,
+      //@ts-ignore
       coinbase,
+      requestsRoot: reqRoot,
     }
 
     // we are not setting setHardfork as common is already set to the correct hf
@@ -380,7 +489,7 @@ export class Block {
       throw Error('Missing executionWitness for EIP-6800 activated executionPayload')
     }
     // Verify blockHash matches payload
-    if (!equalsBytes(block.hash(), hexToBytes(payload.blockHash))) {
+    if (!equalsBytes(block.hash(), hexToBytes(payload.blockHash as PrefixedHexString))) {
       const validationError = `Invalid blockHash, expected: ${
         payload.blockHash
       }, received: ${bytesToHex(block.hash())}`
@@ -414,6 +523,8 @@ export class Block {
     uncleHeaders: BlockHeader[] = [],
     withdrawals?: Withdrawal[],
     opts: BlockOptions = {},
+    deposits?: Deposit[],
+    requests?: CLRequest[],
     executionWitness?: VerkleExecutionWitness | null
   ) {
     this.header = header ?? BlockHeader.fromHeaderData({}, opts)
@@ -422,7 +533,9 @@ export class Block {
 
     this.transactions = transactions
     this.withdrawals = withdrawals ?? (this.common.isActivatedEIP(4895) ? [] : undefined)
+    this.deposits = deposits ?? (this.common.isActivatedEIP(6110) ? [] : undefined)
     this.executionWitness = executionWitness
+    this.requests = requests ?? (this.common.isActivatedEIP(7685) ? [] : undefined)
     // null indicates an intentional absence of value or unavailability
     // undefined indicates that the executionWitness should be initialized with the default state
     if (this.common.isActivatedEIP(6800) && this.executionWitness === undefined) {
@@ -463,6 +576,10 @@ export class Block {
       throw new Error('Cannot have a withdrawals field if EIP 4895 is not active')
     }
 
+    if (!this.common.isActivatedEIP(6110) && deposits !== undefined) {
+      throw new Error('Cannot have a deposits field if EIP 6110 is not active')
+    }
+
     if (
       !this.common.isActivatedEIP(6800) &&
       executionWitness !== undefined &&
@@ -471,6 +588,18 @@ export class Block {
       throw new Error(`Cannot have executionWitness field if EIP 6800 is not active `)
     }
 
+    if (!this.common.isActivatedEIP(7685) && requests !== undefined) {
+      throw new Error(`Cannot have requests field if EIP 7685 is not active`)
+    }
+
+    // Requests should be sorted in monotonically ascending order based on type
+    // and whatever internal sorting logic is defined by each request type
+    if (requests !== undefined && requests.length > 1) {
+      for (let x = 1; x < requests.length; x++) {
+        if (requests[x].type < requests[x - 1].type)
+          throw new Error('requests are not sorted in ascending order')
+      }
+    }
     const freeze = opts?.freeze ?? true
     if (freeze) {
       Object.freeze(this)
@@ -492,6 +621,10 @@ export class Block {
     if (withdrawalsRaw) {
       bytesArray.push(withdrawalsRaw)
     }
+    const depositsRaw = this.deposits?.map((deposit) => deposit.raw())
+    if (depositsRaw) {
+      bytesArray.push(depositsRaw)
+    }
     if (this.executionWitness !== undefined && this.executionWitness !== null) {
       const executionWitnessBytes = RLP.encode(JSON.stringify(this.executionWitness))
       bytesArray.push(executionWitnessBytes as any)
@@ -546,6 +679,25 @@ export class Block {
     return result
   }
 
+  async requestsTrieIsValid(): Promise<boolean> {
+    if (!this.common.isActivatedEIP(7685)) {
+      throw new Error('EIP 7685 is not activated')
+    }
+
+    let result
+    if (this.requests!.length === 0) {
+      result = equalsBytes(this.header.requestsRoot!, KECCAK256_RLP)
+      return result
+    }
+
+    if (this.cache.requestsRoot === undefined) {
+      this.cache.requestsRoot = await Block.genRequestsTrieRoot(this.requests!)
+    }
+
+    result = equalsBytes(this.cache.requestsRoot, this.header.requestsRoot!)
+
+    return result
+  }
   /**
    * Validates transaction signatures and minimum gas requirements.
    * @returns {string[]} an array of error strings
@@ -559,7 +711,7 @@ export class Block {
     // eslint-disable-next-line prefer-const
     for (let [i, tx] of this.transactions.entries()) {
       const errs = tx.getValidationErrors()
-      if (this.common.isActivatedEIP(1559) === true) {
+      if (this.common.isActivatedEIP(1559)) {
         if (tx.supports(Capability.EIP1559FeeMarket)) {
           tx = tx as FeeMarketEIP1559Transaction
           if (tx.maxFeePerGas < this.header.baseFeePerGas!) {
@@ -572,7 +724,7 @@ export class Block {
           }
         }
       }
-      if (this.common.isActivatedEIP(4844) === true) {
+      if (this.common.isActivatedEIP(4844)) {
         if (tx instanceof BlobEIP4844Transaction) {
           blobGasUsed += BigInt(tx.numBlobs()) * blobGasPerBlob
           if (blobGasUsed > blobGasLimit) {
@@ -587,7 +739,7 @@ export class Block {
       }
     }
 
-    if (this.common.isActivatedEIP(4844) === true) {
+    if (this.common.isActivatedEIP(4844)) {
       if (blobGasUsed !== this.header.blobGasUsed) {
         errors.push(`invalid blobGasUsed expected=${this.header.blobGasUsed} actual=${blobGasUsed}`)
       }
@@ -755,6 +907,17 @@ export class Block {
     return result
   }
 
+  async depositsTrieIsValid(): Promise<boolean> {
+    if (!this.common.isActivatedEIP(6110)) {
+      throw new Error('EIP 6110 is not activated')
+    }
+    const depositsRoot = await Block.genDepositsTrieRoot(
+      this.deposits!,
+      new Trie({ common: this.common })
+    )
+    return equalsBytes(depositsRoot, this.header.depositsRoot!)
+  }
+
   /**
    * Consistency checks for uncles included in the block, if any.
    *
@@ -811,11 +974,18 @@ export class Block {
           withdrawals: this.withdrawals.map((wt) => wt.toJSON()),
         }
       : {}
+    const depositsAttr = this.deposits
+      ? {
+          deposits: this.deposits.map((deposit) => deposit.toJSON()),
+        }
+      : {}
     return {
       header: this.header.toJSON(),
       transactions: this.transactions.map((tx) => tx.toJSON()),
       uncleHeaders: this.uncleHeaders.map((uh) => uh.toJSON()),
+      requests: this.requests?.map((req) => bytesToHex(req.serialize())),
       ...withdrawalsAttr,
+      ...depositsAttr,
     }
   }