verkle: address merge conflicts and refactors

ethereumjs · Jul 11, 2024 · 1b6d696 · 1b6d696
1 parent 71924c4
commit 1b6d696
Show file tree

Hide file tree

Showing 6 changed files with 70 additions and 80 deletions.
diff --git a/packages/evm/src/opcodes/gas.ts b/packages/evm/src/opcodes/gas.ts
@@ -261,7 +261,7 @@ export const dynamicGasHandlers: Map<number, AsyncDynamicGasHandler | SyncDynami
           coldAccessGas += runState.env.accessWitness!.touchAddressOnReadAndComputeGas(
             codeAddress,
             0,
-            VERKLE_BASIC_DATA_LEAF_KEY
+            VERKLE_CODE_HASH_LEAF_KEY
           )
 
           gas += coldAccessGas

diff --git a/packages/statemanager/src/statelessVerkleStateManager.ts b/packages/statemanager/src/statelessVerkleStateManager.ts
@@ -4,9 +4,9 @@ import {
   KECCAK256_NULL_S,
   VerkleLeafType,
   bigIntToBytes,
-  bytesToBigInt,
   bytesToHex,
-  bytesToInt32,
+  decodeVerkleLeafBasicData,
+  encodeVerkleLeafBasicData,
   getVerkleKey,
   getVerkleStem,
   getVerkleTreeKeyForCodeChunk,
@@ -549,7 +549,9 @@ export class StatelessVerkleStateManager implements EVMStateManagerInterface {
       throw Error(errorMsg)
     }
 
-    const { version, balance, nonce, codeSize } = decodeLeafBasicData(hexToBytes(basicDataRaw))
+    const { version, balance, nonce, codeSize } = decodeVerkleLeafBasicData(
+      hexToBytes(basicDataRaw)
+    )
 
     const account = Account.fromPartialAccountData({
       version,
@@ -582,7 +584,7 @@ export class StatelessVerkleStateManager implements EVMStateManagerInterface {
     if (this._accountCacheSettings.deactivate) {
       const stem = getVerkleStem(this.verkleCrypto, address, 0)
       const basicDataKey = getVerkleKey(stem, VerkleLeafType.BasicData)
-      const basicDataBytes = encodeLeafBasicData({
+      const basicDataBytes = encodeVerkleLeafBasicData({
         version: account.version,
         balance: account.balance,
         nonce: account.nonce,

diff --git a/packages/util/src/verkle.ts b/packages/util/src/verkle.ts
@@ -1,5 +1,7 @@
 import {
   bigIntToBytes,
+  bytesToBigInt,
+  bytesToInt32,
   concatBytes,
   int32ToBytes,
   intToBytes,
@@ -124,6 +126,23 @@ export enum VerkleLeafType {
   CodeHash = 1,
 }
 
+export type VerkleLeafBasicData = {
+  version: number
+  nonce: bigint
+  balance: bigint
+  codeSize: number
+}
+
+export const VERKLE_VERSION_OFFSET = 0
+export const VERKLE_NONCE_OFFSET = 4
+export const VERKLE_CODE_SIZE_OFFSET = 12
+export const VERKLE_BALANCE_OFFSET = 16
+
+export const VERKLE_VERSION_BYTES_LENGTH = 1
+export const VERKLE_NONCE_BYTES_LENGTH = 8
+export const VERKLE_CODE_SIZE_BYTES_LENGTH = 4
+export const VERKLE_BALANCE_BYTES_LENGTH = 16
+
 export const VERKLE_BASIC_DATA_LEAF_KEY = intToBytes(VerkleLeafType.BasicData)
 export const VERKLE_CODE_HASH_LEAF_KEY = intToBytes(VerkleLeafType.CodeHash)
 
@@ -202,3 +221,46 @@ export const getVerkleTreeKeyForStorageSlot = async (
 
   return concatBytes(getVerkleStem(verkleCrypto, address, treeIndex), toBytes(subIndex))
 }
+
+export function decodeVerkleLeafBasicData(encodedBasicData: Uint8Array): VerkleLeafBasicData {
+  const versionBytes = encodedBasicData.slice(0, VERKLE_VERSION_BYTES_LENGTH)
+  const nonceBytes = encodedBasicData.slice(
+    VERKLE_NONCE_OFFSET,
+    VERKLE_NONCE_OFFSET + VERKLE_NONCE_BYTES_LENGTH
+  )
+  const codeSizeBytes = encodedBasicData.slice(
+    VERKLE_CODE_SIZE_OFFSET,
+    VERKLE_CODE_SIZE_OFFSET + VERKLE_CODE_SIZE_BYTES_LENGTH
+  )
+  const balanceBytes = encodedBasicData.slice(
+    VERKLE_BALANCE_OFFSET,
+    VERKLE_BALANCE_OFFSET + VERKLE_BALANCE_BYTES_LENGTH
+  )
+
+  const version = bytesToInt32(versionBytes, true)
+  const nonce = bytesToBigInt(nonceBytes, true)
+  const codeSize = bytesToInt32(codeSizeBytes, true)
+  const balance = bytesToBigInt(balanceBytes, true)
+
+  return { version, nonce, codeSize, balance }
+}
+
+export function encodeVerkleLeafBasicData(basicData: VerkleLeafBasicData): Uint8Array {
+  const encodedVersion = setLengthRight(
+    int32ToBytes(basicData.version, true),
+    VERKLE_VERSION_BYTES_LENGTH
+  )
+  const encodedNonce = setLengthRight(
+    bigIntToBytes(basicData.nonce, true),
+    VERKLE_NONCE_BYTES_LENGTH
+  )
+  const encodedCodeSize = setLengthRight(
+    int32ToBytes(basicData.codeSize, true),
+    VERKLE_CODE_SIZE_BYTES_LENGTH
+  )
+  const encodedBalance = setLengthRight(
+    bigIntToBytes(basicData.balance, true),
+    VERKLE_BALANCE_BYTES_LENGTH
+  )
+  return concatBytes(encodedVersion, encodedNonce, encodedCodeSize, encodedBalance)
+}
diff --git a/packages/verkle/src/constants.ts b/packages/verkle/src/constants.ts
diff --git a/packages/verkle/src/index.ts b/packages/verkle/src/index.ts
@@ -1,4 +1,3 @@
-export * from './constants.js'
 export * from './db/index.js'
 export * from './node/index.js'
 export * from './types.js'

diff --git a/packages/verkle/src/node/util.ts b/packages/verkle/src/node/util.ts
@@ -1,28 +1,10 @@
 import { RLP } from '@ethereumjs/rlp'
-import {
-  bigIntToBytes,
-  bytesToBigInt,
-  bytesToInt32,
-  concatBytes,
-  int32ToBytes,
-  setLengthRight,
-} from '@ethereumjs/util'
-
-import {
-  BALANCE_BYTES_LENGTH,
-  BALANCE_OFFSET,
-  CODE_SIZE_BYTES_LENGTH,
-  CODE_SIZE_OFFSET,
-  NONCE_BYTES_LENGTH,
-  NONCE_OFFSET,
-  VERSION_BYTES_LENGTH,
-} from '../constants.js'
+import { setLengthRight } from '@ethereumjs/util'
 
 import { InternalNode } from './internalNode.js'
 import { LeafNode } from './leafNode.js'
 import { VerkleLeafNodeValue, type VerkleNode, VerkleNodeType } from './types.js'
 
-import type { VerkleLeafBasicData } from '../types.js'
 import type { VerkleCrypto } from '@ethereumjs/util'
 
 export function decodeRawNode(raw: Uint8Array[], verkleCrypto: VerkleCrypto): VerkleNode {
@@ -113,34 +95,3 @@ export const createCValues = (values: (Uint8Array | VerkleLeafNodeValue)[]) => {
   }
   return expandedValues
 }
-
-export function decodeLeafBasicData(encodedBasicData: Uint8Array): VerkleLeafBasicData {
-  const versionBytes = encodedBasicData.slice(0, VERSION_BYTES_LENGTH)
-  const nonceBytes = encodedBasicData.slice(NONCE_OFFSET, NONCE_OFFSET + NONCE_BYTES_LENGTH)
-  const codeSizeBytes = encodedBasicData.slice(
-    CODE_SIZE_OFFSET,
-    CODE_SIZE_OFFSET + CODE_SIZE_BYTES_LENGTH
-  )
-  const balanceBytes = encodedBasicData.slice(BALANCE_OFFSET, BALANCE_OFFSET + BALANCE_BYTES_LENGTH)
-
-  const version = bytesToInt32(versionBytes, true)
-  const nonce = bytesToBigInt(nonceBytes, true)
-  const codeSize = bytesToInt32(codeSizeBytes, true)
-  const balance = bytesToBigInt(balanceBytes, true)
-
-  return { version, nonce, codeSize, balance }
-}
-
-export function encodeLeafBasicData(basicData: VerkleLeafBasicData): Uint8Array {
-  const encodedVersion = setLengthRight(int32ToBytes(basicData.version, true), VERSION_BYTES_LENGTH)
-  const encodedNonce = setLengthRight(bigIntToBytes(basicData.nonce, true), NONCE_BYTES_LENGTH)
-  const encodedCodeSize = setLengthRight(
-    int32ToBytes(basicData.codeSize, true),
-    CODE_SIZE_BYTES_LENGTH
-  )
-  const encodedBalance = setLengthRight(
-    bigIntToBytes(basicData.balance, true),
-    BALANCE_BYTES_LENGTH
-  )
-  return concatBytes(encodedVersion, encodedNonce, encodedCodeSize, encodedBalance)
-}