Convert trace to ssz container

Author: acolytec3

packages/evm/src/precompiles/12-execute.ts

@@ -7,6 +7,7 @@ import {
   hexToBytes,
 } from '@ethereumjs/util'
 import { createVerkleTree } from '@ethereumjs/verkle'
+import * as ssz from 'micro-eth-signer/ssz'
 
 import { createEVM } from '../constructors.js'
 import { EvmErrorResult, OOGResult } from '../evm.js'
@@ -22,6 +23,56 @@ import type { ExecResult } from '../types.js'
 import type { PrecompileInput } from './types.js'
 import type { VerkleExecutionWitness } from '@ethereumjs/util'
 
+const MAX_CALL_DATA_SIZE = 7500000 // Assuming a transaction with all zero bytes fills up an entire block worth of gas
+export const traceContainer = ssz.container({
+  txs: ssz.list(
+    256,
+    ssz.container({
+      to: ssz.bytevector(20),
+      from: ssz.bytevector(20),
+      gasLimit: ssz.uint64,
+      gasPrice: ssz.uint64,
+      value: ssz.uint64,
+      data: ssz.bytelist(MAX_CALL_DATA_SIZE),
+    }),
+  ),
+  witness: ssz.container({
+    stateDiff: ssz.list(
+      256,
+      ssz.container({
+        stem: ssz.bytevector(31),
+        suffixDiffs: ssz.list(
+          256,
+          ssz.container({
+            suffix: ssz.uint64,
+            currentValue: ssz.bytevector(32),
+            newValue: ssz.bytevector(32),
+          }),
+        ),
+      }),
+    ),
+    parentStateRoot: ssz.bytevector(32),
+  }),
+})
+
+export const executionWitnessJSONToSSZ = (witness: VerkleExecutionWitness) => {
+  return {
+    stateDiff: witness.stateDiff.map((diff) => ({
+      stem: hexToBytes(diff.stem),
+      suffixDiffs: diff.suffixDiffs.map((suffixDiff) => ({
+        suffix: BigInt(suffixDiff.suffix),
+        currentValue:
+          suffixDiff.currentValue !== null
+            ? hexToBytes(suffixDiff.currentValue)
+            : new Uint8Array(32),
+        newValue:
+          suffixDiff.newValue !== null ? hexToBytes(suffixDiff.newValue) : new Uint8Array(32),
+      })),
+    })),
+    parentStateRoot: hexToBytes(witness.parentStateRoot),
+  }
+}
+
 export async function precompile12(opts: PrecompileInput): Promise<ExecResult> {
   const pName = getPrecompileName('12')
   const data = opts.data
@@ -43,15 +94,15 @@ export async function precompile12(opts: PrecompileInput): Promise<ExecResult> {
     return EvmErrorResult(new EvmError(ERROR.REVERT), opts.gasLimit)
   }
 
-  const decodedTrace = JSON.parse(new TextDecoder().decode(traceBlob))
+  const decodedTrace = traceContainer.decode(traceBlob)
 
   if (decodedTrace.txs === undefined || decodedTrace.witness === undefined) {
     opts._debug?.(`${pName} error - trace is invalid`)
     return EvmErrorResult(new EvmError(ERROR.REVERT), opts.gasLimit)
   }
   const executeGasUsed = bytesToBigInt(data.subarray(96))
 
-  const witness = decodedTrace.witness as VerkleExecutionWitness
+  const witness = decodedTrace.witness
   const tree = await createVerkleTree({ verkleCrypto: opts.common.customCrypto.verkle })
 
   // Populate the L2 state trie with the prestate
@@ -61,10 +112,10 @@ export async function precompile12(opts: PrecompileInput): Promise<ExecResult> {
     for (const diff of stateDiff.suffixDiffs) {
       if (diff.currentValue !== null) {
         suffixes.push(Number(diff.suffix))
-        values.push(hexToBytes(diff.currentValue))
+        values.push(diff.currentValue)
       }
     }
-    const stem = hexToBytes(stateDiff.stem)
+    const stem = stateDiff.stem
     await tree.put(stem, suffixes, values)
   }
   const executionResult = true
@@ -83,12 +134,12 @@ export async function precompile12(opts: PrecompileInput): Promise<ExecResult> {
   // Run each transaction in the trace
   for (const tx of decodedTrace.txs) {
     const res = await l2EVM.runCall({
-      to: createAddressFromString(tx.to),
-      caller: createAddressFromString(tx.from),
+      to: createAddressFromString(bytesToHex(tx.to)),
+      caller: createAddressFromString(bytesToHex(tx.from)),
       gasLimit: BigInt(tx.gasLimit),
       gasPrice: BigInt(tx.gasPrice),
       value: BigInt(tx.value),
-      data: tx.data !== undefined ? hexToBytes(tx.data) : undefined,
+      data: tx.data !== undefined ? tx.data : undefined,
     })
     computedGasUsed += res.execResult.executionGasUsed
   }

packages/evm/test/precompiles/12-execute.spec.ts

@@ -21,6 +21,7 @@ import {
   generateExecutionWitness,
   getActivePrecompiles,
 } from '../../src/index.js'
+import { executionWitnessJSONToSSZ, traceContainer } from '../../src/precompiles/12-execute.js'
 
 describe('Precompiles: EXECUTE', () => {
   it('should execute a trace', async () => {
@@ -39,11 +40,12 @@ describe('Precompiles: EXECUTE', () => {
       hexToBytes('0xaeb51ceb07e4f6761ea6ad9a772d0e4a70367020fd6175b5e271d0d12e37d24d'),
     )
     const tx = {
-      to: receiver.toString(),
-      from: address.toString(),
-      gasLimit: '0xffffffffff',
-      gasPrice: '0x1',
-      value: '0x1',
+      to: receiver.toBytes(),
+      from: address.toBytes(),
+      gasLimit: BigInt('0xffffffffff'),
+      gasPrice: BigInt('0x1'),
+      value: BigInt('0x1'),
+      data: new Uint8Array(),
     }
     const tree = await createVerkleTree({ verkleCrypto: verkle })
     const stateManager = new StatefulVerkleStateManager({ common, trie: tree })
@@ -60,9 +62,9 @@ describe('Precompiles: EXECUTE', () => {
     const res = await evm.runCall({
       to: receiver,
       caller: address,
-      gasLimit: BigInt(tx.gasLimit),
-      gasPrice: BigInt(tx.gasPrice),
-      value: BigInt(tx.value),
+      gasLimit: tx.gasLimit,
+      gasPrice: tx.gasPrice,
+      value: tx.value,
     })
     const executionGasUsed = res.execResult.executionGasUsed
     const postStateRoot = tree.root()
@@ -76,15 +78,15 @@ describe('Precompiles: EXECUTE', () => {
 
     // Create a trace
     const trace = {
-      witness: execWitness,
+      witness: executionWitnessJSONToSSZ(execWitness),
       txs: [tx],
     }
-    // TODO: Replace this with proper serialization
-    const bytes = new TextEncoder().encode(JSON.stringify(trace))
+    const traceBytes = traceContainer.encode(trace)
+
     // We use the hash as a reference to the trace.  This should be replaced with a proper blob commitment (or versionedHash)
     // and the data should be stored as a proper Ethereum blob
-    const hash = bytesToHex(sha256(bytes))
-    evm['executionBlobs'].set(hash, bytes)
+    const hash = bytesToHex(sha256(traceBytes))
+    evm['executionBlobs'].set(hash, traceBytes)
 
     const addressStr = '0000000000000000000000000000000000000012'
     const EXECUTE = getActivePrecompiles(common).get(addressStr)!