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: 
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](https://medium.com/fluidity/standing-the-time-of-test-b906fcc374a9):

```
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
}

```
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).