fix: calling evm_mine with a timestamp argument should reflect the change of time in subsequent blocks

src/chains/ethereum/ethereum/src/api.ts

@@ -294,6 +294,9 @@ export default class EthereumApi implements Api {
  async evm_mine(options: Ethereum.MineOptions): Promise<"0x0">;
  @assertArgLength(0, 1)
  async evm_mine(arg?: number | Ethereum.MineOptions): Promise<"0x0"> {
+ // `MINE_ONLY_ONE_BLOCK` refers to the number of blocks mined per call to `blockchain.mine()`
+ const MINE_ONLY_ONE_BLOCK = true;
+
  const blockchain = this.#blockchain;
  const options = this.#options;
  const vmErrorsOnRPCResponse = options.chain.vmErrorsOnRPCResponse;
@@ -310,19 +313,20 @@ export default class EthereumApi implements Api {
  for (let i = 0; i < blocks; i++) {
  const { transactions } = await blockchain.mine(
  Capacity.FillBlock,
- timestamp,
- true
+ MINE_ONLY_ONE_BLOCK,
+ timestamp
  );
 
  if (vmErrorsOnRPCResponse) {
  assertExceptionalTransactions(transactions);
  }
  }
  } else {
+ const timestamp = arg as number | null;
  const { transactions } = await blockchain.mine(
  Capacity.FillBlock,
- arg as number | null,
- true
+ MINE_ONLY_ONE_BLOCK,
+ timestamp
  );
  if (vmErrorsOnRPCResponse) {
  assertExceptionalTransactions(transactions);

src/chains/ethereum/ethereum/src/blockchain.ts

@@ -357,10 +357,10 @@ export default class Blockchain extends Emittery<BlockchainTypedEvents> {
 
  //#region automatic mining
  const nullResolved = Promise.resolve(null);
- const mineAll = (maxTransactions: Capacity, onlyOneBlock = false) =>
+ const mineAll = (maxTransactions: Capacity, onlyOneBlock?: boolean) =>
  this.#isPaused()
  ? nullResolved
- : this.mine(maxTransactions, null, onlyOneBlock);
+ : this.mine(maxTransactions, onlyOneBlock);
  if (instamine) {
  // insta mining
  // whenever the transaction pool is drained mine the txs into blocks
@@ -592,8 +592,8 @@ export default class Blockchain extends Emittery<BlockchainTypedEvents> {
 
  mine = async (
  maxTransactions: number | Capacity,
- timestamp?: number,
- onlyOneBlock: boolean = false
+ onlyOneBlock: boolean = false,
+ timestamp?: number
  ) => {
  const nextBlock = this.#readyNextBlock(this.blocks.latest, timestamp);
 
@@ -608,6 +608,15 @@ export default class Blockchain extends Emittery<BlockchainTypedEvents> {
  onlyOneBlock
  );
  await this.#blockBeingSavedPromise;
+
+ if (
+ timestamp !== undefined &&
+ this.#options.miner.timestampIncrement === "clock"
+ ) {
+ // when miner.timestampIncrement is a number, the previous block timestamp is used as a reference
+ // for the next block, so this call is not required.
+ this.setTimeDiff(timestamp * 1000);
+ }
  return {
  transactions,
  blockNumber: nextBlock.header.number.toArrayLike(Buffer)
@@ -839,7 +848,8 @@ export default class Blockchain extends Emittery<BlockchainTypedEvents> {
  }
 
  /**
- * @param newTime - the number of milliseconds to adjust the time by. Can be negative.
+ * Adjusts the internal time adjustment such that the provided time is considered the "current" time.
+ * @param newTime - the time (in milliseconds) that will be considered the "current" time
  * @returns the total time offset *in milliseconds*
  */
  public setTimeDiff(newTime: number) {

src/chains/ethereum/ethereum/tests/blockchain.test.ts

@@ -112,7 +112,12 @@ describe("blockchain", async () => {
  // assert that second block's timestamp is at least `blockTime` greater
  // than the first block's. meaning, these blocks weren't mined one after
  // the other
- assert(timestamps[1] >= timestamps[0] + blockTime);
+ assert(
+ timestamps[1] >= timestamps[0] + blockTime,
+ `Unexpected timestamp - expected >= ${timestamps[0] + blockTime}, got ${
+ timestamps[1]
+ }`
+ );
  });
  });
 });

src/chains/ethereum/ethereum/tests/provider.test.ts

@@ -141,6 +141,83 @@ describe("provider", () => {
  await provider.disconnect();
  });
 
+ describe("uses timestamp adjustment in subsequent blocks after calling `evm_mine` with a `timestamp` argument", () => {
+ const timestampIncrement = 5; // seconds
+ const timeArgumentSeconds = 100;
+
+ async function mineBlocksForTimestamps(
+ provider: EthereumProvider
+ ): Promise<string[]> {
+ // mine a block with a specified timestamp
+ await provider.request({
+ method: "evm_mine",
+ params: [timeArgumentSeconds]
+ });
+ const specifiedBlock = await provider.request({
+ method: "eth_getBlockByNumber",
+ params: ["latest", false]
+ });
+ // mine a block without a specified timestamp
+ await provider.request({
+ method: "evm_mine",
+ params: []
+ });
+ const unspecifiedBlock = await provider.request({
+ method: "eth_getBlockByNumber",
+ params: ["latest", false]
+ });
+
+ return [specifiedBlock.timestamp, unspecifiedBlock.timestamp];
+ }
+ it("should work with `timestampIncrement` of `clock`", async () => {
+ const provider = await getProvider({
+ miner: { timestampIncrement: "clock" }
+ });
+
+ const [specifiedBlock, unspecifiedBlock] =
+ await mineBlocksForTimestamps(provider);
+
+ assert.strictEqual(
+ specifiedBlock,
+ `0x${timeArgumentSeconds.toString(16)}`,
+ "Unexpected timestamp for block mined with specified timestamp"
+ );
+
+ assert(
+ +unspecifiedBlock >= timeArgumentSeconds &&
+ +unspecifiedBlock <= timeArgumentSeconds + 1000,
+ `Unexpected timestamp for block mined without specified timestamp - expected a value between ${timeArgumentSeconds} and ${
+ timeArgumentSeconds + 1000
+ }, got ${+unspecifiedBlock}`
+ );
+
+ await provider.disconnect();
+ });
+
+ it("should work with a numeric `timestampIncrement`", async () => {
+ const provider = await getProvider({
+ miner: { timestampIncrement }
+ });
+
+ const [specifiedBlock, unspecifiedBlock] =
+ await mineBlocksForTimestamps(provider);
+
+ assert.strictEqual(
+ specifiedBlock,
+ `0x${timeArgumentSeconds.toString(16)}`,
+ "Unexpected timestamp for block mined with specified timestamp"
+ );
+
+ assert.strictEqual(
+ unspecifiedBlock,
+ `0x${(timeArgumentSeconds + timestampIncrement).toString(16)}`,
+ "Unexpected timestamp for block mined without specified timestamp"
+ );
+
+ await provider.disconnect();
+ });
+ });
+
  it("applies the adjustment only once when `timestampIncrement` is used", async () => {
  const time = new Date("2019-01-01T00:00:00.000Z");
  const timestampIncrement = 5; // seconds
@@ -185,9 +262,9 @@ describe("provider", () => {
  "unexpected timestamp for the second block mined"
  );
  await mineAndAssertTimestamp(
- startTimeSeconds + fastForwardSeconds + timestampIncrement * 3
- ),
-  "unexpected timestamp for the third block mined";
+ startTimeSeconds + fastForwardSeconds + timestampIncrement * 3,
+  "unexpected timestamp for the third block mined"
+ );
  });
 
  it("uses the `timestampIncrement` for the first block when forking", async () => {