✅ Test: Add 100% test coverage to tevm/blockchain package

packages/blockchain/src/__snapshots__/createChain.spec.ts.snap

@@ -0,0 +1,3 @@
+// Bun Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`createChain should throw an error for invalid block header validation 1`] = `"header.isGenesis is not a function. (In 'header.isGenesis()', 'header.isGenesis' is undefined)"`;

packages/blockchain/src/actions/__snapshots__/validateHeader.spec.ts.snap

@@ -0,0 +1,9 @@
+// Bun Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`validateHeader should throw an error for invalid block number 1`] = `[TypeError: header.isGenesis is not a function. (In 'header.isGenesis()', 'header.isGenesis' is undefined)]`;
+
+exports[`validateHeader should throw an error for invalid timestamp 1`] = `[TypeError: header.isGenesis is not a function. (In 'header.isGenesis()', 'header.isGenesis' is undefined)]`;
+
+exports[`validateHeader should throw an error for unsupported consensus type 1`] = `"header.isGenesis is not a function. (In 'header.isGenesis()', 'header.isGenesis' is undefined)"`;
+
+exports[`validateHeader should throw an error for invalid timestamp diff (clique) 1`] = `"header.isGenesis is not a function. (In 'header.isGenesis()', 'header.isGenesis' is undefined)"`;

packages/blockchain/src/actions/deepCopy.spec.ts

@@ -0,0 +1,34 @@
+import { describe, expect, it } from 'bun:test'
+import { deepCopy } from './deepCopy.js'
+import { createBaseChain } from '../createBaseChain.js'
+import { optimism } from '@tevm/common'
+import { putBlock } from './putBlock.js'
+import { bytesToHex } from '@tevm/utils'
+import { getBlock } from './getBlock.js'
+import { getMockBlocks } from '../test/getBlocks.js'
+
+describe(deepCopy.name, async () => {
+	it('should deepCopy the chain', async () => {
+		const blocks = await getMockBlocks()
+		const chain = createBaseChain({
+			common: optimism.copy(),
+		})
+		await putBlock(chain)(blocks[0])
+		await putBlock(chain)(blocks[1])
+		await putBlock(chain)(blocks[2])
+		await putBlock(chain)(blocks[3])
+		const copy = await deepCopy(chain)()
+		expect(await getBlock(copy)(blocks[0].header.number)).toEqual(blocks[0])
+		expect(await getBlock(copy)(blocks[1].header.number)).toEqual(blocks[1])
+		expect(await getBlock(copy)(blocks[3].header.number)).toEqual(blocks[3])
+		expect(chain.blocksByTag.get('latest')).toEqual(blocks[3])
+		expect(chain.blocks.get(bytesToHex(blocks[0].hash()))).toEqual(blocks[0])
+		expect(chain.blocks.get(bytesToHex(blocks[1].hash()))).toEqual(blocks[1])
+		expect(chain.blocks.get(bytesToHex(blocks[2].hash()))).toEqual(blocks[2])
+		expect(chain.blocks.get(bytesToHex(blocks[3].hash()))).toEqual(blocks[3])
+		expect(chain.blocksByNumber.get(blocks[0].header.number)).toEqual(blocks[0])
+		expect(chain.blocksByNumber.get(blocks[1].header.number)).toEqual(blocks[1])
+		expect(chain.blocksByNumber.get(blocks[2].header.number)).toEqual(blocks[2])
+		expect(chain.blocksByNumber.get(blocks[3].header.number)).toEqual(blocks[3])
+	})
+})

packages/blockchain/src/actions/delBlock.js

@@ -1,11 +1,28 @@
 import { bytesToHex } from 'viem'
+import { getCanonicalHeadBlock } from './getCanonicalHeadBlock.js'
+import { getBlock } from './getBlock.js'
+import { InvalidBlockError } from '@tevm/errors'
 
 /**
+ * Deletes a block from the blockchain
  * @param {import('../BaseChain.js').BaseChain} baseChain
  * @returns {import('../Chain.js').Chain['delBlock']}
+ * @throws {InvalidBlockError} If the block is the `forked` block
  */
-export const delBlock = (baseChain) => (blockHash) => {
-	baseChain.blocks.delete(bytesToHex(blockHash))
+export const delBlock = (baseChain) => async (blockHash) => {
+	const block = await getBlock(baseChain)(blockHash)
+	const hexHash = bytesToHex(blockHash)
+
+	const latest = await getCanonicalHeadBlock(baseChain)()
+	const forkedBlock = baseChain.blocksByTag.get('forked')
+
+	if (forkedBlock && hexHash === bytesToHex(forkedBlock.hash())) {
+		throw new InvalidBlockError('Cannot delete the forked block!')
+	}
+	if (hexHash === bytesToHex(latest.hash())) {
+		baseChain.blocksByTag.set('latest', await getBlock(baseChain)(latest.header.parentHash))
+	}
+	baseChain.blocksByNumber.delete(block.header.number)
+	baseChain.blocks.delete(hexHash)
 	baseChain.logger.debug({ blockHash }, 'deleted block')
-	return Promise.resolve()
 }

packages/blockchain/src/actions/delBlock.spec.ts

@@ -0,0 +1,56 @@
+import { describe, expect, it } from 'bun:test'
+import { createBaseChain } from '../createBaseChain.js'
+import { optimism } from '@tevm/common'
+import { putBlock } from './putBlock.js'
+import { delBlock } from './delBlock.js'
+import { getMockBlocks } from '../test/getBlocks.js'
+import { bytesToHex } from 'viem'
+import { getCanonicalHeadBlock } from './getCanonicalHeadBlock.js'
+import { InvalidBlockError } from '@tevm/errors'
+
+describe(delBlock.name, async () => {
+	it('should delete block', async () => {
+		const chain = createBaseChain({
+			common: optimism.copy(),
+		})
+		const blocks = await getMockBlocks()
+		await putBlock(chain)(blocks[0])
+		await putBlock(chain)(blocks[1])
+		await putBlock(chain)(blocks[2])
+		await putBlock(chain)(blocks[3])
+
+		await delBlock(chain)(blocks[2].hash())
+
+		expect(chain.blocks.get(bytesToHex(blocks[2].hash()))).toBeUndefined()
+		expect(chain.blocksByNumber.get(blocks[2].header.number)).toBeUndefined()
+	})
+
+	it('should set latest to parent if we delete latest', async () => {
+		const chain = createBaseChain({
+			common: optimism.copy(),
+		})
+		const blocks = await getMockBlocks()
+		await putBlock(chain)(blocks[0])
+		await putBlock(chain)(blocks[1])
+		await putBlock(chain)(blocks[2])
+		await putBlock(chain)(blocks[3])
+
+		await delBlock(chain)(blocks[3].hash())
+
+		expect(await getCanonicalHeadBlock(chain)()).toBe(blocks[2])
+	})
+
+	it('should throw an InvalidBlockError if we attempt to delete the fork block', async () => {
+		const chain = createBaseChain({
+			common: optimism.copy(),
+		})
+		const blocks = await getMockBlocks()
+		await putBlock(chain)(blocks[0])
+		chain.blocksByTag.set('forked', blocks[0])
+
+		const error = await delBlock(chain)(blocks[0].hash()).then((e) => e)
+
+		expect(error).toBeInstanceOf(InvalidBlockError)
+		expect(error).toMatchSnapshot()
+	})
+})

packages/blockchain/src/actions/getBlock.js

@@ -1,6 +1,8 @@
 import { bytesToHex } from '@tevm/utils'
 import { getBlockFromRpc } from '../utils/getBlockFromRpc.js'
 import { putBlock } from './putBlock.js'
+import { UnknownBlockError } from '@tevm/errors'
+import { getCanonicalHeadBlock } from './getCanonicalHeadBlock.js'
 
 /**
  * @param {import('../BaseChain.js').BaseChain} baseChain
@@ -29,7 +31,7 @@ export const getBlock = (baseChain) => async (blockId) => {
 	}
 
 	if (!baseChain.options.fork?.transport) {
-		throw new Error(
+		throw new UnknownBlockError(
 			blockId instanceof Uint8Array
 				? `Block with hash ${bytesToHex(blockId)} does not exist`
 				: `Block number ${blockId} does not exist`,
@@ -48,15 +50,8 @@ export const getBlock = (baseChain) => async (blockId) => {
 
 	baseChain.logger.debug(fetchedBlock.header.toJSON(), 'Saving forked block to blockchain')
 
-	const forkedBlock = baseChain.blocksByTag.get('forked')
-	const latestBlock = baseChain.blocksByTag.get('latest')
-	if (!forkedBlock || !latestBlock) {
-		throw new Error('TevmInternalError: Expected forked and latest blocktags to exist in tevm blockchain')
-	}
-	if (fetchedBlock.header.number > latestBlock.header.number) {
-		throw new Error(`Current blockheight is ${latestBlock.header.number} and the fork block is ${forkedBlock.header.number}. The block requested has height of ${fetchedBlock.header.number}.
-Fetching blocks from future of the current block is not allowed`)
-	}
+	const forkedBlock = /** @type {import('@tevm/block').Block}*/ (baseChain.blocksByTag.get('forked'))
+	const latestBlock = await getCanonicalHeadBlock(baseChain)()
 	if (fetchedBlock.header.number > forkedBlock.header.number) {
 		throw new Error(`The fetched block ${fetchedBlock.header.number} has a higher block height than the forked block ${forkedBlock.header.number} but less than the latest block ${latestBlock.header.number}
 This could indicate a bug in tevm as it implies a block is missing if the internal chain tried fetching it from rpc

packages/blockchain/src/actions/getBlock.spec.ts

@@ -0,0 +1,81 @@
+import { describe, expect, it } from 'bun:test'
+import { getBlock } from './getBlock.js'
+import { createBaseChain } from '../createBaseChain.js'
+import { mainnet } from '@tevm/common'
+import { putBlock } from './putBlock.js'
+import { getMockBlocks } from '../test/getBlocks.js'
+import { UnknownBlockError } from '@tevm/errors'
+import { transports } from '@tevm/test-utils'
+
+describe(getBlock.name, async () => {
+	const chain = createBaseChain({
+		common: mainnet.copy(),
+	})
+
+	const blocks = await getMockBlocks()
+
+	await putBlock(chain)(blocks[0])
+	await putBlock(chain)(blocks[1])
+	await putBlock(chain)(blocks[2])
+
+	it('can get a block by hash', async () => {
+		expect(await getBlock(chain)(blocks[0].hash())).toBe(blocks[0])
+	})
+
+	it('can get a block by number', async () => {
+		expect(await getBlock(chain)(blocks[0].header.number)).toBe(blocks[0])
+	})
+
+	it('can get a block by number that is not a big int', async () => {
+		expect(await getBlock(chain)(Number(blocks[0].header.number))).toBe(blocks[0])
+	})
+
+	it('should throw an error if the block does not exist', async () => {
+		let error = await getBlock(chain)(69).then((e) => e)
+		expect(error).toBeInstanceOf(UnknownBlockError)
+		expect(error).toMatchSnapshot()
+		error = await getBlock(chain)(blocks[3].hash()).catch((e) => e)
+		expect(error).toBeInstanceOf(UnknownBlockError)
+		expect(error).toMatchSnapshot()
+	})
+
+	it('should fetch and cache the block from rpc if it does not exist', async () => {
+		const chain = createBaseChain({
+			common: mainnet.copy(),
+			fork: {
+				transport: transports.optimism,
+				blockTag: blocks[0].header.number,
+			},
+		})
+		await chain.ready()
+		expect(await getBlock(chain)(blocks[1].hash())).toEqual(blocks[1])
+		expect(chain.blocksByNumber.get(blocks[1].header.number)).toEqual(blocks[1])
+	})
+
+	it('should fetch and cache the block by number from rpc if it does not exist', async () => {
+		const chain = createBaseChain({
+			common: mainnet.copy(),
+			fork: {
+				transport: transports.optimism,
+				blockTag: blocks[0].header.number,
+			},
+		})
+		await chain.ready()
+		expect(await getBlock(chain)(blocks[1].header.number)).toEqual(blocks[1])
+		expect(chain.blocksByNumber.get(blocks[1].header.number)).toEqual(blocks[1])
+	})
+
+	it('should throw an error if attempting to fetch a block newer than the forked block', async () => {
+		const chain = createBaseChain({
+			common: mainnet.copy(),
+			fork: {
+				transport: transports.optimism,
+				blockTag: blocks[0].header.number,
+			},
+		})
+		await chain.ready()
+		const error = await getBlock(chain)(blocks[1].header.number).catch((e) => e)
+		expect(error).toBeInstanceOf(UnknownBlockError)
+		expect(error).toMatchSnapshot()
+	})
+})

packages/blockchain/src/actions/getBlockByTag.spec.ts

@@ -0,0 +1,62 @@
+import { describe, expect, it } from 'bun:test'
+import { getBlockByTag } from './getBlockByTag.js'
+import { createBaseChain } from '../createBaseChain.js'
+import { mainnet } from '@tevm/common'
+import { getMockBlocks } from '../test/getBlocks.js'
+import { putBlock } from './putBlock.js'
+import { UnknownBlockError } from '@tevm/errors'
+import { transports } from '@tevm/test-utils'
+
+describe(getBlockByTag.name, async () => {
+	const chain = createBaseChain({
+		common: mainnet.copy(),
+	})
+
+	const blocks = await getMockBlocks()
+
+	await putBlock(chain)(blocks[0])
+	await putBlock(chain)(blocks[1])
+	await putBlock(chain)(blocks[2])
+
+	it('can get a block by hash', async () => {
+		expect(await getBlockByTag(chain)(blocks[0].hash())).toBe(blocks[0])
+	})
+
+	it('can get a block by number', async () => {
+		expect(await getBlockByTag(chain)(blocks[0].header.number)).toBe(blocks[0])
+	})
+
+	it('can get a block by number that is not a big int', async () => {
+		expect(await getBlockByTag(chain)(Number(blocks[0].header.number))).toBe(blocks[0])
+	})
+
+	it('should throw an error if the block does not exist', async () => {
+		let error = await getBlockByTag(chain)(69).then((e) => e)
+		expect(error).toBeInstanceOf(UnknownBlockError)
+		expect(error).toMatchSnapshot()
+		error = await getBlockByTag(chain)(blocks[3].hash()).catch((e) => e)
+		expect(error).toBeInstanceOf(UnknownBlockError)
+		expect(error).toMatchSnapshot()
+	})
+
+	it('should fetch and cache the block from rpc if it does not exist', async () => {
+		const chain = createBaseChain({
+			common: mainnet.copy(),
+			fork: {
+				transport: transports.optimism,
+				blockTag: blocks[0].header.number,
+			},
+		})
+		await chain.ready()
+		expect(await getBlockByTag(chain)('earliest')).toMatchSnapshot()
+	})
+
+	it('should throw UnknownBlockError if tag doesn not exist', async () => {
+		const chain = createBaseChain({
+			common: mainnet.copy(),
+		})
+		const error = await getBlockByTag(chain)('safe').catch((e) => e)
+		expect(error).toBeInstanceOf(UnknownBlockError)
+		expect(error).toMatchSnapshot()
+	})
+})

packages/blockchain/src/actions/getCanonicalHeadBlock.js

@@ -1,11 +1,13 @@
+import { InternalError } from '@tevm/errors'
+
 /**
  * @param {import('../BaseChain.js').BaseChain} baseChain
  * @returns {import('../Chain.js').Chain['getCanonicalHeadBlock']}
  */
 export const getCanonicalHeadBlock = (baseChain) => () => {
 	const block = baseChain.blocksByTag.get('latest')
 	if (!block) {
-		throw new Error('No cannonical head exists on blockchain')
+		throw new InternalError('No cannonical head exists on blockchain')
 	}
 	return Promise.resolve(block)
 }

packages/blockchain/src/actions/getCanonicalHeadBlock.spec.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'bun:test'
+import { getCanonicalHeadBlock } from './getCanonicalHeadBlock.js'
+import { createBaseChain } from '../createBaseChain.js'
+import { putBlock } from './putBlock.js'
+import { getMockBlocks } from '../test/getBlocks.js'
+import { optimism } from '@tevm/common'
+import { InternalError } from '@tevm/errors'
+
+describe(getCanonicalHeadBlock.name, async () => {
+	const blocks = await getMockBlocks()
+	it('should get the canonical head block', async () => {
+		const chain = createBaseChain({ common: optimism.copy() })
+		await putBlock(chain)(blocks[0])
+		expect(await getCanonicalHeadBlock(chain)()).toBe(blocks[0])
+	})
+	it('should throw an error if not cannonical block', async () => {
+		const chain = createBaseChain({ common: optimism.copy() })
+		chain.blocksByTag.set('latest', undefined)
+		let error = await getCanonicalHeadBlock(chain)().catch((e) => e)
+		expect(error).toBeInstanceOf(InternalError)
+		expect(error).toMatchSnapshot()
+	})
+})

packages/blockchain/src/actions/getIteratorHead.spec.ts

@@ -0,0 +1,39 @@
+import { describe, expect, it } from 'bun:test'
+import { getIteratorHead } from './getIteratorHead.js'
+import { createBaseChain } from '../createBaseChain.js'
+import { putBlock } from './putBlock.js'
+import { getMockBlocks } from '../test/getBlocks.js'
+import { optimism } from '@tevm/common'
+
+describe(getIteratorHead.name, async () => {
+	const blocks = await getMockBlocks()
+
+	it('should get the iterator head block for default tag', async () => {
+		const chain = createBaseChain({ common: optimism.copy() })
+		await putBlock(chain)(blocks[0])
+		chain.blocksByTag.set('vm' as any, blocks[0]) // Set the iterator head
+		expect(await getIteratorHead(chain)()).toBe(blocks[0])
+	})
+
+	it('should get the iterator head block for a specific tag', async () => {
+		const chain = createBaseChain({ common: optimism.copy() })
+		await putBlock(chain)(blocks[1])
+		chain.blocksByTag.set('myTag' as any, blocks[1]) // Set the iterator head
+		expect(await getIteratorHead(chain)('myTag')).toBe(blocks[1])
+	})
+
+	it('should throw an error if the iterator head block does not exist', async () => {
+		const chain = createBaseChain({ common: optimism.copy() })
+		let error = await getIteratorHead(chain)('nonExistentTag').catch((e) => e)
+		expect(error).toBeInstanceOf(Error)
+		expect(error.message).toBe('No block with tag nonExistentTag exists. Current tags include ')
+	})
+
+	it('should include current tags in error message if the iterator head block does not exist', async () => {
+		const chain = createBaseChain({ common: optimism.copy() })
+		chain.blocksByTag.set('someTag' as any, blocks[0])
+		let error = await getIteratorHead(chain)('nonExistentTag').catch((e) => e)
+		expect(error).toBeInstanceOf(Error)
+		expect(error.message).toBe(`No block with tag nonExistentTag exists. Current tags include someTag`)
+	})
+})