util: Add ssz roots capability for withdrawals hash tree root

packages/block/src/block.ts

@@ -11,6 +11,7 @@ import {
   bufferToHex,
   intToHex,
   isHexPrefixed,
+  ssz,
 } from '@ethereumjs/util'
 import { keccak256 } from 'ethereum-cryptography/keccak'
 import { ethers } from 'ethers'
@@ -52,6 +53,14 @@ export class Block {
     return trie.root()
   }
 
+  /**
+   * Returns the withdrawals ssz root for array of Withdrawal.
+   * @param wts array of Withdrawal to compute the root of
+   */
+  public static async genWithdrawalsSSZRoot(wts: Withdrawal[]) {
+    ssz.Withdrawals.hashTreeRoot(wts.map((wt) => wt.toValue()))
+  }
+
   /**
    * Returns the txs trie root for array of TypedTransaction
    * @param txs array of TypedTransaction to compute the root of

packages/util/karma.conf.js

@@ -8,6 +8,9 @@ module.exports = function (config) {
     karmaTypescriptConfig: {
       bundlerOptions: {
         entrypoints: /\.spec\.ts$/,
+        acornOptions: {
+          ecmaVersion: 11,
+        },
       },
       tsconfig: './tsconfig.json',
     },

packages/util/package.json

@@ -83,7 +83,8 @@
     "tsc": "../../config/cli/ts-compile.sh"
   },
   "dependencies": {
-    "@ethereumjs/rlp": "^4.0.0-beta.2",
+    "@chainsafe/ssz": "^0.10.0",
+    "@ethereumjs/rlp": "^4.0.0",
     "async": "^3.2.4",
     "ethereum-cryptography": "^1.1.2"
   },

packages/util/src/constants.ts

@@ -63,3 +63,5 @@ export const KECCAK256_RLP = Buffer.from(KECCAK256_RLP_S, 'hex')
  *  RLP encoded empty string
  */
 export const RLP_EMPTY_STRING = Buffer.from([0x80])
+
+export const MAX_WITHDRAWALS_PER_PAYLOAD = 16

packages/util/src/index.ts

@@ -33,6 +33,11 @@ export * from './signature'
  */
 export * from './bytes'
 
+/**
+ * SSZ containers
+ */
+export * as ssz from './ssz'
+
 /**
  * Helpful TypeScript types
  */

packages/util/src/ssz.ts

@@ -0,0 +1,24 @@
+import {
+  ByteVectorType,
+  ContainerType,
+  ListCompositeType,
+  UintBigintType,
+  UintNumberType,
+} from '@chainsafe/ssz'
+
+import { MAX_WITHDRAWALS_PER_PAYLOAD } from './constants'
+
+export const UintNum64 = new UintNumberType(8)
+export const UintBn64 = new UintBigintType(8)
+export const Bytes20 = new ByteVectorType(20)
+
+export const Withdrawal = new ContainerType(
+  {
+    index: UintBn64,
+    validatorIndex: UintBn64,
+    address: Bytes20,
+    amount: UintBn64,
+  },
+  { typeName: 'Withdrawal', jsonCase: 'eth2' }
+)
+export const Withdrawals = new ListCompositeType(Withdrawal, MAX_WITHDRAWALS_PER_PAYLOAD)

packages/util/src/withdrawal.ts

@@ -103,6 +103,15 @@ export class Withdrawal {
     return Withdrawal.toBufferArray(this)
   }
 
+  toValue() {
+    return {
+      index: this.index,
+      validatorIndex: this.validatorIndex,
+      address: this.address.buf,
+      amount: this.amount,
+    }
+  }
+
   toJSON() {
     return {
       index: bigIntToHex(this.index),

packages/util/test/ssz.spec.ts

@@ -0,0 +1,94 @@
+import * as tape from 'tape'
+
+import { Withdrawal, ssz } from '../src'
+const withdrawalsData = [
+  {
+    index: BigInt(0),
+    validatorIndex: BigInt(65535),
+    address: Buffer.from('0000000000000000000000000000000000000000', 'hex'),
+    amount: BigInt('0'),
+  },
+  {
+    index: BigInt(1),
+    validatorIndex: BigInt(65536),
+    address: Buffer.from('0100000000000000000000000000000000000000', 'hex'),
+    amount: BigInt('04523128485832663883'),
+  },
+  {
+    index: BigInt(2),
+    validatorIndex: BigInt(65537),
+    address: Buffer.from('0200000000000000000000000000000000000000', 'hex'),
+    amount: BigInt('09046256971665327767'),
+  },
+  {
+    index: BigInt(4),
+    validatorIndex: BigInt(65538),
+    address: Buffer.from('0300000000000000000000000000000000000000', 'hex'),
+    amount: BigInt('13569385457497991651'),
+  },
+  {
+    index: BigInt(4),
+    validatorIndex: BigInt(65539),
+    address: Buffer.from('0400000000000000000000000000000000000000', 'hex'),
+    amount: BigInt('18446744073709551615'),
+  },
+  {
+    index: BigInt(5),
+    validatorIndex: BigInt(65540),
+    address: Buffer.from('0500000000000000000000000000000000000000', 'hex'),
+    amount: BigInt('02261564242916331941'),
+  },
+  {
+    index: BigInt(6),
+    validatorIndex: BigInt(65541),
+    address: Buffer.from('0600000000000000000000000000000000000000', 'hex'),
+    amount: BigInt('02713877091499598330'),
+  },
+  {
+    index: BigInt(7),
+    validatorIndex: BigInt(65542),
+    address: Buffer.from('0700000000000000000000000000000000000000', 'hex'),
+    amount: BigInt('03166189940082864718'),
+  },
+]
+
+tape('ssz', (t) => {
+  t.test('withdrawals', (st) => {
+    const withdrawals = withdrawalsData.map((wt) => Withdrawal.fromWithdrawalData(wt))
+    const withdrawalsValue = withdrawals.map((wt) => wt.toValue())
+    const sszValues = ssz.Withdrawals.toViewDU(withdrawalsData)
+      .toValue()
+      .map((wt) => {
+        wt.address = Buffer.from(wt.address)
+        return wt
+      })
+    st.deepEqual(sszValues, withdrawalsValue, 'sszValues should be same as withdrawalsValue')
+    const withdrawalsRoot = ssz.Withdrawals.hashTreeRoot(withdrawalsValue)
+    st.equal(
+      Buffer.from(withdrawalsRoot).toString('hex'),
+      'bd97f65e513f870484e85927510acb291fcfb3e593c05ab7f21f206921264946',
+      'ssz root should match'
+    )
+    st.end()
+  })
+
+  const specWithdrawals = [
+    // https://github.com/ethereum/consensus-spec-tests/tree/v1.3.0-rc.1/tests/mainnet/capella/ssz_static/Withdrawal/ssz_random/case_0
+    {
+      index: BigInt('17107150653359250726'),
+      validatorIndex: BigInt('1906681273455760070'),
+      address: Buffer.from('02ab1379b6334b58df82c85d50ff1214663cba20', 'hex'),
+      amount: BigInt('5055030296454530815'),
+    },
+  ]
+
+  t.test('match spec v1.3.0-rc.1', (st) => {
+    const withdrawalsRoot = ssz.Withdrawal.hashTreeRoot(specWithdrawals[0])
+    st.equal(
+      Buffer.from(withdrawalsRoot).toString('hex'),
+      'ed9cec6fb8ee22b146059d02c38940cca1dd22a00d0132b000999b983fceff95',
+      'ssz root should match'
+    )
+    st.end()
+  })
+})

packages/util/test/withdrawal.spec.ts

@@ -83,12 +83,18 @@ tape('Withdrawal', (t) => {
     st.end()
   })
 
-  t.test('fromValuesArray and toJSON', (st) => {
+  t.test('fromValuesArray, toJSON and toValue', (st) => {
     const withdrawals = (gethWithdrawalsBuffer as WithdrawalBuffer[]).map(
       Withdrawal.fromValuesArray
     )
     const withdrawalsJson = withdrawals.map((wt) => wt.toJSON())
     st.deepEqual(withdrawalsGethVector, withdrawalsJson, 'Withdrawals json should match')
+
+    const withdrawalsValue = withdrawals.map((wt) => wt.toValue())
+    st.deepEqual(
+      withdrawalsValue.map((wt) => `0x${wt.address.toString('hex')}`),
+      withdrawalsJson.map((wt) => wt.address)
+    )
     st.end()
   })
 })