feat(protocol): change cooldown and proving window to minutes

packages/protocol/contracts/L1/libs/LibProving.sol

@@ -399,7 +399,7 @@ library LibProving {
         if (tier.contestBond == 0) return;
 
         bool inProvingWindow = uint256(ts.timestamp).max(state.slotB.lastUnpausedAt)
-            + tier.provingWindow >= block.timestamp;
+            + tier.provingWindow * 60 >= block.timestamp;
         bool isAssignedPover = msg.sender == blk.assignedProver;
 
         // The assigned prover can only submit the very first transition.

packages/protocol/contracts/L1/libs/LibVerifying.sol

@@ -172,7 +172,7 @@ library LibVerifying {
                         tierProvider = resolver.resolve("tier_provider", false);
                     }
                     if (
-                        uint256(ITierProvider(tierProvider).getTier(ts.tier).cooldownWindow)
+                        uint256(ITierProvider(tierProvider).getTier(ts.tier).cooldownWindow) * 60
                             + uint256(ts.timestamp).max(state.slotB.lastUnpausedAt) > block.timestamp
                     ) {
                         // If cooldownWindow is 0, the block can theoretically

packages/protocol/contracts/L1/tiers/OptimisticTierProvider.sol → packages/protocol/contracts/L1/tiers/DevnetTierProvider.sol

@@ -17,11 +17,9 @@ pragma solidity 0.8.24;
 import "../../common/EssentialContract.sol";
 import "./ITierProvider.sol";
 
-contract OptimisticTierProvider is EssentialContract, ITierProvider {
+contract DevnetTierProvider is EssentialContract, ITierProvider {
     uint256[50] private __gap;
 
-    error TIER_NOT_FOUND();
-
     /// @notice Initializes the contract with the provided address manager.
     function init() external initializer {
         __Essential_init();
@@ -33,9 +31,9 @@ contract OptimisticTierProvider is EssentialContract, ITierProvider {
                 verifierName: "tier_optimistic",
                 validityBond: 250 ether, // TKO
                 contestBond: 500 ether, // TKO
-                cooldownWindow: 24 hours,
-                provingWindow: 2 hours,
-                maxBlocksToVerifyPerProof: 10
+                cooldownWindow: 1440, //24 hours
+                provingWindow: 120, // 2 hours
+                maxBlocksToVerifyPerProof: 16
             });
         }
 
@@ -44,9 +42,9 @@ contract OptimisticTierProvider is EssentialContract, ITierProvider {
                 verifierName: "tier_guardian",
                 validityBond: 0, // must be 0 for top tier
                 contestBond: 0, // must be 0 for top tier
-                cooldownWindow: 24 hours,
-                provingWindow: 8 hours,
-                maxBlocksToVerifyPerProof: 4
+                cooldownWindow: 60, //1 hours
+                provingWindow: 2880, // 48 hours
+                maxBlocksToVerifyPerProof: 16
             });
         }
 

packages/protocol/contracts/L1/tiers/ITierProvider.sol

@@ -17,12 +17,14 @@ pragma solidity 0.8.24;
 /// @title ITierProvider
 /// @notice Defines interface to return tier configuration.
 interface ITierProvider {
+    error TIER_NOT_FOUND();
+
     struct Tier {
         bytes32 verifierName;
         uint96 validityBond;
         uint96 contestBond;
-        uint24 cooldownWindow;
-        uint16 provingWindow;
+        uint24 cooldownWindow; // in minutes
+        uint16 provingWindow; // in minutes
         uint8 maxBlocksToVerifyPerProof;
     }
 
@@ -42,5 +44,6 @@ interface ITierProvider {
 library LibTiers {
     uint16 public constant TIER_OPTIMISTIC = 100;
     uint16 public constant TIER_SGX = 200;
+    uint16 public constant TIER_SGX_ZKVM = 300;
     uint16 public constant TIER_GUARDIAN = 1000;
 }

packages/protocol/contracts/L1/tiers/MainnetTierProvider.sol

@@ -0,0 +1,85 @@
+// SPDX-License-Identifier: MIT
+//  _____     _ _         _         _
+// |_   _|_ _(_) |_____  | |   __ _| |__ ___
+//   | |/ _` | | / / _ \ | |__/ _` | '_ (_-<
+//   |_|\__,_|_|_\_\___/ |____\__,_|_.__/__/
+//
+//   Email: security@taiko.xyz
+//   Website: https://taiko.xyz
+//   GitHub: https://github.com/taikoxyz
+//   Discord: https://discord.gg/taikoxyz
+//   Twitter: https://twitter.com/taikoxyz
+//   Blog: https://mirror.xyz/labs.taiko.eth
+//   Youtube: https://www.youtube.com/@taikoxyz
+
+pragma solidity 0.8.24;
+
+import "../../common/EssentialContract.sol";
+import "./ITierProvider.sol";
+
+/// @title MainnetTierProvider
+/// @dev Labeled in AddressResolver as "tier_provider"
+/// @dev Assuming liveness bound is 250TKO.
+// Taiko token's total supply is 1 billion. Assuming block time is 2 second, and
+// the cool down period is 2 days. In 2 days, we can have (2*86400/2)=86400
+// blocks. Assuming 10% tokens are used in bonds, then each block may use up to
+// these many tokens: 1,000,000,000 * 10% / 86400=1157 TOK per block, which is
+// about 722 USD.
+contract MainnetTierProvider is EssentialContract, ITierProvider {
+    uint256[50] private __gap;
+
+    /// @notice Initializes the contract with the provided address manager.
+    function init() external initializer {
+        __Essential_init();
+    }
+
+    function getTier(uint16 tierId) public pure override returns (ITierProvider.Tier memory) {
+        if (tierId == LibTiers.TIER_SGX) {
+            return ITierProvider.Tier({
+                verifierName: "tier_sgx",
+                validityBond: 250 ether, // TKO
+                contestBond: 500 ether, // TKO
+                cooldownWindow: 1440, //24 hours
+                provingWindow: 60, // 1 hours
+                maxBlocksToVerifyPerProof: 8
+            });
+        }
+
+        if (tierId == LibTiers.TIER_SGX_ZKVM) {
+            return ITierProvider.Tier({
+                verifierName: "tier_sgx_zkvm",
+                validityBond: 500 ether, // TKO
+                contestBond: 1000 ether, // TKO
+                cooldownWindow: 1440, //24 hours
+                provingWindow: 240, // 4 hours
+                maxBlocksToVerifyPerProof: 4
+            });
+        }
+
+        if (tierId == LibTiers.TIER_GUARDIAN) {
+            return ITierProvider.Tier({
+                verifierName: "tier_guardian",
+                validityBond: 0, // must be 0 for top tier
+                contestBond: 0, // must be 0 for top tier
+                cooldownWindow: 60, //1 hours
+                provingWindow: 2880, // 48 hours
+                maxBlocksToVerifyPerProof: 16
+            });
+        }
+
+        revert TIER_NOT_FOUND();
+    }
+
+    function getTierIds() public pure override returns (uint16[] memory tiers) {
+        tiers = new uint16[](3);
+        tiers[0] = LibTiers.TIER_SGX;
+        tiers[1] = LibTiers.TIER_SGX_ZKVM;
+        tiers[2] = LibTiers.TIER_GUARDIAN;
+    }
+
+    function getMinTier(uint256 rand) public pure override returns (uint16) {
+        // 0.1% require SGX + ZKVM; all others require SGX
+        if (rand % 1000 == 0) return LibTiers.TIER_SGX_ZKVM;
+        else return LibTiers.TIER_SGX;
+    }
+}

packages/protocol/contracts/L1/tiers/TestnetTierProvider.sol

@@ -28,8 +28,6 @@ import "./ITierProvider.sol";
 contract TestnetTierProvider is EssentialContract, ITierProvider {
     uint256[50] private __gap;
 
-    error TIER_NOT_FOUND();
-
     /// @notice Initializes the contract with the provided address manager.
     function init() external initializer {
         __Essential_init();
@@ -41,9 +39,9 @@ contract TestnetTierProvider is EssentialContract, ITierProvider {
                 verifierName: "tier_optimistic",
                 validityBond: 250 ether, // TKO
                 contestBond: 500 ether, // TKO
-                cooldownWindow: 24 hours,
-                provingWindow: 2 hours,
-                maxBlocksToVerifyPerProof: 10
+                cooldownWindow: 1440, //24 hours
+                provingWindow: 30, // 0.5 hours
+                maxBlocksToVerifyPerProof: 12
             });
         }
 
@@ -52,8 +50,8 @@ contract TestnetTierProvider is EssentialContract, ITierProvider {
                 verifierName: "tier_sgx",
                 validityBond: 500 ether, // TKO
                 contestBond: 1000 ether, // TKO
-                cooldownWindow: 24 hours,
-                provingWindow: 4 hours,
+                cooldownWindow: 1440, //24 hours
+                provingWindow: 60, // 1 hours
                 maxBlocksToVerifyPerProof: 8
             });
         }
@@ -63,9 +61,9 @@ contract TestnetTierProvider is EssentialContract, ITierProvider {
                 verifierName: "tier_guardian",
                 validityBond: 0, // must be 0 for top tier
                 contestBond: 0, // must be 0 for top tier
-                cooldownWindow: 24 hours,
-                provingWindow: 8 hours,
-                maxBlocksToVerifyPerProof: 4
+                cooldownWindow: 60, //1 hours
+                provingWindow: 2880, // 48 hours
+                maxBlocksToVerifyPerProof: 16
             });
         }
 

packages/protocol/script/DeployOnL1.s.sol

@@ -19,8 +19,9 @@ import "@openzeppelin/contracts/utils/Strings.sol";
 import "../contracts/L1/TaikoToken.sol";
 import "../contracts/L1/TaikoL1.sol";
 import "../contracts/L1/provers/GuardianProver.sol";
+import "../contracts/L1/tiers/DevnetTierProvider.sol";
 import "../contracts/L1/tiers/TestnetTierProvider.sol";
-import "../contracts/L1/tiers/OptimisticTierProvider.sol";
+import "../contracts/L1/tiers/MainnetTierProvider.sol";
 import "../contracts/L1/hooks/AssignmentHook.sol";
 import "../contracts/L1/gov/TaikoTimelockController.sol";
 import "../contracts/L1/gov/TaikoGovernor.sol";
@@ -320,16 +321,9 @@ contract DeployOnL1 is DeployCapability {
             owner: timelock
         });
 
-        address tierProvider;
-        if (vm.envBool("OPTIMISTIC_TIER_PROVIDER")) {
-            tierProvider = address(new OptimisticTierProvider());
-        } else {
-            tierProvider = address(new TestnetTierProvider());
-        }
-
         deployProxy({
             name: "tier_provider",
-            impl: tierProvider,
+            impl: deployTierProvider(vm.envString("TIER_PROVIDER")),
             data: abi.encodeCall(TestnetTierProvider.init, ()),
             registerTo: rollupAddressManager,
             owner: timelock
@@ -380,6 +374,18 @@ contract DeployOnL1 is DeployCapability {
         );
     }
 
+    function deployTierProvider(string memory tierProviderName) private returns (address) {
+        if (keccak256(abi.encode(tierProviderName)) == keccak256(abi.encode("devnet"))) {
+            return address(new DevnetTierProvider());
+        } else if (keccak256(abi.encode(tierProviderName)) == keccak256(abi.encode("testnet"))) {
+            return address(new TestnetTierProvider());
+        } else if (keccak256(abi.encode(tierProviderName)) == keccak256(abi.encode("mainnet"))) {
+            return address(new MainnetTierProvider());
+        } else {
+            revert("invalid tier provider");
+        }
+    }
+
     function deployAuxContracts() private {
         address horseToken = address(new FreeMintERC20("Horse Token", "HORSE"));
         console2.log("HorseToken", horseToken);

packages/protocol/script/test_deploy_on_l1.sh

@@ -16,7 +16,7 @@ TAIKO_TOKEN_NAME="Taiko Token Katla" \
 TAIKO_TOKEN_SYMBOL=TTKOk \
 SHARED_ADDRESS_MANAGER=0x0000000000000000000000000000000000000000 \
 L2_GENESIS_HASH=0xee1950562d42f0da28bd4550d88886bc90894c77c9c9eaefef775d4c8223f259 \
-OPTIMISTIC_TIER_PROVIDER=false \
+TIER_PROVIDER="devnet" \
 forge script script/DeployOnL1.s.sol:DeployOnL1 \
     --fork-url http://localhost:8545 \
     --broadcast \

packages/protocol/test/L1/TaikoL1.t.sol

@@ -57,7 +57,7 @@ contract TaikoL1Test is TaikoL1TestBase {
             vm.roll(block.number + 15 * 12);
 
             uint16 minTier = meta.minTier;
-            vm.warp(block.timestamp + L1.getTier(minTier).cooldownWindow + 1);
+            vm.warp(block.timestamp + L1.getTier(minTier).cooldownWindow * 60 + 1);
 
             verifyBlock(Carol, 1);
             parentHash = blockHash;
@@ -89,7 +89,7 @@ contract TaikoL1Test is TaikoL1TestBase {
             proveBlock(Bob, Bob, meta, parentHash, blockHash, stateRoot, meta.minTier, "");
             vm.roll(block.number + 15 * 12);
             uint16 minTier = meta.minTier;
-            vm.warp(block.timestamp + L1.getTier(minTier).cooldownWindow + 1);
+            vm.warp(block.timestamp + L1.getTier(minTier).cooldownWindow * 60 + 1);
 
             verifyBlock(Alice, 2);
             parentHash = blockHash;