Refactor Foundry scripts: unify multichain CCIP bridging into single script call

ccip/cct/foundry/deployments.toml

@@ -0,0 +1,5 @@
+[avalanche-fuji]
+endpoint_url = "${RPC_URL_FUJI}"
+
+[arbitrum-sepolia]
+endpoint_url = "${RPC_URL_ARBITRUM_SEPOLIA}"

ccip/cct/foundry/script/AcceptAdminRole.s.sol

@@ -2,47 +2,77 @@
 pragma solidity 0.8.24;
 
 import {Script, console} from "forge-std/Script.sol";
+import {Config} from "forge-std/Config.sol";
 import {HelperUtils} from "./utils/HelperUtils.s.sol"; // Utility functions for JSON parsing and chain info
 import {HelperConfig} from "./HelperConfig.s.sol"; // Network configuration helper
 import {TokenAdminRegistry} from "@chainlink/contracts-ccip/contracts/tokenAdminRegistry/TokenAdminRegistry.sol";
 
-contract AcceptAdminRole is Script {
+contract AcceptAdminRole is Script, Config {
     function run() external {
+        _loadConfigAndForks("./deployments.toml", true);
+        for (uint256 i = 0; i < chainIds.length; i++) {
+            uint256 chainId = chainIds[i];
+            deployToChain(chainId);
+        }
+    }
+
+    function deployToChain(uint256 chainId) internal {
+        vm.selectFork(forkOf[chainId]);
         // Get the chain name based on the current chain ID
         string memory chainName = HelperUtils.getChainName(block.chainid);
 
         // Construct the path to the deployed token JSON file
         string memory root = vm.projectRoot();
-        string memory deployedTokenPath = string.concat(root, "/script/output/deployedToken_", chainName, ".json");
+        string memory deployedTokenPath = string.concat(
+            root,
+            "/script/output/deployedToken_",
+            chainName,
+            ".json"
+        );
 
         // Extract the deployed token address from the JSON file
-        address tokenAddress =
-            HelperUtils.getAddressFromJson(vm, deployedTokenPath, string.concat(".deployedToken_", chainName));
+        address tokenAddress = HelperUtils.getAddressFromJson(
+            vm,
+            deployedTokenPath,
+            string.concat(".deployedToken_", chainName)
+        );
 
         // Fetch the network configuration to get the TokenAdminRegistry address
         HelperConfig helperConfig = new HelperConfig();
-        (,,, address tokenAdminRegistry,,,,) = helperConfig.activeNetworkConfig();
+        (, , , address tokenAdminRegistry, , , , ) = helperConfig
+            .activeNetworkConfig();
 
         // Ensure the token address and TokenAdminRegistry address are valid
         require(tokenAddress != address(0), "Invalid token address");
-        require(tokenAdminRegistry != address(0), "TokenAdminRegistry is not defined for this network");
+        require(
+            tokenAdminRegistry != address(0),
+            "TokenAdminRegistry is not defined for this network"
+        );
 
         vm.startBroadcast();
 
         // Get the address of the signer (the account executing the script)
         address signer = msg.sender;
 
         // Instantiate the TokenAdminRegistry contract
-        TokenAdminRegistry tokenAdminRegistryContract = TokenAdminRegistry(tokenAdminRegistry);
+        TokenAdminRegistry tokenAdminRegistryContract = TokenAdminRegistry(
+            tokenAdminRegistry
+        );
 
         // Fetch the token configuration for the given token address
-        TokenAdminRegistry.TokenConfig memory tokenConfig = tokenAdminRegistryContract.getTokenConfig(tokenAddress);
+        TokenAdminRegistry.TokenConfig
+            memory tokenConfig = tokenAdminRegistryContract.getTokenConfig(
+                tokenAddress
+            );
 
         // Get the pending administrator for the token
         address pendingAdministrator = tokenConfig.pendingAdministrator;
 
         // Ensure the signer is the pending administrator
-        require(pendingAdministrator == signer, "Only the pending administrator can accept the admin role");
+        require(
+            pendingAdministrator == signer,
+            "Only the pending administrator can accept the admin role"
+        );
 
         // Accept the admin role for the token
         tokenAdminRegistryContract.acceptAdminRole(tokenAddress);

ccip/cct/foundry/script/ApplyChainUpdates.s.sol

@@ -2,66 +2,113 @@
 pragma solidity 0.8.24;
 
 import {Script, console} from "forge-std/Script.sol";
+import {Config} from "forge-std/Config.sol";
 import {HelperUtils} from "./utils/HelperUtils.s.sol"; // Utility functions for JSON parsing and chain info
 import {HelperConfig} from "./HelperConfig.s.sol"; // Network configuration helper
 import {TokenPool} from "@chainlink/contracts-ccip/contracts/pools/TokenPool.sol";
 import {RateLimiter} from "@chainlink/contracts-ccip/contracts/libraries/RateLimiter.sol";
 
-contract ApplyChainUpdates is Script {
+contract ApplyChainUpdates is Script, Config {
     function run() external {
+        _loadConfigAndForks("./deployments.toml", true);
+        for (uint256 i = 0; i < chainIds.length; i++) {
+            uint256 chainId = chainIds[i];
+            deployToChain(chainId);
+        }
+    }
+
+    function deployToChain(uint256 chainId) internal {
+        vm.selectFork(forkOf[chainId]);
         // Get the current chain name based on the chain ID
         string memory chainName = HelperUtils.getChainName(block.chainid);
 
         // Construct paths to the configuration and local pool JSON files
         string memory root = vm.projectRoot();
         string memory configPath = string.concat(root, "/script/config.json");
-        string memory localPoolPath = string.concat(root, "/script/output/deployedTokenPool_", chainName, ".json");
+        string memory localPoolPath = string.concat(
+            root,
+            "/script/output/deployedTokenPool_",
+            chainName,
+            ".json"
+        );
 
         // Read the remoteChainId from config.json based on the current chain ID
         uint256 remoteChainId = HelperUtils.getUintFromJson(
-            vm, configPath, string.concat(".remoteChains.", HelperUtils.uintToStr(block.chainid))
+            vm,
+            configPath,
+            string.concat(
+                ".remoteChains.",
+                HelperUtils.uintToStr(block.chainid)
+            )
         );
 
         // Get the remote chain name based on the remoteChainId
         string memory remoteChainName = HelperUtils.getChainName(remoteChainId);
-        string memory remotePoolPath =
-            string.concat(root, "/script/output/deployedTokenPool_", remoteChainName, ".json");
-        string memory remoteTokenPath = string.concat(root, "/script/output/deployedToken_", remoteChainName, ".json");
+        string memory remotePoolPath = string.concat(
+            root,
+            "/script/output/deployedTokenPool_",
+            remoteChainName,
+            ".json"
+        );
+        string memory remoteTokenPath = string.concat(
+            root,
+            "/script/output/deployedToken_",
+            remoteChainName,
+            ".json"
+        );
 
         // Extract addresses from the JSON files
-        address poolAddress =
-            HelperUtils.getAddressFromJson(vm, localPoolPath, string.concat(".deployedTokenPool_", chainName));
-        address remotePoolAddress =
-            HelperUtils.getAddressFromJson(vm, remotePoolPath, string.concat(".deployedTokenPool_", remoteChainName));
-        address remoteTokenAddress =
-            HelperUtils.getAddressFromJson(vm, remoteTokenPath, string.concat(".deployedToken_", remoteChainName));
+        address poolAddress = HelperUtils.getAddressFromJson(
+            vm,
+            localPoolPath,
+            string.concat(".deployedTokenPool_", chainName)
+        );
+        address remotePoolAddress = HelperUtils.getAddressFromJson(
+            vm,
+            remotePoolPath,
+            string.concat(".deployedTokenPool_", remoteChainName)
+        );
+        address remoteTokenAddress = HelperUtils.getAddressFromJson(
+            vm,
+            remoteTokenPath,
+            string.concat(".deployedToken_", remoteChainName)
+        );
 
         // For remotePoolAddresses, create an array with the remotePoolAddress
         address[] memory remotePoolAddresses = new address[](1);
         remotePoolAddresses[0] = remotePoolAddress;
 
         // Fetch the remote network configuration to get the chain selector
         HelperConfig helperConfig = new HelperConfig();
-        HelperConfig.NetworkConfig memory remoteNetworkConfig =
-            HelperUtils.getNetworkConfig(helperConfig, remoteChainId);
+        HelperConfig.NetworkConfig memory remoteNetworkConfig = HelperUtils
+            .getNetworkConfig(helperConfig, remoteChainId);
 
         uint64 remoteChainSelector = remoteNetworkConfig.chainSelector;
 
         require(poolAddress != address(0), "Invalid pool address");
         require(remotePoolAddress != address(0), "Invalid remote pool address");
-        require(remoteTokenAddress != address(0), "Invalid remote token address");
-        require(remoteChainSelector != 0, "chainSelector is not defined for the remote chain");
+        require(
+            remoteTokenAddress != address(0),
+            "Invalid remote token address"
+        );
+        require(
+            remoteChainSelector != 0,
+            "chainSelector is not defined for the remote chain"
+        );
 
         vm.startBroadcast();
 
         // Instantiate the local TokenPool contract
         TokenPool poolContract = TokenPool(poolAddress);
 
         // Prepare chain update data for configuring cross-chain transfers
-        TokenPool.ChainUpdate[] memory chainUpdates = new TokenPool.ChainUpdate[](1);
+        TokenPool.ChainUpdate[]
+            memory chainUpdates = new TokenPool.ChainUpdate[](1);
 
         // Encode remote pool addresses
-        bytes[] memory remotePoolAddressesEncoded = new bytes[](remotePoolAddresses.length);
+        bytes[] memory remotePoolAddressesEncoded = new bytes[](
+            remotePoolAddresses.length
+        );
         for (uint256 i = 0; i < remotePoolAddresses.length; i++) {
             remotePoolAddressesEncoded[i] = abi.encode(remotePoolAddresses[i]);
         }

ccip/cct/foundry/script/ClaimAdmin.s.sol

@@ -2,64 +2,99 @@
 pragma solidity 0.8.24;
 
 import {Script, console} from "forge-std/Script.sol";
+import {Config} from "forge-std/Config.sol";
 import {HelperUtils} from "./utils/HelperUtils.s.sol"; // Utility functions for JSON parsing and chain info
 import {HelperConfig} from "./HelperConfig.s.sol"; // Network configuration helper
-import {RegistryModuleOwnerCustom} from
-    "@chainlink/contracts-ccip/contracts/tokenAdminRegistry/RegistryModuleOwnerCustom.sol";
+import {RegistryModuleOwnerCustom} from "@chainlink/contracts-ccip/contracts/tokenAdminRegistry/RegistryModuleOwnerCustom.sol";
 import {BurnMintERC20} from "@chainlink/contracts/src/v0.8/shared/token/ERC20/BurnMintERC20.sol";
 
-
-contract ClaimAdmin is Script {
+contract ClaimAdmin is Script, Config {
     function run() external {
+        _loadConfigAndForks("./deployments.toml", true);
+        for (uint256 i = 0; i < chainIds.length; i++) {
+            uint256 chainId = chainIds[i];
+            deployToChain(chainId);
+        }
+    }
+
+    function deployToChain(uint256 chainId) internal {
+        vm.selectFork(forkOf[chainId]);
         // Get the chain name based on the current chain ID
         string memory chainName = HelperUtils.getChainName(block.chainid);
 
         // Define paths to the necessary JSON files
         string memory root = vm.projectRoot();
-        string memory deployedTokenPath = string.concat(root, "/script/output/deployedToken_", chainName, ".json");
+        string memory deployedTokenPath = string.concat(
+            root,
+            "/script/output/deployedToken_",
+            chainName,
+            ".json"
+        );
         string memory configPath = string.concat(root, "/script/config.json");
 
         // Extract values from the JSON files
-        address tokenAddress =
-            HelperUtils.getAddressFromJson(vm, deployedTokenPath, string.concat(".deployedToken_", chainName));
-        address tokenAdmin = HelperUtils.getAddressFromJson(vm, configPath, ".BnMToken.ccipAdminAddress");
+        address tokenAddress = HelperUtils.getAddressFromJson(
+            vm,
+            deployedTokenPath,
+            string.concat(".deployedToken_", chainName)
+        );
+        address tokenAdmin = HelperUtils.getAddressFromJson(
+            vm,
+            configPath,
+            ".BnMToken.ccipAdminAddress"
+        );
 
         // Fetch the network configuration
         HelperConfig helperConfig = new HelperConfig();
-        (,,,, address registryModuleOwnerCustom,,,) = helperConfig.activeNetworkConfig();
+        (, , , , address registryModuleOwnerCustom, , , ) = helperConfig
+            .activeNetworkConfig();
 
         require(tokenAddress != address(0), "Invalid token address");
-        require(registryModuleOwnerCustom != address(0), "Registry module owner custom is not defined for this network");
+        require(
+            registryModuleOwnerCustom != address(0),
+            "Registry module owner custom is not defined for this network"
+        );
 
         vm.startBroadcast();
-
-        claimAdminWithCCIPAdmin(tokenAddress, tokenAdmin, registryModuleOwnerCustom);
-
+
+        claimAdminWithCCIPAdmin(
+            tokenAddress,
+            tokenAdmin,
+            registryModuleOwnerCustom
+        );
+
         vm.stopBroadcast();
     }
 
     // Claim admin role using the token's CCIP admin
-    function claimAdminWithCCIPAdmin(address tokenAddress, address tokenAdmin, address registryModuleOwnerCustom)
-        internal
-    {
+    function claimAdminWithCCIPAdmin(
+        address tokenAddress,
+        address tokenAdmin,
+        address registryModuleOwnerCustom
+    ) internal {
         // Instantiate the token contract with CCIP admin functionality
         BurnMintERC20 tokenContract = BurnMintERC20(tokenAddress);
         // Instantiate the registry contract
-        RegistryModuleOwnerCustom registryContract = RegistryModuleOwnerCustom(registryModuleOwnerCustom);
+        RegistryModuleOwnerCustom registryContract = RegistryModuleOwnerCustom(
+            registryModuleOwnerCustom
+        );
 
         // Get the current CCIP admin of the token
         address tokenContractCCIPAdmin = tokenContract.getCCIPAdmin();
         console.log("Current token admin:", tokenContractCCIPAdmin);
 
         // Ensure the CCIP admin matches the expected token admin address
         require(
-            tokenContractCCIPAdmin == tokenAdmin, "CCIP admin of token doesn't match the token admin address."
+            tokenContractCCIPAdmin == tokenAdmin,
+            "CCIP admin of token doesn't match the token admin address."
         );
 
         // Register the admin via getCCIPAdmin() function
-        console.log("Claiming admin of the token via getCCIPAdmin() for CCIP admin:", tokenAdmin);
+        console.log(
+            "Claiming admin of the token via getCCIPAdmin() for CCIP admin:",
+            tokenAdmin
+        );
         registryContract.registerAdminViaGetCCIPAdmin(tokenAddress);
         console.log("Admin claimed successfully for token:", tokenAddress);
     }
-
 }