Increase block number on Ganache

Question

How can we increase block.number on Ganache for testing purpose ? If not possible do you know an alternative like passing X fake transactions to artificially increase block.number.

Or if we have to use a private chain: is it possible to change the time between blocks for faster testing ?

Best regards

Answer 1

You can increase block.timestamp (aka now):

web3.currentProvider.send({method: "evm_increaseTime", params: [numOfSeconds]});

Note that this method is a Ganache-extension of the standard.

So do not count on it on other node types (Geth, Parity, etc).

Also note that the code above is valid for web3.js v0.x.

You might need to run it asynchronously in web3.js v1.x.

Answer 2

In addition to goodvibration's answer, OpenZeppelin recently released their openzeppelin-test-helpers package. This library contains all kinds of helpers for testing smart contracts, including methods to increase the block number or timestamp, such as:

async time.advanceBlock()
async time.increase(duration)
async time.increaseTo(target)

I haven't used the library myself, but it sounds like it might be useful for you.

Answer 3

I needed a promise-based solution that didn't require installing a third-party library. Copy-pasting from Ethan Wessel's amazing article on truffle time testing:

advanceTime = (time) => {
  return new Promise((resolve, reject) => {
    web3.currentProvider.send({
      jsonrpc: '2.0',
      method: 'evm_increaseTime',
      params: [time],
      id: new Date().getTime()
    }, (err, result) => {
      if (err) { return reject(err) }
      return resolve(result)
    })
  })
}

advanceBlock = () => {
  return new Promise((resolve, reject) => {
    web3.currentProvider.send({
      jsonrpc: '2.0',
      method: 'evm_mine',
      id: new Date().getTime()
    }, (err, result) => {
      if (err) { return reject(err) }
      const newBlockHash = web3.eth.getBlock('latest').hash

      return resolve(newBlockHash)
    })
  })
}

takeSnapshot = () => {
  return new Promise((resolve, reject) => {
    web3.currentProvider.send({
      jsonrpc: '2.0',
      method: 'evm_snapshot',
      id: new Date().getTime()
    }, (err, snapshotId) => {
      if (err) { return reject(err) }
      return resolve(snapshotId)
    })
  })
}

revertToSnapShot = (id) => {
  return new Promise((resolve, reject) => {
    web3.currentProvider.send({
      jsonrpc: '2.0',
      method: 'evm_revert',
      params: [id],
      id: new Date().getTime()
    }, (err, result) => {
      if (err) { return reject(err) }
      return resolve(result)
    })
  })
}

advanceTimeAndBlock = async (time) => {
  await advanceTime(time)
  await advanceBlock()
  return Promise.resolve(web3.eth.getBlock('latest'))
}

module.exports = {
  advanceTime,
  advanceBlock,
  advanceTimeAndBlock,
  takeSnapshot,
  revertToSnapShot
}

Answer 4

As Rosco Kalis's suggestion of @openzeppelin/test-helpers

npm install --save-dev @openzeppelin/test-helpers

My Node.js code for contract testing:

const { time } = require("@openzeppelin/test-helpers");
require("@openzeppelin/test-helpers/configure")({
  provider: "http://localhost:7545",
});

async function main() {
  await time.advanceBlock();
  await myTimeRelatedContractMethodCall();
}
main()

Further reading : https://docs.openzeppelin.com/test-helpers/0.5/api#time

Answer 5

With ethers, you can increase the next block timestamp using:

await ethers.provider.send("evm_increaseTime", [numSecondsToIncreaseBy]);
await ethers.provider.send("evm_mine");

or you can choose the next block timestamp as follows (this may be important if you need exact block timestamps, since the above method may result in a timestamp larger than intended, if other blocks are mined before your next contract function call). The new timestamp must be greater than the current block timestamp:

  const currTimestamp =
          (await ethers.provider.getBlock(contract.deployTransaction.blockNumber))
          .timestamp;
  await ethers.provider.send("evm_setNextBlockTimestamp", [currTimestamp + 3600]);
  await ethers.provider.send("evm_mine");

You can also increase the block number by repeatedly sending an evm_mine transaction (but I don't know if there's a way to increase the block number by an arbitrary number of blocks with one call).