conver static only classes to functions

Author: ScottyPoi

packages/portalnetwork/src/networks/state/manager.ts

@@ -6,7 +6,7 @@ import { ContentLookup } from '../contentLookup.js'
 
 import { PortalTrie } from './portalTrie.js'
 import { ContractRetrieval } from './types.js'
-import { ContractCodeContentKey } from './util.js'
+import { encodeContractCodeContentKey } from './util.js'
 
 import type { StateNetwork } from './state.js'
 
@@ -55,7 +55,7 @@ export class StateManager {
       return undefined
     }
     const addressHash = new Trie({ useKeyHashing: true })['hash'](address)
-    const contentKey = ContractCodeContentKey.encode({ codeHash, addressHash })
+    const contentKey = encodeContractCodeContentKey({ codeHash, addressHash })
     const codeLookup = new ContentLookup(this.state, contentKey)
     const response = await codeLookup.startLookup()
     if (response && 'content' in response) {

packages/portalnetwork/src/networks/state/portalTrie.ts

@@ -7,7 +7,12 @@ import { ContentLookup } from '../contentLookup.js'
 import { addressToNibbles, packNibbles, unpackNibbles } from './nibbleEncoding.js'
 import { PortalTrieDB } from './portalTrieDB.js'
 import { AccountTrieNodeRetrieval, StorageTrieNodeRetrieval } from './types.js'
-import { AccountTrieNodeContentKey, StorageTrieNodeContentKey } from './util.js'
+import {
+  decodeAccountTrieNodeContentKey,
+  decodeStorageTrieNodeContentKey,
+  encodeAccountTrieNodeContentKey,
+  encodeStorageTrieNodeContentKey,
+} from './util.js'
 
 import type { Path } from '@ethereumjs/mpt'
 import type { Debugger } from 'debug'
@@ -26,7 +31,7 @@ export class PortalTrie {
   async lookupAccountTrieNode(key: Uint8Array) {
     const lookup = new ContentLookup(this.state, key)
     const request = await lookup.startLookup()
-    const keyobj = AccountTrieNodeContentKey.decode(key)
+    const keyobj = decodeAccountTrieNodeContentKey(key)
     if (request === undefined || !('content' in request)) {
       throw new Error(
         `network doesn't have node [${unpackNibbles(keyobj.path)}]${bytesToHex(keyobj.nodeHash)}`,
@@ -38,7 +43,7 @@ export class PortalTrie {
   async lookupStorageTrieNode(key: Uint8Array) {
     const lookup = new ContentLookup(this.state, key)
     const request = await lookup.startLookup()
-    const keyobj = StorageTrieNodeContentKey.decode(key)
+    const keyobj = decodeStorageTrieNodeContentKey(key)
     if (request === undefined || !('content' in request)) {
       throw new Error(
         `network doesn't have node [${unpackNibbles(keyobj.path)}]${bytesToHex(keyobj.nodeHash)}`,
@@ -56,7 +61,7 @@ export class PortalTrie {
     const addressPath = addressToNibbles(address)
 
     // Find RootNode
-    const rootNodeKey = AccountTrieNodeContentKey.encode({
+    const rootNodeKey = encodeAccountTrieNodeContentKey({
       path: packNibbles([]),
       nodeHash: stateroot,
     })
@@ -115,7 +120,7 @@ export class PortalTrie {
       return { ...accountPath }
     }
     this.logger.extend('findPath')(`Looking for node: [${bytesToHex(nextNodeHash as Uint8Array)}]`)
-    const nextContentKey = AccountTrieNodeContentKey.encode({
+    const nextContentKey = encodeAccountTrieNodeContentKey({
       path: packNibbles(nodePath),
       nodeHash: nextNodeHash as Uint8Array,
     })
@@ -137,7 +142,7 @@ export class PortalTrie {
     const addressPath = addressToNibbles(slot)
 
     // Find RootNode
-    const rootNodeKey = StorageTrieNodeContentKey.encode({
+    const rootNodeKey = encodeStorageTrieNodeContentKey({
       path: packNibbles([]),
       nodeHash: storageRoot,
       addressHash: new Trie({ useKeyHashing: true })['hash'](address),
@@ -198,7 +203,7 @@ export class PortalTrie {
       return { ...contractPath }
     }
     this.logger.extend('findPath')(`Looking for node: [${bytesToHex(nextNodeHash as Uint8Array)}]`)
-    const nextContentKey = StorageTrieNodeContentKey.encode({
+    const nextContentKey = encodeStorageTrieNodeContentKey({
       path: packNibbles(nodePath),
       nodeHash: nextNodeHash as Uint8Array,
       addressHash: new Trie({ useKeyHashing: true })['hash'](address),

packages/portalnetwork/src/networks/state/state.ts

@@ -43,12 +43,14 @@ import {
 } from './types.js'
 import type { TNibbles } from './types.js'
 import {
-  AccountTrieNodeContentKey,
-  ContractCodeContentKey,
-  StateNetworkContentId,
-  StorageTrieNodeContentKey,
+  decodeAccountTrieNodeContentKey,
+  decodeContractCodeContentKey,
+  decodeStorageTrieNodeContentKey,
+  encodeAccountTrieNodeContentKey,
+  encodeStorageTrieNodeContentKey,
   extractAccountProof,
   nextOffer,
+  stateNetworkContentIdFromBytes,
 } from './util.js'
 
 export class StateNetwork extends BaseNetwork {
@@ -67,7 +69,7 @@ export class StateNetwork extends BaseNetwork {
   }
 
   public contentKeyToId = (contentKey: Uint8Array): string => {
-    return bytesToUnprefixedHex(StateNetworkContentId.fromBytes(contentKey))
+    return bytesToUnprefixedHex(stateNetworkContentIdFromBytes(contentKey))
   }
 
   /**
@@ -181,10 +183,10 @@ export class StateNetwork extends BaseNetwork {
         await this.gossipContent(contentKey, content)
       } else {
         if (contentType === StateNetworkContentType.AccountTrieNode) {
-          const { nodeHash } = AccountTrieNodeContentKey.decode(contentKey)
+          const { nodeHash } = decodeAccountTrieNodeContentKey(contentKey)
           this.manager.trie.db.local.set(bytesToUnprefixedHex(nodeHash), bytesToHex(contentKey))
         } else if (contentType === StateNetworkContentType.ContractTrieNode) {
-          const { nodeHash } = StorageTrieNodeContentKey.decode(contentKey)
+          const { nodeHash } = decodeStorageTrieNodeContentKey(contentKey)
           this.manager.trie.db.local.set(bytesToUnprefixedHex(nodeHash), bytesToHex(contentKey))
         }
         await this.db.put(contentKey, content)
@@ -202,7 +204,7 @@ export class StateNetwork extends BaseNetwork {
   ): Promise<{
     stored: number
   }> {
-    const { path } = AccountTrieNodeContentKey.decode(contentKey)
+    const { path } = decodeAccountTrieNodeContentKey(contentKey)
     const { proof, blockHash } = AccountTrieNodeOffer.deserialize(content)
     const interested = await this.storeInterestedAccountTrieNodes(path, proof)
     void this.forwardAccountTrieOffer(path, proof, blockHash)
@@ -235,11 +237,11 @@ export class StateNetwork extends BaseNetwork {
         `${i} Path: [${newpaths}] - ${curNode.constructor.name}: ${bytesToHex(nodeHash).slice(0, 8)}...`,
       )
       i++
-      const contentKey = AccountTrieNodeContentKey.encode({
+      const contentKey = encodeAccountTrieNodeContentKey({
         nodeHash,
         path: packNibbles(newpaths),
       })
-      const contentId = StateNetworkContentId.fromBytes(contentKey)
+      const contentId = stateNetworkContentIdFromBytes(contentKey)
       const in_radius = distance(bytesToUnprefixedHex(contentId), this.enr.nodeId) < this.nodeRadius
       if (in_radius) {
         const dbContent = AccountTrieNodeRetrieval.serialize({
@@ -264,7 +266,7 @@ export class StateNetwork extends BaseNetwork {
     const { nodes, newpaths } = nextOffer(path, proof)
     const content = AccountTrieNodeOffer.serialize({ blockHash, proof: [...nodes] })
     const nodeHash = new Trie({ useKeyHashing: true })['hash'](nodes[nodes.length - 1])
-    const contentKey = AccountTrieNodeContentKey.encode({
+    const contentKey = encodeAccountTrieNodeContentKey({
       nodeHash,
       path: packNibbles(newpaths),
     })
@@ -298,7 +300,7 @@ export class StateNetwork extends BaseNetwork {
   ): Promise<{
     stored: number
   }> {
-    const { addressHash, path } = StorageTrieNodeContentKey.decode(contentKey)
+    const { addressHash, path } = decodeStorageTrieNodeContentKey(contentKey)
     const { blockHash, accountProof, storageProof } = StorageTrieNodeOffer.deserialize(content)
     const interested = await this.storeInterestedStorageTrieNodes(path, storageProof, addressHash)
     await this.receiveAccountTrieNodeOffer(
@@ -339,12 +341,12 @@ export class StateNetwork extends BaseNetwork {
         `${i} Path: [${newpaths}] - ${curNode.constructor.name}: ${bytesToHex(nodeHash).slice(0, 8)}...`,
       )
       i++
-      const contentKey = StorageTrieNodeContentKey.encode({
+      const contentKey = encodeStorageTrieNodeContentKey({
         nodeHash,
         path: packNibbles(newpaths),
         addressHash,
       })
-      const contentId = StateNetworkContentId.fromBytes(contentKey)
+      const contentId = stateNetworkContentIdFromBytes(contentKey)
       const in_radius = distance(bytesToUnprefixedHex(contentId), this.enr.nodeId) < this.nodeRadius
       if (in_radius) {
         const dbContent = StorageTrieNodeRetrieval.serialize({
@@ -378,7 +380,7 @@ export class StateNetwork extends BaseNetwork {
       storageProof: [...nodes],
     })
     const nodeHash = new Trie({ useKeyHashing: true })['hash'](nodes[nodes.length - 1])
-    const contentKey = StorageTrieNodeContentKey.encode({
+    const contentKey = encodeStorageTrieNodeContentKey({
       nodeHash,
       path: packNibbles(newpaths),
       addressHash,
@@ -387,7 +389,7 @@ export class StateNetwork extends BaseNetwork {
     return { content, contentKey }
   }
   async receiveContractCodeOffer(contentKey: Uint8Array, content: Uint8Array) {
-    const { addressHash, codeHash } = ContractCodeContentKey.decode(contentKey)
+    const { addressHash, codeHash } = decodeContractCodeContentKey(contentKey)
     const { accountProof, blockHash, code } = ContractCodeOffer.deserialize(content)
     const codeContent = ContractRetrieval.serialize({ code })
     this.manager.trie.db.local.set(bytesToUnprefixedHex(codeHash), bytesToHex(contentKey))

packages/portalnetwork/src/networks/state/util.ts

@@ -39,68 +39,80 @@ export const keyType = (contentKey: Uint8Array): StateNetworkContentType => {
       throw new Error(`Invalid content key type: ${contentKey[0]}`)
   }
 }
-export class AccountTrieNodeContentKey {
-  static encode({ path, nodeHash }: TAccountTrieNodeKey): Uint8Array {
-    const key = AccountTrieNodeKey.serialize({ path: Uint8Array.from(path), nodeHash })
-    return Uint8Array.from([0x20, ...key])
-  }
-  static decode(key: Uint8Array): TAccountTrieNodeKey {
-    return AccountTrieNodeKey.deserialize(key.slice(1))
-  }
+
+export function encodeAccountTrieNodeContentKey({
+  path,
+  nodeHash,
+}: TAccountTrieNodeKey): Uint8Array {
+  const key = AccountTrieNodeKey.serialize({ path: Uint8Array.from(path), nodeHash })
+  return Uint8Array.from([0x20, ...key])
 }
 
-export class StorageTrieNodeContentKey {
-  static encode({ addressHash, path, nodeHash }: TStorageTrieNodeKey): Uint8Array {
-    const key = StorageTrieNodeKey.serialize({ addressHash, path, nodeHash })
-    return Uint8Array.from([0x21, ...key])
-  }
-  static decode(key: Uint8Array): TStorageTrieNodeKey {
-    return StorageTrieNodeKey.deserialize(key.slice(1))
-  }
+export function decodeAccountTrieNodeContentKey(key: Uint8Array): TAccountTrieNodeKey {
+  return AccountTrieNodeKey.deserialize(key.slice(1))
 }
 
-export class ContractCodeContentKey {
-  static encode({ addressHash, codeHash }: TContractCodeKey): Uint8Array {
-    const key = ContractCodeKey.serialize({ addressHash, codeHash })
-    return Uint8Array.from([0x22, ...key])
-  }
-  static decode(key: Uint8Array): TContractCodeKey {
-    return ContractCodeKey.deserialize(key.slice(1))
-  }
+export function encodeStorageTrieNodeContentKey({
+  addressHash,
+  path,
+  nodeHash,
+}: TStorageTrieNodeKey): Uint8Array {
+  const key = StorageTrieNodeKey.serialize({ addressHash, path, nodeHash })
+  return Uint8Array.from([0x21, ...key])
+}
+
+export function decodeStorageTrieNodeContentKey(key: Uint8Array): TStorageTrieNodeKey {
+  return StorageTrieNodeKey.deserialize(key.slice(1))
+}
+
+export function encodeContractCodeContentKey({
+  addressHash,
+  codeHash,
+}: TContractCodeKey): Uint8Array {
+  const key = ContractCodeKey.serialize({ addressHash, codeHash })
+  return Uint8Array.from([0x22, ...key])
 }
+
+export function decodeContractCodeContentKey(key: Uint8Array): TContractCodeKey {
+  return ContractCodeKey.deserialize(key.slice(1))
+}
+
 export type TStateNetworkContentKey = TAccountTrieNodeKey | TStorageTrieNodeKey | TContractCodeKey
-export class StateNetworkContentKey {
-  static encode(opts: TAccountTrieNodeKey | TStorageTrieNodeKey | TContractCodeKey): Uint8Array {
-    if ('codeHash' in opts) {
-      return ContractCodeContentKey.encode(opts)
-    } else if ('addressHash' in opts) {
-      return StorageTrieNodeContentKey.encode(opts)
-    } else {
-      return AccountTrieNodeContentKey.encode(opts)
-    }
-  }
-  static decode(key: Uint8Array): TStateNetworkContentKey {
-    const type = keyType(key)
-    if (type === StateNetworkContentType.ContractByteCode) {
-      return ContractCodeContentKey.decode(key)
-    } else if (type === StateNetworkContentType.ContractTrieNode) {
-      return StorageTrieNodeContentKey.decode(key)
-    } else {
-      return AccountTrieNodeContentKey.decode(key)
-    }
+
+export function encodeStateNetworkContentKey(
+  opts: TAccountTrieNodeKey | TStorageTrieNodeKey | TContractCodeKey,
+): Uint8Array {
+  if ('codeHash' in opts) {
+    return encodeContractCodeContentKey(opts)
+  } else if ('addressHash' in opts) {
+    return encodeStorageTrieNodeContentKey(opts)
+  } else {
+    return encodeAccountTrieNodeContentKey(opts)
   }
 }
 
-export class StateNetworkContentId {
-  static fromKeyObj(key: TAccountTrieNodeKey | TStorageTrieNodeKey | TContractCodeKey): Uint8Array {
-    const bytes = StateNetworkContentKey.encode(key)
-    return sha256(bytes)
-  }
-  static fromBytes(key: Uint8Array): Uint8Array {
-    return sha256(key)
+export function decodeStateNetworkContentKey(key: Uint8Array): TStateNetworkContentKey {
+  const type = keyType(key)
+  if (type === StateNetworkContentType.ContractByteCode) {
+    return decodeContractCodeContentKey(key)
+  } else if (type === StateNetworkContentType.ContractTrieNode) {
+    return decodeStorageTrieNodeContentKey(key)
+  } else {
+    return decodeAccountTrieNodeContentKey(key)
   }
 }
 
+export function fromKeyObjToStateNetworkContentId(
+  key: TAccountTrieNodeKey | TStorageTrieNodeKey | TContractCodeKey,
+): Uint8Array {
+  const bytes = encodeStateNetworkContentKey(key)
+  return sha256(bytes)
+}
+
+export function stateNetworkContentIdFromBytes(key: Uint8Array): Uint8Array {
+  return sha256(key)
+}
+
 export function wrapDBContent(contentKey: Uint8Array, dbContent: string) {
   const keytype = keyType(contentKey)
   const dbBytes = hexToBytes(`0x${dbContent}`)
@@ -150,13 +162,13 @@ export function getDatabaseKey(contentKey: Uint8Array) {
   let dbKey = contentKey
   switch (type) {
     case StateNetworkContentType.AccountTrieNode:
-      dbKey = AccountTrieNodeContentKey.decode(contentKey).nodeHash
+      dbKey = decodeAccountTrieNodeContentKey(contentKey).nodeHash
       break
     case StateNetworkContentType.ContractTrieNode:
-      dbKey = StorageTrieNodeContentKey.decode(contentKey).nodeHash
+      dbKey = decodeStorageTrieNodeContentKey(contentKey).nodeHash
       break
     case StateNetworkContentType.ContractByteCode:
-      dbKey = ContractCodeContentKey.decode(contentKey).codeHash
+      dbKey = decodeContractCodeContentKey(contentKey).codeHash
       break
     default:
       break
@@ -225,7 +237,7 @@ export function extractAccountProof(
     blockHash,
     proof: accountProof,
   })
-  const accountTrieOfferKey = AccountTrieNodeContentKey.encode({
+  const accountTrieOfferKey = encodeAccountTrieNodeContentKey({
     nodeHash,
     path: packNibbles(nodePath),
   })