[profile.default]
src = "src"
out = "out"
libs = ["lib"]

[profile.ethereum]
fork_url = "${ETHEREUM_RPC_URL}"
fork_block_number = 18500000

[profile.polygon]
fork_url = "${POLYGON_RPC_URL}"
fork_block_number = 50000000

[profile.arbitrum]
fork_url = "${ARBITRUM_RPC_URL}"
fork_block_number = 150000000

[profile.base]
fork_url = "${BASE_RPC_URL}"
fork_block_number = 8000000

pragma solidity ^0.8.19;
import "forge-std/Test.sol";

contract MultiChainTest is Test {
    struct ChainConfig {
        uint256 chainId;
        string name;
        address weth;
        address usdc;
        uint256 blockTime;
        uint256 gasLimit;
    }
    mapping(uint256 => ChainConfig) public chainConfigs;

    function setUp() public {
        chainConfigs[1] = ChainConfig({
            chainId: 1,
            name: "Ethereum",
            weth: 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2,
            usdc: 0xA0b86a33E6441c4C5CCD19e5E15C5B6e4F1A4a3c,
            blockTime: 12,
            gasLimit: 30000000
        });
        chainConfigs[137] = ChainConfig({
            chainId: 137,
            name: "Polygon",
            weth: 0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619,
            usdc: 0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174,
            blockTime: 2,
            gasLimit: 20000000
        });
        // Thêm các chuỗi khác tương tự
    }

    function getCurrentChainConfig() internal view returns (ChainConfig memory) {
        return chainConfigs[block.chainid];
    }
}

contract SwapTest is MultiChainTest {
    MySwap public swap;

    function setUp() public override {
        super.setUp();
        ChainConfig memory config = getCurrentChainConfig();
        swap = new MySwap(config.weth, config.usdc);
    }

    function testSwapWorksOnAllChains() public {
        ChainConfig memory config = getCurrentChainConfig();
        uint256 swapAmount = config.chainId == 1 ? 0.1 ether : 1 ether;
        assertTrue(swap.canSwap(swapAmount));
    }
}

forge test --match-contract SwapTest --fork-url $ETHEREUM_RPC_URL
forge test --match-contract SwapTest --fork-url $POLYGON_RPC_URL

contract CrossChainTest is Test {
    uint256 ethereumFork;
    uint256 polygonFork;

    function setUp() public {
        ethereumFork = vm.createFork(vm.envString("ETHEREUM_RPC_URL"));
        polygonFork = vm.createFork(vm.envString("POLYGON_RPC_URL"));
    }

    function testCrossChainBridge() public {
        vm.selectFork(ethereumFork);
        EthereumBridge ethBridge = new EthereumBridge();
        ethBridge.lockTokens(1000 * 1e18);

        vm.selectFork(polygonFork);
        PolygonBridge polyBridge = new PolygonBridge();
        polyBridge.unlockTokens(1000 * 1e18);

        assertEq(polyBridge.totalSupply(), 1000 * 1e18);
    }
}

contract GasTest is MultiChainTest {
    function testGasConsumptionAcrossChains() public {
        ChainConfig memory config = getCurrentChainConfig();
        uint256 gasBefore = gasleft();

        heavyComputation();

        uint256 gasUsed = gasBefore - gasleft();

        if (config.chainId == 1) {
            assertGt(gasUsed, 100000);
        } else if (config.chainId == 137) {
            assertLt(gasUsed, 50000);
        }
    }
}

contract TimingTest is MultiChainTest {
    function testTimeBasedLogic() public {
        ChainConfig memory config = getCurrentChainConfig();
        uint256 blocksPerHour = 3600 / config.blockTime;

        vm.roll(block.number + blocksPerHour);
        assertTrue(myContract.hasTimeElapsed());
    }
}

#!/bin/bash

chains=("ethereum" "polygon" "arbitrum" "base")
test_files=("SwapTest" "LiquidityTest" "GovernanceTest")

for chain in "${chains[@]}"; do
    echo "Testing on $chain..."
    for test in "${test_files[@]}"; do
        echo "  Running $test..."
        if ! forge test --match-contract $test --fork-url $(eval echo \${chain^^}_RPC_URL); then
            echo " ❌ $test failed on $chain"
            exit 1
        fi
        echo " ✅ $test passed on $chain"
    done
done

echo "🎉 All tests passed across all chains!"

function mockChainSpecificBehavior() internal {
    if (block.chainid == 1) {
        vm.mockCall(
            0x..., // địa chỉ contract Ethereum
            abi.encodeWithSignature("function()"),
            abi.encode(expectedResult)
        );
    } else if (block.chainid == 137) {
        vm.mockCall(polygonContract, data, result);
    }
}

contract InvariantTest is MultiChainTest {
    function invariant_balanceAlwaysPositive() public {
        assertGe(myContract.balance(), 0);
    }

    function invariant_chainSpecificConstraints() public {
        ChainConfig memory config = getCurrentChainConfig();
        if (config.chainId == 1) {
            assertLe(myContract.gasPrice(), 50 gwei);
        }
    }
}