353 lines
15 KiB
Solidity
353 lines
15 KiB
Solidity
|
// SPDX-License-Identifier: MIT
|
||
|
|
pragma solidity ^0.8.13;
|
||
|
|
|
||
|
|
import {Test} from "../src/Test.sol";
|
||
|
|
import {Config} from "../src/Config.sol";
|
||
|
|
import {StdConfig} from "../src/StdConfig.sol";
|
||
|
|
|
||
|
|
contract ConfigTest is Test, Config {
|
||
|
|
function setUp() public {
|
||
|
|
vm.setEnv("MAINNET_RPC", "https://reth-ethereum.ithaca.xyz/rpc");
|
||
|
|
vm.setEnv("WETH_MAINNET", "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2");
|
||
|
|
vm.setEnv("OPTIMISM_RPC", "https://mainnet.optimism.io");
|
||
|
|
vm.setEnv("WETH_OPTIMISM", "0x4200000000000000000000000000000000000006");
|
||
|
|
}
|
||
|
|
|
||
|
|
function test_loadConfig() public {
|
||
|
|
// Deploy the config contract with the test fixture.
|
||
|
|
_loadConfig("./test/fixtures/config.toml", false);
|
||
|
|
|
||
|
|
// -- MAINNET --------------------------------------------------------------
|
||
|
|
|
||
|
|
// Read and assert RPC URL for Mainnet (chain ID 1)
|
||
|
|
assertEq(config.getRpcUrl(1), "https://reth-ethereum.ithaca.xyz/rpc");
|
||
|
|
|
||
|
|
// Read and assert boolean values
|
||
|
|
assertTrue(config.get(1, "is_live").toBool());
|
||
|
|
bool[] memory bool_array = config.get(1, "bool_array").toBoolArray();
|
||
|
|
assertTrue(bool_array[0]);
|
||
|
|
assertFalse(bool_array[1]);
|
||
|
|
|
||
|
|
// Read and assert address values
|
||
|
|
assertEq(config.get(1, "weth").toAddress(), 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
|
||
|
|
address[] memory address_array = config.get(1, "deps").toAddressArray();
|
||
|
|
assertEq(address_array[0], 0x0000000000000000000000000000000000000000);
|
||
|
|
assertEq(address_array[1], 0x1111111111111111111111111111111111111111);
|
||
|
|
|
||
|
|
// Read and assert bytes32 values
|
||
|
|
assertEq(config.get(1, "word").toBytes32(), bytes32(uint256(1234)));
|
||
|
|
bytes32[] memory bytes32_array = config.get(1, "word_array").toBytes32Array();
|
||
|
|
assertEq(bytes32_array[0], bytes32(uint256(5678)));
|
||
|
|
assertEq(bytes32_array[1], bytes32(uint256(9999)));
|
||
|
|
|
||
|
|
// Read and assert uint values
|
||
|
|
assertEq(config.get(1, "number").toUint256(), 1234);
|
||
|
|
uint256[] memory uint_array = config.get(1, "number_array").toUint256Array();
|
||
|
|
assertEq(uint_array[0], 5678);
|
||
|
|
assertEq(uint_array[1], 9999);
|
||
|
|
|
||
|
|
// Read and assert int values
|
||
|
|
assertEq(config.get(1, "signed_number").toInt256(), -1234);
|
||
|
|
int256[] memory int_array = config.get(1, "signed_number_array").toInt256Array();
|
||
|
|
assertEq(int_array[0], -5678);
|
||
|
|
assertEq(int_array[1], 9999);
|
||
|
|
|
||
|
|
// Read and assert bytes values
|
||
|
|
assertEq(config.get(1, "b").toBytes(), hex"abcd");
|
||
|
|
bytes[] memory bytes_array = config.get(1, "b_array").toBytesArray();
|
||
|
|
assertEq(bytes_array[0], hex"dead");
|
||
|
|
assertEq(bytes_array[1], hex"beef");
|
||
|
|
|
||
|
|
// Read and assert string values
|
||
|
|
assertEq(config.get(1, "str").toString(), "foo");
|
||
|
|
string[] memory string_array = config.get(1, "str_array").toStringArray();
|
||
|
|
assertEq(string_array[0], "bar");
|
||
|
|
assertEq(string_array[1], "baz");
|
||
|
|
|
||
|
|
// -- OPTIMISM ------------------------------------------------------------
|
||
|
|
|
||
|
|
// Read and assert RPC URL for Optimism (chain ID 10)
|
||
|
|
assertEq(config.getRpcUrl(10), "https://mainnet.optimism.io");
|
||
|
|
|
||
|
|
// Read and assert boolean values
|
||
|
|
assertFalse(config.get(10, "is_live").toBool());
|
||
|
|
bool_array = config.get(10, "bool_array").toBoolArray();
|
||
|
|
assertFalse(bool_array[0]);
|
||
|
|
assertTrue(bool_array[1]);
|
||
|
|
|
||
|
|
// Read and assert address values
|
||
|
|
assertEq(config.get(10, "weth").toAddress(), 0x4200000000000000000000000000000000000006);
|
||
|
|
address_array = config.get(10, "deps").toAddressArray();
|
||
|
|
assertEq(address_array[0], 0x2222222222222222222222222222222222222222);
|
||
|
|
assertEq(address_array[1], 0x3333333333333333333333333333333333333333);
|
||
|
|
|
||
|
|
// Read and assert bytes32 values
|
||
|
|
assertEq(config.get(10, "word").toBytes32(), bytes32(uint256(9999)));
|
||
|
|
bytes32_array = config.get(10, "word_array").toBytes32Array();
|
||
|
|
assertEq(bytes32_array[0], bytes32(uint256(1234)));
|
||
|
|
assertEq(bytes32_array[1], bytes32(uint256(5678)));
|
||
|
|
|
||
|
|
// Read and assert uint values
|
||
|
|
assertEq(config.get(10, "number").toUint256(), 9999);
|
||
|
|
uint_array = config.get(10, "number_array").toUint256Array();
|
||
|
|
assertEq(uint_array[0], 1234);
|
||
|
|
assertEq(uint_array[1], 5678);
|
||
|
|
|
||
|
|
// Read and assert int values
|
||
|
|
assertEq(config.get(10, "signed_number").toInt256(), 9999);
|
||
|
|
int_array = config.get(10, "signed_number_array").toInt256Array();
|
||
|
|
assertEq(int_array[0], -1234);
|
||
|
|
assertEq(int_array[1], -5678);
|
||
|
|
|
||
|
|
// Read and assert bytes values
|
||
|
|
assertEq(config.get(10, "b").toBytes(), hex"dcba");
|
||
|
|
bytes_array = config.get(10, "b_array").toBytesArray();
|
||
|
|
assertEq(bytes_array[0], hex"c0ffee");
|
||
|
|
assertEq(bytes_array[1], hex"babe");
|
||
|
|
|
||
|
|
// Read and assert string values
|
||
|
|
assertEq(config.get(10, "str").toString(), "alice");
|
||
|
|
string_array = config.get(10, "str_array").toStringArray();
|
||
|
|
assertEq(string_array[0], "bob");
|
||
|
|
assertEq(string_array[1], "charlie");
|
||
|
|
}
|
||
|
|
|
||
|
|
function test_loadConfigAndForks() public {
|
||
|
|
_loadConfigAndForks("./test/fixtures/config.toml", false);
|
||
|
|
|
||
|
|
// assert that the map of chain id and fork ids is created and that the chain ids actually match
|
||
|
|
assertEq(forkOf[1], 0);
|
||
|
|
vm.selectFork(forkOf[1]);
|
||
|
|
assertEq(vm.getChainId(), 1);
|
||
|
|
|
||
|
|
assertEq(forkOf[10], 1);
|
||
|
|
vm.selectFork(forkOf[10]);
|
||
|
|
assertEq(vm.getChainId(), 10);
|
||
|
|
}
|
||
|
|
|
||
|
|
function test_writeConfig() public {
|
||
|
|
// Create a temporary copy of the config file to avoid modifying the original.
|
||
|
|
string memory originalConfig = "./test/fixtures/config.toml";
|
||
|
|
string memory testConfig = "./test/fixtures/config.t.toml";
|
||
|
|
vm.copyFile(originalConfig, testConfig);
|
||
|
|
|
||
|
|
// Deploy the config contract with the temporary fixture.
|
||
|
|
_loadConfig(testConfig, false);
|
||
|
|
|
||
|
|
// Enable writing to file bypassing the context check.
|
||
|
|
vm.store(address(config), bytes32(uint256(5)), bytes32(uint256(1)));
|
||
|
|
|
||
|
|
{
|
||
|
|
// Update a single boolean value and verify the change.
|
||
|
|
config.set(1, "is_live", false);
|
||
|
|
|
||
|
|
assertFalse(config.get(1, "is_live").toBool());
|
||
|
|
|
||
|
|
string memory content = vm.readFile(testConfig);
|
||
|
|
assertFalse(vm.parseTomlBool(content, "$.mainnet.bool.is_live"));
|
||
|
|
|
||
|
|
// Update a single address value and verify the change.
|
||
|
|
address new_addr = 0xDeaDbeefdEAdbeefdEadbEEFdeadbeEFdEaDbeeF;
|
||
|
|
config.set(1, "weth", new_addr);
|
||
|
|
|
||
|
|
assertEq(config.get(1, "weth").toAddress(), new_addr);
|
||
|
|
|
||
|
|
content = vm.readFile(testConfig);
|
||
|
|
assertEq(vm.parseTomlAddress(content, "$.mainnet.address.weth"), new_addr);
|
||
|
|
|
||
|
|
// Update a uint array and verify the change.
|
||
|
|
uint256[] memory new_numbers = new uint256[](3);
|
||
|
|
new_numbers[0] = 1;
|
||
|
|
new_numbers[1] = 2;
|
||
|
|
new_numbers[2] = 3;
|
||
|
|
config.set(10, "number_array", new_numbers);
|
||
|
|
|
||
|
|
uint256[] memory updated_numbers_mem = config.get(10, "number_array").toUint256Array();
|
||
|
|
assertEq(updated_numbers_mem.length, 3);
|
||
|
|
assertEq(updated_numbers_mem[0], 1);
|
||
|
|
assertEq(updated_numbers_mem[1], 2);
|
||
|
|
assertEq(updated_numbers_mem[2], 3);
|
||
|
|
|
||
|
|
content = vm.readFile(testConfig);
|
||
|
|
uint256[] memory updated_numbers_disk = vm.parseTomlUintArray(content, "$.optimism.uint.number_array");
|
||
|
|
assertEq(updated_numbers_disk.length, 3);
|
||
|
|
assertEq(updated_numbers_disk[0], 1);
|
||
|
|
assertEq(updated_numbers_disk[1], 2);
|
||
|
|
assertEq(updated_numbers_disk[2], 3);
|
||
|
|
|
||
|
|
// Update a string array and verify the change.
|
||
|
|
string[] memory new_strings = new string[](2);
|
||
|
|
new_strings[0] = "hello";
|
||
|
|
new_strings[1] = "world";
|
||
|
|
config.set(1, "str_array", new_strings);
|
||
|
|
|
||
|
|
string[] memory updated_strings_mem = config.get(1, "str_array").toStringArray();
|
||
|
|
assertEq(updated_strings_mem.length, 2);
|
||
|
|
assertEq(updated_strings_mem[0], "hello");
|
||
|
|
assertEq(updated_strings_mem[1], "world");
|
||
|
|
|
||
|
|
content = vm.readFile(testConfig);
|
||
|
|
string[] memory updated_strings_disk = vm.parseTomlStringArray(content, "$.mainnet.string.str_array");
|
||
|
|
assertEq(updated_strings_disk.length, 2);
|
||
|
|
assertEq(updated_strings_disk[0], "hello");
|
||
|
|
assertEq(updated_strings_disk[1], "world");
|
||
|
|
|
||
|
|
// Create a new uint variable and verify the change.
|
||
|
|
config.set(1, "new_uint", uint256(42));
|
||
|
|
|
||
|
|
assertEq(config.get(1, "new_uint").toUint256(), 42);
|
||
|
|
|
||
|
|
content = vm.readFile(testConfig);
|
||
|
|
assertEq(vm.parseTomlUint(content, "$.mainnet.uint.new_uint"), 42);
|
||
|
|
|
||
|
|
// Create a new int variable and verify the change.
|
||
|
|
config.set(1, "new_int", int256(-42));
|
||
|
|
|
||
|
|
assertEq(config.get(1, "new_int").toInt256(), -42);
|
||
|
|
|
||
|
|
content = vm.readFile(testConfig);
|
||
|
|
assertEq(vm.parseTomlInt(content, "$.mainnet.int.new_int"), -42);
|
||
|
|
|
||
|
|
// Create a new int array and verify the change.
|
||
|
|
int256[] memory new_ints = new int256[](2);
|
||
|
|
new_ints[0] = -100;
|
||
|
|
new_ints[1] = 200;
|
||
|
|
config.set(10, "new_ints", new_ints);
|
||
|
|
|
||
|
|
int256[] memory updated_ints_mem = config.get(10, "new_ints").toInt256Array();
|
||
|
|
assertEq(updated_ints_mem.length, 2);
|
||
|
|
assertEq(updated_ints_mem[0], -100);
|
||
|
|
assertEq(updated_ints_mem[1], 200);
|
||
|
|
|
||
|
|
content = vm.readFile(testConfig);
|
||
|
|
int256[] memory updated_ints_disk = vm.parseTomlIntArray(content, "$.optimism.int.new_ints");
|
||
|
|
assertEq(updated_ints_disk.length, 2);
|
||
|
|
assertEq(updated_ints_disk[0], -100);
|
||
|
|
assertEq(updated_ints_disk[1], 200);
|
||
|
|
|
||
|
|
// Create a new bytes32 array and verify the change.
|
||
|
|
bytes32[] memory new_words = new bytes32[](2);
|
||
|
|
new_words[0] = bytes32(uint256(0xDEAD));
|
||
|
|
new_words[1] = bytes32(uint256(0xBEEF));
|
||
|
|
config.set(10, "new_words", new_words);
|
||
|
|
|
||
|
|
bytes32[] memory updated_words_mem = config.get(10, "new_words").toBytes32Array();
|
||
|
|
assertEq(updated_words_mem.length, 2);
|
||
|
|
assertEq(updated_words_mem[0], new_words[0]);
|
||
|
|
assertEq(updated_words_mem[1], new_words[1]);
|
||
|
|
|
||
|
|
content = vm.readFile(testConfig);
|
||
|
|
bytes32[] memory updated_words_disk = vm.parseTomlBytes32Array(content, "$.optimism.bytes32.new_words");
|
||
|
|
assertEq(updated_words_disk.length, 2);
|
||
|
|
assertEq(vm.toString(updated_words_disk[0]), vm.toString(new_words[0]));
|
||
|
|
assertEq(vm.toString(updated_words_disk[1]), vm.toString(new_words[1]));
|
||
|
|
}
|
||
|
|
|
||
|
|
// Clean up the temporary file.
|
||
|
|
vm.removeFile(testConfig);
|
||
|
|
}
|
||
|
|
|
||
|
|
function test_writeUpdatesBackToFile() public {
|
||
|
|
// Create a temporary copy of the config file to avoid modifying the original.
|
||
|
|
string memory originalConfig = "./test/fixtures/config.toml";
|
||
|
|
string memory testConfig = "./test/fixtures/write_config.t.toml";
|
||
|
|
vm.copyFile(originalConfig, testConfig);
|
||
|
|
|
||
|
|
// Deploy the config contract with `writeToFile = false` (disabled).
|
||
|
|
_loadConfig(testConfig, false);
|
||
|
|
|
||
|
|
// Update a single boolean value and verify the file is NOT changed.
|
||
|
|
config.set(1, "is_live", false);
|
||
|
|
string memory content = vm.readFile(testConfig);
|
||
|
|
assertTrue(vm.parseTomlBool(content, "$.mainnet.bool.is_live"), "File should not be updated yet");
|
||
|
|
|
||
|
|
// Enable writing to file bypassing the context check.
|
||
|
|
vm.store(address(config), bytes32(uint256(5)), bytes32(uint256(1)));
|
||
|
|
|
||
|
|
// Update the value again and verify the file IS changed.
|
||
|
|
config.set(1, "is_live", false);
|
||
|
|
content = vm.readFile(testConfig);
|
||
|
|
assertFalse(vm.parseTomlBool(content, "$.mainnet.bool.is_live"), "File should be updated now");
|
||
|
|
|
||
|
|
// Disable writing to file.
|
||
|
|
config.writeUpdatesBackToFile(false);
|
||
|
|
|
||
|
|
// Update the value again and verify the file is NOT changed.
|
||
|
|
config.set(1, "is_live", true);
|
||
|
|
content = vm.readFile(testConfig);
|
||
|
|
assertFalse(vm.parseTomlBool(content, "$.mainnet.bool.is_live"), "File should not be updated again");
|
||
|
|
|
||
|
|
// Clean up the temporary file.
|
||
|
|
vm.removeFile(testConfig);
|
||
|
|
}
|
||
|
|
|
||
|
|
function testRevert_WriteToFileInForbiddenCtxt() public {
|
||
|
|
// Cannot initialize enabling writing to file unless we are in SCRIPT mode.
|
||
|
|
vm.expectRevert(StdConfig.WriteToFileInForbiddenCtxt.selector);
|
||
|
|
_loadConfig("./test/fixtures/config.toml", true);
|
||
|
|
|
||
|
|
// Initialize with `writeToFile = false`.
|
||
|
|
_loadConfig("./test/fixtures/config.toml", false);
|
||
|
|
|
||
|
|
// Cannot enable writing to file unless we are in SCRIPT mode.
|
||
|
|
vm.expectRevert(StdConfig.WriteToFileInForbiddenCtxt.selector);
|
||
|
|
config.writeUpdatesBackToFile(true);
|
||
|
|
}
|
||
|
|
|
||
|
|
function testRevert_InvalidChainKey() public {
|
||
|
|
// Create a fixture with an invalid chain key
|
||
|
|
string memory invalidChainConfig = "./test/fixtures/config_invalid_chain.toml";
|
||
|
|
vm.writeFile(
|
||
|
|
invalidChainConfig,
|
||
|
|
string.concat(
|
||
|
|
"[mainnet]\n",
|
||
|
|
"endpoint_url = \"https://reth-ethereum.ithaca.xyz/rpc\"\n",
|
||
|
|
"\n",
|
||
|
|
"[mainnet.uint]\n",
|
||
|
|
"valid_number = 123\n",
|
||
|
|
"\n",
|
||
|
|
"# Invalid chain key (not a number and not a valid alias)\n",
|
||
|
|
"[invalid_chain]\n",
|
||
|
|
"endpoint_url = \"https://invalid.com\"\n",
|
||
|
|
"\n",
|
||
|
|
"[invalid_chain_9999.uint]\n",
|
||
|
|
"some_value = 456\n"
|
||
|
|
)
|
||
|
|
);
|
||
|
|
|
||
|
|
vm.expectRevert(abi.encodeWithSelector(StdConfig.InvalidChainKey.selector, "invalid_chain"));
|
||
|
|
new StdConfig(invalidChainConfig, false);
|
||
|
|
vm.removeFile(invalidChainConfig);
|
||
|
|
}
|
||
|
|
|
||
|
|
function testRevert_ChainNotInitialized() public {
|
||
|
|
_loadConfig("./test/fixtures/config.toml", false);
|
||
|
|
|
||
|
|
// Enable writing to file bypassing the context check.
|
||
|
|
vm.store(address(config), bytes32(uint256(5)), bytes32(uint256(1)));
|
||
|
|
|
||
|
|
// Try to write a value for a non-existent chain ID
|
||
|
|
vm.expectRevert(abi.encodeWithSelector(StdConfig.ChainNotInitialized.selector, uint256(999999)));
|
||
|
|
config.set(999999, "some_key", uint256(123));
|
||
|
|
}
|
||
|
|
|
||
|
|
function testRevert_UnableToParseVariable() public {
|
||
|
|
// Create a temporary fixture with an unparsable variable
|
||
|
|
string memory badParseConfig = "./test/fixtures/config_bad_parse.toml";
|
||
|
|
vm.writeFile(
|
||
|
|
badParseConfig,
|
||
|
|
string.concat(
|
||
|
|
"[mainnet]\n",
|
||
|
|
"endpoint_url = \"https://reth-ethereum.ithaca.xyz/rpc\"\n",
|
||
|
|
"\n",
|
||
|
|
"[mainnet.uint]\n",
|
||
|
|
"bad_value = \"not_a_number\"\n"
|
||
|
|
)
|
||
|
|
);
|
||
|
|
|
||
|
|
vm.expectRevert(abi.encodeWithSelector(StdConfig.UnableToParseVariable.selector, "bad_value"));
|
||
|
|
new StdConfig(badParseConfig, false);
|
||
|
|
vm.removeFile(badParseConfig);
|
||
|
|
}
|
||
|
|
}
|