Files
erc-3643/test/utilities/ComplianceCheck.t.sol
Mohamad HammoudandGitHub 94182deb9c ✨ BT-1418 integrate foundry & hardhat + migrating solidity tests (#76)
* ✨ integrate foundry alongside hardhat for dual testing framework

- Add foundry.toml configuration
- Reorganize test structure: test/forge/ and test/hardhat/
- Add Foundry scripts to package.json (build:forge, test:forge, coverage:forge)
- Update hardhat.config.ts with evmVersion for compatibility
- Add GitHub workflows and coverage scripts from template
- Add Husky hooks (pre-commit, post-checkout, post-merge)
- Add .vscode/settings.json for better IDE support
- Disable coverage checks until tests are migrated (commented with TODO)

This migration is based on TokenySolutions/contracts-template and enables
gradual migration of tests from Hardhat (TypeScript) to Foundry (Solidity).

Related to: BT-1418

* ✅ trex factory tests

* ⚰️ remove trex suit

* feat(forge): reorganize Foundry test structure and sync GitHub workflows

- Move TREXFactorySetup to helpers folder
- Rename TREXSuite.t.sol to TREXFactory.t.sol
- Update fixture to inherit from Test for proper Foundry pattern
- Transfer ownership to deployer address to match Hardhat behavior
- Sync GitHub workflows with package.json scripts
- Update test.yml to use npm run build and npm run test
- Update push_checking.yml to use unified npm run lint
- Update forge_coverage.sh to use npm run coverage

* fix(ci): install Foundry and skip husky in push_checking workflow

- Add Foundry installation step before npm ci
- Set HUSKY=0 to skip husky setup in CI environment
- Fixes 'forge: not found' error during npm prepare script

* 🔧 keep hardhat settings

* ✅ create addressess directly

* ✅ removed test_StandardAddressesSet

* ✅ fix lint

* 💡 removed title natspecs

* ✅ migrated trex factort tests

* ✅ added test module multicall

* ✅ migrate agent role test

* ✅ migrate claim topics registry

* ✅ migrated trusted issuer registry

* ✅ migrate identity registry storage

* ✅ migrated identity registry tests

* ✅ migrated implementation authority test

* ✅ migrated token agen restrictions

* ✅ migrated token information test

* ✅ migrated token recover

* ✅ migrated token permit

* ✅ migrated token transfer

* ✅ migrated utilities upgrade

* ✅ migrated freeze check

* ✅ migrated compliance check in utilities test

* ✅ migrated eligibility check

* ✅ migrated transfer check in utilities

* ✅ migrated compliance test

* ✅ migrated gateway tests

* 🔥 removed already defined events

* 🗑️ imported Initializable error from openzeppelin

* ➕ added already defined events and errors

* ✅ added base test token

* ✅ used idFactory

* ♻️ refactored compliance test

* ⚰️ remoced useless vm.prank

* 🔧 deleted hardhat configurations

* 💚 fixed ci

* refactor: remove 100% coverage requirement from forge_coverage.sh

- Remove strict 100% coverage checks that were causing workflow failures
- Script now only generates and displays coverage report without failing
- Aligns with previous behavior where coverage was informational only

* ✅ resolve getVerifiedDetails

* ✅ applied _getEligibility and remove via-ir from foundry.toml

* ✅ cover tokena and token permit

* ✅ cover compliance

* ✅ cover identity registry

* ✅ increased trex gateway coverage

* ✅ increase coverage for trex factory

* ✅ increased AbstractModuleUpgradeable.sol coverage

* ⚰️ removed abstract module

* 🔧 updted generate coverage

* ✅ coverage 100% identity registry

* ✅ coverage 100% trex gate way

* ✅ coverage trex factory

* ✅ coverage 100% AbstractModuleUpgradeable by test module

* ✅ coverage IAFactory.sol

* ✅ coverage 100% for implementation authority

* ✅ coverage 1005 abstract proxy

* ✅ coverage 100% claim topic registry

* ✅ coverage 100% identity registry storage

* ✅ coverage 100% modular compliance proxy

* ✅ coverage trusted issuer registry proxy

* ✅ coverage 100% identity registry

* ✅ coverage 100% token proxy

* 🚨 resolve linter in token information

* ✅ coverage 100% roles

* 🚨 resolve linter

* 🔧 added no coverage for test, _testContracts and  utils

* ✅ coverage 100% for token.sol

* ✅ coverage 100% for modular compliance

* ✅ coverage 100% trusted issuer registry

* 🔧 restore package.json

* ✅ coverage 100% for utlity checker

* 🚨 fix linter
2025-12-31 16:58:16 +08:00

126 lines
5.4 KiB
Solidity

// SPDX-License-Identifier: UNLICENSED
pragma solidity 0.8.30;
import { ERC1967Proxy } from "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol";
import { MockContract } from "contracts/_testContracts/MockContract.sol";
import { TestModule } from "contracts/_testContracts/TestModule.sol";
import { ModularCompliance } from "contracts/compliance/modular/ModularCompliance.sol";
import { ModuleProxy } from "contracts/compliance/modular/modules/ModuleProxy.sol";
import { UtilityChecker } from "contracts/utils/UtilityChecker.sol";
import { Test } from "forge-std/Test.sol";
contract ComplianceCheckTest is Test {
// Standard test addresses
address public deployer = makeAddr("deployer");
address public alice = makeAddr("alice");
address public bob = makeAddr("bob");
ModularCompliance public compliance;
TestModule public testModule;
MockContract public mockContract;
UtilityChecker public utilityChecker;
function setUp() public {
// Deploy ModularCompliance implementation
ModularCompliance complianceImplementation = new ModularCompliance();
// Deploy ModularCompliance proxy with init using ERC1967Proxy
bytes memory initData = abi.encodeWithSelector(ModularCompliance.init.selector);
ERC1967Proxy complianceProxy = new ERC1967Proxy(address(complianceImplementation), initData);
compliance = ModularCompliance(address(complianceProxy));
// Transfer ownership to deployer
// Proxy is owned by the deployer (test contract)
compliance.transferOwnership(deployer);
// Deploy TestModule implementation
TestModule testModuleImplementation = new TestModule();
// Deploy TestModule proxy with initialize using ModuleProxy
bytes memory moduleInitData = abi.encodeWithSelector(TestModule.initialize.selector);
ModuleProxy testModuleProxy = new ModuleProxy(address(testModuleImplementation), moduleInitData);
testModule = TestModule(address(testModuleProxy));
// Add module to compliance
vm.prank(deployer);
compliance.addModule(address(testModule));
// Deploy MockContract
mockContract = new MockContract();
// Bind token to compliance
vm.prank(deployer);
compliance.bindToken(address(mockContract));
// Set compliance on mock contract
mockContract.setCompliance(address(compliance));
// Deploy UtilityChecker
utilityChecker = new UtilityChecker();
utilityChecker.initialize();
}
// ============ getTransferDetails() Tests ============
/// @notice Should return pass for single module
function test_getTransferDetails_ReturnsPass_ForSingleModule() public {
UtilityChecker.ComplianceCheckDetails[] memory results =
utilityChecker.getTransferDetails(address(mockContract), alice, bob, 100);
assertEq(results.length, 1);
assertEq(keccak256(bytes(results[0].moduleName)), keccak256(bytes("TestModule")));
assertTrue(results[0].pass);
}
/// @notice Should return no pass for one of multiple modules
function test_getTransferDetails_ReturnsNoPass_ForOneOfMultipleModules() public {
// Deploy second module with proxy
TestModule testModule2Implementation = new TestModule();
bytes memory module2InitData = abi.encodeWithSelector(TestModule.initialize.selector);
ModuleProxy testModule2Proxy = new ModuleProxy(address(testModule2Implementation), module2InitData);
TestModule testModule2 = TestModule(address(testModule2Proxy));
// Add the proxy address to compliance
vm.prank(deployer);
compliance.addModule(address(testModule2));
// Block the second test module to show 2 different outputs
bytes memory blockModuleCall = abi.encodeWithSignature("blockModule(bool)", true);
vm.prank(deployer);
compliance.callModuleFunction(blockModuleCall, address(testModule2));
UtilityChecker.ComplianceCheckDetails[] memory results =
utilityChecker.getTransferDetails(address(mockContract), alice, bob, 100);
assertEq(results.length, 2);
assertEq(keccak256(bytes(results[0].moduleName)), keccak256(bytes("TestModule")));
assertTrue(results[0].pass);
assertEq(keccak256(bytes(results[1].moduleName)), keccak256(bytes("TestModule")));
assertFalse(results[1].pass);
}
/// @notice Should return pass for multiple modules
function test_getTransferDetails_ReturnsPass_ForMultipleModules() public {
// Deploy second module with proxy
TestModule testModule2Implementation = new TestModule();
bytes memory module2InitData = abi.encodeWithSelector(TestModule.initialize.selector);
ModuleProxy testModule2Proxy = new ModuleProxy(address(testModule2Implementation), module2InitData);
TestModule testModule2 = TestModule(address(testModule2Proxy));
// Add the proxy address to compliance
vm.prank(deployer);
compliance.addModule(address(testModule2));
UtilityChecker.ComplianceCheckDetails[] memory results =
utilityChecker.getTransferDetails(address(mockContract), alice, bob, 100);
assertEq(results.length, 2);
assertEq(keccak256(bytes(results[0].moduleName)), keccak256(bytes("TestModule")));
assertTrue(results[0].pass);
assertEq(keccak256(bytes(results[1].moduleName)), keccak256(bytes("TestModule")));
assertTrue(results[1].pass);
}
}