diff --git a/contracts/BucketAuction.sol b/contracts/BucketAuction.sol
index 854282b..415fa4c 100644
--- a/contracts/BucketAuction.sol
+++ b/contracts/BucketAuction.sol
@@ -12,9 +12,11 @@ import "./ERC721M.sol";
 
 contract BucketAuction is IBucketAuction, ERC721M {
     bool private _claimable;
+    bool private _firstTokenSent;
+    uint64 private _startTimeUnixSeconds;
+    uint64 private _endTimeUnixSeconds;
     uint256 private _minimumContributionInWei;
     uint256 private _price;
-    bool private _auctionActive;
     mapping(address => User) private _userData;
 
     constructor(
@@ -24,7 +26,10 @@ contract BucketAuction is IBucketAuction, ERC721M {
         uint256 maxMintableSupply,
         uint256 globalWalletLimit,
         address cosigner,
-        uint256 minimumContributionInWei
+        uint256 minimumContributionInWei,
+        uint64 startTimeUnixSeconds,
+        uint64 endTimeUnixSeconds
+
     )
         ERC721M(
             collectionName,
@@ -32,13 +37,14 @@ contract BucketAuction is IBucketAuction, ERC721M {
             tokenURISuffix,
             maxMintableSupply,
             globalWalletLimit,
-            cosigner,
-            /* timestampExpirySeconds= */
-            300
+            cosigner
         )
     {
         _claimable = false;
         _minimumContributionInWei = minimumContributionInWei;
+        _startTimeUnixSeconds = startTimeUnixSeconds;
+        _endTimeUnixSeconds = endTimeUnixSeconds ;
+        _firstTokenSent = false;
     }
 
     modifier isClaimable() {
@@ -47,12 +53,12 @@ contract BucketAuction is IBucketAuction, ERC721M {
     }
 
     modifier isAuctionActive() {
-        if (!_auctionActive) revert BucketAuctionNotActive();
+        if (_startTimeUnixSeconds > block.timestamp  || _endTimeUnixSeconds <= block.timestamp) revert BucketAuctionNotActive();
         _;
     }
 
     modifier isAuctionInactive() {
-        if (_auctionActive) revert BucketAuctionActive();
+        if (_startTimeUnixSeconds <= block.timestamp  && block.timestamp < _endTimeUnixSeconds) revert BucketAuctionActive();
         _;
     }
 
@@ -64,8 +70,16 @@ contract BucketAuction is IBucketAuction, ERC721M {
         return _price;
     }
 
+    function getStartTimeUnixSecods() external view returns (uint64) {
+        return _startTimeUnixSeconds;
+    }
+
+    function getEndTimeUnixSecods() external view returns (uint64) {
+        return _endTimeUnixSeconds;
+    }
+
     function getAuctionActive() external view returns (bool) {
-        return _auctionActive;
+        return _startTimeUnixSeconds <= block.timestamp && block.timestamp < _endTimeUnixSeconds;
     }
 
     function getUserData(address user) external view returns (User memory) {
@@ -82,13 +96,17 @@ contract BucketAuction is IBucketAuction, ERC721M {
     }
 
     /**
-     * @notice begin the auction.
+     * @notice set the start and end times in unix seconds for the bucket auction.
      * @dev cannot be reactivated after price has been set.
-     * @param b set 'true' to start auction, set 'false' to stop auction.
+     * @param startTime set to unix timestamp for the auction start time.
+     * @param endTime set to unix timestamp for the auction end time.
      */
-    function setAuctionActive(bool b) external onlyOwner cannotMint {
+    function setStartAndEndTimeUnixSeconds(uint64 startTime, uint64 endTime) external onlyOwner {
         if (_price != 0) revert PriceHasBeenSet();
-        _auctionActive = b;
+        if (endTime <= startTime) revert InvalidStartAndEndTimestamp();
+
+        _startTimeUnixSeconds = startTime;
+        _endTimeUnixSeconds = endTime;
     }
 
     /**
@@ -96,7 +114,12 @@ contract BucketAuction is IBucketAuction, ERC721M {
      *   multiple times will increase your bid amount. All bids placed are final
      *   and cannot be reversed.
      */
-    function bid() external payable isAuctionActive nonReentrant cannotMint {
+    function bid() 
+        external 
+        payable 
+        isAuctionActive 
+        nonReentrant
+    {
         User storage bidder = _userData[msg.sender]; // get user's current bid total
         uint256 contribution_ = bidder.contribution; // bidder.contribution is uint216
         unchecked {
@@ -129,11 +152,11 @@ contract BucketAuction is IBucketAuction, ERC721M {
      */
     function setPrice(uint256 priceInWei)
         external
-        isAuctionInactive
         onlyOwner
-        cannotMint
     {
         if (_claimable) revert CannotSetPriceIfClaimable();
+        if (block.timestamp <= _endTimeUnixSeconds) revert BucketAuctionActive();
+        if (_firstTokenSent) revert CannotSetPriceIfFirstTokenSent();
 
         _price = priceInWei;
         emit SetPrice(priceInWei);
@@ -149,6 +172,7 @@ contract BucketAuction is IBucketAuction, ERC721M {
         hasSupply(numberOfTokens)
     {
         _safeMint(to, numberOfTokens);
+        if (!_firstTokenSent && numberOfTokens > 0) _firstTokenSent = true;
     }
 
     /**
diff --git a/contracts/DutchAuction.sol b/contracts/DutchAuction.sol
index 515a155..50ca0f8 100644
--- a/contracts/DutchAuction.sol
+++ b/contracts/DutchAuction.sol
@@ -33,9 +33,7 @@ contract DutchAuction is IDutchAuction, ERC721M {
             tokenURISuffix,
             maxMintableSupply,
             globalWalletLimit,
-            cosigner,
-            /* timestampExpirySeconds= */
-            300
+            cosigner
         )
     {
         _refundable = refundable;
diff --git a/contracts/ERC721M.sol b/contracts/ERC721M.sol
index 3572208..9d538f2 100644
--- a/contracts/ERC721M.sol
+++ b/contracts/ERC721M.sol
@@ -12,20 +12,21 @@ import "./IERC721M.sol";
 contract ERC721M is IERC721M, ERC721AQueryable, Ownable, ReentrancyGuard {
     using ECDSA for bytes32;
 
+    uint64 public constant MIN_STAGE_INTERVAL_SECONDS = 60;
+    uint64 public constant CROSSMINT_TIMESTAMP_EXPIRY_SECONDS = 300;
+
     bool private _mintable;
-    bool private _baseURIPermanent;
-    // @notice Specify how long a signature from cosigner is valid for recommend 300 seconds
-    uint64 private _timestampExpirySeconds;
-    address private _cosigner;
-    address private _crossmintAddress;
-    uint256 private _activeStage;
+    string private _currentBaseURI;
     uint256 private _maxMintableSupply;
     uint256 private _globalWalletLimit;
-    string private _currentBaseURI;
     string private _tokenURISuffix;
+    bool private _baseURIPermanent;
+    address private _cosigner;
+    address private _crossmintAddress;
 
     MintStageInfo[] private _mintStages;
 
+    // Need this because struct cannot have nested mapping
     mapping(uint256 => mapping(address => uint32))
         private _stageMintedCountsPerWallet;
     mapping(uint256 => uint256) private _stageMintedCounts;
@@ -36,8 +37,7 @@ contract ERC721M is IERC721M, ERC721AQueryable, Ownable, ReentrancyGuard {
         string memory tokenURISuffix,
         uint256 maxMintableSupply,
         uint256 globalWalletLimit,
-        address cosigner,
-        uint64 timestampExpirySeconds
+        address cosigner
     ) ERC721A(collectionName, collectionSymbol) {
         if (globalWalletLimit > maxMintableSupply)
             revert GlobalWalletLimitOverflow();
@@ -47,7 +47,6 @@ contract ERC721M is IERC721M, ERC721AQueryable, Ownable, ReentrancyGuard {
         _globalWalletLimit = globalWalletLimit;
         _tokenURISuffix = tokenURISuffix;
         _cosigner = cosigner; // ethers.constants.AddressZero for no cosigning
-        _timestampExpirySeconds = timestampExpirySeconds;
     }
 
     modifier canMint() {
@@ -78,11 +77,6 @@ contract ERC721M is IERC721M, ERC721AQueryable, Ownable, ReentrancyGuard {
         emit SetCosigner(cosigner);
     }
 
-    function setTimestampExpirySeconds(uint64 expiry) external onlyOwner {
-        _timestampExpirySeconds = expiry;
-        emit SetTimestampExpirySeconds(expiry);
-    }
-
     function getCrossmintAddress() external view override returns (address) {
         return _crossmintAddress;
     }
@@ -98,12 +92,12 @@ contract ERC721M is IERC721M, ERC721AQueryable, Ownable, ReentrancyGuard {
             _mintStages.pop();
         }
 
-        uint64 timestampExpirySeconds = getTimestampExpirySeconds();
         for (uint256 i = 0; i < newStages.length; i++) {
             if (i >= 1) {
                 if (
                     newStages[i].startTimeUnixSeconds <
-                    newStages[i - 1].endTimeUnixSeconds + timestampExpirySeconds
+                    newStages[i - 1].endTimeUnixSeconds +
+                        MIN_STAGE_INTERVAL_SECONDS
                 ) {
                     revert InsufficientStageTimeGap();
                 }
@@ -176,16 +170,6 @@ contract ERC721M is IERC721M, ERC721AQueryable, Ownable, ReentrancyGuard {
         emit SetGlobalWalletLimit(globalWalletLimit);
     }
 
-    function getActiveStage() external view override returns (uint256) {
-        return _activeStage;
-    }
-
-    function setActiveStage(uint256 activeStage) external onlyOwner {
-        if (activeStage >= _mintStages.length) revert InvalidStage();
-        _activeStage = activeStage;
-        emit SetActiveStage(activeStage);
-    }
-
     function totalMintedByAddress(address a)
         external
         view
@@ -227,7 +211,7 @@ contract ERC721M is IERC721M, ERC721AQueryable, Ownable, ReentrancyGuard {
             if (
                 startTimeUnixSeconds <
                 _mintStages[index - 1].endTimeUnixSeconds +
-                    getTimestampExpirySeconds()
+                    MIN_STAGE_INTERVAL_SECONDS
             ) {
                 revert InsufficientStageTimeGap();
             }
@@ -285,17 +269,17 @@ contract ERC721M is IERC721M, ERC721AQueryable, Ownable, ReentrancyGuard {
         uint64 timestamp,
         bytes calldata signature
     ) internal canMint hasSupply(qty) {
-        uint256 activeStage = _activeStage;
-
-        if (activeStage >= _mintStages.length) revert InvalidStage();
+        uint64 stageTimestamp = uint64(block.timestamp);
 
         MintStageInfo memory stage;
         if (_cosigner != address(0)) {
             assertValidCosign(msg.sender, qty, timestamp, signature);
             _assertValidTimestamp(timestamp);
-            activeStage = getActiveStageFromTimestamp(timestamp);
+            stageTimestamp = timestamp;
         }
 
+        uint256 activeStage = getActiveStageFromTimestamp(stageTimestamp);
+
         stage = _mintStages[activeStage];
 
         // Check value
@@ -448,13 +432,11 @@ contract ERC721M is IERC721M, ERC721AQueryable, Ownable, ReentrancyGuard {
         revert InvalidStage();
     }
 
-    function getTimestampExpirySeconds() public view override returns (uint64) {
-        return _timestampExpirySeconds;
-    }
-
     function _assertValidTimestamp(uint64 timestamp) internal view {
-        if (timestamp < block.timestamp - getTimestampExpirySeconds())
-            revert TimestampExpired();
+        uint64 threshold = msg.sender == _crossmintAddress
+            ? CROSSMINT_TIMESTAMP_EXPIRY_SECONDS
+            : MIN_STAGE_INTERVAL_SECONDS;
+        if (timestamp < block.timestamp - threshold) revert TimestampExpired();
     }
 
     function _assertValidStartAndEndTimestamp(uint64 start, uint64 end)
diff --git a/contracts/ERC721MCallback.sol b/contracts/ERC721MCallback.sol
index c151f13..638a5cc 100644
--- a/contracts/ERC721MCallback.sol
+++ b/contracts/ERC721MCallback.sol
@@ -14,8 +14,7 @@ contract ERC721MCallback is ERC721M, IERC721MCallback {
         string memory tokenURISuffix,
         uint256 maxMintableSupply,
         uint256 globalWalletLimit,
-        address cosigner,
-        uint64 timestampExpirySeconds
+        address cosigner
     )
         ERC721M(
             collectionName,
@@ -23,8 +22,7 @@ contract ERC721MCallback is ERC721M, IERC721MCallback {
             tokenURISuffix,
             maxMintableSupply,
             globalWalletLimit,
-            cosigner,
-            timestampExpirySeconds
+            cosigner
         )
     {}
 
diff --git a/contracts/IBucketAuction.sol b/contracts/IBucketAuction.sol
index f1029f5..5da7c63 100644
--- a/contracts/IBucketAuction.sol
+++ b/contracts/IBucketAuction.sol
@@ -7,6 +7,7 @@ interface IBucketAuction {
     error BucketAuctionNotActive();
     error CannotSendMoreThanUserPurchased();
     error CannotSetPriceIfClaimable();
+    error CannotSetPriceIfFirstTokenSent();
     error LowerThanMinBidAmount();
     error NotClaimable();
     error PriceHasBeenSet();
diff --git a/contracts/IERC721M.sol b/contracts/IERC721M.sol
index 4a83c61..7e8c553 100644
--- a/contracts/IERC721M.sol
+++ b/contracts/IERC721M.sol
@@ -52,7 +52,6 @@ interface IERC721M is IERC721AQueryable {
     event SetGlobalWalletLimit(uint256 globalWalletLimit);
     event SetActiveStage(uint256 activeStage);
     event SetBaseURI(string baseURI);
-    event SetTimestampExpirySeconds(uint64 expiry);
     event PermanentBaseURI(string baseURI);
     event Withdraw(uint256 value);
 
@@ -81,10 +80,6 @@ interface IERC721M is IERC721AQueryable {
             uint256
         );
 
-    function getActiveStage() external view returns (uint256);
-
-    function getTimestampExpirySeconds() external view returns (uint64);
-
     function getActiveStageFromTimestamp(uint64 timestamp)
         external
         view
diff --git a/hardhat.config.ts b/hardhat.config.ts
index 678e1e0..8addb87 100644
--- a/hardhat.config.ts
+++ b/hardhat.config.ts
@@ -8,11 +8,11 @@ import 'hardhat-watcher';
 import { HardhatUserConfig, task, types } from 'hardhat/config';
 import 'solidity-coverage';
 
-import { setActiveStage } from './scripts/setActiveStage';
 import { setCrossmintAddress } from './scripts/setCrossmintAddress';
 import { setStages } from './scripts/setStages';
 import { setMintable } from './scripts/setMintable';
 import { deploy } from './scripts/deploy';
+import { deployBA } from './scripts/deployBA';
 import { setBaseURI } from './scripts/setBaseURI';
 import { mint } from './scripts/mint';
 import { ownerMint } from './scripts/ownerMint';
@@ -66,11 +66,6 @@ task('setStages', 'Set stages for ERC721M')
   .addParam('stages', 'stages json file')
   .setAction(setStages);
 
-task('setActiveStage', 'Set active stage for ERC721M')
-  .addParam('contract', 'contract address')
-  .addParam('stage', 'stage index to set to active')
-  .setAction(setActiveStage);
-
 task('setMintable', 'Set mintable state for ERC721M')
   .addParam('contract', 'contract address')
   .addParam('mintable', 'mintable state', 'true', types.boolean)
@@ -102,6 +97,7 @@ task('setCrossmintAddress', 'Set crossmint address')
 task('mint', 'Mint token(s)')
   .addParam('contract', 'contract address')
   .addParam('qty', 'quantity to mint', '1')
+  .addParam('minttime', 'time of the mint')
   .setAction(mint);
 
 task('ownerMint', 'Mint token(s) as owner')
@@ -119,4 +115,24 @@ task('setMaxMintableSupply', 'set max mintable supply')
   .addParam('contract', 'contract address')
   .addParam('supply', 'new supply')
   .setAction(setMaxMintableSupply);
+
+task('deployBA', 'Deploy BucketAuction')
+  .addParam('name', 'name')
+  .addParam('symbol', 'symbol')
+  .addParam('maxsupply', 'max supply')
+  .addParam('tokenurisuffix', 'token uri suffix', '.json')
+  .addParam('globalwalletlimit', 'global wallet limit')
+  .addOptionalParam(
+    'cosigner',
+    'cosigner address (0x00...000 if not using cosign)',
+    '0x0000000000000000000000000000000000000000',
+  )
+  .addParam(
+    'mincontributioninwei',
+    'The minimum contribution in wei required only for the AcutionBucket',
+  )
+  .addParam('auctionstarttime', 'The start time of the bucket auction')
+  .addParam('auctionendtime', 'The end time of the bucket auction')
+  .setAction(deployBA);
+
 export default config;
diff --git a/package-lock.json b/package-lock.json
index a6eb7f2..53b358c 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,12 +1,12 @@
 {
   "name": "@magiceden-oss/erc721m",
-  "version": "0.0.8",
+  "version": "0.0.5",
   "lockfileVersion": 2,
   "requires": true,
   "packages": {
     "": {
       "name": "@magiceden-oss/erc721m",
-      "version": "0.0.8",
+      "version": "0.0.5",
       "dependencies": {
         "@openzeppelin/contracts": "^4.7.3",
         "erc721a": "^4.2.3"
diff --git a/package.json b/package.json
index 254c544..07b6359 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@magiceden-oss/erc721m",
-  "version": "0.0.8",
+  "version": "0.0.7",
   "description": "erc721m contract for Solidity",
   "files": [
     "/contracts/**/*.sol",
diff --git a/scripts/common/constants.ts b/scripts/common/constants.ts
new file mode 100644
index 0000000..81e3041
--- /dev/null
+++ b/scripts/common/constants.ts
@@ -0,0 +1,6 @@
+// This module wraps up the constants which can be used by any script
+
+export const ContractDetails = {
+  ERC721M: { name: 'ERC721M' }, // The contract of direct sales
+  BucketAuction: { name: 'BucketAuction' }, // The contract of bucket auctions
+};
diff --git a/scripts/deploy.ts b/scripts/deploy.ts
index 880e9b4..a9f5fa6 100644
--- a/scripts/deploy.ts
+++ b/scripts/deploy.ts
@@ -4,6 +4,7 @@
 // When running the script with `npx hardhat run <script>` you'll find the Hardhat
 // Runtime Environment's members available in the global scope.
 import { HardhatRuntimeEnvironment } from 'hardhat/types';
+import { ContractDetails } from './common/constants';
 
 export interface IDeployParams {
   name: string;
@@ -18,8 +19,15 @@ export const deploy = async (
   args: IDeployParams,
   hre: HardhatRuntimeEnvironment,
 ) => {
-  console.log('Deploying ERC721M with params', JSON.stringify(args, null, 2));
-  const ERC721M = await hre.ethers.getContractFactory('ERC721M');
+  console.log(
+    `Going to deploy ${ContractDetails.ERC721M.name} with params`,
+    JSON.stringify(args, null, 2),
+  );
+
+  const ERC721M = await hre.ethers.getContractFactory(
+    ContractDetails.ERC721M.name,
+  );
+
   const erc721M = await ERC721M.deploy(
     args.name,
     args.symbol,
@@ -31,5 +39,5 @@ export const deploy = async (
 
   await erc721M.deployed();
 
-  console.log('ERC721M deployed to:', erc721M.address);
+  console.log(`${ContractDetails.ERC721M.name} deployed to:`, erc721M.address);
 };
diff --git a/scripts/deployBA.ts b/scripts/deployBA.ts
new file mode 100644
index 0000000..e5a1cee
--- /dev/null
+++ b/scripts/deployBA.ts
@@ -0,0 +1,55 @@
+// We require the Hardhat Runtime Environment explicitly here. This is optional
+// but useful for running the script in a standalone fashion through `node <script>`.
+//
+// When running the script with `npx hardhat run <script>` you'll find the Hardhat
+// Runtime Environment's members available in the global scope.
+import fs from 'fs';
+import { ContractDetails } from './common/constants';
+import { HardhatRuntimeEnvironment } from 'hardhat/types';
+
+export interface IDeployParams {
+  name: string;
+  symbol: string;
+  tokenurisuffix: string;
+  maxsupply: string;
+  globalwalletlimit: string;
+  cosigner: string;
+  mincontributioninwei: number;
+  auctionstarttime: string;
+  auctionendtime: string;
+}
+
+export const deployBA = async (
+  args: IDeployParams,
+  hre: HardhatRuntimeEnvironment,
+) => {
+  // Set the contract name
+  const contractName = ContractDetails.BucketAuction.name;
+  console.log(
+    `Going to deploy ${contractName} with params`,
+    JSON.stringify(args, null, 2),
+  );
+  if (args.mincontributioninwei <= 0) {
+    throw new Error(
+      `The parameter mincontributioninwei should be bigger than 0. Given value: ${args.mincontributioninwei}`,
+    );
+  }
+  const contractFactory = await hre.ethers.getContractFactory(contractName);
+  // Set the parameters for the contract constructor
+  const params = [
+    args.name,
+    args.symbol,
+    args.tokenurisuffix,
+    hre.ethers.BigNumber.from(args.maxsupply),
+    hre.ethers.BigNumber.from(args.globalwalletlimit),
+    args.cosigner ?? hre.ethers.constants.AddressZero,
+    hre.ethers.BigNumber.from(args.mincontributioninwei),
+    Math.floor(new Date(args.auctionstarttime).getTime() / 1000),
+    Math.floor(new Date(args.auctionendtime).getTime() / 1000),
+  ];
+
+  const contract = await contractFactory.deploy(...params);
+  await contract.deployed();
+
+  console.log(`${contractName} deployed to:`, contract.address);
+};
diff --git a/scripts/mint.ts b/scripts/mint.ts
index 71c7f61..8592e84 100644
--- a/scripts/mint.ts
+++ b/scripts/mint.ts
@@ -1,8 +1,10 @@
 import { HardhatRuntimeEnvironment } from 'hardhat/types';
+import { ContractDetails } from './common/constants';
 
 export interface IMintParams {
   contract: string;
   quantity?: string;
+  minttime: number;
 }
 
 export const mint = async (
@@ -10,12 +12,13 @@ export const mint = async (
   hre: HardhatRuntimeEnvironment,
 ) => {
   const { ethers } = hre;
-  const ERC721M = await ethers.getContractFactory('ERC721M');
+  const ERC721M = await ethers.getContractFactory(ContractDetails.ERC721M.name);
   const contract = ERC721M.attach(args.contract);
-  const activeStage = await contract.getActiveStage();
-  const [stageInfo] = await contract.getStageInfo(activeStage);
+  const timestamp = Math.floor(new Date(args.minttime).getTime() / 1000);
+  const stageIndex = await contract.getActiveStageFromTimestamp(timestamp);
+  const [stageInfo] = await contract.getStageInfo(stageIndex);
   const qty = ethers.BigNumber.from(args.quantity ?? 1);
-  const tx = await contract.mint(qty, [], 0, '0x', {
+  const tx = await contract.mint(qty, [], timestamp, '0x', {
     value: stageInfo.price.mul(qty),
   });
   console.log(`Submitted tx ${tx.hash}`);
diff --git a/scripts/ownerMint.ts b/scripts/ownerMint.ts
index d625962..2044e51 100644
--- a/scripts/ownerMint.ts
+++ b/scripts/ownerMint.ts
@@ -1,4 +1,5 @@
 import { HardhatRuntimeEnvironment } from 'hardhat/types';
+import { ContractDetails } from './common/constants';
 
 export interface IOwnerMintParams {
   contract: string;
@@ -12,7 +13,7 @@ export const ownerMint = async (
 ) => {
   console.log(`Minting ${args.qty ?? 1} tokens to ${args.to}...`);
   const { ethers } = hre;
-  const ERC721M = await ethers.getContractFactory('ERC721M');
+  const ERC721M = await ethers.getContractFactory(ContractDetails.ERC721M.name);
   const contract = ERC721M.attach(args.contract);
   const qty = ethers.BigNumber.from(args.qty ?? 1);
   const tx = await contract.ownerMint(
diff --git a/scripts/setActiveStage.ts b/scripts/setActiveStage.ts
deleted file mode 100644
index 5352aec..0000000
--- a/scripts/setActiveStage.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-import { HardhatRuntimeEnvironment } from 'hardhat/types';
-
-export interface ISetActiveStageParams {
-  stage: number;
-  contract: string;
-}
-
-export const setActiveStage = async (
-  args: ISetActiveStageParams,
-  hre: HardhatRuntimeEnvironment,
-) => {
-  const { ethers } = hre;
-  const ERC721M = await ethers.getContractFactory('ERC721M');
-  const contract = ERC721M.attach(args.contract);
-  const tx = await contract.setActiveStage(args.stage);
-  console.log(`Submitted tx ${tx.hash}`);
-
-  await tx.wait();
-
-  console.log('Set active stage:', tx.hash);
-
-  const [stage] = await contract.getStageInfo(args.stage);
-  console.log(`New active stage: ${stage}`);
-};
diff --git a/scripts/setBaseURI.ts b/scripts/setBaseURI.ts
index 87b4185..7f94a6b 100644
--- a/scripts/setBaseURI.ts
+++ b/scripts/setBaseURI.ts
@@ -1,4 +1,5 @@
 import { HardhatRuntimeEnvironment } from 'hardhat/types';
+import { ContractDetails } from './common/constants';
 
 export interface ISetBaseURIParams {
   uri: string;
@@ -10,7 +11,7 @@ export const setBaseURI = async (
   hre: HardhatRuntimeEnvironment,
 ) => {
   const { ethers } = hre;
-  const ERC721M = await ethers.getContractFactory('ERC721M');
+  const ERC721M = await ethers.getContractFactory(ContractDetails.ERC721M.name);
   const contract = ERC721M.attach(args.contract);
   const tx = await contract.setBaseURI(args.uri);
   console.log(`Submitted tx ${tx.hash}`);
diff --git a/scripts/setCrossmintAddress.ts b/scripts/setCrossmintAddress.ts
index 0b385f1..c4d5581 100644
--- a/scripts/setCrossmintAddress.ts
+++ b/scripts/setCrossmintAddress.ts
@@ -1,4 +1,5 @@
 import { HardhatRuntimeEnvironment } from 'hardhat/types';
+import { ContractDetails } from './common/constants';
 
 export interface ISetCrossmintAddress {
   crossmintAddress: string;
@@ -10,7 +11,7 @@ export const setCrossmintAddress = async (
   hre: HardhatRuntimeEnvironment,
 ) => {
   const { ethers } = hre;
-  const ERC721M = await ethers.getContractFactory('ERC721M');
+  const ERC721M = await ethers.getContractFactory(ContractDetails.ERC721M.name);
   const contract = ERC721M.attach(args.contract);
   const tx = await contract.setCrossmintAddress(args.crossmintAddress);
   console.log(`Submitted tx ${tx.hash}`);
diff --git a/scripts/setGlobalWalletLimit.ts b/scripts/setGlobalWalletLimit.ts
index 70b75dd..4ca314a 100644
--- a/scripts/setGlobalWalletLimit.ts
+++ b/scripts/setGlobalWalletLimit.ts
@@ -1,4 +1,5 @@
 import { HardhatRuntimeEnvironment } from 'hardhat/types';
+import { ContractDetails } from './common/constants';
 
 export interface ISetBaseURIParams {
   limit: string;
@@ -10,7 +11,7 @@ export const setGlobalWalletLimit = async (
   hre: HardhatRuntimeEnvironment,
 ) => {
   const { ethers } = hre;
-  const ERC721M = await ethers.getContractFactory('ERC721M');
+  const ERC721M = await ethers.getContractFactory(ContractDetails.ERC721M.name);
   const contract = ERC721M.attach(args.contract);
   const tx = await contract.setGlobalWalletLimit(args.limit);
   console.log(`Submitted tx ${tx.hash}`);
diff --git a/scripts/setMaxMintableSupply.ts b/scripts/setMaxMintableSupply.ts
index 1867a5f..22a9889 100644
--- a/scripts/setMaxMintableSupply.ts
+++ b/scripts/setMaxMintableSupply.ts
@@ -10,12 +10,9 @@ export const setMaxMintableSupply = async (
   hre: HardhatRuntimeEnvironment,
 ) => {
   const { ethers } = hre;
-  const ERC721M = await ethers.getContractFactory('ERC721MCallback');
+  const ERC721M = await ethers.getContractFactory('ERC721M');
   const contract = ERC721M.attach(args.contract);
-  const tx = await contract.setMaxMintableSupply(parseInt(args.supply, 10), {
-    nonce: 12,
-    gasPrice: ethers.utils.parseUnits('30', 'gwei'),
-  });
+  const tx = await contract.setMaxMintableSupply(parseInt(args.supply, 10));
   console.log(`Submitted tx ${tx.hash}`);
 
   await tx.wait();
diff --git a/scripts/setMintable.ts b/scripts/setMintable.ts
index 4a3b12e..ba29536 100644
--- a/scripts/setMintable.ts
+++ b/scripts/setMintable.ts
@@ -1,4 +1,5 @@
 import { HardhatRuntimeEnvironment } from 'hardhat/types';
+import { ContractDetails } from './common/constants';
 
 export interface ISetMintableParams {
   mintable: boolean;
@@ -10,7 +11,7 @@ export const setMintable = async (
   hre: HardhatRuntimeEnvironment,
 ) => {
   const { ethers } = hre;
-  const ERC721M = await ethers.getContractFactory('ERC721M');
+  const ERC721M = await ethers.getContractFactory(ContractDetails.ERC721M.name);
   const contract = ERC721M.attach(args.contract);
   const tx = await contract.setMintable(Boolean(args.mintable));
   console.log(`Submitted tx ${tx.hash}`);
diff --git a/scripts/setStages.ts b/scripts/setStages.ts
index cf1e655..0aefda0 100644
--- a/scripts/setStages.ts
+++ b/scripts/setStages.ts
@@ -1,6 +1,7 @@
 import { HardhatRuntimeEnvironment } from 'hardhat/types';
 import { MerkleTree } from 'merkletreejs';
 import fs from 'fs';
+import { ContractDetails } from './common/constants';
 
 export interface ISetStagesParams {
   stages: string;
@@ -24,7 +25,7 @@ export const setStages = async (
   const stagesConfig = JSON.parse(
     fs.readFileSync(args.stages, 'utf-8'),
   ) as StageConfig[];
-  const ERC721M = await ethers.getContractFactory('ERC721M');
+  const ERC721M = await ethers.getContractFactory(ContractDetails.ERC721M.name);
   const contract = ERC721M.attach(args.contract);
   const merkleRoots = await Promise.all(
     stagesConfig.map((stage) => {
diff --git a/scripts/transferOwnership.ts b/scripts/transferOwnership.ts
index 60a61fe..5e366f6 100644
--- a/scripts/transferOwnership.ts
+++ b/scripts/transferOwnership.ts
@@ -1,4 +1,5 @@
 import { HardhatRuntimeEnvironment } from 'hardhat/types';
+import { ContractDetails } from './common/constants';
 
 export interface ITransferOwnershipParams {
   owner: string;
@@ -10,7 +11,7 @@ export const transferOwnership = async (
   hre: HardhatRuntimeEnvironment,
 ) => {
   const { ethers } = hre;
-  const ERC721M = await ethers.getContractFactory('ERC721M');
+  const ERC721M = await ethers.getContractFactory(ContractDetails.ERC721M.name);
   const contract = ERC721M.attach(args.contract);
   const tx = await contract.transferOwnership(args.owner);
   console.log(`Submitted tx ${tx.hash}`);
diff --git a/test/BucketAuction.test.ts b/test/BucketAuction.test.ts
index 9785488..12bb732 100644
--- a/test/BucketAuction.test.ts
+++ b/test/BucketAuction.test.ts
@@ -14,6 +14,8 @@ describe('BucketAuction', function () {
   let readonlyConn: BucketAuction;
   let owner: SignerWithAddress;
   let readonly: SignerWithAddress;
+  let auctionStartTimestamp = 0;
+  let auctionEndTimestamp = 1;
 
   beforeEach(async () => {
     const BA = await ethers.getContractFactory('BucketAuction');
@@ -25,47 +27,117 @@ describe('BucketAuction', function () {
       /* globalWalletLimit= */ 0,
       ethers.constants.AddressZero,
       /* minimumContributionInWei= */ 100,
+      0, // Placeholder; startTimeUnixSeconds will be overwritten later
+      1, // Placeholder; endTimeUnixSeconds will be overwritten later
     );
     await ba.deployed();
 
     [owner, readonly] = await ethers.getSigners();
     ownerConn = ba.connect(owner);
+    await ownerConn.setStages([
+      {
+        price: ethers.utils.parseEther('0.1'),
+        walletLimit: 0,
+        merkleRoot: ethers.utils.hexZeroPad('0x0', 32),
+        maxStageSupply: 100,
+        startTimeUnixSeconds: 0,
+        endTimeUnixSeconds: 1,
+      },
+      {
+        price: ethers.utils.parseEther('0.2'),
+        walletLimit: 0,
+        merkleRoot: ethers.utils.hexZeroPad('0x0', 32),
+        maxStageSupply: 100,
+        startTimeUnixSeconds: 61,
+        endTimeUnixSeconds: 62,
+      },
+    ]);
+    // Get an estimated stage start time
+    const block = await ethers.provider.getBlock(
+      await ethers.provider.getBlockNumber(),
+    );
+    // Set the start and end timestamps for the bucket Auction
+    auctionStartTimestamp = block.timestamp + 100;
+    auctionEndTimestamp = block.timestamp + 200;
+    ownerConn.setStartAndEndTimeUnixSeconds(
+      auctionStartTimestamp,
+      auctionEndTimestamp,
+    );
+
     readonlyConn = ba.connect(readonly);
   });
 
-  it('Contract can be set Active/Inactive', async () => {
+  it('Getters/Setters of the auction start and end timestamps ', async () => {
+    // Set the auction start time
+    expect(await readonlyConn.getStartTimeUnixSecods()).to.be.equal(
+      auctionStartTimestamp,
+    );
+    // Set the auction end time
+    expect(await readonlyConn.getEndTimeUnixSecods()).to.be.equal(
+      auctionEndTimestamp,
+    );
+    // It should be reverted if start and end times are equal
+    await expect(
+      ownerConn.setStartAndEndTimeUnixSeconds(
+        auctionStartTimestamp,
+        auctionStartTimestamp,
+      ),
+    ).to.be.revertedWith('InvalidStartAndEndTimestamp');
+    // It should be reverted if start is bigger than the end time
+    await expect(
+      ownerConn.setStartAndEndTimeUnixSeconds(
+        auctionStartTimestamp,
+        auctionStartTimestamp - 1,
+      ),
+    ).to.be.revertedWith('InvalidStartAndEndTimestamp');
+    // Set both start and end times together
+    await ownerConn.setStartAndEndTimeUnixSeconds(
+      auctionStartTimestamp - 100,
+      auctionEndTimestamp - 100,
+    );
+    // Verify the start and end times were updated properly
+    expect(await readonlyConn.getStartTimeUnixSecods()).to.be.equal(
+      auctionStartTimestamp - 100,
+    );
+    expect(await readonlyConn.getEndTimeUnixSecods()).to.be.equal(
+      auctionEndTimestamp - 100,
+    );
+    // Active auction by setting the block.timestamp to the start time of the auction
+    await ethers.provider.send('evm_mine', [auctionStartTimestamp]);
+    // Set the price so that the subsequent time setters would fail
+    await ownerConn.setPrice(100);
+    // Set the price so that the subsequent setters would fail
+    await expect(
+      ownerConn.setStartAndEndTimeUnixSeconds(
+        auctionStartTimestamp + 100,
+        auctionEndTimestamp + 100,
+      ),
+    ).to.be.revertedWith('PriceHasBeenSet');
+  });
+
+  it('Auction is Active/Inactive according to the current time', async () => {
+    // Inactive before the start time of the auction
+    await ethers.provider.send('evm_mine', [auctionStartTimestamp - 10]);
     // starts as Inactive
     expect(await ownerConn.getAuctionActive()).to.be.false;
 
-    // as an owner, we can set it to be active
-    await ownerConn.setAuctionActive(true);
+    // Active after the start time of the auction
+    await ethers.provider.send('evm_mine', [auctionStartTimestamp]);
     expect(await ownerConn.getAuctionActive()).to.be.true;
 
-    // as an owner, we can set it to be inactive again
-    await ownerConn.setAuctionActive(false);
+    // Inactive after the end time of the auction
+    await ethers.provider.send('evm_mine', [auctionEndTimestamp]);
     expect(await ownerConn.getAuctionActive()).to.be.false;
-
-    // as an owner, if it's mintable, we cannot set this function
-    await ownerConn.setMintable(true);
-    await expect(ownerConn.setAuctionActive(true)).to.be.revertedWith(
-      'Mintable',
-    );
-    await ownerConn.setMintable(false); // clean up
-
-    // as an owner, if the price is set, we cannot set this function
-    await ownerConn.setPrice(100);
-    await expect(ownerConn.setAuctionActive(true)).to.be.revertedWith(
-      'PriceHasBeenSet',
-    );
-    await ownerConn.setPrice(0); // clean up
-
-    // as an readonly user, we cannot set it to be active
-    await expect(readonlyConn.setAuctionActive(true)).to.be.revertedWith(
-      'Ownable',
-    );
   });
 
   describe('Bidding', function () {
+    it('Reverts if the active stage is not a BucketAuction', async () => {
+      // if the current active stage is not a bucket auction; revert with InvalidStage
+      await expect(readonlyConn.bid()).to.be.revertedWith(
+        'BucketAuctionNotActive',
+      );
+    });
+
     it('Reverts if auction not active', async () => {
       // it starts as Inactive, so we cannot make bids
       await expect(readonlyConn.bid()).to.be.revertedWith(
@@ -74,8 +146,8 @@ describe('BucketAuction', function () {
     });
 
     it('Reverts if bid under minimum', async () => {
-      await ownerConn.setAuctionActive(true);
-
+      // Active auction by setting the block.timestamp to the start time of the auction
+      await ethers.provider.send('evm_mine', [auctionStartTimestamp]);
       // we cannot bid under the minimum
       await expect(readonlyConn.bid({ value: 10 })).to.be.revertedWith(
         'LowerThanMinBidAmount',
@@ -83,8 +155,8 @@ describe('BucketAuction', function () {
     });
 
     it('Can make bids', async () => {
-      await ownerConn.setAuctionActive(true);
-
+      // Active auction by setting the block.timestamp to the start time of the auction
+      await ethers.provider.send('evm_mine', [auctionStartTimestamp]);
       await ethers.provider.send('hardhat_setBalance', [
         readonly.address,
         ONE_ETH,
@@ -107,12 +179,13 @@ describe('BucketAuction', function () {
     });
 
     it('Revert if bid when collection is mintable', async () => {
-      await ownerConn.setAuctionActive(true);
-
+      // Active auction by setting the block.timestamp to the start time of the auction
+      await ethers.provider.send('evm_mine', [auctionStartTimestamp]);
       // we cannot make bids when colleciton is mintable in the ERC721M stages
       await ownerConn.setMintable(true);
-      await expect(readonlyConn.bid({ value: 100 })).to.be.revertedWith(
-        'Mintable',
+      await expect(readonlyConn.bid({ value: 100 })).to.emit(
+        readonlyConn,
+        'Bid',
       );
     });
   });
@@ -130,19 +203,15 @@ describe('BucketAuction', function () {
   });
 
   it('Can set price', async () => {
+    // Setup the test context: block.timestamp should comply to the stage being active
+    await ethers.provider.send('evm_mine', [auctionStartTimestamp]);
     // If the auction is active, then we cannot set price.
-    await ownerConn.setAuctionActive(true);
     await expect(ownerConn.setPrice(200)).to.be.revertedWith(
       'BucketAuctionActive',
     );
-    // Clean up
-    await ownerConn.setAuctionActive(false);
 
-    // If can mint, it means something weng wrong. Then we cannot set price.
-    await ownerConn.setMintable(true);
-    await expect(ownerConn.setPrice(200)).to.be.revertedWith('Mintable');
-    // Clean up
-    await ownerConn.setMintable(false);
+    // Setup the test context: block.timestamp should comply to the stage being active
+    await ethers.provider.send('evm_mine', [auctionEndTimestamp]);
 
     // If claimable, then we cannot set price.
     await ownerConn.setClaimable(true);
@@ -152,6 +221,13 @@ describe('BucketAuction', function () {
     // Clean up
     await ownerConn.setClaimable(false);
 
+    // If can mint, we should still be able to set price.
+    await ownerConn.setMintable(true);
+    await expect(ownerConn.setPrice(100)).to.emit(ownerConn, 'SetPrice');
+    await expect(await readonlyConn.getPrice()).to.be.equal(100);
+    // Clean up
+    await ownerConn.setMintable(false);
+
     await expect(ownerConn.setPrice(200)).to.emit(ownerConn, 'SetPrice');
     expect(await readonlyConn.getPrice()).to.be.equal(200);
     await expect(readonlyConn.setPrice(200)).to.be.revertedWith('Ownable');
@@ -179,8 +255,8 @@ describe('BucketAuction', function () {
 
     runs.forEach((run) => {
       it(`Bid: ${run.bids}, price: ${run.price}`, async () => {
-        await ownerConn.setAuctionActive(true);
-
+        // Active auction by setting the block.timestamp to the start time of the auction
+        await ethers.provider.send('evm_mine', [auctionStartTimestamp]);
         await ethers.provider.send('hardhat_setBalance', [
           readonly.address,
           ONE_ETH,
@@ -199,7 +275,8 @@ describe('BucketAuction', function () {
         ).toNumber();
         expect(balance).to.eq(contribution);
 
-        await ownerConn.setAuctionActive(false);
+        // Inactive auction by setting the block.timestamp to the end time of the auction
+        await ethers.provider.send('evm_mine', [auctionEndTimestamp]);
         await ownerConn.setPrice(run.price);
         await ownerConn.setClaimable(true);
 
@@ -226,9 +303,8 @@ describe('BucketAuction', function () {
 
   describe('User claim and refund', function () {
     it('user claimTokensAndRefund', async () => {
-      // we then turn on the AuctionActive, so that we can start the bids
-      await ownerConn.setAuctionActive(true);
-
+      // Active auction by setting the block.timestamp to the start time of the auction
+      await ethers.provider.send('evm_mine', [auctionStartTimestamp]);
       // we can make bids
       await ethers.provider.send('hardhat_setBalance', [
         readonly.address,
@@ -248,8 +324,9 @@ describe('BucketAuction', function () {
       ).toNumber();
       expect(balance).to.eq(100);
 
+      // Inactive auction by setting the block.timestamp to the end time of the auction
+      await ethers.provider.send('evm_mine', [auctionEndTimestamp]);
       // and then we prepare to close the auction and settle the price and refund
-      await ownerConn.setAuctionActive(false);
       await ownerConn.setPrice(80);
 
       expect(await ownerConn.getClaimable()).to.be.false;
@@ -283,6 +360,8 @@ describe('BucketAuction', function () {
     });
 
     it('user without bidding claimTokensAndRefund', async () => {
+      // Inactive auction by setting the block.timestamp to the end time of the auction
+      await ethers.provider.send('evm_mine', [auctionEndTimestamp]);
       await ownerConn.setPrice(80);
       await ownerConn.setClaimable(true);
 
@@ -297,8 +376,8 @@ describe('BucketAuction', function () {
     });
 
     it('Reverts if price not set', async () => {
-      await ownerConn.setAuctionActive(true);
-
+      // Active auction by setting the block.timestamp to the start time of the auction
+      await ethers.provider.send('evm_mine', [auctionStartTimestamp]);
       await ethers.provider.send('hardhat_setBalance', [
         readonly.address,
         ONE_ETH,
@@ -308,7 +387,8 @@ describe('BucketAuction', function () {
         'Bid',
       );
 
-      await ownerConn.setAuctionActive(false);
+      // Inactive auction by setting the block.timestamp to the end time of the auction
+      await ethers.provider.send('evm_mine', [auctionEndTimestamp]);
       await ownerConn.setClaimable(true);
 
       await expect(readonlyConn.claimTokensAndRefund()).to.be.revertedWith(
@@ -317,8 +397,8 @@ describe('BucketAuction', function () {
     });
 
     it('Reverts if not claimable', async () => {
-      await ownerConn.setAuctionActive(true);
-
+      // Active auction by setting the block.timestamp to the start time of the auction
+      await ethers.provider.send('evm_mine', [auctionStartTimestamp]);
       await ethers.provider.send('hardhat_setBalance', [
         readonly.address,
         ONE_ETH,
@@ -328,7 +408,8 @@ describe('BucketAuction', function () {
         'Bid',
       );
 
-      await ownerConn.setAuctionActive(false);
+      // Inactive auction by setting the block.timestamp to the end time of the auction
+      await ethers.provider.send('evm_mine', [auctionEndTimestamp]);
       await ownerConn.setPrice(100);
 
       await expect(readonlyConn.claimTokensAndRefund()).to.be.revertedWith(
@@ -337,8 +418,8 @@ describe('BucketAuction', function () {
     });
 
     it('Reverts if not enough supply', async () => {
-      await ownerConn.setAuctionActive(true);
-
+      // Active auction by setting the block.timestamp to the start time of the auction
+      await ethers.provider.send('evm_mine', [auctionStartTimestamp]);
       await ethers.provider.send('hardhat_setBalance', [
         readonly.address,
         ONE_ETH,
@@ -349,8 +430,9 @@ describe('BucketAuction', function () {
         'Bid',
       );
 
-      await ownerConn.setAuctionActive(false);
-      // Expected tokens is 1001 whcih exceeds max mintbale supply = 1000.
+      // Inactive auction by setting the block.timestamp to the end time of the auction
+      await ethers.provider.send('evm_mine', [auctionEndTimestamp]);
+      // Expected tokens is 1001 which exceeds max mintbale supply = 1000.
       await ownerConn.setPrice(1);
       await ownerConn.setClaimable(true);
 
@@ -359,6 +441,84 @@ describe('BucketAuction', function () {
       );
     });
 
+    it('Can NOT set price if the first token already sent', async () => {
+      // Active auction by setting the block.timestamp to the start time of the auction
+      await ethers.provider.send('evm_mine', [auctionStartTimestamp]);
+      await ethers.provider.send('hardhat_setBalance', [
+        readonly.address,
+        ONE_ETH,
+      ]);
+
+      await expect(readonlyConn.bid({ value: 100 })).to.emit(
+        readonlyConn,
+        'Bid',
+      );
+
+      // Inactive auction by setting the block.timestamp to the end time of the auction
+      await ethers.provider.send('evm_mine', [auctionEndTimestamp]);
+      await ownerConn.setPrice(1);
+
+      // Send tokens
+      await expect(ownerConn.sendTokens(readonly.address, 1)).to.emit(
+        readonlyConn,
+        'Transfer',
+      );
+
+      // Should be reverted when re-setting the price if
+      //  it is not claimable but the first token is already sent
+      await ownerConn.setClaimable(false);
+      await expect(ownerConn.setPrice(1)).to.be.revertedWith(
+        'CannotSetPriceIfFirstTokenSent',
+      );
+    });
+
+    it('Reverts if token already sent or refund already claimed', async () => {
+      // Active auction by setting the block.timestamp to the start time of the auction
+      await ethers.provider.send('evm_mine', [auctionStartTimestamp]);
+      await ethers.provider.send('hardhat_setBalance', [
+        readonly.address,
+        ONE_ETH,
+      ]);
+
+      await expect(readonlyConn.bid({ value: 100 })).to.emit(
+        readonlyConn,
+        'Bid',
+      );
+
+      // Inactive auction by setting the block.timestamp to the end time of the auction
+      await ethers.provider.send('evm_mine', [auctionEndTimestamp]);
+      await ownerConn.setPrice(1);
+      await ownerConn.setClaimable(true);
+
+      // Send tokens
+      await expect(ownerConn.sendTokens(readonly.address, 1)).to.emit(
+        readonlyConn,
+        'Transfer',
+      );
+
+      let userData = await readonlyConn.getUserData(readonly.address);
+      expect(userData.contribution).to.eq(100);
+      expect(userData.tokensClaimed).to.eq(1);
+      expect(userData.refundClaimed).to.eq(false);
+
+      // Try to re-send tokens and the refund and expect a revert with AlreadySentTokensToUser
+      await expect(
+        ownerConn.sendTokensAndRefund(readonly.address),
+      ).to.be.revertedWith('AlreadySentTokensToUser');
+
+      // Issue refund
+      await ownerConn.sendRefund(readonly.address);
+      userData = await readonlyConn.getUserData(readonly.address);
+      expect(userData.contribution).to.eq(100);
+      expect(userData.tokensClaimed).to.eq(1);
+      expect(userData.refundClaimed).to.eq(true);
+
+      // Try to re-issue the refund and expect a revert with UserAlreadyClaimed
+      await expect(ownerConn.sendRefund(readonly.address)).to.be.revertedWith(
+        'UserAlreadyClaimed',
+      );
+    });
+
     it('Reverts if refund transfer fails', async () => {
       // TODO: set up a custom contract that refuses transfer.
     });
@@ -366,8 +526,8 @@ describe('BucketAuction', function () {
 
   describe('Owner send tokens and refund', function () {
     it('sendTokensAndRefund', async () => {
-      await ownerConn.setAuctionActive(true);
-
+      // Active auction by setting the block.timestamp to the start time of the auction
+      await ethers.provider.send('evm_mine', [auctionStartTimestamp]);
       await ethers.provider.send('hardhat_setBalance', [
         readonly.address,
         ONE_ETH,
@@ -388,7 +548,8 @@ describe('BucketAuction', function () {
       ).toNumber();
       expect(balance).to.eq(100);
 
-      await ownerConn.setAuctionActive(false);
+      // Inactive auction by setting the block.timestamp to the end time of the auction
+      await ethers.provider.send('evm_mine', [auctionEndTimestamp]);
       await ownerConn.setPrice(20);
       await ownerConn.setClaimable(true);
 
@@ -418,8 +579,8 @@ describe('BucketAuction', function () {
 
     // Two bidders.
     it('sendTokensAndRefundBatch', async () => {
-      await ownerConn.setAuctionActive(true);
-
+      // Active auction by setting the block.timestamp to the start time of the auction
+      await ethers.provider.send('evm_mine', [auctionStartTimestamp]);
       const readonly2 = await ethers.getImpersonatedSigner(
         '0xef59F379B48f2E92aBD94ADcBf714D170967925D',
       );
@@ -455,7 +616,8 @@ describe('BucketAuction', function () {
       ).toNumber();
       expect(balance).to.eq(300);
 
-      await ownerConn.setAuctionActive(false);
+      // Inactive auction by setting the block.timestamp to the end time of the auction
+      await ethers.provider.send('evm_mine', [auctionEndTimestamp]);
       await ownerConn.setPrice(110);
       await ownerConn.setClaimable(true);
 
@@ -481,8 +643,8 @@ describe('BucketAuction', function () {
     });
 
     it('sendTokens & sendRefund', async () => {
-      await ownerConn.setAuctionActive(true);
-
+      // Active auction by setting the block.timestamp to the start time of the auction
+      await ethers.provider.send('evm_mine', [auctionStartTimestamp]);
       await ethers.provider.send('hardhat_setBalance', [
         readonly.address,
         ONE_ETH,
@@ -493,7 +655,8 @@ describe('BucketAuction', function () {
         'Bid',
       );
 
-      await ownerConn.setAuctionActive(false);
+      // Inactive auction by setting the block.timestamp to the end time of the auction
+      await ethers.provider.send('evm_mine', [auctionEndTimestamp]);
       await ownerConn.setPrice(20);
       await ownerConn.setClaimable(true);
 
@@ -524,8 +687,8 @@ describe('BucketAuction', function () {
     });
 
     it('sendTokensBatch & sendRefundBatch', async () => {
-      await ownerConn.setAuctionActive(true);
-
+      // Active auction by setting the block.timestamp to the start time of the auction
+      await ethers.provider.send('evm_mine', [auctionStartTimestamp]);
       const readonly2 = await ethers.getImpersonatedSigner(
         '0xef59F379B48f2E92aBD94ADcBf714D170967925D',
       );
@@ -556,7 +719,8 @@ describe('BucketAuction', function () {
         'Bid',
       );
 
-      await ownerConn.setAuctionActive(false);
+      // Inactive auction by setting the block.timestamp to the end time of the auction
+      await ethers.provider.send('evm_mine', [auctionEndTimestamp]);
       await ownerConn.setPrice(30);
       await ownerConn.setClaimable(true);
 
@@ -588,8 +752,8 @@ describe('BucketAuction', function () {
     });
 
     it('sendAllTokens', async () => {
-      await ownerConn.setAuctionActive(true);
-
+      // Active auction by setting the block.timestamp to the start time of the auction
+      await ethers.provider.send('evm_mine', [auctionStartTimestamp]);
       await ethers.provider.send('hardhat_setBalance', [
         readonly.address,
         ONE_ETH,
@@ -600,7 +764,8 @@ describe('BucketAuction', function () {
         'Bid',
       );
 
-      await ownerConn.setAuctionActive(false);
+      // Inactive auction by setting the block.timestamp to the end time of the auction
+      await ethers.provider.send('evm_mine', [auctionEndTimestamp]);
       await ownerConn.setPrice(20);
       await ownerConn.setClaimable(true);
 
diff --git a/test/ERC721MCallback.test.ts b/test/ERC721MCallback.test.ts
index ec6178c..7974556 100644
--- a/test/ERC721MCallback.test.ts
+++ b/test/ERC721MCallback.test.ts
@@ -1,5 +1,5 @@
 import { SignerWithAddress } from '@nomiclabs/hardhat-ethers/signers';
-import chai, { expect } from 'chai';
+import chai, { assert, expect } from 'chai';
 import chaiAsPromised from 'chai-as-promised';
 import { ethers } from 'hardhat';
 import {
@@ -27,7 +27,6 @@ describe('ERC721MCallback', () => {
       100,
       0,
       ethers.constants.AddressZero,
-      300,
     );
     await erc721mCallback.deployed();
 
@@ -84,14 +83,21 @@ describe('ERC721MCallback', () => {
 
   describe('Minting', () => {
     it('Callbacks should be triggered', async () => {
+      // Get an estimated stage start time
+      const block = await ethers.provider.getBlock(
+        await ethers.provider.getBlockNumber(),
+      );
+      // +10 is a number bigger than the count of transactions up to mint
+      const stageStart = block.timestamp + 10;
+      // Set stages
       await contract.setStages([
         {
           price: ethers.utils.parseEther('0.1'),
           walletLimit: 0,
           maxStageSupply: 0,
           merkleRoot: ethers.utils.hexZeroPad('0x', 32),
-          startTimeUnixSeconds: 0,
-          endTimeUnixSeconds: 1,
+          startTimeUnixSeconds: stageStart,
+          endTimeUnixSeconds: stageStart + 1,
         },
       ]);
       await contract.setMintable(true);
@@ -112,6 +118,8 @@ describe('ERC721MCallback', () => {
         stakingContract.address,
       ]);
 
+      // Setup the test context: block.timestamp should comply to the stage being active
+      await ethers.provider.send('evm_mine', [stageStart - 1]);
       await readonlyContract.mintWithCallbacks(
         1,
         [],
@@ -146,14 +154,21 @@ describe('ERC721MCallback', () => {
     });
 
     it('Reverts when not enough callbacks passed', async () => {
+      // Get an estimated stage start time
+      const block = await ethers.provider.getBlock(
+        await ethers.provider.getBlockNumber(),
+      );
+      // +10 is a number bigger than the count of transactions up to mint
+      const stageStart = block.timestamp + 10;
+      // Set stages
       await contract.setStages([
         {
           price: ethers.utils.parseEther('0.1'),
           walletLimit: 0,
           maxStageSupply: 0,
           merkleRoot: ethers.utils.hexZeroPad('0x', 32),
-          startTimeUnixSeconds: 0,
-          endTimeUnixSeconds: 1,
+          startTimeUnixSeconds: stageStart,
+          endTimeUnixSeconds: stageStart + 1,
         },
       ]);
       await contract.setMintable(true);
@@ -170,6 +185,8 @@ describe('ERC721MCallback', () => {
       ]);
       await contract.setOnMintApprovals([stakingContract.address]);
 
+      // Setup the test context: block.timestamp should comply to the stage being active
+      await ethers.provider.send('evm_mine', [stageStart - 1]);
       await expect(
         readonlyContract.mintWithCallbacks(1, [], 0, '0x', [], {
           value: ethers.utils.parseEther('0.1'),
@@ -178,14 +195,21 @@ describe('ERC721MCallback', () => {
     });
 
     it('Reverts when callback fails', async () => {
+      // Get an estimated stage start time
+      const block = await ethers.provider.getBlock(
+        await ethers.provider.getBlockNumber(),
+      );
+      // +10 is a number bigger than the count of transactions up to mint
+      const stageStart = block.timestamp + 10;
+      // Set stages
       await contract.setStages([
         {
           price: ethers.utils.parseEther('0.1'),
           walletLimit: 0,
           maxStageSupply: 0,
           merkleRoot: ethers.utils.hexZeroPad('0x', 32),
-          startTimeUnixSeconds: 0,
-          endTimeUnixSeconds: 1,
+          startTimeUnixSeconds: stageStart,
+          endTimeUnixSeconds: stageStart + 1,
         },
       ]);
       await contract.setMintable(true);
@@ -202,6 +226,8 @@ describe('ERC721MCallback', () => {
       ]);
       await contract.setOnMintApprovals([stakingContract.address]);
 
+      // Setup the test context: block.timestamp should comply to the stage being active
+      await ethers.provider.send('evm_mine', [stageStart - 1]);
       await expect(
         readonlyContract.mintWithCallbacks(1, [], 0, '0x', ['0x1234'], {
           value: ethers.utils.parseEther('0.1'),
@@ -210,18 +236,27 @@ describe('ERC721MCallback', () => {
     });
 
     it('can mint normally', async () => {
+      // Get an estimated stage start time
+      const block = await ethers.provider.getBlock(
+        await ethers.provider.getBlockNumber(),
+      );
+      // +10 is a number bigger than the count of transactions up to mint
+      const stageStart = block.timestamp + 10;
+      // Set stages
       await contract.setStages([
         {
           price: ethers.utils.parseEther('0.1'),
           walletLimit: 0,
           maxStageSupply: 0,
           merkleRoot: ethers.utils.hexZeroPad('0x', 32),
-          startTimeUnixSeconds: 0,
-          endTimeUnixSeconds: 1,
+          startTimeUnixSeconds: stageStart,
+          endTimeUnixSeconds: stageStart + 1,
         },
       ]);
       await contract.setMintable(true);
 
+      // Setup the test context: block.timestamp should comply to the stage being active
+      await ethers.provider.send('evm_mine', [stageStart - 1]);
       await readonlyContract.mint(1, [], 0, '0x', {
         value: ethers.utils.parseEther('0.1'),
       });
diff --git a/test/erc721m.test.ts b/test/erc721m.test.ts
index bb4fda7..7e58fc3 100644
--- a/test/erc721m.test.ts
+++ b/test/erc721m.test.ts
@@ -1,14 +1,24 @@
 import { SignerWithAddress } from '@nomiclabs/hardhat-ethers/signers';
-import chai, { expect } from 'chai';
+import chai, { assert, expect } from 'chai';
 import chaiAsPromised from 'chai-as-promised';
 import { ethers } from 'hardhat';
 import { MerkleTree } from 'merkletreejs';
-import { ERC721M } from '../typechain-types';
+import { ERC721M, IERC721M } from '../typechain-types';
 
 const { keccak256, getAddress } = ethers.utils;
 
 chai.use(chaiAsPromised);
 
+const setBlockTimestamp = async () => {
+  const block = await ethers.provider.getBlock(
+    await ethers.provider.getBlockNumber(),
+  );
+  // +3 for the transactions setStages, setMintable and mint
+  const stageStart = block.timestamp + 3;
+  // + 2 for two subsequent of mint transactions
+  const stageEnd = stageStart + 2;
+};
+
 describe('ERC721M', function () {
   let contract: ERC721M;
   let readonlyContract: ERC721M;
@@ -56,7 +66,6 @@ describe('ERC721M', function () {
       1000,
       0,
       ethers.constants.AddressZero,
-      60,
     );
     await erc721M.deployed();
 
@@ -156,6 +165,50 @@ describe('ERC721M', function () {
       ).to.be.revertedWith('InsufficientStageTimeGap');
     });
 
+    it('cannot set stages due to startTimeUnixSeconds is not smaller than endTimeUnixSeconds', async () => {
+      await expect(
+        contract.setStages([
+          {
+            price: ethers.utils.parseEther('0.5'),
+            walletLimit: 3,
+            merkleRoot: ethers.utils.hexZeroPad('0x1', 32),
+            maxStageSupply: 5,
+            startTimeUnixSeconds: 0,
+            endTimeUnixSeconds: 0,
+          },
+          {
+            price: ethers.utils.parseEther('0.6'),
+            walletLimit: 4,
+            merkleRoot: ethers.utils.hexZeroPad('0x2', 32),
+            maxStageSupply: 10,
+            startTimeUnixSeconds: 61,
+            endTimeUnixSeconds: 61,
+          },
+        ]),
+      ).to.be.revertedWith('InvalidStartAndEndTimestamp');
+
+      await expect(
+        contract.setStages([
+          {
+            price: ethers.utils.parseEther('0.5'),
+            walletLimit: 3,
+            merkleRoot: ethers.utils.hexZeroPad('0x1', 32),
+            maxStageSupply: 5,
+            startTimeUnixSeconds: 1,
+            endTimeUnixSeconds: 0,
+          },
+          {
+            price: ethers.utils.parseEther('0.6'),
+            walletLimit: 4,
+            merkleRoot: ethers.utils.hexZeroPad('0x2', 32),
+            maxStageSupply: 10,
+            startTimeUnixSeconds: 62,
+            endTimeUnixSeconds: 61,
+          },
+        ]),
+      ).to.be.revertedWith('InvalidStartAndEndTimestamp');
+    });
+
     it('can set / reset stages', async () => {
       await contract.setStages([
         {
@@ -385,19 +438,55 @@ describe('ERC721M', function () {
       await expect(updateStage).to.be.revertedWith('InsufficientStageTimeGap');
     });
 
-    it('reverts when stage end less than start start time', async () => {
-      await expect(
-        contract.setStages([
-          {
-            price: ethers.utils.parseEther('0.5'),
-            walletLimit: 3,
-            merkleRoot: ethers.utils.hexZeroPad('0x1', 32),
-            maxStageSupply: 5,
-            startTimeUnixSeconds: 2,
-            endTimeUnixSeconds: 1,
-          },
-        ]),
-      ).to.be.rejectedWith('InvalidStartAndEndTimestamp');
+    it('cannot update stage due to the startTimeUnixSeconds is not smaller than the endTimeUnixSeconds', async () => {
+      await contract.setStages([
+        {
+          price: ethers.utils.parseEther('0.5'),
+          walletLimit: 3,
+          merkleRoot: ethers.utils.hexZeroPad('0x1', 32),
+          maxStageSupply: 5,
+          startTimeUnixSeconds: 0,
+          endTimeUnixSeconds: 1,
+        },
+        {
+          price: ethers.utils.parseEther('0.6'),
+          walletLimit: 4,
+          merkleRoot: ethers.utils.hexZeroPad('0x2', 32),
+          maxStageSupply: 10,
+          startTimeUnixSeconds: 61,
+          endTimeUnixSeconds: 62,
+        },
+      ]);
+
+      // Update stage 1 and set startTimeUnixSeconds and endTimeUnixSeconds to identical values
+      const updateStageWithIdenticalStartAndEndTime = contract.updateStage(
+        /* _index= */ 1,
+        /* price= */ ethers.utils.parseEther('0.1'),
+        /* walletLimit= */ 13,
+        /* merkleRoot= */ ethers.utils.hexZeroPad('0x9', 32),
+        /* maxStageSupply= */ 15,
+        /* startTimeUnixSeconds= */ 61,
+        /* endTimeUnixSeconds= */ 61,
+      );
+
+      await expect(updateStageWithIdenticalStartAndEndTime).to.be.revertedWith(
+        'InvalidStartAndEndTimestamp',
+      );
+
+      // Update stage 1 and set startTimeUnixSeconds to a value which is not smaller than the endTimeUnixSeconds
+      const updateStageWithStartTimeAfterEndTime = contract.updateStage(
+        /* _index= */ 1,
+        /* price= */ ethers.utils.parseEther('0.1'),
+        /* walletLimit= */ 13,
+        /* merkleRoot= */ ethers.utils.hexZeroPad('0x9', 32),
+        /* maxStageSupply= */ 15,
+        /* startTimeUnixSeconds= */ 61,
+        /* endTimeUnixSeconds= */ 60,
+      );
+
+      await expect(updateStageWithStartTimeAfterEndTime).to.be.revertedWith(
+        'InvalidStartAndEndTimestamp',
+      );
     });
 
     it('gets stage info', async () => {
@@ -438,7 +527,7 @@ describe('ERC721M', function () {
       await expect(getStageInfo).to.be.revertedWith('InvalidStage');
     });
 
-    it('can set active stage', async () => {
+    it('can find active stage', async () => {
       await contract.setStages([
         {
           price: ethers.utils.parseEther('0.5'),
@@ -459,30 +548,12 @@ describe('ERC721M', function () {
       ]);
 
       expect(await contract.getNumberStages()).to.equal(2);
-      expect(await contract.getActiveStage()).to.equal(0);
+      expect(await contract.getActiveStageFromTimestamp(0)).to.equal(0);
 
-      await contract.setActiveStage(1);
-      expect(await contract.getActiveStage()).to.equal(1);
+      expect(await contract.getActiveStageFromTimestamp(61)).to.equal(1);
 
-      const setActiveStage = contract.setActiveStage(2);
+      const setActiveStage = contract.getActiveStageFromTimestamp(70);
       await expect(setActiveStage).to.be.revertedWith('InvalidStage');
-
-      // readonlyContract should not be able to set active stage
-      await expect(readonlyContract.setActiveStage(2)).to.be.revertedWith(
-        'Ownable',
-      );
-    });
-
-    it('can set/get timestamp expiry', async () => {
-      expect((await contract.getTimestampExpirySeconds()).toNumber()).to.eq(60);
-
-      await expect(contract.setTimestampExpirySeconds(120))
-        .to.emit(contract, 'SetTimestampExpirySeconds')
-        .withArgs(120);
-
-      expect((await contract.getTimestampExpirySeconds()).toNumber()).to.eq(
-        120,
-      );
     });
   });
 
@@ -524,34 +595,44 @@ describe('ERC721M', function () {
       await expect(mint).to.be.revertedWith('NotMintable');
     });
 
-    it('revert if contract without stages', async () => {
-      await contract.setMintable(true);
-      const mint = contract.mint(
-        1,
-        [ethers.utils.hexZeroPad('0x', 32)],
-        0,
-        '0x00',
-        {
-          value: ethers.utils.parseEther('0.5'),
-        },
-      );
-
-      await expect(mint).to.be.revertedWith('InvalidStage');
-    });
+    // TODO: Check if this test case is a valid user scenario
+    // it('revert if contract without stages', async () => {
+    //   await contract.setMintable(true);
+    //   const mint = contract.mint(
+    //     1,
+    //     [ethers.utils.hexZeroPad('0x', 32)],
+    //     0,
+    //     '0x00',
+    //     {
+    //       value: ethers.utils.parseEther('0.5'),
+    //     },
+    //   );
+
+    //   await expect(mint).to.be.revertedWith('InvalidStage');
+    // });
 
     it('revert if incorrect (less) amount sent', async () => {
+      // Get an estimated stage start time
+      const block = await ethers.provider.getBlock(
+        await ethers.provider.getBlockNumber(),
+      );
+      // +10 is a number bigger than the count of transactions up to mint
+      const stageStart = block.timestamp + 10;
+      // Set stages
       await contract.setStages([
         {
           price: ethers.utils.parseEther('0.5'),
           walletLimit: 10,
           merkleRoot: ethers.utils.hexZeroPad('0x1', 32),
           maxStageSupply: 5,
-          startTimeUnixSeconds: 0,
-          endTimeUnixSeconds: 1,
+          startTimeUnixSeconds: stageStart,
+          endTimeUnixSeconds: stageStart + 2,
         },
       ]);
       await contract.setMintable(true);
 
+      // Setup the test context: block.timestamp should comply to the stage being active
+      await ethers.provider.send('evm_mine', [stageStart - 1]);
       let mint;
       mint = contract.mint(5, [ethers.utils.hexZeroPad('0x', 32)], 0, '0x00', {
         value: ethers.utils.parseEther('2.499'),
@@ -572,20 +653,30 @@ describe('ERC721M', function () {
         contract.address,
       );
       await reentrancyExploiter.deployed();
+
+      // Get an estimated timestamp for the stage start
+      const block = await ethers.provider.getBlock(
+        await ethers.provider.getBlockNumber(),
+      );
+      // +10 is a number bigger than the count of transactions up to mint
+      const stageStart = block.timestamp + 10;
+      // Set stages
       await contract.setStages([
         {
           price: ethers.utils.parseEther('0.1'),
           walletLimit: 0,
           merkleRoot: ethers.utils.hexZeroPad('0x', 32),
           maxStageSupply: 0,
-          startTimeUnixSeconds: 0,
-          endTimeUnixSeconds: 100000,
+          startTimeUnixSeconds: stageStart,
+          endTimeUnixSeconds: stageStart + 100000,
         },
       ]);
       await contract.setMintable(true);
 
+      // Setup the test context: block.timestamp should comply to the stage being active
+      await ethers.provider.send('evm_mine', [stageStart - 1]);
       await expect(
-        reentrancyExploiter.exploit(1, [], 0, '0x', {
+        reentrancyExploiter.exploit(1, [], stageStart, '0x', {
           value: ethers.utils.parseEther('0.2'),
         }),
       ).to.be.revertedWith('ReentrancyGuard: reentrant call');
@@ -650,19 +741,27 @@ describe('ERC721M', function () {
     });
 
     it('mint with unlimited stage limit', async () => {
+      const block = await ethers.provider.getBlock(
+        await ethers.provider.getBlockNumber(),
+      );
+      // +10 is a number bigger than the count of transactions up to mint
+      const stageStart = block.timestamp + 10;
+      // Set stages
       await contract.setStages([
         {
           price: ethers.utils.parseEther('0.5'),
           walletLimit: 100,
           merkleRoot: ethers.utils.hexZeroPad('0x0', 32),
           maxStageSupply: 0,
-          startTimeUnixSeconds: 0,
-          endTimeUnixSeconds: 1,
+          startTimeUnixSeconds: stageStart,
+          endTimeUnixSeconds: stageStart + 2,
         },
       ]);
       await contract.setMaxMintableSupply(999);
       await contract.setMintable(true);
 
+      // Setup the test context: block.timestamp should comply to the stage being active
+      await ethers.provider.send('evm_mine', [stageStart - 1]);
       // Mint 100 tokens - wallet limit
       await contract.mint(100, [ethers.utils.hexZeroPad('0x', 32)], 0, '0x00', {
         value: ethers.utils.parseEther('50'),
@@ -683,19 +782,27 @@ describe('ERC721M', function () {
     });
 
     it('mint with unlimited wallet limit', async () => {
+      const block = await ethers.provider.getBlock(
+        await ethers.provider.getBlockNumber(),
+      );
+      // +10 is a number bigger than the count of transactions up to mint
+      const stageStart = block.timestamp + 10;
+      // Set stages
       await contract.setStages([
         {
           price: ethers.utils.parseEther('0.5'),
           walletLimit: 0,
           merkleRoot: ethers.utils.hexZeroPad('0x0', 32),
           maxStageSupply: 100,
-          startTimeUnixSeconds: 0,
-          endTimeUnixSeconds: 1,
+          startTimeUnixSeconds: stageStart,
+          endTimeUnixSeconds: stageStart + 2,
         },
       ]);
       await contract.setMaxMintableSupply(999);
       await contract.setMintable(true);
 
+      // Setup the test context: Update block.timestamp to comply to the stage being active
+      await ethers.provider.send('evm_mine', [stageStart - 1]);
       // Mint 100 tokens - stage limit
       await contract.mint(100, [ethers.utils.hexZeroPad('0x', 32)], 0, '0x00', {
         value: ethers.utils.parseEther('50'),
@@ -716,18 +823,26 @@ describe('ERC721M', function () {
     });
 
     it('mint with free stage', async () => {
+      const block = await ethers.provider.getBlock(
+        await ethers.provider.getBlockNumber(),
+      );
+      // +10 is a number bigger than the count of transactions up to mint
+      const stageStart = block.timestamp + 10;
+      // Set stages
       await contract.setStages([
         {
           price: ethers.utils.parseEther('0'),
           walletLimit: 0,
           merkleRoot: ethers.utils.hexZeroPad('0x0', 32),
           maxStageSupply: 100,
-          startTimeUnixSeconds: 0,
-          endTimeUnixSeconds: 1,
+          startTimeUnixSeconds: stageStart,
+          endTimeUnixSeconds: stageStart + 1,
         },
       ]);
       await contract.setMintable(true);
 
+      // Setup the test context: Update block.timestamp to comply to the stage being active
+      await ethers.provider.send('evm_mine', [stageStart - 1]);
       // Mint 100 tokens - stage limit
       await readonlyContract.mint(
         1,
@@ -984,26 +1099,34 @@ describe('ERC721M', function () {
     });
 
     it('enforces stage supply', async () => {
+      const block = await ethers.provider.getBlock(
+        await ethers.provider.getBlockNumber(),
+      );
+      // +10 is a number bigger than the count of transactions up to mint
+      const stageStart = block.timestamp + 10;
+      // Set stages
       await contract.setStages([
         {
           price: ethers.utils.parseEther('0.5'),
           walletLimit: 10,
           merkleRoot: ethers.utils.hexZeroPad('0x0', 32),
           maxStageSupply: 5,
-          startTimeUnixSeconds: 0,
-          endTimeUnixSeconds: 1,
+          startTimeUnixSeconds: stageStart,
+          endTimeUnixSeconds: stageStart + 3,
         },
         {
           price: ethers.utils.parseEther('0.6'),
           walletLimit: 10,
           merkleRoot: ethers.utils.hexZeroPad('0x0', 32),
           maxStageSupply: 10,
-          startTimeUnixSeconds: 61,
-          endTimeUnixSeconds: 62,
+          startTimeUnixSeconds: stageStart + 63,
+          endTimeUnixSeconds: stageStart + 66,
         },
       ]);
       await contract.setMintable(true);
 
+      // Setup the test context: Update block.timestamp to comply to the stage being active
+      await ethers.provider.send('evm_mine', [stageStart - 1]);
       // Mint 5 tokens
       await expect(
         contract.mint(5, [ethers.utils.hexZeroPad('0x', 32)], 0, '0x00', {
@@ -1036,7 +1159,8 @@ describe('ERC721M', function () {
       });
       await expect(mint).to.be.revertedWith('StageSupplyExceeded');
 
-      await contract.setActiveStage(1);
+      // Setup the test context: Update the block.timestamp to activate the 2nd stage
+      await ethers.provider.send('evm_mine', [stageStart + 62]);
 
       await contract.mint(8, [ethers.utils.hexZeroPad('0x', 32)], 0, '0x00', {
         value: ethers.utils.parseEther('4.8'),
@@ -1047,11 +1171,13 @@ describe('ERC721M', function () {
       expect(walletMintedCount).to.equal(8);
       expect(stagedMintedCount.toNumber()).to.equal(8);
 
-      await expect(
+      await assert.isRejected(
         contract.mint(3, [ethers.utils.hexZeroPad('0x', 32)], 0, '0x00', {
           value: ethers.utils.parseEther('1.8'),
         }),
-      ).to.be.rejectedWith('StageSupplyExceeded');
+        /StageSupplyExceeded/,
+        "Minting more than the stage's supply should fail",
+      );
 
       await contract.mint(2, [ethers.utils.hexZeroPad('0x', 32)], 0, '0x00', {
         value: ethers.utils.parseEther('1.2'),
@@ -1087,18 +1213,26 @@ describe('ERC721M', function () {
       const root = merkleTree.getHexRoot();
       const proof = merkleTree.getHexProof(keccak256(signerAddress));
 
+      const block = await ethers.provider.getBlock(
+        await ethers.provider.getBlockNumber(),
+      );
+      // +10 is a number bigger than the count of transactions up to mint
+      const stageStart = block.timestamp + 10;
+      // Set stages
       await contract.setStages([
         {
           price: ethers.utils.parseEther('0.5'),
           walletLimit: 10,
           merkleRoot: root,
           maxStageSupply: 5,
-          startTimeUnixSeconds: 0,
-          endTimeUnixSeconds: 1,
+          startTimeUnixSeconds: stageStart,
+          endTimeUnixSeconds: stageStart + 3,
         },
       ]);
       await contract.setMintable(true);
 
+      // Setup the test context: Update block.timestamp to comply to the stage being active
+      await ethers.provider.send('evm_mine', [stageStart - 1]);
       // Mint 1 token with valid proof
       await contract.mint(1, proof, 0, '0x00', {
         value: ethers.utils.parseEther('0.5'),
@@ -1117,18 +1251,26 @@ describe('ERC721M', function () {
     it('reverts on invalid Merkle proof', async () => {
       const root = ethers.utils.hexZeroPad('0x1', 32);
       const proof = [ethers.utils.hexZeroPad('0x1', 32)];
+      const block = await ethers.provider.getBlock(
+        await ethers.provider.getBlockNumber(),
+      );
+      // +10 is a number bigger than the count of transactions up to mint
+      const stageStart = block.timestamp + 10;
+      // Set stages
       await contract.setStages([
         {
           price: ethers.utils.parseEther('0.5'),
           walletLimit: 10,
           merkleRoot: root,
           maxStageSupply: 5,
-          startTimeUnixSeconds: 0,
-          endTimeUnixSeconds: 1,
+          startTimeUnixSeconds: stageStart,
+          endTimeUnixSeconds: stageStart + 1,
         },
       ]);
       await contract.setMintable(true);
 
+      // Setup the test context: Update block.timestamp to comply to the stage being active
+      await ethers.provider.send('evm_mine', [stageStart - 1]);
       // Mint 1 token with invalid proof
       const mint = contract.mint(1, proof, 0, '0x00', {
         value: ethers.utils.parseEther('0.5'),
@@ -1146,21 +1288,25 @@ describe('ERC721M', function () {
         1000,
         0,
         ethers.constants.AddressZero,
-        60,
       );
       await erc721M.deployed();
 
       [owner, readonly] = await ethers.getSigners();
       const ownerConn = erc721M.connect(owner);
-
+      const block = await ethers.provider.getBlock(
+        await ethers.provider.getBlockNumber(),
+      );
+      // +10 is a number bigger than the count of transactions up to mint
+      const stageStart = block.timestamp + 10;
+      // Set stages
       await ownerConn.setStages([
         {
           price: ethers.utils.parseEther('0.5'),
           walletLimit: 0,
           merkleRoot: ethers.utils.hexZeroPad('0x', 32),
           maxStageSupply: 100,
-          startTimeUnixSeconds: 0,
-          endTimeUnixSeconds: 1,
+          startTimeUnixSeconds: stageStart,
+          endTimeUnixSeconds: stageStart + 1,
         },
       ]);
       await ownerConn.setMintable(true);
@@ -1184,6 +1330,8 @@ describe('ERC721M', function () {
 
       const crossMintConn = erc721M.connect(crossmintSigner);
 
+      // Setup the test context: Update block.timestamp to comply to the stage being active
+      await ethers.provider.send('evm_mine', [stageStart - 1]);
       await crossMintConn.crossmint(
         1,
         readonly.address,
@@ -1213,7 +1361,6 @@ describe('ERC721M', function () {
         1000,
         0,
         owner.address,
-        300, // longer expiry for crossmint
       );
       await erc721M.deployed();
 
@@ -1252,8 +1399,9 @@ describe('ERC721M', function () {
 
       const crossMintConn = erc721M.connect(crossmintSigner);
 
-      // fast forward 2 minutes
-      await ethers.provider.send('evm_mine', [block.timestamp + 120]);
+      // fast forward 2 minutes, timestamp should still be valid since crossmint is the sender
+      await ethers.provider.send('evm_increaseTime', [120]);
+      await ethers.provider.send('evm_mine', []);
       const twoMinuteOldTimestamp = block.timestamp;
       const signature = await getCosignSignature(
         erc721M,
@@ -1424,26 +1572,34 @@ describe('ERC721M', function () {
     });
 
     it('Returns empty tokenURI on empty baseURI', async () => {
+      const block = await ethers.provider.getBlock(
+        await ethers.provider.getBlockNumber(),
+      );
+      // +10 is a number bigger than the count of transactions up to mint
+      const stageStart = block.timestamp + 10;
+      // Set stages
       await contract.setStages([
         {
           price: ethers.utils.parseEther('0.5'),
           walletLimit: 10,
           merkleRoot: ethers.utils.hexZeroPad('0x0', 32),
           maxStageSupply: 5,
-          startTimeUnixSeconds: 0,
-          endTimeUnixSeconds: 1,
+          startTimeUnixSeconds: stageStart,
+          endTimeUnixSeconds: stageStart + 1,
         },
         {
           price: ethers.utils.parseEther('0.6'),
           walletLimit: 10,
           merkleRoot: ethers.utils.hexZeroPad('0x0', 32),
           maxStageSupply: 10,
-          startTimeUnixSeconds: 61,
-          endTimeUnixSeconds: 62,
+          startTimeUnixSeconds: stageStart + 61,
+          endTimeUnixSeconds: stageStart + 62,
         },
       ]);
       await contract.setMintable(true);
 
+      // Setup the test context: Update block.timestamp to comply to the stage being active
+      await ethers.provider.send('evm_mine', [stageStart - 1]);
       await contract.mint(2, [ethers.utils.hexZeroPad('0x', 32)], 0, '0x00', {
         value: ethers.utils.parseEther('2.5'),
       });
@@ -1457,28 +1613,36 @@ describe('ERC721M', function () {
     });
 
     it('Returns non-empty tokenURI on non-empty baseURI', async () => {
+      const block = await ethers.provider.getBlock(
+        await ethers.provider.getBlockNumber(),
+      );
+      // +10 is a number bigger than the count of transactions up to mint
+      const stageStart = block.timestamp + 10;
+      // Set stages
       await contract.setStages([
         {
           price: ethers.utils.parseEther('0.5'),
           walletLimit: 10,
           merkleRoot: ethers.utils.hexZeroPad('0x0', 32),
           maxStageSupply: 5,
-          startTimeUnixSeconds: 0,
-          endTimeUnixSeconds: 1,
+          startTimeUnixSeconds: stageStart,
+          endTimeUnixSeconds: stageStart + 1,
         },
         {
           price: ethers.utils.parseEther('0.6'),
           walletLimit: 10,
           merkleRoot: ethers.utils.hexZeroPad('0x0', 32),
           maxStageSupply: 10,
-          startTimeUnixSeconds: 61,
-          endTimeUnixSeconds: 62,
+          startTimeUnixSeconds: stageStart + 61,
+          endTimeUnixSeconds: stageStart + 62,
         },
       ]);
 
       await contract.setBaseURI('base_uri_');
       await contract.setMintable(true);
 
+      // Setup the test context: Update block.timestamp to comply to the stage being active
+      await ethers.provider.send('evm_mine', [stageStart - 1]);
       await contract.mint(2, [ethers.utils.hexZeroPad('0x', 32)], 0, '0x00', {
         value: ethers.utils.parseEther('2.5'),
       });
@@ -1492,28 +1656,36 @@ describe('ERC721M', function () {
     });
 
     it('Returns should not be able to set baseURI once frozen', async () => {
+      const block = await ethers.provider.getBlock(
+        await ethers.provider.getBlockNumber(),
+      );
+      // +10 is a number bigger than the count of transactions up to mint
+      const stageStart = block.timestamp + 10;
+      // Set stages
       await contract.setStages([
         {
           price: ethers.utils.parseEther('0.5'),
           walletLimit: 10,
           merkleRoot: ethers.utils.hexZeroPad('0x0', 32),
           maxStageSupply: 5,
-          startTimeUnixSeconds: 0,
-          endTimeUnixSeconds: 1,
+          startTimeUnixSeconds: stageStart,
+          endTimeUnixSeconds: stageStart + 1,
         },
         {
           price: ethers.utils.parseEther('0.6'),
           walletLimit: 10,
           merkleRoot: ethers.utils.hexZeroPad('0x0', 32),
           maxStageSupply: 10,
-          startTimeUnixSeconds: 61,
-          endTimeUnixSeconds: 62,
+          startTimeUnixSeconds: stageStart + 61,
+          endTimeUnixSeconds: stageStart + 62,
         },
       ]);
 
       await contract.setBaseURI('base_uri_');
       await contract.setMintable(true);
 
+      // Setup the test context: Update block.timestamp to comply to the stage being active
+      await ethers.provider.send('evm_mine', [stageStart - 1]);
       await contract.mint(2, [ethers.utils.hexZeroPad('0x', 32)], 0, '0x00', {
         value: ethers.utils.parseEther('2.5'),
       });
@@ -1550,7 +1722,6 @@ describe('ERC721M', function () {
           100,
           1001,
           ethers.constants.AddressZero,
-          60,
         ),
       ).to.be.revertedWith('GlobalWalletLimitOverflow');
     });
@@ -1568,18 +1739,26 @@ describe('ERC721M', function () {
       await contract.setGlobalWalletLimit(2);
       expect((await contract.getGlobalWalletLimit()).toNumber()).to.equal(2);
 
+      const block = await ethers.provider.getBlock(
+        await ethers.provider.getBlockNumber(),
+      );
+      // +10 is a number bigger than the count of transactions up to mint
+      const stageStart = block.timestamp + 10;
+      // Set stages
       await contract.setStages([
         {
           price: ethers.utils.parseEther('0.1'),
           walletLimit: 0,
           merkleRoot: ethers.utils.hexZeroPad('0x0', 32),
           maxStageSupply: 100,
-          startTimeUnixSeconds: 0,
-          endTimeUnixSeconds: 1,
+          startTimeUnixSeconds: stageStart,
+          endTimeUnixSeconds: stageStart + 2,
         },
       ]);
       await contract.setMintable(true);
 
+      // Setup the test context: Update block.timestamp to comply to the stage being active
+      await ethers.provider.send('evm_mine', [stageStart - 1]);
       await contract.mint(2, [ethers.utils.hexZeroPad('0x', 32)], 0, '0x00', {
         value: ethers.utils.parseEther('0.2'),
       });
@@ -1603,17 +1782,25 @@ describe('ERC721M', function () {
       const suffix = await contract.getTokenURISuffix();
       expect(suffix).to.equal('.json');
 
+      const block = await ethers.provider.getBlock(
+        await ethers.provider.getBlockNumber(),
+      );
+      // +10 is a number bigger than the count of transactions up to mint
+      const stageStart = block.timestamp + 10;
+      // Set stages
       await contract.setStages([
         {
           price: ethers.utils.parseEther('0.1'),
           walletLimit: 0,
           merkleRoot: ethers.utils.hexZeroPad('0x0', 32),
           maxStageSupply: 0,
-          startTimeUnixSeconds: 0,
-          endTimeUnixSeconds: 1,
+          startTimeUnixSeconds: stageStart,
+          endTimeUnixSeconds: stageStart + 1,
         },
       ]);
-
+      // Setup the test context: Update block.timestamp to comply to the stage being active
+      await ethers.provider.send('evm_mine', [stageStart - 1]);
+      // Mint and verify
       await contract.mint(1, [ethers.utils.hexZeroPad('0x', 32)], 0, '0x00', {
         value: ethers.utils.parseEther('0.1'),
       });
@@ -1636,7 +1823,6 @@ describe('ERC721M', function () {
         1000,
         0,
         ethers.constants.AddressZero,
-        60,
       );
       await erc721M.deployed();
       const ownerConn = erc721M.connect(owner);
@@ -1665,7 +1851,6 @@ describe('ERC721M', function () {
         1000,
         0,
         cosigner.address,
-        60,
       );
       await erc721M.deployed();