hardhat 2.10.1 → 2.11.0-dev.0

package/src/internal/core/providers/gas-providers.ts

@@ -1,9 +1,8 @@
-import { BN } from "ethereumjs-util";
 import { EIP1193Provider, RequestArguments } from "../../../types";
 import {
   numberToRpcQuantity,
   rpcQuantityToNumber,
-  rpcQuantityToBN,
+  rpcQuantityToBigInt,
 } from "../jsonrpc/types/base-types";
 
 import { ProviderWrapper } from "./wrapper";
@@ -11,7 +10,7 @@ import { ProviderWrapper } from "./wrapper";
 const DEFAULT_GAS_MULTIPLIER = 1;
 
 export class FixedGasProvider extends ProviderWrapper {
-  constructor(provider: EIP1193Provider, private readonly _gasLimit: number) {
+  constructor(provider: EIP1193Provider, private readonly _gasLimit: bigint) {
     super(provider);
   }
 
@@ -31,7 +30,7 @@ export class FixedGasProvider extends ProviderWrapper {
 }
 
 export class FixedGasPriceProvider extends ProviderWrapper {
-  constructor(provider: EIP1193Provider, private readonly _gasPrice: number) {
+  constructor(provider: EIP1193Provider, private readonly _gasPrice: bigint) {
     super(provider);
   }
 
@@ -140,10 +139,11 @@ export class AutomaticGasProvider extends MultipliedGasEstimationProvider {
 export class AutomaticGasPriceProvider extends ProviderWrapper {
   // We pay the max base fee that can be required if the next
   // EIP1559_BASE_FEE_MAX_FULL_BLOCKS_PREFERENCE are full.
-  public static readonly EIP1559_BASE_FEE_MAX_FULL_BLOCKS_PREFERENCE: number = 3;
+  public static readonly EIP1559_BASE_FEE_MAX_FULL_BLOCKS_PREFERENCE: bigint =
+    3n;
 
   // See eth_feeHistory for an explanation of what this means
-  public static readonly EIP1559_REWARD_PERCENTILE: number = 50;
+  public static readonly EIP1559_REWARD_PERCENTILE: bigint = 50n;
 
   private _nodeHasFeeHistory?: boolean;
   private _nodeSupportsEIP1559?: boolean;
@@ -195,16 +195,16 @@ export class AutomaticGasPriceProvider extends ProviderWrapper {
 
     let maxFeePerGas =
       tx.maxFeePerGas !== undefined
-        ? rpcQuantityToBN(tx.maxFeePerGas)
+        ? rpcQuantityToBigInt(tx.maxFeePerGas)
         : suggestedEip1559Values.maxFeePerGas;
 
     const maxPriorityFeePerGas =
       tx.maxPriorityFeePerGas !== undefined
-        ? rpcQuantityToBN(tx.maxPriorityFeePerGas)
+        ? rpcQuantityToBigInt(tx.maxPriorityFeePerGas)
         : suggestedEip1559Values.maxPriorityFeePerGas;
 
-    if (maxFeePerGas.lt(maxPriorityFeePerGas)) {
-      maxFeePerGas = maxFeePerGas.add(maxPriorityFeePerGas);
+    if (maxFeePerGas < maxPriorityFeePerGas) {
+      maxFeePerGas += maxPriorityFeePerGas;
     }
 
     tx.maxFeePerGas = numberToRpcQuantity(maxFeePerGas);
@@ -213,18 +213,18 @@ export class AutomaticGasPriceProvider extends ProviderWrapper {
     return this._wrappedProvider.request(args);
   }
 
-  private async _getGasPrice(): Promise<BN> {
+  private async _getGasPrice(): Promise<bigint> {
     const response = (await this._wrappedProvider.request({
       method: "eth_gasPrice",
     })) as string;
 
-    return rpcQuantityToBN(response);
+    return rpcQuantityToBigInt(response);
   }
 
   private async _suggestEip1559FeePriceValues(): Promise<
     | {
-        maxFeePerGas: BN;
-        maxPriorityFeePerGas: BN;
+        maxFeePerGas: bigint;
+        maxPriorityFeePerGas: bigint;
       }
     | undefined
   > {
@@ -258,25 +258,17 @@ export class AutomaticGasPriceProvider extends ProviderWrapper {
         // Each block increases the base fee by 1/8 at most, when full.
         // We have the next block's base fee, so we compute a cap for the
         // next N blocks here.
-        maxFeePerGas: rpcQuantityToBN(response.baseFeePerGas[1])
-          .mul(
-            new BN(9).pow(
-              new BN(
-                AutomaticGasPriceProvider.EIP1559_BASE_FEE_MAX_FULL_BLOCKS_PREFERENCE -
-                  1
-              )
-            )
-          )
-          .div(
-            new BN(8).pow(
-              new BN(
-                AutomaticGasPriceProvider.EIP1559_BASE_FEE_MAX_FULL_BLOCKS_PREFERENCE -
-                  1
-              )
-            )
-          ),
-
-        maxPriorityFeePerGas: rpcQuantityToBN(response.reward[0][0]),
+
+        maxFeePerGas:
+          (rpcQuantityToBigInt(response.baseFeePerGas[1]) *
+            9n **
+              (AutomaticGasPriceProvider.EIP1559_BASE_FEE_MAX_FULL_BLOCKS_PREFERENCE -
+                1n)) /
+          8n **
+            (AutomaticGasPriceProvider.EIP1559_BASE_FEE_MAX_FULL_BLOCKS_PREFERENCE -
+              1n),
+
+        maxPriorityFeePerGas: rpcQuantityToBigInt(response.reward[0][0]),
       };
     } catch {
       this._nodeHasFeeHistory = false;

package/src/internal/core/providers/util.ts

@@ -53,7 +53,7 @@ export function normalizeHardhatNetworkAccountsConfig(
     return accountsConfig;
   }
 
-  const { bufferToHex } = require("ethereumjs-util");
+  const { bufferToHex } = require("@ignored/util");
 
   return derivePrivateKeys(
     accountsConfig.mnemonic,

package/src/internal/hardhat-network/jsonrpc/client.ts

@@ -1,4 +1,4 @@
-import { Address, BN, bufferToHex } from "ethereumjs-util";
+import { Address, bufferToHex } from "@ignored/util";
 import fsExtra from "fs-extra";
 import * as t from "io-ts";
 import path from "path";
@@ -29,8 +29,8 @@ export class JsonRpcClient {
   constructor(
     private _httpProvider: HttpProvider,
     private _networkId: number,
-    private _latestBlockNumberOnCreation: number,
-    private _maxReorg: number,
+    private _latestBlockNumberOnCreation: bigint,
+    private _maxReorg: bigint,
     private _forkCachePath?: string
   ) {}
 
@@ -50,8 +50,8 @@ export class JsonRpcClient {
   // Storage key must be 32 bytes long
   public async getStorageAt(
     address: Address,
-    position: BN,
-    blockNumber: BN
+    position: bigint,
+    blockNumber: bigint
   ): Promise<Buffer> {
     return this._perform(
       "eth_getStorageAt",
@@ -66,17 +66,17 @@ export class JsonRpcClient {
   }
 
   public async getBlockByNumber(
-    blockNumber: BN,
+    blockNumber: bigint,
     includeTransactions?: false
   ): Promise<RpcBlock | null>;
 
   public async getBlockByNumber(
-    blockNumber: BN,
+    blockNumber: bigint,
     includeTransactions: true
   ): Promise<RpcBlockWithTransactions | null>;
 
   public async getBlockByNumber(
-    blockNumber: BN,
+    blockNumber: bigint,
     includeTransactions = false
   ): Promise<RpcBlock | RpcBlockWithTransactions | null> {
     if (includeTransactions) {
@@ -136,7 +136,7 @@ export class JsonRpcClient {
     );
   }
 
-  public async getTransactionCount(address: Buffer, blockNumber: BN) {
+  public async getTransactionCount(address: Buffer, blockNumber: bigint) {
     return this._perform(
       "eth_getTransactionCount",
       [bufferToHex(address), numberToRpcQuantity(blockNumber)],
@@ -155,8 +155,8 @@ export class JsonRpcClient {
   }
 
   public async getLogs(options: {
-    fromBlock: BN;
-    toBlock: BN;
+    fromBlock: bigint;
+    toBlock: bigint;
     address?: Buffer | Buffer[];
     topics?: Array<Array<Buffer | null> | null>;
   }) {
@@ -192,8 +192,8 @@ export class JsonRpcClient {
 
   public async getAccountData(
     address: Address,
-    blockNumber: BN
-  ): Promise<{ code: Buffer; transactionCount: BN; balance: BN }> {
+    blockNumber: bigint
+  ): Promise<{ code: Buffer; transactionCount: bigint; balance: bigint }> {
     const results = await this._performBatch(
       [
         {
@@ -225,8 +225,8 @@ export class JsonRpcClient {
   // This is part of a temporary fix to https://github.com/NomicFoundation/hardhat/issues/2380
   // This method caches each request instead of caching each block's fee info individually, which is not ideal
   public async getFeeHistory(
-    blockCount: BN,
-    newestBlock: BN | "pending",
+    blockCount: bigint,
+    newestBlock: bigint | "pending",
     rewardPercentiles: number[]
   ): Promise<FeeHistory> {
     return this._perform(
@@ -244,11 +244,11 @@ export class JsonRpcClient {
         gasUsedRatio: t.array(t.number),
         reward: optional(t.array(t.array(rpcQuantity))),
       }),
-      (res) => res.oldestBlock.addn(res.baseFeePerGas.length)
+      (res) => res.oldestBlock + BigInt(res.baseFeePerGas.length)
     );
   }
 
-  public async getLatestBlockNumber(): Promise<BN> {
+  public async getLatestBlockNumber(): Promise<bigint> {
     return this._perform(
       "eth_blockNumber",
       [],
@@ -261,7 +261,7 @@ export class JsonRpcClient {
     method: string,
     params: any[],
     tType: t.Type<T>,
-    getMaxAffectedBlockNumber: (decodedResult: T) => BN | undefined
+    getMaxAffectedBlockNumber: (decodedResult: T) => bigint | undefined
   ): Promise<T> {
     const cacheKey = this._getCacheKey(method, params);
 
@@ -303,7 +303,7 @@ export class JsonRpcClient {
       params: any[];
       tType: t.Type<any>;
     }>,
-    getMaxAffectedBlockNumber: (decodedResults: any[]) => BN | undefined
+    getMaxAffectedBlockNumber: (decodedResults: any[]) => bigint | undefined
   ): Promise<any[]> {
     // Perform Batch caches the entire batch at once.
     // It could implement something more clever, like caching per request
@@ -496,15 +496,15 @@ export class JsonRpcClient {
     );
   }
 
-  private _canBeCached(blockNumber: BN | undefined) {
+  private _canBeCached(blockNumber: bigint | undefined) {
     if (blockNumber === undefined) {
       return false;
     }
 
-    return !this._canBeReorgedOut(blockNumber.toNumber());
+    return !this._canBeReorgedOut(blockNumber);
   }
 
-  private _canBeReorgedOut(blockNumber: number) {
+  private _canBeReorgedOut(blockNumber: bigint) {
     const maxSafeBlockNumber =
       this._latestBlockNumberOnCreation - this._maxReorg;
     return blockNumber > maxSafeBlockNumber;

package/src/internal/hardhat-network/provider/BlockchainBase.ts

@@ -1,19 +1,44 @@
-import { Block } from "@ethereumjs/block";
-import Common from "@ethereumjs/common";
-import { TypedTransaction } from "@ethereumjs/tx";
-import { BN } from "ethereumjs-util";
+import { Block, BlockHeader } from "@ignored/block";
+import {
+  BlockchainInterface,
+  CasperConsensus,
+  CliqueConsensus,
+  Consensus,
+  EthashConsensus,
+} from "@ignored/blockchain";
+import { Common, ConsensusAlgorithm } from "@ignored/common";
+import { TypedTransaction } from "@ignored/tx";
 
 import { assertHardhatInvariant } from "../../core/errors";
+import { BigIntUtils } from "../../util/bigint";
 import { BlockchainData } from "./BlockchainData";
 import { RpcReceiptOutput } from "./output";
 
 /* eslint-disable @nomiclabs/hardhat-internal-rules/only-hardhat-error */
 
 export abstract class BlockchainBase {
+  public consensus: Consensus;
   protected readonly _data: BlockchainData;
 
   constructor(protected _common: Common) {
     this._data = new BlockchainData(_common);
+
+    // copied from blockchain.ts in @ignored/blockchain
+    switch (this._common.consensusAlgorithm()) {
+      case ConsensusAlgorithm.Casper:
+        this.consensus = new CasperConsensus();
+        break;
+      case ConsensusAlgorithm.Clique:
+        this.consensus = new CliqueConsensus();
+        break;
+      case ConsensusAlgorithm.Ethash:
+        this.consensus = new EthashConsensus();
+        break;
+      default:
+        throw new Error(
+          `consensus algorithm ${this._common.consensusAlgorithm()} not supported`
+        );
+    }
   }
 
   public abstract addBlock(block: Block): Promise<Block>;
@@ -37,25 +62,26 @@ export abstract class BlockchainBase {
   }
 
   public async getBlock(
-    blockHashOrNumber: Buffer | BN | number
+    blockHashOrNumber: Buffer | bigint | number
   ): Promise<Block | null> {
     if (
-      (typeof blockHashOrNumber === "number" || BN.isBN(blockHashOrNumber)) &&
-      this._data.isReservedBlock(new BN(blockHashOrNumber))
+      (typeof blockHashOrNumber === "number" ||
+        BigIntUtils.isBigInt(blockHashOrNumber)) &&
+      this._data.isReservedBlock(BigInt(blockHashOrNumber))
     ) {
-      this._data.fulfillBlockReservation(new BN(blockHashOrNumber));
+      this._data.fulfillBlockReservation(BigInt(blockHashOrNumber));
     }
 
     if (typeof blockHashOrNumber === "number") {
-      return this._data.getBlockByNumber(new BN(blockHashOrNumber)) ?? null;
+      return this._data.getBlockByNumber(BigInt(blockHashOrNumber)) ?? null;
     }
-    if (BN.isBN(blockHashOrNumber)) {
+    if (BigIntUtils.isBigInt(blockHashOrNumber)) {
       return this._data.getBlockByNumber(blockHashOrNumber) ?? null;
     }
     return this._data.getBlockByHash(blockHashOrNumber) ?? null;
   }
 
-  public abstract getLatestBlockNumber(): BN;
+  public abstract getLatestBlockNumber(): bigint;
 
   public async getLatestBlock(): Promise<Block> {
     const block = await this.getBlock(this.getLatestBlockNumber());
@@ -74,7 +100,7 @@ export abstract class BlockchainBase {
   public iterator(
     _name: string,
     _onBlock: (block: Block, reorg: boolean) => void | Promise<void>
-  ): Promise<number | void> {
+  ): Promise<number> {
     throw new Error("Method not implemented.");
   }
 
@@ -83,14 +109,14 @@ export abstract class BlockchainBase {
   }
 
   public reserveBlocks(
-    count: BN,
-    interval: BN,
+    count: bigint,
+    interval: bigint,
     previousBlockStateRoot: Buffer,
-    previousBlockTotalDifficulty: BN,
-    previousBlockBaseFeePerGas: BN | undefined
+    previousBlockTotalDifficulty: bigint,
+    previousBlockBaseFeePerGas: bigint | undefined
   ) {
     this._data.reserveBlocks(
-      this.getLatestBlockNumber().addn(1),
+      this.getLatestBlockNumber() + 1n,
       count,
       interval,
       previousBlockStateRoot,
@@ -99,32 +125,43 @@ export abstract class BlockchainBase {
     );
   }
 
-  protected _delBlock(blockNumber: BN): void {
+  public copy(): BlockchainInterface {
+    throw new Error("Method not implemented.");
+  }
+
+  public validateHeader(
+    _header: BlockHeader,
+    _height?: bigint | undefined
+  ): Promise<void> {
+    throw new Error("Method not implemented.");
+  }
+
+  protected _delBlock(blockNumber: bigint): void {
     let i = blockNumber;
 
-    while (i.lte(this.getLatestBlockNumber())) {
+    while (i <= this.getLatestBlockNumber()) {
       if (this._data.isReservedBlock(i)) {
         const reservation = this._data.cancelReservationWithBlock(i);
-        i = reservation.last.addn(1);
+        i = reservation.last + 1n;
       } else {
         const current = this._data.getBlockByNumber(i);
         if (current !== undefined) {
           this._data.removeBlock(current);
         }
-        i = i.addn(1);
+        i++;
       }
     }
   }
 
-  protected async _computeTotalDifficulty(block: Block): Promise<BN> {
+  protected async _computeTotalDifficulty(block: Block): Promise<bigint> {
     const difficulty = block.header.difficulty;
     const blockNumber = block.header.number;
 
-    if (blockNumber.eqn(0)) {
+    if (blockNumber === 0n) {
       return difficulty;
     }
 
-    const parentBlock = await this.getBlock(blockNumber.subn(1));
+    const parentBlock = await this.getBlock(blockNumber - 1n);
     assertHardhatInvariant(parentBlock !== null, "Parent block should exist");
 
     const parentHash = parentBlock.hash();
@@ -134,6 +171,6 @@ export abstract class BlockchainBase {
       "Parent block should have total difficulty"
     );
 
-    return parentTD.add(difficulty);
+    return parentTD + difficulty;
   }
 }

package/src/internal/hardhat-network/provider/BlockchainData.ts

@@ -1,8 +1,8 @@
-import { Block } from "@ethereumjs/block";
-import Common from "@ethereumjs/common";
-import { TypedTransaction } from "@ethereumjs/tx";
-import Bloom from "@ethereumjs/vm/dist/bloom";
-import { BN, bufferToHex } from "ethereumjs-util";
+import { Block } from "@ignored/block";
+import { Common } from "@ignored/common";
+import { TypedTransaction } from "@ignored/tx";
+import { bufferToHex } from "@ignored/util";
+import { Bloom } from "@ignored/vm";
 
 import { assertHardhatInvariant } from "../../core/errors";
 import { bloomFilter, filterLogs } from "./filter";
@@ -10,36 +10,36 @@ import { FilterParams } from "./node-types";
 import { RpcLogOutput, RpcReceiptOutput } from "./output";
 
 interface Reservation {
-  first: BN;
-  last: BN;
-  interval: BN;
+  first: bigint;
+  last: bigint;
+  interval: bigint;
   previousBlockStateRoot: Buffer;
-  previousBlockTotalDifficulty: BN;
-  previousBlockBaseFeePerGas: BN | undefined;
+  previousBlockTotalDifficulty: bigint;
+  previousBlockBaseFeePerGas: bigint | undefined;
 }
 
 export class BlockchainData {
-  private _blocksByNumber: Map<number, Block> = new Map();
+  private _blocksByNumber: Map<bigint, Block> = new Map();
   private _blocksByHash: Map<string, Block> = new Map();
   private _blocksByTransactions: Map<string, Block> = new Map();
   private _transactions: Map<string, TypedTransaction> = new Map();
   private _transactionReceipts: Map<string, RpcReceiptOutput> = new Map();
-  private _totalDifficulty: Map<string, BN> = new Map();
+  private _totalDifficulty: Map<string, bigint> = new Map();
   private _blockReservations: Reservation[] = new Array();
 
   constructor(private _common: Common) {}
 
   public reserveBlocks(
-    first: BN,
-    count: BN,
-    interval: BN,
+    first: bigint,
+    count: bigint,
+    interval: bigint,
     previousBlockStateRoot: Buffer,
-    previousBlockTotalDifficulty: BN,
-    previousBlockBaseFeePerGas: BN | undefined
+    previousBlockTotalDifficulty: bigint,
+    previousBlockBaseFeePerGas: bigint | undefined
   ) {
     const reservation: Reservation = {
       first,
-      last: first.add(count.subn(1)),
+      last: first + count - 1n,
       interval,
       previousBlockStateRoot,
       previousBlockTotalDifficulty,
@@ -48,8 +48,8 @@ export class BlockchainData {
     this._blockReservations.push(reservation);
   }
 
-  public getBlockByNumber(blockNumber: BN) {
-    return this._blocksByNumber.get(blockNumber.toNumber());
+  public getBlockByNumber(blockNumber: bigint) {
+    return this._blocksByNumber.get(blockNumber);
   }
 
   public getBlockByHash(blockHash: Buffer) {
@@ -74,16 +74,12 @@ export class BlockchainData {
 
   public getLogs(filterParams: FilterParams) {
     const logs: RpcLogOutput[] = [];
-    for (
-      let i = filterParams.fromBlock;
-      i.lte(filterParams.toBlock);
-      i = i.addn(1)
-    ) {
+    for (let i = filterParams.fromBlock; i <= filterParams.toBlock; i++) {
       const block = this.getBlockByNumber(i);
       if (
         block === undefined ||
         !bloomFilter(
-          new Bloom(block.header.bloom),
+          new Bloom(block.header.logsBloom),
           filterParams.addresses,
           filterParams.normalizedTopics
         )
@@ -107,9 +103,9 @@ export class BlockchainData {
     return logs;
   }
 
-  public addBlock(block: Block, totalDifficulty: BN) {
+  public addBlock(block: Block, totalDifficulty: bigint) {
     const blockHash = bufferToHex(block.hash());
-    const blockNumber = new BN(block.header.number).toNumber();
+    const blockNumber = block.header.number;
     this._blocksByNumber.set(blockNumber, block);
     this._blocksByHash.set(blockHash, block);
     this._totalDifficulty.set(blockHash, totalDifficulty);
@@ -128,7 +124,7 @@ export class BlockchainData {
    */
   public removeBlock(block: Block) {
     const blockHash = bufferToHex(block.hash());
-    const blockNumber = new BN(block.header.number).toNumber();
+    const blockNumber = block.header.number;
     this._blocksByNumber.delete(blockNumber);
     this._blocksByHash.delete(blockHash);
     this._totalDifficulty.delete(blockHash);
@@ -149,14 +145,14 @@ export class BlockchainData {
     this._transactionReceipts.set(receipt.transactionHash, receipt);
   }
 
-  public isReservedBlock(blockNumber: BN): boolean {
+  public isReservedBlock(blockNumber: bigint): boolean {
     return this._findBlockReservation(blockNumber) !== -1;
   }
 
-  private _findBlockReservation(blockNumber: BN): number {
+  private _findBlockReservation(blockNumber: bigint): number {
     return this._blockReservations.findIndex(
       (reservation) =>
-        reservation.first.lte(blockNumber) && blockNumber.lte(reservation.last)
+        reservation.first <= blockNumber && blockNumber <= reservation.last
     );
   }
 
@@ -180,11 +176,11 @@ export class BlockchainData {
   /**
    * Cancel and return the reservation that has block `blockNumber`
    */
-  public cancelReservationWithBlock(blockNumber: BN): Reservation {
+  public cancelReservationWithBlock(blockNumber: bigint): Reservation {
     return this._removeReservation(this._findBlockReservation(blockNumber));
   }
 
-  public fulfillBlockReservation(blockNumber: BN) {
+  public fulfillBlockReservation(blockNumber: bigint) {
     // in addition to adding the given block, the reservation needs to be split
     // in two in order to accomodate access to the given block.
 
@@ -200,17 +196,17 @@ export class BlockchainData {
     // split the block reservation:
     const oldReservation = this._removeReservation(reservationIndex);
 
-    if (!blockNumber.eq(oldReservation.first)) {
+    if (blockNumber !== oldReservation.first) {
       this._blockReservations.push({
         ...oldReservation,
-        last: blockNumber.subn(1),
+        last: blockNumber - 1n,
       });
     }
 
-    if (!blockNumber.eq(oldReservation.last)) {
+    if (blockNumber !== oldReservation.last) {
       this._blockReservations.push({
         ...oldReservation,
-        first: blockNumber.addn(1),
+        first: blockNumber + 1n,
       });
     }
 
@@ -230,7 +226,7 @@ export class BlockchainData {
     );
   }
 
-  private _calculateTimestampForReservedBlock(blockNumber: BN): BN {
+  private _calculateTimestampForReservedBlock(blockNumber: bigint): bigint {
     const reservationIndex = this._findBlockReservation(blockNumber);
 
     assertHardhatInvariant(
@@ -240,7 +236,7 @@ export class BlockchainData {
 
     const reservation = this._blockReservations[reservationIndex];
 
-    const blockNumberBeforeReservation = reservation.first.subn(1);
+    const blockNumberBeforeReservation = reservation.first - 1n;
 
     const blockBeforeReservation = this.getBlockByNumber(
       blockNumberBeforeReservation
@@ -254,8 +250,9 @@ export class BlockchainData {
       ? this._calculateTimestampForReservedBlock(blockNumberBeforeReservation)
       : blockBeforeReservation.header.timestamp;
 
-    return previousTimestamp.add(
-      reservation.interval.mul(blockNumber.sub(reservation.first).addn(1))
+    return (
+      previousTimestamp +
+      reservation.interval * (blockNumber - reservation.first + 1n)
     );
   }
 }