feat(taiko-client): changes based on the protocol forced inclusion feature

packages/protocol/contracts/layer1/devnet/DevnetInbox.sol

@@ -19,7 +19,7 @@ contract DevnetInbox is TaikoInbox {
     /// @inheritdoc ITaikoInbox
     function pacayaConfig() public pure override returns (ITaikoInbox.Config memory) {
         return ITaikoInbox.Config({
-            chainId: 167_001,
+            chainId: 167,
             maxUnverifiedBatches: 324_000,
             batchRingBufferSize: 360_000,
             maxBatchesToVerify: 16,

packages/protocol/contracts/layer1/preconf/PreconfInbox.sol

@@ -0,0 +1,45 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+import "../based/TaikoInbox.sol";
+
+/// @title PreconfInbox
+/// @dev Labeled in address resolver as "taiko"
+/// @custom:security-contact security@taiko.xyz
+contract PreconfInbox is TaikoInbox {
+    constructor(
+        address _wrapper,
+        address _verifier,
+        address _bondToken,
+        address _signalService
+    )
+        TaikoInbox(_wrapper, _verifier, _bondToken, _signalService)
+    { }
+
+    /// @inheritdoc ITaikoInbox
+    function pacayaConfig() public pure override returns (ITaikoInbox.Config memory) {
+        return ITaikoInbox.Config({
+            chainId: 167_010,
+            maxUnverifiedBatches: 324_000,
+            batchRingBufferSize: 360_000,
+            maxBatchesToVerify: 16,
+            blockMaxGasLimit: 240_000_000,
+            livenessBondBase: 125e18, // 125 Taiko token per batch
+            livenessBondPerBlock: 5e18, // 5 Taiko token per block
+            stateRootSyncInternal: 16,
+            maxAnchorHeightOffset: 64,
+            baseFeeConfig: LibSharedData.BaseFeeConfig({
+                adjustmentQuotient: 8,
+                sharingPctg: 75,
+                gasIssuancePerSecond: 5_000_000,
+                minGasExcess: 1_340_000_000,
+                maxGasIssuancePerBlock: 600_000_000
+            }),
+            provingWindow: 2 hours,
+            cooldownWindow: 0 hours,
+            maxSignalsToReceive: 16,
+            maxBlocksPerBatch: 768,
+            forkHeights: ITaikoInbox.ForkHeights({ ontake: 0, pacaya: 0, shasta: 0, unzen: 0 })
+        });
+    }
+}

packages/protocol/contracts/layer1/provers/ProverSetBase.sol

@@ -61,6 +61,8 @@ abstract contract ProverSetBase is EssentialContract, IERC1271 {
         bondToken = _bondToken;
     }
 
+    receive() external payable { }
+
     /// @notice Initializes the contract.
     function init(address _owner, address _admin) external nonZeroAddr(_admin) initializer {
         __Essential_init(_owner);

packages/protocol/contracts/shared/libs/LibNetwork.sol

@@ -10,9 +10,11 @@ library LibNetwork {
     uint256 internal constant ETHEREUM_KOVAN = 42;
     uint256 internal constant ETHEREUM_HOLESKY = 17_000;
     uint256 internal constant ETHEREUM_SEPOLIA = 11_155_111;
+    uint256 internal constant ETHEREUM_HELDER = 7_014_190_335;
 
     uint64 internal constant TAIKO_MAINNET = 167_000;
     uint64 internal constant TAIKO_HEKLA = 167_009;
+    uint64 internal constant TAIKO_PRECONFS = 167_010;
 
     uint256 internal constant ETHEREUM_BLOCK_TIME = 12 seconds;
 
@@ -22,7 +24,8 @@ library LibNetwork {
     function isEthereumTestnet(uint256 _chainId) internal pure returns (bool) {
         return _chainId == LibNetwork.ETHEREUM_ROPSTEN || _chainId == LibNetwork.ETHEREUM_RINKEBY
             || _chainId == LibNetwork.ETHEREUM_GOERLI || _chainId == LibNetwork.ETHEREUM_KOVAN
-            || _chainId == LibNetwork.ETHEREUM_HOLESKY || _chainId == LibNetwork.ETHEREUM_SEPOLIA;
+            || _chainId == LibNetwork.ETHEREUM_HOLESKY || _chainId == LibNetwork.ETHEREUM_SEPOLIA
+            || _chainId == LibNetwork.ETHEREUM_HELDER;
     }
 
     /// @dev Checks if the chain ID represents an Ethereum testnet or the Etheruem mainnet.
@@ -54,6 +57,7 @@ library LibNetwork {
     /// @return true if the chain supports Dencun hardfork, false otherwise.
     function isDencunSupported(uint256 _chainId) internal pure returns (bool) {
         return _chainId == LibNetwork.ETHEREUM_MAINNET || _chainId == LibNetwork.ETHEREUM_HOLESKY
-            || _chainId == LibNetwork.ETHEREUM_SEPOLIA || isTaikoDevnet(_chainId);
+            || _chainId == LibNetwork.ETHEREUM_SEPOLIA || _chainId == LibNetwork.ETHEREUM_HELDER
+            || isTaikoDevnet(_chainId);
     }
 }

packages/protocol/script/layer1/based/DeployProtocolOnL1.s.sol

@@ -28,6 +28,7 @@ import "src/layer1/mainnet/multirollup/MainnetERC721Vault.sol";
 import "src/layer1/mainnet/multirollup/MainnetSignalService.sol";
 import "src/layer1/preconf/impl/PreconfWhitelist.sol";
 import "src/layer1/preconf/impl/PreconfRouter.sol";
+import "src/layer1/preconf/PreconfInbox.sol";
 import "src/layer1/provers/ProverSet.sol";
 import "src/layer1/token/TaikoToken.sol";
 import "src/layer1/verifiers/Risc0Verifier.sol";
@@ -65,7 +66,8 @@ contract DeployProtocolOnL1 is DeployCapability {
         console2.log("sharedResolver: ", sharedResolver);
         // ---------------------------------------------------------------
         // Deploy rollup contracts
-        address rollupResolver = deployRollupContracts(sharedResolver, contractOwner);
+        (address rollupResolver, address proofVerifier) =
+            deployRollupContracts(sharedResolver, contractOwner);
 
         // ---------------------------------------------------------------
         // Signal service need to authorize the new rollup
@@ -114,7 +116,9 @@ contract DeployProtocolOnL1 is DeployCapability {
         }
 
         if (vm.envBool("DEPLOY_PRECONF_CONTRACTS")) {
-            deployPreconfContracts(contractOwner, sharedResolver, address(taikoInbox));
+            deployPreconfContracts(
+                contractOwner, rollupResolver, sharedResolver, address(taikoInbox), proofVerifier
+            );
         }
 
         if (DefaultResolver(sharedResolver).owner() == msg.sender) {
@@ -124,6 +128,8 @@ contract DeployProtocolOnL1 is DeployCapability {
 
         DefaultResolver(rollupResolver).transferOwnership(contractOwner);
         console2.log("** rollupResolver ownership transferred to:", contractOwner);
+
+        Ownable2StepUpgradeable(taikoInboxAddr).transferOwnership(contractOwner);
     }
 
     function deploySharedContracts(address owner) internal returns (address sharedResolver) {
@@ -236,7 +242,7 @@ contract DeployProtocolOnL1 is DeployCapability {
         address owner
     )
         internal
-        returns (address rollupResolver)
+        returns (address rollupResolver, address proofVerifier)
     {
         addressNotNull(_sharedResolver, "sharedResolver");
         addressNotNull(owner, "owner");
@@ -255,7 +261,7 @@ contract DeployProtocolOnL1 is DeployCapability {
         copyRegister(rollupResolver, _sharedResolver, "bridge");
 
         // Proof verifier
-        address proofVerifier = deployProxy({
+        proofVerifier = deployProxy({
             name: "proof_verifier",
             impl: address(
                 new DevnetVerifier(address(0), address(0), address(0), address(0), address(0))
@@ -299,14 +305,31 @@ contract DeployProtocolOnL1 is DeployCapability {
                 )
             );
         }
-        address newFork = address(
-            new DevnetInbox(
-                address(0),
-                proofVerifier,
-                IResolver(_sharedResolver).resolve(uint64(block.chainid), "bond_token", false),
-                IResolver(_sharedResolver).resolve(uint64(block.chainid), "signal_service", false)
-            )
-        );
+        address newFork;
+
+        if (vm.envBool("PRECONF_INBOX")) {
+            newFork = address(
+                new PreconfInbox(
+                    address(0),
+                    proofVerifier,
+                    IResolver(_sharedResolver).resolve(uint64(block.chainid), "bond_token", false),
+                    IResolver(_sharedResolver).resolve(
+                        uint64(block.chainid), "signal_service", false
+                    )
+                )
+            );
+        } else {
+            newFork = address(
+                new DevnetInbox(
+                    address(0),
+                    proofVerifier,
+                    IResolver(_sharedResolver).resolve(uint64(block.chainid), "bond_token", false),
+                    IResolver(_sharedResolver).resolve(
+                        uint64(block.chainid), "signal_service", false
+                    )
+                )
+            );
+        }
         console2.log("  oldFork       :", oldFork);
         console2.log("  newFork       :", newFork);
 
@@ -318,7 +341,7 @@ contract DeployProtocolOnL1 is DeployCapability {
         });
 
         TaikoInbox taikoInbox = TaikoInbox(payable(taikoInboxAddr));
-        taikoInbox.init(owner, vm.envBytes32("L2_GENESIS_HASH"));
+        taikoInbox.init(msg.sender, vm.envBytes32("L2_GENESIS_HASH"));
         uint64 l2ChainId = taikoInbox.pacayaConfig().chainId;
         require(l2ChainId != block.chainid, "same chainid");
 
@@ -430,17 +453,19 @@ contract DeployProtocolOnL1 is DeployCapability {
 
     function deployPreconfContracts(
         address owner,
-        address resolver,
-        address taikoInbox
+        address rollupResolver,
+        address sharedResolver,
+        address taikoInbox,
+        address verifier
     )
         private
         returns (address whitelist, address router, address store, address taikoWrapper)
     {
         whitelist = deployProxy({
             name: "preconf_whitelist",
-            impl: address(new PreconfWhitelist(resolver)),
+            impl: address(new PreconfWhitelist(rollupResolver)),
             data: abi.encodeCall(PreconfWhitelist.init, (owner)),
-            registerTo: resolver
+            registerTo: rollupResolver
         });
 
         // Initializable a forced inclusion store with a fake address for TaikoWrapper at first,
@@ -456,16 +481,72 @@ contract DeployProtocolOnL1 is DeployCapability {
                 )
             ),
             data: abi.encodeCall(ForcedInclusionStore.init, (address(0))),
-            registerTo: resolver
+            registerTo: rollupResolver
         });
 
         taikoWrapper = deployProxy({
             name: "taiko_wrapper",
             impl: address(new TaikoWrapper(taikoInbox, store, router)),
-            data: abi.encodeCall(TaikoWrapper.init, (owner)),
-            registerTo: resolver
+            data: abi.encodeCall(TaikoWrapper.init, (msg.sender)),
+            registerTo: rollupResolver
+        });
+
+        address oldFork = vm.envAddress("OLD_FORK_TAIKO_INBOX");
+        if (oldFork == address(0)) {
+            oldFork = address(
+                new DevnetInbox(
+                    address(0),
+                    verifier,
+                    IResolver(sharedResolver).resolve(uint64(block.chainid), "bond_token", false),
+                    IResolver(sharedResolver).resolve(
+                        uint64(block.chainid), "signal_service", false
+                    )
+                )
+            );
+        }
+
+        address newFork;
+
+        if (vm.envBool("PRECONF_INBOX")) {
+            newFork = address(
+                new PreconfInbox(
+                    taikoWrapper,
+                    verifier,
+                    IResolver(sharedResolver).resolve(uint64(block.chainid), "bond_token", false),
+                    IResolver(sharedResolver).resolve(
+                        uint64(block.chainid), "signal_service", false
+                    )
+                )
+            );
+        } else {
+            newFork = address(
+                new DevnetInbox(
+                    taikoWrapper,
+                    verifier,
+                    IResolver(sharedResolver).resolve(uint64(block.chainid), "bond_token", false),
+                    IResolver(sharedResolver).resolve(
+                        uint64(block.chainid), "signal_service", false
+                    )
+                )
+            );
+        }
+
+        UUPSUpgradeable(taikoInbox).upgradeTo({
+            newImplementation: address(
+                new PacayaForkRouter(
+                    oldFork, // dont need old fork, we are using pacaya fork height 0 here
+                    newFork
+                )
+            )
         });
 
+        UUPSUpgradeable(taikoWrapper).upgradeTo({
+            newImplementation: address(new TaikoWrapper(taikoInbox, store, router))
+        });
+
+        Ownable2StepUpgradeable(taikoWrapper).transferOwnership(owner);
+        console2.log("** taiko_wrapper ownership transferred to:", owner);
+
         UUPSUpgradeable(store).upgradeTo(
             address(
                 new ForcedInclusionStore(
@@ -484,7 +565,7 @@ contract DeployProtocolOnL1 is DeployCapability {
             name: "preconf_router",
             impl: address(new PreconfRouter(taikoWrapper, whitelist)),
             data: abi.encodeCall(PreconfRouter.init, (owner)),
-            registerTo: resolver
+            registerTo: rollupResolver
         });
 
         return (whitelist, router, store, taikoWrapper);

packages/protocol/script/layer1/based/deploy_protocol_on_l1.sh

@@ -18,6 +18,7 @@ L2_GENESIS_HASH=0xee1950562d42f0da28bd4550d88886bc90894c77c9c9eaefef775d4c8223f2
 PAUSE_BRIDGE=true \
 FOUNDRY_PROFILE="layer1" \
 DEPLOY_PRECONF_CONTRACTS=true \
+PRECONF_INBOX=false \
 INCLUSION_WINDOW=24 \
 INCLUSION_FEE_IN_GWEI=100 \
 forge script ./script/layer1/based/DeployProtocolOnL1.s.sol:DeployProtocolOnL1 \