add and handle further modifications and flags to handle skeleton fun…

…ctionality

packages/blockchain/src/blockchain.ts

@@ -25,6 +25,7 @@ import {
 import { DBManager } from './db/manager.js'
 import { DBTarget } from './db/operation.js'
 
+import type { OptimisticOpts } from './db/operation.js'
 import type {
  BlockchainEvents,
  BlockchainInterface,
@@ -272,8 +273,8 @@ export class Blockchain implements BlockchainInterface {
  * heads/hashes are overwritten.
  * @param block - The block to be added to the blockchain
  */
- async putBlock(block: Block, optimistic: boolean = false) {
- await this._putBlockOrHeader(block, optimistic)
+ async putBlock(block: Block, opts?: OptimisticOpts) {
+ await this._putBlockOrHeader(block, opts)
  }
 
  /**
@@ -344,7 +345,7 @@ export class Blockchain implements BlockchainInterface {
  * header using the iterator method.
  * @hidden
  */
- private async _putBlockOrHeader(item: Block | BlockHeader, optimistic: boolean = false) {
+ private async _putBlockOrHeader(item: Block | BlockHeader, optimisticOpts?: OptimisticOpts) {
  await this.runWithLock<void>(async () => {
  // Save the current sane state incase _putBlockOrHeader midway with some
  // dirty changes in head trackers
@@ -362,13 +363,13 @@ export class Blockchain implements BlockchainInterface {
  if (isGenesis) {
  if (equalsBytes(this.genesisBlock.hash(), block.hash())) {
  // Try to re-put the existing genesis block, accept this
- optimistic = false
+ // genesis block is not optimistic
+ optimisticOpts = undefined
  return
  }
  throw new Error(
  'Cannot put a different genesis block than current blockchain genesis: create a new Blockchain',
  )
- // genesis block is not optimistic
  }
 
  if (block.common.chainId() !== this.common.chainId()) {
@@ -377,12 +378,12 @@ export class Blockchain implements BlockchainInterface {
  )
  }
 
- if (this._validateBlocks && !isGenesis && item instanceof Block) {
+ if (this._validateBlocks && !isGenesis && item instanceof Block && optimisticOpts === undefined) {
  // this calls into `getBlock`, which is why we cannot lock yet
  await this.validateBlock(block)
  }
 
- if (this._validateConsensus) {
+ if (this._validateConsensus && optimisticOpts === undefined) {
  await this.consensus!.validateConsensus(block)
  }
 
@@ -397,20 +398,20 @@ export class Blockchain implements BlockchainInterface {
  if (!block.isGenesis()) {
  td += parentTd
  }
- // since its linked its no more optimistic
- optimistic = false
  } catch (e) {
  // opimistic insertion does care about td
- if (!optimistic) {
+ if (optimisticOpts === undefined) {
  throw e
  }
  }
 
  let dbOps: DBOp[] = []
- if (optimistic) {
+ if (optimisticOpts !== undefined) {
  dbOps = dbOps.concat(DBSetBlockOrHeader(item))
  dbOps.push(DBSetHashToNumber(blockHash, blockNumber))
- dbOps.push(DBOp.set(DBTarget.OptimisticNumberToHash, blockHash, { blockNumber }))
+ if (optimisticOpts.fcUed) {
+ dbOps.push(DBOp.set(DBTarget.OptimisticNumberToHash, blockHash, { blockNumber }))
+ }
  await this.dbManager.batch(dbOps)
  } else {
  const currentTd = { header: BIGINT_0, block: BIGINT_0 }
@@ -676,13 +677,16 @@ export class Blockchain implements BlockchainInterface {
  * this will be immediately looked up, otherwise it will wait until we have
  * unlocked the DB
  */
- async getBlock(blockId: Uint8Array | number | bigint): Promise<Block> {
+ async getBlock(
+ blockId: Uint8Array | number | bigint,
+ optimisticOpts?: OptimisticOpts,
+ ): Promise<Block> {
  // cannot wait for a lock here: it is used both in `validate` of `Block`
  // (calls `getBlock` to get `parentHash`) it is also called from `runBlock`
  // in the `VM` if we encounter a `BLOCKHASH` opcode: then a bigint is used we
  // need to then read the block from the canonical chain Q: is this safe? We
  // know it is OK if we call it from the iterator... (runBlock)
- const block = await this.dbManager.getBlock(blockId)
+ const block = await this.dbManager.getBlock(blockId, optimisticOpts)
 
  if (block === undefined) {
  if (typeof blockId === 'object') {

packages/blockchain/src/db/manager.ts

@@ -12,7 +12,7 @@ import {
 import { Cache } from './cache.js'
 import { DBOp, DBTarget } from './operation.js'
 
-import type { DatabaseKey } from './operation.js'
+import type { DatabaseKey, OptimisticOpts } from './operation.js'
 import type { Block, BlockBodyBytes, BlockBytes, BlockOptions } from '@ethereumjs/block'
 import type { Common } from '@ethereumjs/common'
 import type { BatchDBOp, DB, DBObject, DelBatch, PutBatch } from '@ethereumjs/util'
@@ -47,6 +47,7 @@ export class DBManager {
  body: new Cache({ max: 256 }),
  numberToHash: new Cache({ max: 2048 }),
  hashToNumber: new Cache({ max: 2048 }),
+ optimisticNumberToHash: new Cache({ max: 2048 }),
  }
  }
 
@@ -86,7 +87,7 @@ export class DBManager {
  */
  async getBlock(
  blockId: Uint8Array | bigint | number,
- optimistic: boolean = false,
+ optimisticOpts?: OptimisticOpts,
  ): Promise<Block | undefined> {
  if (typeof blockId === 'number' && Number.isInteger(blockId)) {
  blockId = BigInt(blockId)
@@ -98,13 +99,30 @@ export class DBManager {
  if (blockId instanceof Uint8Array) {
  hash = blockId
  number = await this.hashToNumber(blockId)
+ if (number === undefined) {
+ return undefined
+ }
+
+ if (optimisticOpts?.fcUed === true) {
+ let optimisticHash = await this.optimisticNumberToHash(number)
+ if (optimisticHash === undefined && optimisticOpts.linked === true) {
+ optimisticHash = await this.numberToHash(number)
+ }
+ if (optimisticHash === undefined || !equalsBytes(optimisticHash, hash)) {
+ return undefined
+ }
+ }
  } else if (typeof blockId === 'bigint') {
  number = blockId
- if (optimistic) {
+ if (optimisticOpts !== undefined) {
+ if (!optimisticOpts.fcUed) {
+ throw Error(`Invalid fcUed optimistic block by number lookup`)
+ }
  hash = await this.optimisticNumberToHash(blockId)
- }
- // hash will be undefined if it no optimistic lookup was done or if that was not successful
- if (hash === undefined) {
+ if (hash === undefined && optimisticOpts.linked === true) {
+ hash = await this.numberToHash(blockId)
+ }
+ } else {
  hash = await this.numberToHash(blockId)
  }
  } else {

packages/blockchain/src/db/operation.ts

@@ -14,6 +14,8 @@ import {
 
 import type { CacheMap } from './manager.js'
 
+export type OptimisticOpts = { fcUed: boolean; linked?: boolean }
+
 export enum DBTarget {
  Heads,
  HeadHeader,

packages/blockchain/src/types.ts

@@ -1,3 +1,4 @@
+import type { OptimisticOpts } from './db/operation.js'
 import type { Blockchain } from './index.js'
 import type { Block, BlockHeader } from '@ethereumjs/block'
 import type { Common, ConsensusAlgorithm } from '@ethereumjs/common'
@@ -16,7 +17,7 @@ export interface BlockchainInterface {
  *
  * @param block - The block to be added to the blockchain.
  */
- putBlock(block: Block): Promise<void>
+ putBlock(block: Block, optimisticOpts?: OptimisticOpts): Promise<void>
 
  /**
  * Deletes a block from the blockchain. All child blocks in the chain are
@@ -29,7 +30,7 @@ export interface BlockchainInterface {
  /**
  * Returns a block by its hash or number.
  */
- getBlock(blockId: Uint8Array | number | bigint): Promise<Block>
+ getBlock(blockId: Uint8Array | number | bigint, optimisticOpts?: OptimisticOpts): Promise<Block>
 
  /**
  * Iterates through blocks starting at the specified iterator head and calls

packages/client/src/service/skeleton.ts

@@ -1362,21 +1362,7 @@ export class Skeleton extends MetaDBManager {
  */
  private async putBlock(block: Block, onlyUnfinalized: boolean = false): Promise<boolean> {
  // Serialize the block with its hardfork so that its easy to load the block latter
- const rlp = this.serialize({ hardfork: block.common.hardfork(), blockRLP: block.serialize() })
- await this.put(DBKey.SkeletonUnfinalizedBlockByHash, block.hash(), rlp)
-
- if (!onlyUnfinalized) {
- await this.put(DBKey.SkeletonBlock, bigIntToBytes(block.header.number), rlp)
- // this is duplication of the unfinalized blocks but for now an easy reference
- // will be pruned on finalization changes. this could be simplified and deduped
- // but will anyway will move into blockchain class and db on upcoming skeleton refactor
- await this.put(
- DBKey.SkeletonBlockHashToNumber,
- block.hash(),
- bigIntToBytes(block.header.number),
- )
- }
-
+ await this.chain.blockchain.putBlock(block, { fcUed: !onlyUnfinalized })
  return true
  }
 
@@ -1395,22 +1381,10 @@ export class Skeleton extends MetaDBManager {
  * Gets a block from the skeleton or canonical db by number.
  */
  async getBlock(number: bigint, onlyCanonical = false): Promise<Block | undefined> {
- try {
- const skeletonBlockRlp = await this.get(DBKey.SkeletonBlock, bigIntToBytes(number))
- if (skeletonBlockRlp === null) {
- throw Error(`SkeletonBlock rlp lookup failed for ${number} onlyCanonical=${onlyCanonical}`)
- }
- return this.skeletonBlockRlpToBlock(skeletonBlockRlp)
- } catch (error: any) {
- // If skeleton is linked, it probably has deleted the block and put it into the chain
- if (onlyCanonical && !this.status.linked) return undefined
- // As a fallback, try to get the block from the canonical chain in case it is available there
- try {
- return await this.chain.getBlock(number)
- } catch (error) {
- return undefined
- }
- }
+ return this.chain.blockchain.dbManager.getBlock(number, {
+ fcUed: onlyCanonical,
+ linked: this.status.linked,
+ })
  }
 
  /**
@@ -1420,63 +1394,17 @@ export class Skeleton extends MetaDBManager {
  hash: Uint8Array,
  onlyCanonical: boolean = false,
  ): Promise<Block | undefined> {
- const number = await this.get(DBKey.SkeletonBlockHashToNumber, hash)
- if (number) {
- const block = await this.getBlock(bytesToBigInt(number), onlyCanonical)
- if (block !== undefined && equalsBytes(block.hash(), hash)) {
- return block
- }
- }
-
- if (onlyCanonical === true && !this.status.linked) {
- return undefined
- }
-
- let block = onlyCanonical === false ? await this.getUnfinalizedBlock(hash) : undefined
- if (block === undefined && (onlyCanonical === false || this.status.linked)) {
- block = await this.chain.getBlock(hash).catch((_e) => undefined)
- }
-
- if (onlyCanonical === false) {
- return block
- } else {
- if (this.status.linked && block !== undefined) {
- const canBlock = await this.chain.getBlock(block.header.number).catch((_e) => undefined)
- if (canBlock !== undefined && equalsBytes(canBlock.hash(), block.hash())) {
- // block is canonical
- return block
- }
- }
-
- // no canonical block found or the block was not canonical
- return undefined
- }
- }
-
- async getUnfinalizedBlock(hash: Uint8Array): Promise<Block | undefined> {
- try {
- const skeletonBlockRlp = await this.get(DBKey.SkeletonUnfinalizedBlockByHash, hash)
- if (skeletonBlockRlp === null) {
- throw Error(`SkeletonUnfinalizedBlockByHash rlp lookup failed for hash=${short(hash)}`)
- }
- return this.skeletonBlockRlpToBlock(skeletonBlockRlp)
- } catch (_e) {
- return undefined
- }
+ return this.chain.blockchain.dbManager.getBlock(hash, {
+ fcUed: !onlyCanonical,
+ linked: this.status.linked,
+ })
  }
 
  /**
  * Deletes a skeleton block from the db by number
  */
- async deleteBlock(block: Block): Promise<boolean> {
- try {
- await this.delete(DBKey.SkeletonBlock, bigIntToBytes(block.header.number))
- await this.delete(DBKey.SkeletonBlockHashToNumber, block.hash())
- await this.delete(DBKey.SkeletonUnfinalizedBlockByHash, block.hash())
- return true
- } catch (error: any) {
- return false
- }
+ async deleteBlock(_block: Block): Promise<boolean> {
+ return true
  }
 
  /**