add crosschain test orchestration (ported from protocol-internal PR #13)

Adds CrossChainTestManager used by deploy.py for crosschaintest:hub
and crosschaintest:spoke steps. Was missing from the branch despite
deploy.py already importing it.

Author: gpmayorga

script/deploy/lib/crosschain.py

@@ -0,0 +1,265 @@
+#!/usr/bin/env python3
+"""
+Centrifuge Protocol Deployment Tool - Cross-Chain Test Manager
+
+Handles orchestration of cross-chain test deployments:
+- Hub test: runs TestCrossChainHub.s.sol and logs parameters
+- Spoke tests: runs TestCrossChainSpoke.s.sol on connected networks
+- Explorer links: generates adapter and contract explorer URLs
+"""
+
+import json
+import time
+import re
+import pathlib
+from typing import Dict, List, Optional, Any
+from .formatter import *
+from .load_config import EnvironmentLoader
+from .runner import DeploymentRunner
+
+
+class CrossChainTestManager:
+    def __init__(self, env_loader: EnvironmentLoader, args, root_dir: pathlib.Path):
+        self.env_loader = env_loader
+        self.args = args
+        self.root_dir = root_dir
+        self.logs_dir = root_dir / "script" / "deploy" / "logs"
+        self.logs_dir.mkdir(exist_ok=True)
+
+    def run_hub_test(self) -> Dict[str, Any]:
+        """Run hub cross-chain test and log parameters"""
+        print_section("Running Cross-Chain Hub Test")
+        
+        # Ensure we have connectsTo networks
+        connects_to = self.env_loader.config.get("network", {}).get("connectsTo", [])
+        if not connects_to:
+            print_error("No connected networks found in config. Add 'connectsTo' array to network config.")
+            raise SystemExit(1)
+
+        # Validate required contracts exist
+        required_contracts = ["gateway", "hub", "balanceSheet", "batchRequestManager"]
+        contracts = self.env_loader.config.get("contracts", {})
+        missing_contracts = [c for c in required_contracts if c not in contracts]
+        if missing_contracts:
+            print_error(f"Missing required contracts in config: {', '.join(missing_contracts)}")
+            print_info("Run deploy:protocol first to deploy these contracts")
+            raise SystemExit(1)
+
+        print_info(f"Hub network: {self.env_loader.network_name}")
+        print_info(f"Connected networks: {', '.join(connects_to)}")
+        print_info(f"Ops admin: {format_account(self.env_loader.ops_admin_address)}")
+
+        # Strip --resume if present for fresh run
+        original_forge_args = list(self.args.forge_args)
+        self.args.forge_args = [a for a in self.args.forge_args if a != "--resume"]
+
+        # Run the hub test
+        runner = DeploymentRunner(self.env_loader, self.args)
+        if not runner.run_deploy("TestCrossChainHub"):
+            print_error("Hub test deployment failed")
+            raise SystemExit(1)
+
+        # Restore forge args
+        self.args.forge_args = original_forge_args
+
+        # Extract parameters from script output (fallback to defaults)
+        pool_index_offset = self._extract_pool_offset()
+        test_run_id = self._extract_test_run_id()
+
+        # Create log entry
+        log_data = {
+            "hubNetwork": self.env_loader.network_name,
+            "hubCentrifugeId": self.env_loader.config["network"]["centrifugeId"],
+            "poolIndexOffset": pool_index_offset,
+            "testRunId": test_run_id,
+            "spokes": []
+        }
+
+        # Add spoke network info and validate
+        for spoke_network in connects_to:
+            spoke_config_file = self.root_dir / "env" / f"{spoke_network}.json"
+            if not spoke_config_file.exists():
+                print_error(f"Spoke network config not found: {spoke_config_file}")
+                raise SystemExit(1)
+            
+            with open(spoke_config_file, 'r') as f:
+                spoke_config = json.load(f)
+                
+            # Validate spoke has required contracts
+            spoke_contracts = spoke_config.get("contracts", {})
+            spoke_required = ["gateway", "spoke", "vaultRegistry"]
+            missing_spoke_contracts = [c for c in spoke_required if c not in spoke_contracts]
+            if missing_spoke_contracts:
+                print_error(f"Spoke {spoke_network} missing required contracts: {', '.join(missing_spoke_contracts)}")
+                print_info(f"Run deploy:protocol on {spoke_network} first")
+                raise SystemExit(1)
+                
+            log_data["spokes"].append({
+                "network": spoke_network,
+                "centrifugeId": spoke_config["network"]["centrifugeId"]
+            })
+
+        # Save log file
+        timestamp = int(time.time())
+        log_file = self.logs_dir / f"crosschain-{self.env_loader.network_name}-{timestamp}.json"
+        with open(log_file, 'w') as f:
+            json.dump(log_data, f, indent=2)
+
+        print_success("Hub test completed successfully")
+        print_info(f"Parameters logged to: {log_file}")
+
+        # Generate and print explorer links
+        self._print_hub_explorer_links(log_data)
+
+        return {
+            "log_file": str(log_file),
+            "log_data": log_data
+        }
+
+    def run_spoke_tests(self, log_path: Optional[str] = None) -> Dict[str, Any]:
+        """Run spoke tests for all connected networks"""
+        print_section("Running Cross-Chain Spoke Tests")
+
+        # Load hub log
+        if log_path:
+            log_file = pathlib.Path(log_path)
+        else:
+            # Find most recent log file
+            log_files = list(self.logs_dir.glob("crosschain-*.json"))
+            if not log_files:
+                print_error("No hub test log found. Run crosschaintest:hub first.")
+                raise SystemExit(1)
+            log_file = max(log_files, key=lambda f: f.stat().st_mtime)
+
+        print_info(f"Loading hub test log: {log_file}")
+        with open(log_file, 'r') as f:
+            log_data = json.load(f)
+
+        print_warning(f"About to run spoke tests for {len(log_data['spokes'])} networks:")
+        for spoke in log_data["spokes"]:
+            print_info(f"  - {spoke['network']} (centrifugeId: {spoke['centrifugeId']})")
+        print_warning("Press Ctrl+C to abort in the next 5 seconds...")
+        
+        try:
+            time.sleep(5)
+        except KeyboardInterrupt:
+            print_info("Aborted by user")
+            raise SystemExit(1)
+
+        # Run spoke tests
+        results = []
+        for spoke in log_data["spokes"]:
+            spoke_network = spoke["network"]
+            print_section(f"Running spoke test for {spoke_network}")
+            
+            try:
+                # Create environment loader for spoke network
+                spoke_env_loader = EnvironmentLoader(spoke_network, self.root_dir, self.args)
+                spoke_runner = DeploymentRunner(spoke_env_loader, self.args)
+                
+                # Set environment variables for the spoke script
+                spoke_env = spoke_runner.env.copy()
+                spoke_env["HUB_CENTRIFUGE_ID"] = str(log_data["hubCentrifugeId"])
+                # Allow environment variable to override log file value
+                import os
+                pool_offset = os.environ.get("POOL_INDEX_OFFSET", str(log_data["poolIndexOffset"]))
+                spoke_env["POOL_INDEX_OFFSET"] = pool_offset
+                spoke_env["TEST_RUN_ID"] = log_data["testRunId"]
+                
+                # Update runner environment
+                spoke_runner.env = spoke_env
+                
+                # Strip --resume if present
+                original_forge_args = list(self.args.forge_args)
+                self.args.forge_args = [a for a in self.args.forge_args if a != "--resume"]
+                
+                success = spoke_runner.run_deploy("TestCrossChainSpoke")
+                
+                # Restore forge args
+                self.args.forge_args = original_forge_args
+                
+                if success:
+                    print_success(f"Spoke test completed for {spoke_network}")
+                    results.append({"network": spoke_network, "success": True})
+                else:
+                    print_error(f"Spoke test failed for {spoke_network}")
+                    results.append({"network": spoke_network, "success": False})
+                    
+            except Exception as e:
+                print_error(f"Error running spoke test for {spoke_network}: {e}")
+                results.append({"network": spoke_network, "success": False})
+
+        # Print hub explorer links
+        self._print_spoke_explorer_links(log_data)
+
+        return {
+            "log_data": log_data,
+            "results": results
+        }
+
+    def _extract_pool_offset(self) -> int:
+        """Extract pool index offset from environment or generate from timestamp"""
+        import os
+        # Check if POOL_INDEX_OFFSET is set in environment
+        if "POOL_INDEX_OFFSET" in os.environ:
+            return int(os.environ["POOL_INDEX_OFFSET"])
+        # The TestCrossChainHub script uses timestamp-based default if not set
+        # We'll use the same logic for consistency
+        return int(time.time()) % 1000
+
+    def _extract_test_run_id(self) -> str:
+        """Extract test run ID from script output"""
+        # The TestCrossChainHub script uses timestamp-based default if not set
+        # We'll use the same logic for consistency
+        return str(int(time.time()))
+
+    def _print_hub_explorer_links(self, log_data: Dict[str, Any]) -> None:
+        """Print explorer links for hub test"""
+        print_section("Cross-Chain Test Explorer Links")
+        
+        ops_admin = self.env_loader.ops_admin_address
+        
+        print_subsection("Adapter Explorers (watch for outgoing messages)")
+        print_info("Axelar: https://testnet.axelarscan.io/address/{0}?transfersType=gmp".format(ops_admin))
+        print_info("Wormhole: https://wormholescan.io/#/txs?address={0}&network=Testnet".format(ops_admin))
+        print_info("LayerZero: https://testnet.layerzeroscan.com/address/{0}".format(ops_admin))
+        
+        print_subsection("Destination Contract Explorers (watch for incoming messages)")
+        for spoke in log_data["spokes"]:
+            spoke_network = spoke["network"]
+            spoke_config_file = self.root_dir / "env" / f"{spoke_network}.json"
+            if spoke_config_file.exists():
+                with open(spoke_config_file, 'r') as f:
+                    spoke_config = json.load(f)
+                    etherscan_url = spoke_config.get("network", {}).get("etherscanUrl", "")
+                    if etherscan_url:
+                        contracts = spoke_config.get("contracts", {})
+                        print_info(f"\n{spoke_network} contracts:")
+                        if "gateway" in contracts:
+                            print_info(f"  Gateway: {etherscan_url}/address/{contracts['gateway']}")
+                        if "spoke" in contracts:
+                            print_info(f"  Spoke: {etherscan_url}/address/{contracts['spoke']}")
+                        if "vaultRegistry" in contracts:
+                            print_info(f"  VaultRegistry: {etherscan_url}/address/{contracts['vaultRegistry']}")
+
+    def _print_spoke_explorer_links(self, log_data: Dict[str, Any]) -> None:
+        """Print hub explorer links for spoke tests"""
+        print_section("Hub Contract Explorers (watch for cross-chain results)")
+        
+        hub_network = log_data["hubNetwork"]
+        hub_config_file = self.root_dir / "env" / f"{hub_network}.json"
+        if hub_config_file.exists():
+            with open(hub_config_file, 'r') as f:
+                hub_config = json.load(f)
+                etherscan_url = hub_config.get("network", {}).get("etherscanUrl", "")
+                if etherscan_url:
+                    contracts = hub_config.get("contracts", {})
+                    print_info(f"\n{hub_network} hub contracts:")
+                    if "gateway" in contracts:
+                        print_info(f"  Gateway: {etherscan_url}/address/{contracts['gateway']}")
+                    if "hub" in contracts:
+                        print_info(f"  Hub: {etherscan_url}/address/{contracts['hub']}")
+                    if "balanceSheet" in contracts:
+                        print_info(f"  BalanceSheet: {etherscan_url}/address/{contracts['balanceSheet']}")
+                    if "batchRequestManager" in contracts:
+                        print_info(f"  BatchRequestManager: {etherscan_url}/address/{contracts['batchRequestManager']}")