lint

Author: acolytec3

packages/statemanager/src/statelessVerkleStateManager.ts

@@ -332,7 +332,7 @@ export class StatelessVerkleStateManager implements EVMStateManagerInterface {
 
   async getTreeKeyForCodeChunk(address: Address, chunkId: number) {
     const { treeIndex, subIndex } = getTreeIndicesForCodeChunk(chunkId)
-    return getKey(await getStem(this.verkleCrypto, address, treeIndex), toBytes(subIndex))
+    return getKey(getStem(this.verkleCrypto, address, treeIndex), toBytes(subIndex))
   }
 
   chunkifyCode(code: Uint8Array) {
@@ -348,7 +348,7 @@ export class StatelessVerkleStateManager implements EVMStateManagerInterface {
   async getTreeKeyForStorageSlot(address: Address, storageKey: bigint) {
     const { treeIndex, subIndex } = getTreeIndexesForStorageSlot(storageKey)
 
-    return getKey(await getStem(this.verkleCrypto, address, treeIndex), toBytes(subIndex))
+    return getKey(getStem(this.verkleCrypto, address, treeIndex), toBytes(subIndex))
   }
 
   async checkChunkWitnessPresent(address: Address, codeOffset: number) {
@@ -419,7 +419,7 @@ export class StatelessVerkleStateManager implements EVMStateManagerInterface {
     }
 
     // Get the contract code size
-    const codeSizeKey = this.getTreeKeyForCodeSize(await getStem(this.verkleCrypto, address, 0))
+    const codeSizeKey = this.getTreeKeyForCodeSize(getStem(this.verkleCrypto, address, 0))
     const codeSizeLE = hexToBytes(this._state[bytesToHex(codeSizeKey)] ?? '0x')
     const codeSize = bytesToInt32(codeSizeLE, true)
     // allocate the code and copy onto it from the available witness chunks
@@ -531,7 +531,7 @@ export class StatelessVerkleStateManager implements EVMStateManagerInterface {
    * @param address -  Address to clear the storage of
    */
   async clearContractStorage(address: Address): Promise<void> {
-    const stem = await getStem(this.verkleCrypto, address, 0)
+    const stem = getStem(this.verkleCrypto, address, 0)
     const codeHashKey = this.getTreeKeyForCodeHash(stem)
     this._storageCache?.clearContractStorage(address)
     // Update codeHash to `c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470`
@@ -550,7 +550,7 @@ export class StatelessVerkleStateManager implements EVMStateManagerInterface {
       }
     }
 
-    const stem = await getStem(this.verkleCrypto, address, 0)
+    const stem = getStem(this.verkleCrypto, address, 0)
     const versionKey = this.getTreeKeyForVersion(stem)
     const balanceKey = this.getTreeKeyForBalance(stem)
     const nonceKey = this.getTreeKeyForNonce(stem)
@@ -637,7 +637,7 @@ export class StatelessVerkleStateManager implements EVMStateManagerInterface {
     }
 
     if (this._accountCacheSettings.deactivate) {
-      const stem = await getStem(this.verkleCrypto, address, 0)
+      const stem = getStem(this.verkleCrypto, address, 0)
       const balanceKey = this.getTreeKeyForBalance(stem)
       const nonceKey = this.getTreeKeyForNonce(stem)
       const codeHashKey = this.getTreeKeyForCodeHash(stem)

packages/statemanager/test/statelessVerkleStateManager.spec.ts

@@ -106,7 +106,7 @@ describe('StatelessVerkleStateManager: Kaustinen Verkle Block', () => {
     stateManager.initVerkleExecutionWitness(block.header.number, block.executionWitness)
 
     const address = Address.fromString('0x9791ded6e5d3d5dafca71bb7bb2a14187d17e32e')
-    const stem = await getStem(stateManager.verkleCrypto, address, 0)
+    const stem = getStem(stateManager.verkleCrypto, address, 0)
 
     const balanceKey = stateManager.getTreeKeyForBalance(stem)
     const nonceKey = stateManager.getTreeKeyForNonce(stem)

packages/verkle/test/crypto.spec.ts

@@ -12,20 +12,16 @@ describe('Verkle cryptographic helpers', () => {
     verkle = await loadVerkleCrypto()
   })
 
-  it('getStem(): returns the expected stems', async () => {
+  it('getStem(): returns the expected stems', () => {
     // Empty address
     assert.equal(
-      bytesToHex(
-        await getStem(verkle, Address.fromString('0x0000000000000000000000000000000000000000'))
-      ),
+      bytesToHex(getStem(verkle, Address.fromString('0x0000000000000000000000000000000000000000'))),
       '0xbf101a6e1c8e83c11bd203a582c7981b91097ec55cbd344ce09005c1f26d19'
     )
 
     // Non-empty address
     assert.equal(
-      bytesToHex(
-        await getStem(verkle, Address.fromString('0x71562b71999873DB5b286dF957af199Ec94617f7'))
-      ),
+      bytesToHex(getStem(verkle, Address.fromString('0x71562b71999873DB5b286dF957af199Ec94617f7'))),
       '0x274cde18dd9dbb04caf16ad5ee969c19fe6ca764d5688b5e1d419f4ac6cd16'
     )
   })

packages/vm/src/runBlock.ts

@@ -456,9 +456,8 @@ export async function accumulateParentBlockHash(
   async function putBlockHash(vm: VM, hash: Uint8Array, number: bigint) {
     // generate access witness
     if (vm.common.isActivatedEIP(6800) === true) {
-      const { treeIndex, subIndex } = getTreeIndexesForStorageSlot(number)
-      // just create access witnesses without charging for the gas
-      await (
+      const { treeIndex, subIndex } = getTreeIndexesForStorageSlot(number)(
+        // just create access witnesses without charging for the gas
         vm.stateManager as StatelessVerkleStateManager
       ).accessWitness!.touchAddressOnWriteAndComputeGas(historyAddress, treeIndex, subIndex)
     }
@@ -681,7 +680,7 @@ export async function rewardAccount(
   let account = await evm.stateManager.getAccount(address)
   if (account === undefined) {
     if (common?.isActivatedEIP(6800) === true) {
-      await (
+      ;(
         evm.stateManager as StatelessVerkleStateManager
       ).accessWitness!.touchAndChargeProofOfAbsence(address)
     }
@@ -692,9 +691,10 @@ export async function rewardAccount(
 
   if (common?.isActivatedEIP(6800) === true) {
     // use this utility to build access but the computed gas is not charged and hence free
-    await (
-      evm.stateManager as StatelessVerkleStateManager
-    ).accessWitness!.touchTxExistingAndComputeGas(address, { sendsValue: true })
+    ;(evm.stateManager as StatelessVerkleStateManager).accessWitness!.touchTxExistingAndComputeGas(
+      address,
+      { sendsValue: true }
+    )
   }
   return account
 }

packages/vm/src/runTx.ts

@@ -327,14 +327,14 @@ async function _runTx(this: VM, opts: RunTxOpts): Promise<RunTxResult> {
 
   let upfrontAwGas = BIGINT_0
   if (this.common.isActivatedEIP(6800)) {
-    upfrontAwGas += await txAccesses!.touchTxOriginAndComputeGas(caller)
+    upfrontAwGas += txAccesses!.touchTxOriginAndComputeGas(caller)
     const sendsValue = tx.value !== BIGINT_0
     if (tx.to !== undefined) {
-      upfrontAwGas += await txAccesses!.touchTxExistingAndComputeGas(tx.to, { sendsValue })
+      upfrontAwGas += txAccesses!.touchTxExistingAndComputeGas(tx.to, { sendsValue })
       debug(`Sender upfront awGas requirement for non contract creation tx is ${upfrontAwGas}`)
     } else {
       const contractTo = new Address(generateAddress(caller.bytes, bigIntToBytes(nonce)))
-      upfrontAwGas += await txAccesses!.touchAndChargeContractCreateInit(contractTo, { sendsValue })
+      upfrontAwGas += txAccesses!.touchAndChargeContractCreateInit(contractTo, { sendsValue })
       debug(
         `Sender upfront awGas requirement is contract creation at=${short(
           contractTo.bytes
@@ -600,9 +600,7 @@ async function _runTx(this: VM, opts: RunTxOpts): Promise<RunTxResult> {
   let minerAccount = await state.getAccount(miner)
   if (minerAccount === undefined) {
     if (this.common.isActivatedEIP(6800)) {
-      await (state as StatelessVerkleStateManager).accessWitness!.touchAndChargeProofOfAbsence(
-        miner
-      )
+      ;(state as StatelessVerkleStateManager).accessWitness!.touchAndChargeProofOfAbsence(miner)
     }
     minerAccount = new Account()
   }
@@ -615,12 +613,9 @@ async function _runTx(this: VM, opts: RunTxOpts): Promise<RunTxResult> {
 
   if (this.common.isActivatedEIP(6800)) {
     // use this utility to build access but the computed gas is not charged and hence free
-    await (state as StatelessVerkleStateManager).accessWitness!.touchTxExistingAndComputeGas(
-      miner,
-      {
-        sendsValue: true,
-      }
-    )
+    ;(state as StatelessVerkleStateManager).accessWitness!.touchTxExistingAndComputeGas(miner, {
+      sendsValue: true,
+    })
   }
 
   // Put the miner account into the state. If the balance of the miner account remains zero, note that