Migrate HardHat tests to DS-tests (Solidity tests)

contract-examples/contracts/AllowList.sol

@@ -13,6 +13,12 @@ contract AllowList is Ownable {
   uint256 constant STATUS_ENABLED = 1;
   uint256 constant STATUS_ADMIN = 2;
 
+  enum Role {
+    None,
+    Enabled,
+    Admin
+  }
+
   constructor(address precompileAddr) Ownable() {
     allowList = IAllowList(precompileAddr);
   }

contract-examples/contracts/ERC20NativeMinter.sol

@@ -5,11 +5,12 @@ import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
 import "./AllowList.sol";
 import "./INativeMinter.sol";
 
+// Precompiled Native Minter Contract Address
+address constant MINTER_ADDRESS = 0x0200000000000000000000000000000000000001;
+// Designated Blackhole Address
+address constant BLACKHOLE_ADDRESS = 0x0100000000000000000000000000000000000000;
+
 contract ERC20NativeMinter is ERC20, AllowList {
-  // Precompiled Native Minter Contract Address
-  address constant MINTER_ADDRESS = 0x0200000000000000000000000000000000000001;
-  // Designated Blackhole Address
-  address constant BLACKHOLE_ADDRESS = 0x0100000000000000000000000000000000000000;
   string private constant TOKEN_NAME = "ERC20NativeMinterToken";
   string private constant TOKEN_SYMBOL = "XMPL";
 

contract-examples/contracts/ExampleDeployerList.sol

@@ -5,11 +5,20 @@ import "@openzeppelin/contracts/access/Ownable.sol";
 import "./IAllowList.sol";
 import "./AllowList.sol";
 
+address constant DEPLOYER_LIST = 0x0200000000000000000000000000000000000000;
+address constant OTHER_ADDRESS = 0x0Fa8EA536Be85F32724D57A37758761B86416123;
+
 // ExampleDeployerList shows how ContractDeployerAllowList precompile can be used in a smart contract
 // All methods of [allowList] can be directly called. There are example calls as tasks in hardhat.config.ts file.
 contract ExampleDeployerList is AllowList {
   // Precompiled Allow List Contract Address
-  address constant DEPLOYER_LIST = 0x0200000000000000000000000000000000000000;
-
   constructor() AllowList(DEPLOYER_LIST) {}
+
+  function deployContract() public {
+    new Example();
+  }
 }
+
+// This is an empty contract that can be used to test contract deployment
+contract Example {}
+

contract-examples/contracts/ExampleFeeManager.sol

@@ -6,49 +6,67 @@ import "@openzeppelin/contracts/access/Ownable.sol";
 import "./AllowList.sol";
 import "./IFeeManager.sol";
 
+address constant FEE_MANAGER_ADDRESS = 0x0200000000000000000000000000000000000003;
+
+uint constant WAGMI_GAS_LIMIT = 20_000_000;
+uint constant WAGMI_TARGET_BLOCK_RATE = 2;
+uint constant WAGMI_MIN_BASE_FEE = 1_000_000_000;
+uint constant WAGMI_TARGET_GAS = 100_000_000;
+uint constant WAGMI_BASE_FEE_CHANGE_DENOMINATOR = 48;
+uint constant WAGMI_MIN_BLOCK_GAS_COST = 0;
+uint constant WAGMI_MAX_BLOCK_GAS_COST = 10_000_000;
+uint constant WAGMI_BLOCK_GAS_COST_STEP = 500_000;
+
+uint constant CCHAIN_GAS_LIMIT = 8_000_000;
+uint constant CCHAIN_TARGET_BLOCK_RATE = 2;
+uint constant CCHAIN_MIN_BASE_FEE = 25_000_000_000;
+uint constant CCHAIN_TARGET_GAS = 15_000_000;
+uint constant CCHAIN_BASE_FEE_CHANGE_DENOMINATOR = 36;
+uint constant CCHAIN_MIN_BLOCK_GAS_COST = 0;
+uint constant CCHAIN_MAX_BLOCK_GAS_COST = 1_000_000;
+uint constant CCHAIN_BLOCK_GAS_COST_STEP = 100_000;
+
+struct FeeConfig {
+  uint256 gasLimit;
+  uint256 targetBlockRate;
+  uint256 minBaseFee;
+  uint256 targetGas;
+  uint256 baseFeeChangeDenominator;
+  uint256 minBlockGasCost;
+  uint256 maxBlockGasCost;
+  uint256 blockGasCostStep;
+}
+
 // ExampleFeeManager shows how FeeManager precompile can be used in a smart contract
 // All methods of [allowList] can be directly called. There are example calls as tasks in hardhat.config.ts file.
 contract ExampleFeeManager is AllowList {
-  // Precompiled Fee Manager Contract Address
-  address constant FEE_MANAGER_ADDRESS = 0x0200000000000000000000000000000000000003;
   IFeeManager feeManager = IFeeManager(FEE_MANAGER_ADDRESS);
 
-  struct FeeConfig {
-    uint256 gasLimit;
-    uint256 targetBlockRate;
-    uint256 minBaseFee;
-    uint256 targetGas;
-    uint256 baseFeeChangeDenominator;
-    uint256 minBlockGasCost;
-    uint256 maxBlockGasCost;
-    uint256 blockGasCostStep;
-  }
-
   constructor() AllowList(FEE_MANAGER_ADDRESS) {}
 
   function enableWAGMIFees() public onlyEnabled {
     feeManager.setFeeConfig(
-      20_000_000, // gasLimit
-      2, // targetBlockRate
-      1_000_000_000, // minBaseFee
-      100_000_000, // targetGas
-      48, // baseFeeChangeDenominator
-      0, // minBlockGasCost
-      10_000_000, // maxBlockGasCost
-      500_000 // blockGasCostStep
+      WAGMI_GAS_LIMIT,
+      WAGMI_TARGET_BLOCK_RATE,
+      WAGMI_MIN_BASE_FEE,
+      WAGMI_TARGET_GAS,
+      WAGMI_BASE_FEE_CHANGE_DENOMINATOR,
+      WAGMI_MIN_BLOCK_GAS_COST,
+      WAGMI_MAX_BLOCK_GAS_COST,
+      WAGMI_BLOCK_GAS_COST_STEP
     );
   }
 
   function enableCChainFees() public onlyEnabled {
     feeManager.setFeeConfig(
-      8_000_000, // gasLimit
-      2, // targetBlockRate
-      25_000_000_000, // minBaseFee
-      15_000_000, // targetGas
-      36, // baseFeeChangeDenominator
-      0, // minBlockGasCost
-      1_000_000, // maxBlockGasCost
-      200_000 // blockGasCostStep
+      CCHAIN_GAS_LIMIT,
+      CCHAIN_TARGET_BLOCK_RATE,
+      CCHAIN_MIN_BASE_FEE,
+      CCHAIN_TARGET_GAS,
+      CCHAIN_BASE_FEE_CHANGE_DENOMINATOR,
+      CCHAIN_MIN_BLOCK_GAS_COST,
+      CCHAIN_MAX_BLOCK_GAS_COST,
+      CCHAIN_BLOCK_GAS_COST_STEP
     );
   }
 

contract-examples/contracts/ExampleRewardManager.sol

@@ -4,9 +4,10 @@ pragma solidity ^0.8.0;
 import "./IRewardManager.sol";
 import "@openzeppelin/contracts/access/Ownable.sol";
 
+address constant REWARD_MANAGER_ADDRESS = 0x0200000000000000000000000000000000000004;
+
 // ExampleRewardManager is a sample wrapper contract for RewardManager precompile.
 contract ExampleRewardManager is Ownable {
-  address constant REWARD_MANAGER_ADDRESS = 0x0200000000000000000000000000000000000004;
   IRewardManager rewardManager = IRewardManager(REWARD_MANAGER_ADDRESS);
 
   constructor() Ownable() {}

contract-examples/contracts/ExampleTxAllowList.sol

@@ -1,14 +1,21 @@
 //SPDX-License-Identifier: MIT
 pragma solidity ^0.8.0;
 
-import "@openzeppelin/contracts/access/Ownable.sol";
 import "./AllowList.sol";
+import "./IAllowList.sol";
+
+// Precompiled Allow List Contract Address
+address constant TX_ALLOW_LIST = 0x0200000000000000000000000000000000000002;
+address constant OTHER_ADDRESS = 0x0Fa8EA536Be85F32724D57A37758761B86416123;
 
 // ExampleTxAllowList shows how TxAllowList precompile can be used in a smart contract
 // All methods of [allowList] can be directly called. There are example calls as tasks in hardhat.config.ts file.
 contract ExampleTxAllowList is AllowList {
-  // Precompiled Allow List Contract Address
-  address constant TX_ALLOW_LIST = 0x0200000000000000000000000000000000000002;
-
   constructor() AllowList(TX_ALLOW_LIST) {}
+
+  function deployContract() public {
+    new Example();
+  }
 }
+
+contract Example {}

contract-examples/contracts/test/AllowListTest.sol

@@ -0,0 +1,11 @@
+//SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "../AllowList.sol";
+import "ds-test/src/test.sol";
+
+contract AllowListTest is DSTest {
+  function assertRole(uint result, AllowList.Role role) internal {
+    assertEq(result, uint(role));
+  }
+}

contract-examples/contracts/test/ERC20NativeMinterTest.sol

@@ -0,0 +1,144 @@
+//SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "../ERC20NativeMinter.sol";
+import "../INativeMinter.sol";
+import "./AllowListTest.sol";
+
+// TODO:
+// this contract adds another (unwanted) layer of indirection
+// but it's the easiest way to match the previous HardHat testing functionality.
+// Once we completely migrate to DS-test, we can simplify this set of tests.
+contract Minter {
+  ERC20NativeMinter token;
+
+  constructor(address tokenAddress) {
+    token = ERC20NativeMinter(tokenAddress);
+  }
+
+  function mintdraw(uint amount) external {
+    token.mintdraw(amount);
+  }
+
+  function deposit(uint value) external {
+    token.deposit{value: value}();
+  }
+}
+
+contract ERC20NativeMinterTest is AllowListTest {
+  INativeMinter nativeMinter = INativeMinter(MINTER_ADDRESS);
+
+  function setUp() public {
+    // noop
+  }
+
+  function step_mintdrawFailure() public {
+    ERC20NativeMinter token = new ERC20NativeMinter(1000);
+    address tokenAddress = address(token);
+
+    assertRole(nativeMinter.readAllowList(tokenAddress), AllowList.Role.None);
+
+    try token.mintdraw(100) {
+      assertTrue(false, "mintdraw should fail");
+    } catch {} // TODO should match on an error to make sure that this is failing in the way that's expected
+  }
+
+  function step_addMinter() public {
+    ERC20NativeMinter token = new ERC20NativeMinter(1000);
+    address tokenAddress = address(token);
+
+    assertRole(nativeMinter.readAllowList(tokenAddress), AllowList.Role.None);
+
+    nativeMinter.setEnabled(tokenAddress);
+
+    assertRole(nativeMinter.readAllowList(tokenAddress), AllowList.Role.Enabled);
+  }
+
+  function step_adminMintdraw() public {
+    ERC20NativeMinter token = new ERC20NativeMinter(1000);
+    address tokenAddress = address(token);
+
+    address testAddress = address(this);
+
+    nativeMinter.setEnabled(tokenAddress);
+
+    uint initialTokenBalance = token.balanceOf(testAddress);
+    uint initialNativeBalance = testAddress.balance;
+
+    uint amount = 100;
+
+    token.mintdraw(amount);
+
+    assertEq(token.balanceOf(testAddress), initialTokenBalance - amount);
+    assertEq(testAddress.balance, initialNativeBalance + amount);
+  }
+
+  function step_minterMintdrawFailure() public {
+    ERC20NativeMinter token = new ERC20NativeMinter(1000);
+    address tokenAddress = address(token);
+
+    Minter minter = new Minter(tokenAddress);
+    address minterAddress = address(minter);
+
+    nativeMinter.setEnabled(tokenAddress);
+
+    uint initialTokenBalance = token.balanceOf(minterAddress);
+    uint initialNativeBalance = minterAddress.balance;
+
+    assertEq(initialTokenBalance, 0);
+
+    try minter.mintdraw(100) {
+      assertTrue(false, "mintdraw should fail");
+    } catch {} // TODO should match on an error to make sure that this is failing in the way that's expected
+
+    assertEq(token.balanceOf(minterAddress), initialTokenBalance);
+    assertEq(minterAddress.balance, initialNativeBalance);
+  }
+
+  function step_minterDeposit() public {
+    ERC20NativeMinter token = new ERC20NativeMinter(1000);
+    address tokenAddress = address(token);
+
+    Minter minter = new Minter(tokenAddress);
+    address minterAddress = address(minter);
+
+    nativeMinter.setEnabled(tokenAddress);
+
+    uint amount = 100;
+
+    nativeMinter.mintNativeCoin(minterAddress, amount);
+
+    uint initialTokenBalance = token.balanceOf(minterAddress);
+    uint initialNativeBalance = minterAddress.balance;
+
+    minter.deposit(amount);
+
+    assertEq(token.balanceOf(minterAddress), initialTokenBalance + amount);
+    assertEq(minterAddress.balance, initialNativeBalance - amount);
+  }
+
+  function step_mintdraw() public {
+    ERC20NativeMinter token = new ERC20NativeMinter(1000);
+    address tokenAddress = address(token);
+
+    Minter minter = new Minter(tokenAddress);
+    address minterAddress = address(minter);
+
+    nativeMinter.setEnabled(tokenAddress);
+
+    uint amount = 100;
+
+    uint initialNativeBalance = minterAddress.balance;
+    assertEq(initialNativeBalance, 0);
+
+    token.mint(minterAddress, amount);
+
+    uint initialTokenBalance = token.balanceOf(minterAddress);
+    assertEq(initialTokenBalance, amount);
+
+    minter.mintdraw(amount);
+
+    assertEq(token.balanceOf(minterAddress), 0);
+    assertEq(minterAddress.balance, amount);
+  }
+}