@elizaos/autonomous 2.0.0-alpha.21 → 2.0.0-alpha.22

package/test/contracts/lib/openzeppelin-contracts/lib/forge-std/src/StdAssertions.sol

@@ -0,0 +1,376 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.6.2 <0.9.0;
+
+import {DSTest} from "ds-test/test.sol";
+import {stdMath} from "./StdMath.sol";
+
+abstract contract StdAssertions is DSTest {
+    event log_array(uint256[] val);
+    event log_array(int256[] val);
+    event log_array(address[] val);
+    event log_named_array(string key, uint256[] val);
+    event log_named_array(string key, int256[] val);
+    event log_named_array(string key, address[] val);
+
+    function fail(string memory err) internal virtual {
+        emit log_named_string("Error", err);
+        fail();
+    }
+
+    function assertFalse(bool data) internal virtual {
+        assertTrue(!data);
+    }
+
+    function assertFalse(bool data, string memory err) internal virtual {
+        assertTrue(!data, err);
+    }
+
+    function assertEq(bool a, bool b) internal virtual {
+        if (a != b) {
+            emit log("Error: a == b not satisfied [bool]");
+            emit log_named_string("      Left", a ? "true" : "false");
+            emit log_named_string("     Right", b ? "true" : "false");
+            fail();
+        }
+    }
+
+    function assertEq(bool a, bool b, string memory err) internal virtual {
+        if (a != b) {
+            emit log_named_string("Error", err);
+            assertEq(a, b);
+        }
+    }
+
+    function assertEq(bytes memory a, bytes memory b) internal virtual {
+        assertEq0(a, b);
+    }
+
+    function assertEq(bytes memory a, bytes memory b, string memory err) internal virtual {
+        assertEq0(a, b, err);
+    }
+
+    function assertEq(uint256[] memory a, uint256[] memory b) internal virtual {
+        if (keccak256(abi.encode(a)) != keccak256(abi.encode(b))) {
+            emit log("Error: a == b not satisfied [uint[]]");
+            emit log_named_array("      Left", a);
+            emit log_named_array("     Right", b);
+            fail();
+        }
+    }
+
+    function assertEq(int256[] memory a, int256[] memory b) internal virtual {
+        if (keccak256(abi.encode(a)) != keccak256(abi.encode(b))) {
+            emit log("Error: a == b not satisfied [int[]]");
+            emit log_named_array("      Left", a);
+            emit log_named_array("     Right", b);
+            fail();
+        }
+    }
+
+    function assertEq(address[] memory a, address[] memory b) internal virtual {
+        if (keccak256(abi.encode(a)) != keccak256(abi.encode(b))) {
+            emit log("Error: a == b not satisfied [address[]]");
+            emit log_named_array("      Left", a);
+            emit log_named_array("     Right", b);
+            fail();
+        }
+    }
+
+    function assertEq(uint256[] memory a, uint256[] memory b, string memory err) internal virtual {
+        if (keccak256(abi.encode(a)) != keccak256(abi.encode(b))) {
+            emit log_named_string("Error", err);
+            assertEq(a, b);
+        }
+    }
+
+    function assertEq(int256[] memory a, int256[] memory b, string memory err) internal virtual {
+        if (keccak256(abi.encode(a)) != keccak256(abi.encode(b))) {
+            emit log_named_string("Error", err);
+            assertEq(a, b);
+        }
+    }
+
+    function assertEq(address[] memory a, address[] memory b, string memory err) internal virtual {
+        if (keccak256(abi.encode(a)) != keccak256(abi.encode(b))) {
+            emit log_named_string("Error", err);
+            assertEq(a, b);
+        }
+    }
+
+    // Legacy helper
+    function assertEqUint(uint256 a, uint256 b) internal virtual {
+        assertEq(uint256(a), uint256(b));
+    }
+
+    function assertApproxEqAbs(uint256 a, uint256 b, uint256 maxDelta) internal virtual {
+        uint256 delta = stdMath.delta(a, b);
+
+        if (delta > maxDelta) {
+            emit log("Error: a ~= b not satisfied [uint]");
+            emit log_named_uint("      Left", a);
+            emit log_named_uint("     Right", b);
+            emit log_named_uint(" Max Delta", maxDelta);
+            emit log_named_uint("     Delta", delta);
+            fail();
+        }
+    }
+
+    function assertApproxEqAbs(uint256 a, uint256 b, uint256 maxDelta, string memory err) internal virtual {
+        uint256 delta = stdMath.delta(a, b);
+
+        if (delta > maxDelta) {
+            emit log_named_string("Error", err);
+            assertApproxEqAbs(a, b, maxDelta);
+        }
+    }
+
+    function assertApproxEqAbsDecimal(uint256 a, uint256 b, uint256 maxDelta, uint256 decimals) internal virtual {
+        uint256 delta = stdMath.delta(a, b);
+
+        if (delta > maxDelta) {
+            emit log("Error: a ~= b not satisfied [uint]");
+            emit log_named_decimal_uint("      Left", a, decimals);
+            emit log_named_decimal_uint("     Right", b, decimals);
+            emit log_named_decimal_uint(" Max Delta", maxDelta, decimals);
+            emit log_named_decimal_uint("     Delta", delta, decimals);
+            fail();
+        }
+    }
+
+    function assertApproxEqAbsDecimal(uint256 a, uint256 b, uint256 maxDelta, uint256 decimals, string memory err)
+        internal
+        virtual
+    {
+        uint256 delta = stdMath.delta(a, b);
+
+        if (delta > maxDelta) {
+            emit log_named_string("Error", err);
+            assertApproxEqAbsDecimal(a, b, maxDelta, decimals);
+        }
+    }
+
+    function assertApproxEqAbs(int256 a, int256 b, uint256 maxDelta) internal virtual {
+        uint256 delta = stdMath.delta(a, b);
+
+        if (delta > maxDelta) {
+            emit log("Error: a ~= b not satisfied [int]");
+            emit log_named_int("       Left", a);
+            emit log_named_int("      Right", b);
+            emit log_named_uint(" Max Delta", maxDelta);
+            emit log_named_uint("     Delta", delta);
+            fail();
+        }
+    }
+
+    function assertApproxEqAbs(int256 a, int256 b, uint256 maxDelta, string memory err) internal virtual {
+        uint256 delta = stdMath.delta(a, b);
+
+        if (delta > maxDelta) {
+            emit log_named_string("Error", err);
+            assertApproxEqAbs(a, b, maxDelta);
+        }
+    }
+
+    function assertApproxEqAbsDecimal(int256 a, int256 b, uint256 maxDelta, uint256 decimals) internal virtual {
+        uint256 delta = stdMath.delta(a, b);
+
+        if (delta > maxDelta) {
+            emit log("Error: a ~= b not satisfied [int]");
+            emit log_named_decimal_int("      Left", a, decimals);
+            emit log_named_decimal_int("     Right", b, decimals);
+            emit log_named_decimal_uint(" Max Delta", maxDelta, decimals);
+            emit log_named_decimal_uint("     Delta", delta, decimals);
+            fail();
+        }
+    }
+
+    function assertApproxEqAbsDecimal(int256 a, int256 b, uint256 maxDelta, uint256 decimals, string memory err)
+        internal
+        virtual
+    {
+        uint256 delta = stdMath.delta(a, b);
+
+        if (delta > maxDelta) {
+            emit log_named_string("Error", err);
+            assertApproxEqAbsDecimal(a, b, maxDelta, decimals);
+        }
+    }
+
+    function assertApproxEqRel(
+        uint256 a,
+        uint256 b,
+        uint256 maxPercentDelta // An 18 decimal fixed point number, where 1e18 == 100%
+    ) internal virtual {
+        if (b == 0) return assertEq(a, b); // If the left is 0, right must be too.
+
+        uint256 percentDelta = stdMath.percentDelta(a, b);
+
+        if (percentDelta > maxPercentDelta) {
+            emit log("Error: a ~= b not satisfied [uint]");
+            emit log_named_uint("        Left", a);
+            emit log_named_uint("       Right", b);
+            emit log_named_decimal_uint(" Max % Delta", maxPercentDelta, 18);
+            emit log_named_decimal_uint("     % Delta", percentDelta, 18);
+            fail();
+        }
+    }
+
+    function assertApproxEqRel(
+        uint256 a,
+        uint256 b,
+        uint256 maxPercentDelta, // An 18 decimal fixed point number, where 1e18 == 100%
+        string memory err
+    ) internal virtual {
+        if (b == 0) return assertEq(a, b, err); // If the left is 0, right must be too.
+
+        uint256 percentDelta = stdMath.percentDelta(a, b);
+
+        if (percentDelta > maxPercentDelta) {
+            emit log_named_string("Error", err);
+            assertApproxEqRel(a, b, maxPercentDelta);
+        }
+    }
+
+    function assertApproxEqRelDecimal(
+        uint256 a,
+        uint256 b,
+        uint256 maxPercentDelta, // An 18 decimal fixed point number, where 1e18 == 100%
+        uint256 decimals
+    ) internal virtual {
+        if (b == 0) return assertEq(a, b); // If the left is 0, right must be too.
+
+        uint256 percentDelta = stdMath.percentDelta(a, b);
+
+        if (percentDelta > maxPercentDelta) {
+            emit log("Error: a ~= b not satisfied [uint]");
+            emit log_named_decimal_uint("        Left", a, decimals);
+            emit log_named_decimal_uint("       Right", b, decimals);
+            emit log_named_decimal_uint(" Max % Delta", maxPercentDelta, 18);
+            emit log_named_decimal_uint("     % Delta", percentDelta, 18);
+            fail();
+        }
+    }
+
+    function assertApproxEqRelDecimal(
+        uint256 a,
+        uint256 b,
+        uint256 maxPercentDelta, // An 18 decimal fixed point number, where 1e18 == 100%
+        uint256 decimals,
+        string memory err
+    ) internal virtual {
+        if (b == 0) return assertEq(a, b, err); // If the left is 0, right must be too.
+
+        uint256 percentDelta = stdMath.percentDelta(a, b);
+
+        if (percentDelta > maxPercentDelta) {
+            emit log_named_string("Error", err);
+            assertApproxEqRelDecimal(a, b, maxPercentDelta, decimals);
+        }
+    }
+
+    function assertApproxEqRel(int256 a, int256 b, uint256 maxPercentDelta) internal virtual {
+        if (b == 0) return assertEq(a, b); // If the left is 0, right must be too.
+
+        uint256 percentDelta = stdMath.percentDelta(a, b);
+
+        if (percentDelta > maxPercentDelta) {
+            emit log("Error: a ~= b not satisfied [int]");
+            emit log_named_int("        Left", a);
+            emit log_named_int("       Right", b);
+            emit log_named_decimal_uint(" Max % Delta", maxPercentDelta, 18);
+            emit log_named_decimal_uint("     % Delta", percentDelta, 18);
+            fail();
+        }
+    }
+
+    function assertApproxEqRel(int256 a, int256 b, uint256 maxPercentDelta, string memory err) internal virtual {
+        if (b == 0) return assertEq(a, b, err); // If the left is 0, right must be too.
+
+        uint256 percentDelta = stdMath.percentDelta(a, b);
+
+        if (percentDelta > maxPercentDelta) {
+            emit log_named_string("Error", err);
+            assertApproxEqRel(a, b, maxPercentDelta);
+        }
+    }
+
+    function assertApproxEqRelDecimal(int256 a, int256 b, uint256 maxPercentDelta, uint256 decimals) internal virtual {
+        if (b == 0) return assertEq(a, b); // If the left is 0, right must be too.
+
+        uint256 percentDelta = stdMath.percentDelta(a, b);
+
+        if (percentDelta > maxPercentDelta) {
+            emit log("Error: a ~= b not satisfied [int]");
+            emit log_named_decimal_int("        Left", a, decimals);
+            emit log_named_decimal_int("       Right", b, decimals);
+            emit log_named_decimal_uint(" Max % Delta", maxPercentDelta, 18);
+            emit log_named_decimal_uint("     % Delta", percentDelta, 18);
+            fail();
+        }
+    }
+
+    function assertApproxEqRelDecimal(int256 a, int256 b, uint256 maxPercentDelta, uint256 decimals, string memory err)
+        internal
+        virtual
+    {
+        if (b == 0) return assertEq(a, b, err); // If the left is 0, right must be too.
+
+        uint256 percentDelta = stdMath.percentDelta(a, b);
+
+        if (percentDelta > maxPercentDelta) {
+            emit log_named_string("Error", err);
+            assertApproxEqRelDecimal(a, b, maxPercentDelta, decimals);
+        }
+    }
+
+    function assertEqCall(address target, bytes memory callDataA, bytes memory callDataB) internal virtual {
+        assertEqCall(target, callDataA, target, callDataB, true);
+    }
+
+    function assertEqCall(address targetA, bytes memory callDataA, address targetB, bytes memory callDataB)
+        internal
+        virtual
+    {
+        assertEqCall(targetA, callDataA, targetB, callDataB, true);
+    }
+
+    function assertEqCall(address target, bytes memory callDataA, bytes memory callDataB, bool strictRevertData)
+        internal
+        virtual
+    {
+        assertEqCall(target, callDataA, target, callDataB, strictRevertData);
+    }
+
+    function assertEqCall(
+        address targetA,
+        bytes memory callDataA,
+        address targetB,
+        bytes memory callDataB,
+        bool strictRevertData
+    ) internal virtual {
+        (bool successA, bytes memory returnDataA) = address(targetA).call(callDataA);
+        (bool successB, bytes memory returnDataB) = address(targetB).call(callDataB);
+
+        if (successA && successB) {
+            assertEq(returnDataA, returnDataB, "Call return data does not match");
+        }
+
+        if (!successA && !successB && strictRevertData) {
+            assertEq(returnDataA, returnDataB, "Call revert data does not match");
+        }
+
+        if (!successA && successB) {
+            emit log("Error: Calls were not equal");
+            emit log_named_bytes("  Left call revert data", returnDataA);
+            emit log_named_bytes(" Right call return data", returnDataB);
+            fail();
+        }
+
+        if (successA && !successB) {
+            emit log("Error: Calls were not equal");
+            emit log_named_bytes("  Left call return data", returnDataA);
+            emit log_named_bytes(" Right call revert data", returnDataB);
+            fail();
+        }
+    }
+}

package/test/contracts/lib/openzeppelin-contracts/lib/forge-std/src/StdChains.sol

@@ -0,0 +1,233 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.6.2 <0.9.0;
+
+pragma experimental ABIEncoderV2;
+
+import {VmSafe} from "./Vm.sol";
+
+/**
+ * StdChains provides information about EVM compatible chains that can be used in scripts/tests.
+ * For each chain, the chain's name, chain ID, and a default RPC URL are provided. Chains are
+ * identified by their alias, which is the same as the alias in the `[rpc_endpoints]` section of
+ * the `foundry.toml` file. For best UX, ensure the alias in the `foundry.toml` file match the
+ * alias used in this contract, which can be found as the first argument to the
+ * `setChainWithDefaultRpcUrl` call in the `initialize` function.
+ *
+ * There are two main ways to use this contract:
+ *   1. Set a chain with `setChain(string memory chainAlias, ChainData memory chain)` or
+ *      `setChain(string memory chainAlias, Chain memory chain)`
+ *   2. Get a chain with `getChain(string memory chainAlias)` or `getChain(uint256 chainId)`.
+ *
+ * The first time either of those are used, chains are initialized with the default set of RPC URLs.
+ * This is done in `initialize`, which uses `setChainWithDefaultRpcUrl`. Defaults are recorded in
+ * `defaultRpcUrls`.
+ *
+ * The `setChain` function is straightforward, and it simply saves off the given chain data.
+ *
+ * The `getChain` methods use `getChainWithUpdatedRpcUrl` to return a chain. For example, let's say
+ * we want to retrieve `mainnet`'s RPC URL:
+ *   - If you haven't set any mainnet chain info with `setChain`, you haven't specified that
+ *     chain in `foundry.toml` and no env var is set, the default data and RPC URL will be returned.
+ *   - If you have set a mainnet RPC URL in `foundry.toml` it will return that, if valid (e.g. if
+ *     a URL is given or if an environment variable is given and that environment variable exists).
+ *     Otherwise, the default data is returned.
+ *   - If you specified data with `setChain` it will return that.
+ *
+ * Summarizing the above, the prioritization hierarchy is `setChain` -> `foundry.toml` -> environment variable -> defaults.
+ */
+abstract contract StdChains {
+    VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256("hevm cheat code")))));
+
+    bool private initialized;
+
+    struct ChainData {
+        string name;
+        uint256 chainId;
+        string rpcUrl;
+    }
+
+    struct Chain {
+        // The chain name.
+        string name;
+        // The chain's Chain ID.
+        uint256 chainId;
+        // The chain's alias. (i.e. what gets specified in `foundry.toml`).
+        string chainAlias;
+        // A default RPC endpoint for this chain.
+        // NOTE: This default RPC URL is included for convenience to facilitate quick tests and
+        // experimentation. Do not use this RPC URL for production test suites, CI, or other heavy
+        // usage as you will be throttled and this is a disservice to others who need this endpoint.
+        string rpcUrl;
+    }
+
+    // Maps from the chain's alias (matching the alias in the `foundry.toml` file) to chain data.
+    mapping(string => Chain) private chains;
+    // Maps from the chain's alias to it's default RPC URL.
+    mapping(string => string) private defaultRpcUrls;
+    // Maps from a chain ID to it's alias.
+    mapping(uint256 => string) private idToAlias;
+
+    bool private fallbackToDefaultRpcUrls = true;
+
+    // The RPC URL will be fetched from config or defaultRpcUrls if possible.
+    function getChain(string memory chainAlias) internal virtual returns (Chain memory chain) {
+        require(bytes(chainAlias).length != 0, "StdChains getChain(string): Chain alias cannot be the empty string.");
+
+        initialize();
+        chain = chains[chainAlias];
+        require(
+            chain.chainId != 0,
+            string(abi.encodePacked("StdChains getChain(string): Chain with alias \"", chainAlias, "\" not found."))
+        );
+
+        chain = getChainWithUpdatedRpcUrl(chainAlias, chain);
+    }
+
+    function getChain(uint256 chainId) internal virtual returns (Chain memory chain) {
+        require(chainId != 0, "StdChains getChain(uint256): Chain ID cannot be 0.");
+        initialize();
+        string memory chainAlias = idToAlias[chainId];
+
+        chain = chains[chainAlias];
+
+        require(
+            chain.chainId != 0,
+            string(abi.encodePacked("StdChains getChain(uint256): Chain with ID ", vm.toString(chainId), " not found."))
+        );
+
+        chain = getChainWithUpdatedRpcUrl(chainAlias, chain);
+    }
+
+    // set chain info, with priority to argument's rpcUrl field.
+    function setChain(string memory chainAlias, ChainData memory chain) internal virtual {
+        require(
+            bytes(chainAlias).length != 0,
+            "StdChains setChain(string,ChainData): Chain alias cannot be the empty string."
+        );
+
+        require(chain.chainId != 0, "StdChains setChain(string,ChainData): Chain ID cannot be 0.");
+
+        initialize();
+        string memory foundAlias = idToAlias[chain.chainId];
+
+        require(
+            bytes(foundAlias).length == 0 || keccak256(bytes(foundAlias)) == keccak256(bytes(chainAlias)),
+            string(
+                abi.encodePacked(
+                    "StdChains setChain(string,ChainData): Chain ID ",
+                    vm.toString(chain.chainId),
+                    " already used by \"",
+                    foundAlias,
+                    "\"."
+                )
+            )
+        );
+
+        uint256 oldChainId = chains[chainAlias].chainId;
+        delete idToAlias[oldChainId];
+
+        chains[chainAlias] =
+            Chain({name: chain.name, chainId: chain.chainId, chainAlias: chainAlias, rpcUrl: chain.rpcUrl});
+        idToAlias[chain.chainId] = chainAlias;
+    }
+
+    // set chain info, with priority to argument's rpcUrl field.
+    function setChain(string memory chainAlias, Chain memory chain) internal virtual {
+        setChain(chainAlias, ChainData({name: chain.name, chainId: chain.chainId, rpcUrl: chain.rpcUrl}));
+    }
+
+    function _toUpper(string memory str) private pure returns (string memory) {
+        bytes memory strb = bytes(str);
+        bytes memory copy = new bytes(strb.length);
+        for (uint256 i = 0; i < strb.length; i++) {
+            bytes1 b = strb[i];
+            if (b >= 0x61 && b <= 0x7A) {
+                copy[i] = bytes1(uint8(b) - 32);
+            } else {
+                copy[i] = b;
+            }
+        }
+        return string(copy);
+    }
+
+    // lookup rpcUrl, in descending order of priority:
+    // current -> config (foundry.toml) -> environment variable -> default
+    function getChainWithUpdatedRpcUrl(string memory chainAlias, Chain memory chain) private returns (Chain memory) {
+        if (bytes(chain.rpcUrl).length == 0) {
+            try vm.rpcUrl(chainAlias) returns (string memory configRpcUrl) {
+                chain.rpcUrl = configRpcUrl;
+            } catch (bytes memory err) {
+                string memory envName = string(abi.encodePacked(_toUpper(chainAlias), "_RPC_URL"));
+                if (fallbackToDefaultRpcUrls) {
+                    chain.rpcUrl = vm.envOr(envName, defaultRpcUrls[chainAlias]);
+                } else {
+                    chain.rpcUrl = vm.envString(envName);
+                }
+                // distinguish 'not found' from 'cannot read'
+                bytes memory notFoundError =
+                    abi.encodeWithSignature("CheatCodeError", string(abi.encodePacked("invalid rpc url ", chainAlias)));
+                if (keccak256(notFoundError) != keccak256(err) || bytes(chain.rpcUrl).length == 0) {
+                    /// @solidity memory-safe-assembly
+                    assembly {
+                        revert(add(32, err), mload(err))
+                    }
+                }
+            }
+        }
+        return chain;
+    }
+
+    function setFallbackToDefaultRpcUrls(bool useDefault) internal {
+        fallbackToDefaultRpcUrls = useDefault;
+    }
+
+    function initialize() private {
+        if (initialized) return;
+
+        initialized = true;
+
+        // If adding an RPC here, make sure to test the default RPC URL in `testRpcs`
+        setChainWithDefaultRpcUrl("anvil", ChainData("Anvil", 31337, "http://127.0.0.1:8545"));
+        setChainWithDefaultRpcUrl(
+            "mainnet", ChainData("Mainnet", 1, "https://mainnet.infura.io/v3/f4a0bdad42674adab5fc0ac077ffab2b")
+        );
+        setChainWithDefaultRpcUrl(
+            "goerli", ChainData("Goerli", 5, "https://goerli.infura.io/v3/f4a0bdad42674adab5fc0ac077ffab2b")
+        );
+        setChainWithDefaultRpcUrl(
+            "sepolia", ChainData("Sepolia", 11155111, "https://sepolia.infura.io/v3/f4a0bdad42674adab5fc0ac077ffab2b")
+        );
+        setChainWithDefaultRpcUrl("optimism", ChainData("Optimism", 10, "https://mainnet.optimism.io"));
+        setChainWithDefaultRpcUrl("optimism_goerli", ChainData("Optimism Goerli", 420, "https://goerli.optimism.io"));
+        setChainWithDefaultRpcUrl("arbitrum_one", ChainData("Arbitrum One", 42161, "https://arb1.arbitrum.io/rpc"));
+        setChainWithDefaultRpcUrl(
+            "arbitrum_one_goerli", ChainData("Arbitrum One Goerli", 421613, "https://goerli-rollup.arbitrum.io/rpc")
+        );
+        setChainWithDefaultRpcUrl("arbitrum_nova", ChainData("Arbitrum Nova", 42170, "https://nova.arbitrum.io/rpc"));
+        setChainWithDefaultRpcUrl("polygon", ChainData("Polygon", 137, "https://polygon-rpc.com"));
+        setChainWithDefaultRpcUrl(
+            "polygon_mumbai", ChainData("Polygon Mumbai", 80001, "https://rpc-mumbai.maticvigil.com")
+        );
+        setChainWithDefaultRpcUrl("avalanche", ChainData("Avalanche", 43114, "https://api.avax.network/ext/bc/C/rpc"));
+        setChainWithDefaultRpcUrl(
+            "avalanche_fuji", ChainData("Avalanche Fuji", 43113, "https://api.avax-test.network/ext/bc/C/rpc")
+        );
+        setChainWithDefaultRpcUrl(
+            "bnb_smart_chain", ChainData("BNB Smart Chain", 56, "https://bsc-dataseed1.binance.org")
+        );
+        setChainWithDefaultRpcUrl(
+            "bnb_smart_chain_testnet",
+            ChainData("BNB Smart Chain Testnet", 97, "https://rpc.ankr.com/bsc_testnet_chapel")
+        );
+        setChainWithDefaultRpcUrl("gnosis_chain", ChainData("Gnosis Chain", 100, "https://rpc.gnosischain.com"));
+    }
+
+    // set chain info, with priority to chainAlias' rpc url in foundry.toml
+    function setChainWithDefaultRpcUrl(string memory chainAlias, ChainData memory chain) private {
+        string memory rpcUrl = chain.rpcUrl;
+        defaultRpcUrls[chainAlias] = rpcUrl;
+        chain.rpcUrl = "";
+        setChain(chainAlias, chain);
+        chain.rpcUrl = rpcUrl; // restore argument
+    }
+}