tbg time in unix instead of b.number

Author: peersky

deploy/03_deployGame.ts

@@ -3,11 +3,11 @@ import { DeployFunction } from 'hardhat-deploy/types';
 import {
   BESTOF_CONTRACT_NAME,
   BESTOF_CONTRACT_VERSION,
-  BOG_BLOCKS_PER_TURN,
+  BOG_TIME_PER_TURN,
   BOG_MAX_PLAYERS,
   BOG_MIN_PLAYERS,
   BOG_MAX_TURNS,
-  BOG_BLOCKS_TO_JOIN,
+  BOG_TIME_TO_JOIN,
   BOG_GAME_PRICE,
   BOG_JOIN_GAME_PRICE,
   BOG_NUM_WINNERS,
@@ -50,12 +50,12 @@ const func: DeployFunction = async (hre: HardhatRuntimeEnvironment) => {
   const settings: BestOfInit.ContractInitializerStruct =
     process.env.NODE_ENV === 'TEST'
       ? {
-          blocksPerTurn: BOG_BLOCKS_PER_TURN,
+          timePerTurn: BOG_TIME_PER_TURN,
           maxTurns: BOG_MAX_TURNS,
           maxPlayersSize: BOG_MAX_PLAYERS,
           minPlayersSize: BOG_MIN_PLAYERS,
           rankTokenAddress: rankToken.address,
-          blocksToJoin: BOG_BLOCKS_TO_JOIN,
+          timeToJoin: BOG_TIME_TO_JOIN,
           gamePrice: BOG_GAME_PRICE,
           joinGamePrice: BOG_JOIN_GAME_PRICE,
           numWinners: BOG_NUM_WINNERS,
@@ -64,12 +64,12 @@ const func: DeployFunction = async (hre: HardhatRuntimeEnvironment) => {
           agendaToken: agendaToken.address,
         }
       : {
-          blocksPerTurn: getProcessEnv(false, 'BLOCKS_PER_TURN'),
+          timePerTurn: getProcessEnv(false, 'TIME_PER_TURN'),
           maxTurns: getProcessEnv(false, 'MAX_TURNS'),
           maxPlayersSize: getProcessEnv(false, 'MAX_PLAYERS'),
           minPlayersSize: getProcessEnv(false, 'MIN_PLAYERS'),
           rankTokenAddress: rankToken.address,
-          blocksToJoin: getProcessEnv(false, 'BLOCKS_TO_JOIN'),
+          timeToJoin: getProcessEnv(false, 'BLOCKS_TO_JOIN'),
           gamePrice: ethers.utils.parseEther(getProcessEnv(false, 'GAME_PRICE_ETH')),
           joinGamePrice: ethers.utils.parseEther(getProcessEnv(false, 'JOIN_GAME_PRICE_ETH')),
           numWinners: getProcessEnv(false, 'NUM_WINNERS'),

src/facets/GameOwnersFacet.sol

@@ -50,13 +50,13 @@ contract GameOwnersFacet {
         _BOG.rankTokenAddress = newRankToken;
     }
 
-    function setBlocksPerTurn(uint256 newBlocksPerTurn) external {
+    function setTimePerTurn(uint256 newTimePerTurn) external {
         LibDiamond.enforceIsContractOwner();
-        if (newBlocksPerTurn == 0) {
+        if (newTimePerTurn == 0) {
             revert ZeroValue();
         }
         LibTBG.TBGStorageStruct storage tbg = LibTBG.TBGStorage();
-        tbg.settings.blocksPerTurn = newBlocksPerTurn;
+        tbg.settings.timePerTurn = newTimePerTurn;
     }
 
     function setMaxPlayersSize(uint256 newMaxPlayersSize) external {
@@ -77,13 +77,13 @@ contract GameOwnersFacet {
         tbg.settings.minPlayersSize = newMinPlayersSize;
     }
 
-    function setBlocksToJoin(uint256 newBlocksToJoin) external {
+    function setBlocksToJoin(uint256 newTimeToJoin) external {
         LibDiamond.enforceIsContractOwner();
-        if (newBlocksToJoin == 0) {
+        if (newTimeToJoin == 0) {
             revert ZeroValue();
         }
         LibTBG.TBGStorageStruct storage tbg = LibTBG.TBGStorage();
-        tbg.settings.blocksToJoin = newBlocksToJoin;
+        tbg.settings.timeToJoin = newTimeToJoin;
     }
 
     function setMaxTurns(uint256 newMaxTurns) external {

src/initializers/BestOfInit.sol

@@ -42,11 +42,11 @@ contract BestOfInit {
     }
 
     struct contractInitializer {
-        uint256 blocksPerTurn;
+        uint256 timePerTurn;
         uint256 maxPlayersSize;
         uint256 minPlayersSize;
         address rankTokenAddress;
-        uint256 blocksToJoin;
+        uint256 timeToJoin;
         uint256 gamePrice;
         uint256 joinGamePrice;
         uint256 maxTurns;
@@ -93,10 +93,10 @@ contract BestOfInit {
         _BOG.contractInitialized = true;
 
         LibTBG.GameSettings memory settings;
-        settings.blocksPerTurn = initializer.blocksPerTurn;
+        settings.timePerTurn = initializer.timePerTurn;
         settings.maxPlayersSize = initializer.maxPlayersSize;
         settings.minPlayersSize = initializer.minPlayersSize;
-        settings.blocksToJoin = initializer.blocksToJoin;
+        settings.timeToJoin = initializer.timeToJoin;
         settings.maxTurns = initializer.maxTurns;
         settings.numWinners = initializer.numWinners;
         settings.subject = initializer.subject;

src/libraries/LibTurnBasedGame.sol

@@ -11,16 +11,17 @@ import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
 import {LibArray} from "../libraries/LibArray.sol";
 import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
 
+error invalidConfiguration(string paramter);
 library LibTBG {
     // using EnumerableMap for EnumerableMap.AddressToUintMap;
     // using EnumerableMap for EnumerableMap.UintToAddressMap;
     using EnumerableSet for EnumerableSet.AddressSet;
 
     struct GameSettings {
-        uint256 blocksPerTurn;
+        uint256 timePerTurn;
         uint256 maxPlayersSize;
         uint256 minPlayersSize;
-        uint256 blocksToJoin;
+        uint256 timeToJoin;
         uint256 maxTurns;
         uint256 numWinners;
         uint256 voteCredits;
@@ -68,15 +69,16 @@ library LibTBG {
 
     function init(GameSettings memory settings) internal {
         TBGStorageStruct storage tbg = TBGStorage();
-        require(settings.blocksPerTurn != 0, "init->blocksPerTurn");
-        require(settings.maxPlayersSize != 0, "init->maxPartySize");
-        require(settings.minPlayersSize > 2, "init->minPartySize");
-        require(settings.maxTurns != 0, "init->maxTurns");
-        require((settings.numWinners != 0) && (settings.numWinners < settings.minPlayersSize), "init->numWinners");
-        require(settings.blocksToJoin != 0, "init->blocksToJoin");
-        require(settings.maxPlayersSize >= settings.minPlayersSize, "init->maxPlayersSize");
-        require(settings.voteCredits > 0, "init->voteCredits");
-        require(bytes(settings.subject).length != 0, "init->subject");
+        if(settings.timePerTurn == 0) revert invalidConfiguration('timePerTurn');
+        if(settings.maxPlayersSize == 0) revert invalidConfiguration('maxPlayersSize');
+        if(settings.minPlayersSize < 2) revert invalidConfiguration('minPlayersSize');
+        if(settings.maxTurns == 0) revert invalidConfiguration('maxTurns');
+        if(settings.numWinners == 0 || settings.numWinners >= settings.minPlayersSize) revert invalidConfiguration('numWinners');
+        if(settings.timeToJoin == 0) revert invalidConfiguration('timeToJoin');
+        if(settings.maxPlayersSize < settings.minPlayersSize) revert invalidConfiguration('maxPlayersSize');
+        if(settings.voteCredits < 1) revert invalidConfiguration('voteCredits');
+        if(bytes(settings.subject).length == 0) revert invalidConfiguration('subject length');
+
 
         tbg.settings = settings;
         tbg.maxQuadraticVote = Math.sqrt(settings.voteCredits);
@@ -159,7 +161,7 @@ library LibTBG {
         GameInstance storage _game = _getGame(gameId);
         assert(gameId != 0);
         assert(_game.hasStarted == true);
-        if (block.number <= tbg.settings.blocksPerTurn + _game.turnStartedAt) return false;
+        if (block.timestamp <= tbg.settings.timePerTurn + _game.turnStartedAt) return false;
         return true;
     }
 
@@ -232,7 +234,7 @@ library LibTBG {
     function openRegistration(uint256 gameId) internal {
         require(gameExists(gameId), "game not found");
         GameInstance storage _game = _getGame(gameId);
-        _game.registrationOpenAt = block.number;
+        _game.registrationOpenAt = block.timestamp;
     }
 
     function isRegistrationOpen(uint256 gameId) internal view returns (bool) {
@@ -241,7 +243,7 @@ library LibTBG {
         if (_game.registrationOpenAt == 0) {
             return false;
         } else {
-            return _game.registrationOpenAt < block.number + tbg.settings.blocksToJoin ? true : false;
+            return _game.registrationOpenAt < block.timestamp + tbg.settings.timeToJoin ? true : false;
         }
     }
 
@@ -251,7 +253,7 @@ library LibTBG {
         bool retval = true;
         if (_game.hasStarted != false) retval = false;
         if (_game.registrationOpenAt == 0) retval = false;
-        if (block.number <= _game.registrationOpenAt + tbg.settings.blocksToJoin) retval = false;
+        if (block.timestamp <= _game.registrationOpenAt + tbg.settings.timeToJoin) retval = false;
         if (gameId == 0) retval = false;
         if (_game.players.length() < tbg.settings.minPlayersSize) retval = false;
         return retval;
@@ -262,13 +264,13 @@ library LibTBG {
         TBGStorageStruct storage tbg = TBGStorage();
         require(_game.hasStarted == false, "startGame->already started");
         require(_game.registrationOpenAt != 0, "startGame->Game registration was not yet open");
-        require(block.number > _game.registrationOpenAt + tbg.settings.blocksToJoin, "startGame->Still Can Join");
+        require(block.timestamp > _game.registrationOpenAt + tbg.settings.timeToJoin, "startGame->Still Can Join");
         require(gameId != 0, "startGame->Game not found");
         require(_game.players.length() >= tbg.settings.minPlayersSize, "startGame->Not enough players");
         _game.hasStarted = true;
         _game.hasEnded = false;
         _game.currentTurn = 1;
-        _game.turnStartedAt = block.number;
+        _game.turnStartedAt = block.timestamp;
         _resetPlayerStates(_game);
     }
 
@@ -327,7 +329,7 @@ library LibTBG {
         enforceIsNotOver(gameId);
         _clearCurrentMoves(_game);
         _game.currentTurn += 1;
-        _game.turnStartedAt = block.number;
+        _game.turnStartedAt = block.timestamp;
         bool _isLastTurn = isLastTurn(gameId);
         bool _isOvertime = _game.isOvertime;
         address[] memory sortedLeaders = new address[](getPlayers(gameId).length);

test/BestOfGame.ts

@@ -218,7 +218,7 @@ const startGame = async (
   gameId: BigNumberish,
   // players: [SignerIdentity, SignerIdentity, ...SignerIdentity[]]
 ) => {
-  await mineBlocks(BOGSettings.BOG_BLOCKS_TO_JOIN + 1);
+  await mineBlocks(BOGSettings.BOG_TIME_TO_JOIN + 1);
   await env.bestOfGame.connect(adr.gameMaster1.wallet).startGame(gameId);
   // proposalsStruct = await mockProposals({
   //   players: players,
@@ -267,7 +267,7 @@ const fillParty = async (
     await env.rankToken.connect(players[i].wallet).setApprovalForAll(env.bestOfGame.address, true);
     await gameContract.connect(players[i].wallet).joinGame(gameId, { value: ethers.utils.parseEther('0.4') });
   }
-  if (mineJoinBlocks) await mineBlocks(BOGSettings.BOG_BLOCKS_TO_JOIN + 1);
+  if (mineJoinBlocks) await mineBlocks(BOGSettings.BOG_TIME_TO_JOIN + 1);
   if (startGame && gameMaster) {
     await env.bestOfGame.connect(gameMaster.wallet).startGame(gameId);
   }
@@ -337,9 +337,9 @@ describe(scriptName, () => {
     expect(state.BestOfState.numGames).to.be.equal(0);
     expect(state.BestOfState.rankTokenAddress).to.be.equal(env.rankToken.address);
     expect(state.TBGSEttings.maxTurns).to.be.equal(BOGSettings.BOG_MAX_TURNS);
-    expect(state.TBGSEttings.blocksPerTurn).to.be.equal(BOGSettings.BOG_BLOCKS_PER_TURN);
+    expect(state.TBGSEttings.timePerTurn).to.be.equal(BOGSettings.BOG_TIME_PER_TURN);
     expect(state.TBGSEttings.minPlayersSize).to.be.equal(BOGSettings.BOG_MIN_PLAYERS);
-    expect(state.TBGSEttings.blocksToJoin).to.be.equal(BOGSettings.BOG_BLOCKS_TO_JOIN);
+    expect(state.TBGSEttings.timeToJoin).to.be.equal(BOGSettings.BOG_TIME_TO_JOIN);
     expect(state.TBGSEttings.maxTurns).to.be.equal(BOGSettings.BOG_MAX_TURNS);
   });
   it('Transfer ownership can be done only by contract owner', async () => {
@@ -570,7 +570,7 @@ describe(scriptName, () => {
         ).to.be.revertedWith('Game has not yet started');
       });
       it('Cannot be started if not enough players', async () => {
-        await mineBlocks(BOGSettings.BOG_BLOCKS_TO_JOIN + 1);
+        await mineBlocks(BOGSettings.BOG_TIME_TO_JOIN + 1);
         await expect(env.bestOfGame.connect(adr.gameMaster1.wallet).startGame(1)).to.be.revertedWith(
           'startGame->Not enough players',
         );
@@ -583,7 +583,7 @@ describe(scriptName, () => {
           await expect(env.bestOfGame.connect(adr.gameMaster1.wallet).startGame(1)).to.be.revertedWith(
             'startGame->Still Can Join',
           );
-          await mineBlocks(BOGSettings.BOG_BLOCKS_TO_JOIN + 1);
+          await mineBlocks(BOGSettings.BOG_TIME_TO_JOIN + 1);
           await expect(env.bestOfGame.connect(adr.gameMaster1.wallet).startGame(1)).to.be.emit(
             env.bestOfGame,
             'GameStarted',
@@ -667,7 +667,7 @@ describe(scriptName, () => {
             ).to.be.revertedWith('Only game master');
           });
           it('Can end turn if timeout reached with zero scores', async () => {
-            await mineBlocks(BOGSettings.BOG_BLOCKS_PER_TURN + 1);
+            await mineBlocks(BOGSettings.BOG_TIME_PER_TURN + 1);
             await expect(env.bestOfGame.connect(adr.gameMaster1.wallet).endTurn(1, [], [], []))
               .to.be.emit(env.bestOfGame, 'TurnEnded')
               .withArgs(
@@ -752,7 +752,7 @@ describe(scriptName, () => {
               //       );
               //   }
 
-              //   await mineBlocks(BOGSettings.BOG_BLOCKS_PER_TURN + 1);
+              //   await mineBlocks(BOGSettings.BOG_TIME_PER_TURN + 1);
               //   await expect(
               //     env.bestOfGame.connect(adr.gameMaster1.wallet).endTurn(
               //       1,
@@ -784,7 +784,7 @@ describe(scriptName, () => {
                   ).to.be.revertedWith('Some players still have time to propose');
                 });
                 it('Can end turn if timeout reached', async () => {
-                  await mineBlocks(BOGSettings.BOG_BLOCKS_PER_TURN + 1);
+                  await mineBlocks(BOGSettings.BOG_TIME_PER_TURN + 1);
                   expect(await env.bestOfGame.getTurn(1)).to.be.equal(2);
                   const players = getPlayers(adr, BOGSettings.BOG_MIN_PLAYERS);
                   const expectedScores: number[] = players.map(v => 0);

test/utils.ts

@@ -257,22 +257,22 @@ export const setupAddresses = async (
 const baseFee = 1 * 10 ** 18;
 export const BESTOF_CONTRACT_NAME = 'BESTOFNAME';
 export const BESTOF_CONTRACT_VERSION = '0.0.1';
-export const BOG_BLOCKS_PER_TURN = '25';
+export const BOG_TIME_PER_TURN = '25';
 export const BOG_MAX_PLAYERS = 5;
 export const BOG_MIN_PLAYERS = 4;
 export const BOG_MAX_TURNS = 3;
-export const BOG_BLOCKS_TO_JOIN = '200';
+export const BOG_TIME_TO_JOIN = '200';
 export const BOG_GAME_PRICE = ethers.utils.parseEther('0.001');
 export const BOG_JOIN_GAME_PRICE = ethers.utils.parseEther('0.001');
 export const BOG_NUM_WINNERS = 3;
 export const BOG_VOTE_CREDITS = 14;
 export const BOG_SUBJECT = 'Best Music on youtube';
 export const BOGSettings = {
-  BOG_BLOCKS_PER_TURN,
+  BOG_TIME_PER_TURN,
   BOG_MAX_PLAYERS,
   BOG_MIN_PLAYERS,
   BOG_MAX_TURNS,
-  BOG_BLOCKS_TO_JOIN,
+  BOG_TIME_TO_JOIN,
   BOG_GAME_PRICE,
   BOG_JOIN_GAME_PRICE,
   BOG_NUM_WINNERS,