fix import_genesis_block.ts

contracts/.gitignore

@@ -8,9 +8,10 @@ typechain
 cache
 cache-hardhat
 artifacts
+broadcast
 
 # logs
 *.log
 
 # eslint
-.eslintcache
+.eslintcache

contracts/foundry.toml

@@ -1,6 +1,7 @@
-[default]
+[profile.default]
 src = 'src'                                             # the source directory
 test = 'src/test'                                       # the test directory
+script = 'scripts'                                      # the script directory
 out = 'artifacts/src'                                   # the output directory (for artifacts)
 libs = []                                                     # a list of library directories
 remappings = []                                               # a list of remappings

contracts/scripts/foundry/DeployL1BridgeContracts.s.sol

@@ -0,0 +1,105 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.10;
+
+import { Script } from "forge-std/Script.sol";
+import { console} from "forge-std/console.sol";
+
+import { ProxyAdmin } from "@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol";
+import { TransparentUpgradeableProxy } from "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol";
+
+import { L1CustomERC20Gateway } from "../../src/L1/gateways/L1CustomERC20Gateway.sol";
+import { L1ERC1155Gateway } from "../../src/L1/gateways/L1ERC1155Gateway.sol";
+import { L1ERC721Gateway } from "../../src/L1/gateways/L1ERC721Gateway.sol";
+import { L1GatewayRouter } from "../../src/L1/gateways/L1GatewayRouter.sol";
+import { L1ScrollMessenger } from "../../src/L1/L1ScrollMessenger.sol";
+import { L1StandardERC20Gateway } from "../../src/L1/gateways/L1StandardERC20Gateway.sol";
+import { RollupVerifier } from "../../src/libraries/verifier/RollupVerifier.sol";
+import { ZKRollup } from "../../src/L1/rollup/ZKRollup.sol";
+
+contract DeployL1BridgeContracts is Script {
+    uint256 L1_DEPLOYER_PRIVATE_KEY = vm.envUint("L1_DEPLOYER_PRIVATE_KEY");
+    ProxyAdmin proxyAdmin;
+
+    function run() external {
+        vm.startBroadcast(L1_DEPLOYER_PRIVATE_KEY);
+
+        // note: the RollupVerifier library is deployed implicitly
+
+        deployProxyAdmin();
+        deployZKRollup();
+        deployL1StandardERC20Gateway();
+        deployL1GatewayRouter();
+        deployL1ScrollMessenger();
+        deployL1CustomERC20Gateway();
+        deployL1ERC721Gateway();
+        deployL1ERC1155Gateway();
+
+        vm.stopBroadcast();
+    }
+
+    function deployProxyAdmin() internal {
+        proxyAdmin = new ProxyAdmin();
+
+        logAddress("L1_PROXY_ADMIN_ADDR", address(proxyAdmin));
+    }
+
+    function deployZKRollup() internal {
+        ZKRollup impl = new ZKRollup();
+        TransparentUpgradeableProxy proxy = new TransparentUpgradeableProxy(address(impl), address(proxyAdmin), new bytes(0));
+
+        logAddress("L1_ZK_ROLLUP_IMPLEMENTATION_ADDR", address(impl));
+        logAddress("L1_ZK_ROLLUP_PROXY_ADDR", address(proxy));
+    }
+
+    function deployL1StandardERC20Gateway() internal {
+        L1StandardERC20Gateway impl = new L1StandardERC20Gateway();
+        TransparentUpgradeableProxy proxy = new TransparentUpgradeableProxy(address(impl), address(proxyAdmin), new bytes(0));
+
+        logAddress("L1_STANDARD_ERC20_GATEWAY_IMPLEMENTATION_ADDR", address(impl));
+        logAddress("L1_STANDARD_ERC20_GATEWAY_PROXY_ADDR", address(proxy));
+    }
+
+    function deployL1GatewayRouter() internal {
+        L1GatewayRouter impl = new L1GatewayRouter();
+        TransparentUpgradeableProxy proxy = new TransparentUpgradeableProxy(address(impl), address(proxyAdmin), new bytes(0));
+
+        logAddress("L1_GATEWAY_ROUTER_IMPLEMENTATION_ADDR", address(impl));
+        logAddress("L1_GATEWAY_ROUTER_PROXY_ADDR", address(proxy));
+    }
+
+    function deployL1ScrollMessenger() internal {
+        L1ScrollMessenger impl = new L1ScrollMessenger();
+        TransparentUpgradeableProxy proxy = new TransparentUpgradeableProxy(address(impl), address(proxyAdmin), new bytes(0));
+
+        logAddress("L1_SCROLL_MESSENGER_IMPLEMENTATION_ADDR", address(impl));
+        logAddress("L1_SCROLL_MESSENGER_PROXY_ADDR", address(proxy));
+    }
+
+    function deployL1CustomERC20Gateway() internal {
+        L1CustomERC20Gateway impl = new L1CustomERC20Gateway();
+        TransparentUpgradeableProxy proxy = new TransparentUpgradeableProxy(address(impl), address(proxyAdmin), new bytes(0));
+
+        logAddress("L1_CUSTOM_ERC20_GATEWAY_IMPLEMENTATION_ADDR", address(impl));
+        logAddress("L1_CUSTOM_ERC20_GATEWAY_PROXY_ADDR", address(proxy));
+    }
+
+    function deployL1ERC721Gateway() internal {
+        L1ERC721Gateway impl = new L1ERC721Gateway();
+        TransparentUpgradeableProxy proxy = new TransparentUpgradeableProxy(address(impl), address(proxyAdmin), new bytes(0));
+
+        logAddress("L1_ERC721_GATEWAY_IMPLEMENTATION_ADDR", address(impl));
+        logAddress("L1_ERC721_GATEWAY_PROXY_ADDR", address(proxy));
+    }
+
+    function deployL1ERC1155Gateway() internal {
+        L1ERC1155Gateway impl = new L1ERC1155Gateway();
+        TransparentUpgradeableProxy proxy = new TransparentUpgradeableProxy(address(impl), address(proxyAdmin), new bytes(0));
+
+        logAddress("L1_ERC1155_GATEWAY_IMPLEMENTATION_ADDR", address(impl));
+        logAddress("L1_ERC1155_GATEWAY_PROXY_ADDR", address(proxy));
+    }
+
+    function logAddress(string memory name, address addr) internal {
+        console.log(string(abi.encodePacked(name, "=", vm.toString(address(addr)))));
+    }
+}

contracts/scripts/foundry/DeployL2BridgeContracts.s.sol

@@ -0,0 +1,102 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.10;
+
+import { Script } from "forge-std/Script.sol";
+import { console} from "forge-std/console.sol";
+
+import { ProxyAdmin } from "@openzeppelin/contracts/proxy/transparent/ProxyAdmin.sol";
+import { TransparentUpgradeableProxy } from "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol";
+
+import { L2CustomERC20Gateway } from "../../src/L2/gateways/L2CustomERC20Gateway.sol";
+import { L2ERC1155Gateway } from "../../src/L2/gateways/L2ERC1155Gateway.sol";
+import { L2ERC721Gateway } from "../../src/L2/gateways/L2ERC721Gateway.sol";
+import { L2GatewayRouter } from "../../src/L2/gateways/L2GatewayRouter.sol";
+import { L2ScrollMessenger } from "../../src/L2/L2ScrollMessenger.sol";
+import { L2StandardERC20Gateway } from "../../src/L2/gateways/L2StandardERC20Gateway.sol";
+import { ScrollStandardERC20 } from "../../src/libraries/token/ScrollStandardERC20.sol";
+import { ScrollStandardERC20Factory } from "../../src/libraries/token/ScrollStandardERC20Factory.sol";
+
+contract DeployL2BridgeContracts is Script {
+    uint256 L2_DEPLOYER_PRIVATE_KEY = vm.envUint("L2_DEPLOYER_PRIVATE_KEY");
+    ProxyAdmin proxyAdmin;
+
+    function run() external {
+        vm.startBroadcast(L2_DEPLOYER_PRIVATE_KEY);
+
+        deployL2ScrollMessenger();
+        deployProxyAdmin();
+        deployL2StandardERC20Gateway();
+        deployL2GatewayRouter();
+        deployScrollStandardERC20Factory();
+        deployL2CustomERC20Gateway();
+        deployL2ERC721Gateway();
+        deployL2ERC1155Gateway();
+
+        vm.stopBroadcast();
+    }
+
+    function deployL2ScrollMessenger() internal {
+        address owner = vm.addr(L2_DEPLOYER_PRIVATE_KEY);
+        L2ScrollMessenger l2ScrollMessenger = new L2ScrollMessenger(owner);
+
+        logAddress("L2_SCROLL_MESSENGER_ADDR", address(l2ScrollMessenger));
+    }
+
+    function deployProxyAdmin() internal {
+        proxyAdmin = new ProxyAdmin();
+
+        logAddress("L2_PROXY_ADMIN_ADDR", address(proxyAdmin));
+    }
+
+    function deployL2StandardERC20Gateway() internal {
+        L2StandardERC20Gateway impl = new L2StandardERC20Gateway();
+        TransparentUpgradeableProxy proxy = new TransparentUpgradeableProxy(address(impl), address(proxyAdmin), new bytes(0));
+
+        logAddress("L2_STANDARD_ERC20_GATEWAY_IMPLEMENTATION_ADDR", address(impl));
+        logAddress("L2_STANDARD_ERC20_GATEWAY_PROXY_ADDR", address(proxy));
+    }
+
+    function deployL2GatewayRouter() internal {
+        L2GatewayRouter impl = new L2GatewayRouter();
+        TransparentUpgradeableProxy proxy = new TransparentUpgradeableProxy(address(impl), address(proxyAdmin), new bytes(0));
+
+        logAddress("L2_GATEWAY_ROUTER_IMPLEMENTATION_ADDR", address(impl));
+        logAddress("L2_GATEWAY_ROUTER_PROXY_ADDR", address(proxy));
+    }
+
+    function deployScrollStandardERC20Factory() internal {
+        ScrollStandardERC20 tokenImpl = new ScrollStandardERC20();
+        ScrollStandardERC20Factory scrollStandardERC20Factory = new ScrollStandardERC20Factory(address(tokenImpl));
+
+        logAddress("L2_SCROLL_STANDARD_ERC20_ADDR", address(tokenImpl));
+        logAddress("L2_SCROLL_STANDARD_ERC20_FACTORY_ADDR", address(scrollStandardERC20Factory));
+    }
+
+    function deployL2CustomERC20Gateway() internal {
+        L2CustomERC20Gateway impl = new L2CustomERC20Gateway();
+        TransparentUpgradeableProxy proxy = new TransparentUpgradeableProxy(address(impl), address(proxyAdmin), new bytes(0));
+
+        logAddress("L2_CUSTOM_ERC20_GATEWAY_IMPLEMENTATION_ADDR", address(impl));
+        logAddress("L2_CUSTOM_ERC20_GATEWAY_PROXY_ADDR", address(proxy));
+    }
+
+    function deployL2ERC721Gateway() internal {
+        L2ERC721Gateway impl = new L2ERC721Gateway();
+        TransparentUpgradeableProxy proxy = new TransparentUpgradeableProxy(address(impl), address(proxyAdmin), new bytes(0));
+
+        logAddress("L2_ERC721_GATEWAY_IMPLEMENTATION_ADDR", address(impl));
+        logAddress("L2_ERC721_GATEWAY_PROXY_ADDR", address(proxy));
+    }
+
+    function deployL2ERC1155Gateway() internal {
+        L2ERC1155Gateway impl = new L2ERC1155Gateway();
+        TransparentUpgradeableProxy proxy = new TransparentUpgradeableProxy(address(impl), address(proxyAdmin), new bytes(0));
+
+        logAddress("L2_ERC1155_GATEWAY_IMPLEMENTATION_ADDR", address(impl));
+        logAddress("L2_ERC1155_GATEWAY_PROXY_ADDR", address(proxy));
+    }
+
+    function logAddress(string memory name, address addr) internal {
+        console.log(string(abi.encodePacked(name, "=", vm.toString(address(addr)))));
+    }
+}

contracts/scripts/foundry/InitializeL1BridgeContracts.s.sol

@@ -0,0 +1,86 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.10;
+
+import { Script } from "forge-std/Script.sol";
+
+import { L1CustomERC20Gateway } from "../../src/L1/gateways/L1CustomERC20Gateway.sol";
+import { L1ERC1155Gateway } from "../../src/L1/gateways/L1ERC1155Gateway.sol";
+import { L1ERC721Gateway } from "../../src/L1/gateways/L1ERC721Gateway.sol";
+import { L1GatewayRouter } from "../../src/L1/gateways/L1GatewayRouter.sol";
+import { L1ScrollMessenger } from "../../src/L1/L1ScrollMessenger.sol";
+import { L1StandardERC20Gateway } from "../../src/L1/gateways/L1StandardERC20Gateway.sol";
+import { ZKRollup } from "../../src/L1/rollup/ZKRollup.sol";
+
+contract InitializeL1BridgeContracts is Script {
+    uint256 L1_DEPLOYER_PRIVATE_KEY = vm.envUint("L1_DEPLOYER_PRIVATE_KEY");
+
+    uint256 CHAIN_ID_L2 = vm.envUint("CHAIN_ID_L2");
+    address L1_ROLLUP_OPERATOR_ADDR = vm.envAddress("L1_ROLLUP_OPERATOR_ADDR");
+
+    address L1_ZK_ROLLUP_PROXY_ADDR = vm.envAddress("L1_ZK_ROLLUP_PROXY_ADDR");
+    address L1_STANDARD_ERC20_GATEWAY_PROXY_ADDR = vm.envAddress("L1_STANDARD_ERC20_GATEWAY_PROXY_ADDR");
+    address L1_GATEWAY_ROUTER_PROXY_ADDR = vm.envAddress("L1_GATEWAY_ROUTER_PROXY_ADDR");
+    address L1_SCROLL_MESSENGER_PROXY_ADDR = vm.envAddress("L1_SCROLL_MESSENGER_PROXY_ADDR");
+    address L1_CUSTOM_ERC20_GATEWAY_PROXY_ADDR = vm.envAddress("L1_CUSTOM_ERC20_GATEWAY_PROXY_ADDR");
+    address L1_ERC721_GATEWAY_PROXY_ADDR = vm.envAddress("L1_ERC721_GATEWAY_PROXY_ADDR");
+    address L1_ERC1155_GATEWAY_PROXY_ADDR = vm.envAddress("L1_ERC1155_GATEWAY_PROXY_ADDR");
+
+    address L2_STANDARD_ERC20_GATEWAY_PROXY_ADDR = vm.envAddress("L2_STANDARD_ERC20_GATEWAY_PROXY_ADDR");
+    address L2_GATEWAY_ROUTER_PROXY_ADDR = vm.envAddress("L2_GATEWAY_ROUTER_PROXY_ADDR");
+    address L2_SCROLL_STANDARD_ERC20_ADDR = vm.envAddress("L2_SCROLL_STANDARD_ERC20_ADDR");
+    address L2_SCROLL_STANDARD_ERC20_FACTORY_ADDR = vm.envAddress("L2_SCROLL_STANDARD_ERC20_FACTORY_ADDR");
+    address L2_CUSTOM_ERC20_GATEWAY_PROXY_ADDR = vm.envAddress("L2_CUSTOM_ERC20_GATEWAY_PROXY_ADDR");
+    address L2_ERC721_GATEWAY_PROXY_ADDR = vm.envAddress("L2_ERC721_GATEWAY_PROXY_ADDR");
+    address L2_ERC1155_GATEWAY_PROXY_ADDR = vm.envAddress("L2_ERC1155_GATEWAY_PROXY_ADDR");
+
+    function run() external {
+        vm.startBroadcast(L1_DEPLOYER_PRIVATE_KEY);
+
+        // initialize L1StandardERC20Gateway
+        L1StandardERC20Gateway(L1_STANDARD_ERC20_GATEWAY_PROXY_ADDR).initialize(
+            L2_STANDARD_ERC20_GATEWAY_PROXY_ADDR,
+            L1_GATEWAY_ROUTER_PROXY_ADDR,
+            L1_SCROLL_MESSENGER_PROXY_ADDR,
+            L2_SCROLL_STANDARD_ERC20_ADDR,
+            L2_SCROLL_STANDARD_ERC20_FACTORY_ADDR
+        );
+
+        // initialize L1GatewayRouter
+        L1GatewayRouter(L1_GATEWAY_ROUTER_PROXY_ADDR).initialize(
+            L1_STANDARD_ERC20_GATEWAY_PROXY_ADDR,
+            L2_GATEWAY_ROUTER_PROXY_ADDR,
+            L1_SCROLL_MESSENGER_PROXY_ADDR
+        );
+
+        // initialize ZKRollup
+        ZKRollup(L1_ZK_ROLLUP_PROXY_ADDR).initialize(CHAIN_ID_L2);
+        ZKRollup(L1_ZK_ROLLUP_PROXY_ADDR).updateMessenger(L1_SCROLL_MESSENGER_PROXY_ADDR);
+        ZKRollup(L1_ZK_ROLLUP_PROXY_ADDR).updateOperator(L1_ROLLUP_OPERATOR_ADDR);
+
+        // initialize L1ScrollMessenger
+        L1ScrollMessenger(payable(L1_SCROLL_MESSENGER_PROXY_ADDR)).initialize(
+            L1_ZK_ROLLUP_PROXY_ADDR
+        );
+
+        // initialize L1CustomERC20Gateway
+        L1CustomERC20Gateway(L1_CUSTOM_ERC20_GATEWAY_PROXY_ADDR).initialize(
+            L2_CUSTOM_ERC20_GATEWAY_PROXY_ADDR,
+            L1_GATEWAY_ROUTER_PROXY_ADDR,
+            L1_SCROLL_MESSENGER_PROXY_ADDR
+        );
+
+        // initialize L1ERC1155Gateway
+        L1ERC1155Gateway(L1_ERC1155_GATEWAY_PROXY_ADDR).initialize(
+            L2_ERC1155_GATEWAY_PROXY_ADDR,
+            L1_SCROLL_MESSENGER_PROXY_ADDR
+        );
+
+        // initialize L1ERC721Gateway
+        L1ERC721Gateway(L1_ERC721_GATEWAY_PROXY_ADDR).initialize(
+            L2_ERC721_GATEWAY_PROXY_ADDR,
+            L1_SCROLL_MESSENGER_PROXY_ADDR
+        );
+
+        vm.stopBroadcast();
+    }
+}

contracts/scripts/foundry/InitializeL2BridgeContracts.s.sol

@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.10;
+
+import { Script } from "forge-std/Script.sol";
+
+import { L2CustomERC20Gateway } from "../../src/L2/gateways/L2CustomERC20Gateway.sol";
+import { L2ERC1155Gateway } from "../../src/L2/gateways/L2ERC1155Gateway.sol";
+import { L2ERC721Gateway } from "../../src/L2/gateways/L2ERC721Gateway.sol";
+import { L2GatewayRouter } from "../../src/L2/gateways/L2GatewayRouter.sol";
+import { L2StandardERC20Gateway } from "../../src/L2/gateways/L2StandardERC20Gateway.sol";
+import { ScrollStandardERC20Factory } from "../../src/libraries/token/ScrollStandardERC20Factory.sol";
+
+contract InitializeL2BridgeContracts is Script {
+    uint256 deployerPrivateKey = vm.envUint("L2_DEPLOYER_PRIVATE_KEY");
+
+    address L1_STANDARD_ERC20_GATEWAY_PROXY_ADDR = vm.envAddress("L1_STANDARD_ERC20_GATEWAY_PROXY_ADDR");
+    address L1_GATEWAY_ROUTER_PROXY_ADDR = vm.envAddress("L1_GATEWAY_ROUTER_PROXY_ADDR");
+    address L1_CUSTOM_ERC20_GATEWAY_PROXY_ADDR = vm.envAddress("L1_CUSTOM_ERC20_GATEWAY_PROXY_ADDR");
+    address L1_ERC721_GATEWAY_PROXY_ADDR = vm.envAddress("L1_ERC721_GATEWAY_PROXY_ADDR");
+    address L1_ERC1155_GATEWAY_PROXY_ADDR = vm.envAddress("L1_ERC1155_GATEWAY_PROXY_ADDR");
+
+    address L2_SCROLL_MESSENGER_ADDR = vm.envAddress("L2_SCROLL_MESSENGER_ADDR");
+    address L2_STANDARD_ERC20_GATEWAY_PROXY_ADDR = vm.envAddress("L2_STANDARD_ERC20_GATEWAY_PROXY_ADDR");
+    address L2_GATEWAY_ROUTER_PROXY_ADDR = vm.envAddress("L2_GATEWAY_ROUTER_PROXY_ADDR");
+    address L2_SCROLL_STANDARD_ERC20_FACTORY_ADDR = vm.envAddress("L2_SCROLL_STANDARD_ERC20_FACTORY_ADDR");
+    address L2_CUSTOM_ERC20_GATEWAY_PROXY_ADDR = vm.envAddress("L2_CUSTOM_ERC20_GATEWAY_PROXY_ADDR");
+    address L2_ERC721_GATEWAY_PROXY_ADDR = vm.envAddress("L2_ERC721_GATEWAY_PROXY_ADDR");
+    address L2_ERC1155_GATEWAY_PROXY_ADDR = vm.envAddress("L2_ERC1155_GATEWAY_PROXY_ADDR");
+
+    function run() external {
+        vm.startBroadcast(deployerPrivateKey);
+
+        // initialize L2StandardERC20Gateway
+        L2StandardERC20Gateway(L2_STANDARD_ERC20_GATEWAY_PROXY_ADDR).initialize(
+            L1_STANDARD_ERC20_GATEWAY_PROXY_ADDR,
+            L2_GATEWAY_ROUTER_PROXY_ADDR,
+            L2_SCROLL_MESSENGER_ADDR,
+            L2_SCROLL_STANDARD_ERC20_FACTORY_ADDR
+        );
+
+        // initialize L2GatewayRouter
+        L2GatewayRouter(L2_GATEWAY_ROUTER_PROXY_ADDR).initialize(
+            L2_STANDARD_ERC20_GATEWAY_PROXY_ADDR,
+            L1_GATEWAY_ROUTER_PROXY_ADDR,
+            L2_SCROLL_MESSENGER_ADDR
+        );
+
+        // initialize ScrollStandardERC20Factory
+        ScrollStandardERC20Factory(L2_SCROLL_STANDARD_ERC20_FACTORY_ADDR).transferOwnership(
+            L2_STANDARD_ERC20_GATEWAY_PROXY_ADDR
+        );
+
+        // initialize L2CustomERC20Gateway
+        L2CustomERC20Gateway(L2_CUSTOM_ERC20_GATEWAY_PROXY_ADDR).initialize(
+            L1_CUSTOM_ERC20_GATEWAY_PROXY_ADDR,
+            L2_GATEWAY_ROUTER_PROXY_ADDR,
+            L2_SCROLL_MESSENGER_ADDR
+        );
+
+        // initialize L2ERC1155Gateway
+        L2ERC1155Gateway(L2_ERC1155_GATEWAY_PROXY_ADDR).initialize(
+            L1_ERC1155_GATEWAY_PROXY_ADDR,
+            L2_SCROLL_MESSENGER_ADDR
+        );
+
+        // initialize L2ERC721Gateway
+        L2ERC721Gateway(L2_ERC721_GATEWAY_PROXY_ADDR).initialize(
+            L1_ERC721_GATEWAY_PROXY_ADDR,
+            L2_SCROLL_MESSENGER_ADDR
+        );
+
+        vm.stopBroadcast();
+    }
+}

contracts/scripts/import_genesis_block.ts

@@ -15,7 +15,10 @@ async function main() {
 
   const [deployer] = await ethers.getSigners();
 
-  const ZKRollup = await ethers.getContractAt("ZKRollup", addressFile.get("ZKRollup.proxy"), deployer);
+  const rollupAddr = process.env.L1_ZK_ROLLUP_PROXY_ADDR || addressFile.get("ZKRollup.proxy") || "0x";
+  console.log("Using rollup proxy address:", rollupAddr);
+
+  const ZKRollup = await ethers.getContractAt("ZKRollup", rollupAddr, deployer);
   const genesis = JSON.parse(fs.readFileSync(GENESIS_FILE_PATH, 'utf8'));
   console.log("Using genesis block:", genesis.blockHash);