@gooddollar/goodprotocol 1.0.28 → 1.0.29-beta.1

package/contracts/utils/GoodDollarMintBurnWrapper.sol

@@ -0,0 +1,638 @@
+// SPDX-License-Identifier: MIT
+/**
+ Wrap the G$ token to provide mint permissions to multichain.org router/bridge
+ based on https://github.com/anyswap/multichain-smart-contracts/blob/1459fe6281867319af8ffb1849e5c16d242d6530/contracts/wrapper/MintBurnWrapper.sol
+
+ Added onTokenTransfer
+ Notice: contract needs to be registered as a scheme on Controller to be able to call mintTokens
+ Fixed:
+ https://github.com/anyswap/multichain-smart-contracts/issues/4
+ https://github.com/anyswap/multichain-smart-contracts/issues/3
+ */
+
+pragma solidity ^0.8;
+
+import "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/access/AccessControlEnumerableUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+import "@openzeppelin/contracts/utils/math/Math.sol";
+import "hardhat/console.sol";
+
+import "./DAOUpgradeableContract.sol";
+
+library TokenOperation {
+	using AddressUpgradeable for address;
+
+	function safeBurnSelf(address token, uint256 value) internal {
+		// burn(uint256)
+		_callOptionalReturn(token, abi.encodeWithSelector(0x42966c68, value));
+	}
+
+	function safeBurnFrom(
+		address token,
+		address from,
+		uint256 value
+	) internal {
+		// burnFrom(address,uint256)
+		_callOptionalReturn(token, abi.encodeWithSelector(0x79cc6790, from, value));
+	}
+
+	function _callOptionalReturn(address token, bytes memory data) private {
+		bytes memory returndata = token.functionCall(
+			data,
+			"TokenOperation: low-level call failed"
+		);
+		if (returndata.length > 0) {
+			// Return data is optional
+			require(
+				abi.decode(returndata, (bool)),
+				"TokenOperation: did not succeed"
+			);
+		}
+	}
+}
+
+interface IRouter {
+	function mint(address to, uint256 amount) external returns (bool);
+
+	function burn(address from, uint256 amount) external returns (bool);
+}
+
+//License-Identifier: GPL-3.0-or-later
+
+abstract contract PausableControl {
+	mapping(bytes32 => bool) private _pausedRoles;
+
+	bytes32 public constant PAUSE_ALL_ROLE = 0x00;
+
+	event Paused(bytes32 role);
+	event Unpaused(bytes32 role);
+
+	modifier whenNotPaused(bytes32 role) {
+		require(
+			!paused(role) && !paused(PAUSE_ALL_ROLE),
+			"PausableControl: paused"
+		);
+		_;
+	}
+
+	modifier whenPaused(bytes32 role) {
+		require(
+			paused(role) || paused(PAUSE_ALL_ROLE),
+			"PausableControl: not paused"
+		);
+		_;
+	}
+
+	function paused(bytes32 role) public view virtual returns (bool) {
+		return _pausedRoles[role];
+	}
+
+	function _pause(bytes32 role) internal virtual whenNotPaused(role) {
+		_pausedRoles[role] = true;
+		emit Paused(role);
+	}
+
+	function _unpause(bytes32 role) internal virtual whenPaused(role) {
+		_pausedRoles[role] = false;
+		emit Unpaused(role);
+	}
+}
+
+/// @dev MintBurnWrapper has the following aims:
+/// 1. wrap token which does not support interface `IRouter`
+/// 2. wrap token which wants to support multiple minters
+/// 3. add security enhancement (mint cap, pausable, etc.)
+contract GoodDollarMintBurnWrapper is
+	IRouter,
+	AccessControlEnumerableUpgradeable,
+	PausableControl,
+	DAOUpgradeableContract
+{
+	using SafeERC20Upgradeable for IERC20Upgradeable;
+
+	// access control roles
+	bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
+	bytes32 public constant BRIDGE_ROLE = keccak256("BRIDGE_ROLE");
+	bytes32 public constant ROUTER_ROLE = keccak256("ROUTER_ROLE");
+	bytes32 public constant REWARDS_ROLE = keccak256("REWARDS_ROLE");
+	bytes32 public constant GUARDIAN_ROLE = keccak256("GUARDIAN_ROLE");
+
+	// pausable control roles
+	bytes32 public constant PAUSE_MINT_ROLE = keccak256("PAUSE_MINT_ROLE");
+	bytes32 public constant PAUSE_BURN_ROLE = keccak256("PAUSE_BURN_ROLE");
+	bytes32 public constant PAUSE_ROUTER_ROLE = keccak256("PAUSE_ROUTER_ROLE");
+	bytes32 public constant PAUSE_REWARDS_ROLE = keccak256("PAUSE_REWARDS_ROLE");
+
+	struct InLimits {
+		uint256 maxIn; // single limit of each mint
+		uint256 capIn; // total limit of all mint
+		uint256 totalIn; // total minted minus burned
+		uint128 dailyCapIn; //cap per day
+		uint128 mintedToday; //total minted today
+		uint128 lastUpdate; //last update of dailyCap
+		uint128 totalRewards; // total rewards sent (sent + minted)
+		uint32 bpsPerDayIn; //basis points relative to token supply daily limit
+		uint128 lastDayReset; //last day we reset the daily limits
+	}
+
+	struct OutLimits {
+		uint256 maxOut; // single limit of each burn
+		uint256 capOut; // total limit of all burn
+		uint256 totalOut; // total burned minus minted
+		uint128 dailyCapOut; //burn cap per day
+		uint128 burnedToday; //total burned today
+		uint32 bpsPerDayOut; //basis points relative to token supply daily limit
+	}
+
+	mapping(address => InLimits) public minterSupply;
+	uint256 public totalMintCap_unused; // total mint cap, not used, kept because of upgradable storage
+	uint256 public totalMinted; // total minted amount
+
+	address public token; // the target token this contract is wrapping
+	uint256 private unused_tokenType; //kept because of upgradable storage layout, contract already deployed to Celo contains it
+
+	uint128 public currentDay; //used to reset daily minter limit
+	uint128 public updateFrequency; //how often to update the relative to supply daily limit
+	uint128 public totalMintDebt; // total outstanding rewards mint debt
+	uint128 public totalRewards; // total rewards sent (sent + minted)
+	mapping(address => OutLimits) public minterOutLimits;
+
+	event Minted(address minter, address to, uint256 amount);
+	event Burned(address minter, address to, uint256 amount);
+	event SendOrMint(
+		address rewarder,
+		address to,
+		uint256 amount,
+		uint256 sent,
+		uint256 minted,
+		uint256 outstandingMintDebt
+	);
+	event MinterSet(
+		address minter,
+		uint256 totalMintCapIn,
+		uint256 perTxCapIn,
+		uint32 bpsIn,
+		uint256 totalMintCapOut,
+		uint256 perTxCapOut,
+		uint32 bpsOut,
+		bool rewardsRole,
+		bool isUpdate
+	);
+
+	event UpdateFrequencySet(uint128 newFrequency);
+
+	modifier onlyRoles(bytes32[2] memory roles) {
+		require(
+			hasRole(roles[0], _msgSender()) || hasRole(roles[1], _msgSender()),
+			"role missing"
+		);
+		_;
+	}
+
+	function initialize(address _admin, INameService _nameService)
+		external
+		initializer
+	{
+		__AccessControlEnumerable_init();
+		setDAO(_nameService);
+		require(_admin != address(0), "zero admin address");
+		token = address(nativeToken());
+		updateFrequency = 90 days;
+		_setupRole(DEFAULT_ADMIN_ROLE, avatar);
+		_setupRole(DEFAULT_ADMIN_ROLE, _admin);
+	}
+
+	function upgrade1() external {
+		if (updateFrequency == 0) {
+			updateFrequency = 90 days;
+		}
+	}
+
+	function upgrade2() external {
+		IGoodDollar(token).renounceMinter(); //moving to mint via Controller
+	}
+
+	function decimals() external view returns (uint8) {
+		return ERC20(token).decimals();
+	}
+
+	function name() external view returns (string memory) {
+		return ERC20(token).name();
+	}
+
+	function symbol() external view returns (string memory) {
+		return ERC20(token).symbol();
+	}
+
+	function balanceOf(address account) external view returns (uint256 balance) {
+		return ERC20(token).balanceOf(account);
+	}
+
+	function owner() external view returns (address) {
+		return getRoleMember(DEFAULT_ADMIN_ROLE, 0);
+	}
+
+	/**
+	 @notice set how frequent to udpate rewarder daily limit based on bps out of total supply
+	 @param inSeconds frequency in seconds
+	 */
+	function setUpdateFrequency(uint128 inSeconds)
+		external
+		onlyRoles([GUARDIAN_ROLE, DEFAULT_ADMIN_ROLE])
+	{
+		updateFrequency = inSeconds;
+		emit UpdateFrequencySet(inSeconds);
+	}
+
+	/**
+	 * @notice pause one of the functions of the wrapper (see pause roles), only dev/guardian roles can call this
+	 * @param role which function to pause
+	 */
+	function pause(bytes32 role)
+		external
+		onlyRoles([GUARDIAN_ROLE, DEFAULT_ADMIN_ROLE])
+	{
+		_pause(role);
+	}
+
+	/**
+	 * @notice unpause one of the functions of the wrapper (see pause roles), only dev/guardian roles can call this
+	 * @param role which function to unpause
+	 */
+	function unpause(bytes32 role)
+		external
+		onlyRoles([GUARDIAN_ROLE, DEFAULT_ADMIN_ROLE])
+	{
+		_unpause(role);
+	}
+
+	/**
+	 * @notice implement the IRouter mint required for work with multichain router. This method is used by the multichain bridge to mint new tokens on sidechain
+	 * on bridge transfer from another chain. Can only be called by the ROUTER role
+	 * @param to recipient
+	 * @param amount amount to mint
+	 */
+	function mint(address to, uint256 amount)
+		external
+		onlyRole(MINTER_ROLE)
+		returns (bool)
+	{
+		_updateDailyLimitCap(msg.sender);
+		_mint(to, amount);
+		emit Minted(msg.sender, to, amount);
+		return true;
+	}
+
+	/**
+	 * @notice implement the IRouter burn required for work with multichain router. This method is used by the multichain bridge to burn tokens on sidechain
+	 * on bridge transfer to other chain. Can only be called by the ROUTER role
+	 * @param from sender - requires sender to first approve tokens to the wrapper or use transferAndCall
+	 * @param amount amount to mint
+	 */
+	function burn(address from, uint256 amount)
+		external
+		onlyRole(MINTER_ROLE)
+		whenNotPaused(PAUSE_ROUTER_ROLE)
+		returns (bool)
+	{
+		_updateDailyLimitCap(msg.sender);
+		_burn(from, amount);
+		emit Burned(msg.sender, from, amount);
+		return true;
+	}
+
+	/**
+	 * @notice helper function to transfer from sidechain to another chain without the need to first approve tokens for burn.
+	 * sender call transferAndCall(wrapperAddress,abi.encode(recipient,target chain id))
+	 * @param sender sender
+	 * @param amount sent by sender
+	 * @param data expected to be recipient + target chain abi encoded
+	 */
+	function onTokenTransfer(
+		address sender,
+		uint256 amount,
+		bytes memory data
+	) external returns (bool) {
+		require(msg.sender == token); //verify this was called from a token transfer
+		(address bindaddr, uint256 chainId) = abi.decode(data, (address, uint256));
+		require(chainId != 0, "zero chainId");
+		bindaddr = bindaddr != address(0) ? bindaddr : sender;
+
+		IMultichainRouter(nameService.getAddress("MULTICHAIN_ROUTER")).anySwapOut(
+			address(this),
+			bindaddr,
+			amount,
+			chainId
+		);
+		return true;
+	}
+
+	/**
+	 * @notice allow REWARDS_ROLE to send existing funds in balance or mint new G$ on sidechain to recipient.
+	 * @param to recipient
+	 * @param amount amount to send or mint. if not enough balance the rest will be minted up to the rewarder dailyLimit
+	 */
+	function sendOrMint(address to, uint256 amount)
+		external
+		onlyRole(REWARDS_ROLE)
+		whenNotPaused(PAUSE_REWARDS_ROLE)
+		returns (uint256 totalSent)
+	{
+		_updateDailyLimitCap(msg.sender);
+
+		uint256 maxMintToday = minterSupply[msg.sender].dailyCapIn == 0
+			? amount
+			: minterSupply[msg.sender].dailyCapIn -
+				minterSupply[msg.sender].mintedToday;
+
+		//calcualte how much to send and mint
+		uint256 toSend = Math.min(
+			IERC20Upgradeable(token).balanceOf(address(this)),
+			amount
+		);
+		uint256 toMint = Math.min(amount - toSend, maxMintToday);
+		// console.log("sendOrMint %s %s %s", toMint, toSend, maxMintToday);
+		totalSent = toSend + toMint;
+		minterSupply[msg.sender].totalRewards += uint128(totalSent);
+		totalRewards += uint128(totalSent);
+		totalMintDebt += uint128(toMint);
+		if (toMint > 0) _mint(to, toMint);
+
+		if (toSend > 0) {
+			IERC20Upgradeable(token).safeTransfer(to, toSend);
+		}
+
+		if (toMint == 0) {
+			//if we are not minting then we might have positive balance, check if we can cover out debt and burn some
+			//from balance in exchange for what we minted in the past ie mintDebt
+			_balanceDebt();
+		}
+
+		emit SendOrMint(_msgSender(), to, amount, toSend, toMint, totalMintDebt);
+	}
+
+	/**
+	 * @notice add minter or rewards role
+	 * @param minter address of minter
+	 * @param globalLimitIn minter global limit
+	 * @param perTxLimitIn minter per tx limit
+	 * @param bpsPerDayIn limit for rewards role in bps relative to G$ total supply
+	 * @param globalLimitOut minter global limit
+	 * @param perTxLimitOut minter per tx limit
+	 * @param bpsPerDayOut limit for rewards role in bps relative to G$ total supply
+	 * @param withRewardsRole should also grant REWARDS_ROLE to minter
+	 */
+	function addMinter(
+		address minter,
+		uint256 globalLimitIn,
+		uint256 perTxLimitIn,
+		uint32 bpsPerDayIn,
+		uint256 globalLimitOut,
+		uint256 perTxLimitOut,
+		uint32 bpsPerDayOut,
+		bool withRewardsRole
+	) external onlyRole(DEFAULT_ADMIN_ROLE) {
+		if (withRewardsRole) {
+			grantRole(REWARDS_ROLE, minter);
+			revokeRole(MINTER_ROLE, minter);
+		} else {
+			grantRole(MINTER_ROLE, minter);
+			revokeRole(REWARDS_ROLE, minter);
+		}
+		_setMinterCaps(
+			minter,
+			globalLimitIn,
+			perTxLimitIn,
+			bpsPerDayIn,
+			globalLimitOut,
+			perTxLimitOut,
+			bpsPerDayOut
+		);
+	}
+
+	/**
+	 * @notice update minter or rewards role limits
+	 * @param minter address of minter
+	 * @param globalLimitIn minter global limit
+	 * @param perTxLimitIn minter per tx limit
+	 * @param bpsPerDayIn limit for rewards role in bps relative to G$ total supply
+	 * @param globalLimitOut minter global limit
+	 * @param perTxLimitOut minter per tx limit
+	 * @param bpsPerDayOut limit for rewards role in bps relative to G$ total supply
+	 */
+	function setMinterCaps(
+		address minter,
+		uint256 globalLimitIn,
+		uint256 perTxLimitIn,
+		uint32 bpsPerDayIn,
+		uint256 globalLimitOut,
+		uint256 perTxLimitOut,
+		uint32 bpsPerDayOut
+	) external onlyRoles([GUARDIAN_ROLE, DEFAULT_ADMIN_ROLE]) {
+		_setMinterCaps(
+			minter,
+			globalLimitIn,
+			perTxLimitIn,
+			bpsPerDayIn,
+			globalLimitOut,
+			perTxLimitOut,
+			bpsPerDayOut
+		);
+	}
+
+	/**
+	 * @notice update minter or rewards role limits
+	 * @param minter address of minter
+	 * @param globalLimitIn minter global limit
+	 * @param perTxLimitIn minter per tx limit
+	 * @param bpsPerDayIn limit for rewards role in bps relative to G$ total supply
+	 * @param globalLimitOut minter global limit
+	 * @param perTxLimitOut minter per tx limit
+	 * @param bpsPerDayOut limit for rewards role in bps relative to G$ total supply
+	 */
+	function _setMinterCaps(
+		address minter,
+		uint256 globalLimitIn,
+		uint256 perTxLimitIn,
+		uint32 bpsPerDayIn,
+		uint256 globalLimitOut,
+		uint256 perTxLimitOut,
+		uint32 bpsPerDayOut
+	) internal {
+		InLimits storage m = minterSupply[minter];
+		OutLimits storage o = minterOutLimits[minter];
+		bool isUpdate = m.lastUpdate > 0;
+		bool withRewardsRole = hasRole(REWARDS_ROLE, minter);
+		m.capIn = globalLimitIn;
+		m.maxIn = perTxLimitIn;
+		m.bpsPerDayIn = bpsPerDayIn;
+		m.lastUpdate = uint128(block.timestamp);
+		m.dailyCapIn =
+			uint128(IERC20Upgradeable(token).totalSupply() * bpsPerDayIn) /
+			10000;
+		o.dailyCapOut =
+			uint128(IERC20Upgradeable(token).totalSupply() * bpsPerDayOut) /
+			10000;
+		o.capOut = globalLimitOut;
+		o.maxOut = perTxLimitOut;
+		o.bpsPerDayOut = bpsPerDayOut;
+
+		emit MinterSet(
+			minter,
+			globalLimitIn,
+			perTxLimitIn,
+			bpsPerDayIn,
+			globalLimitOut,
+			perTxLimitOut,
+			bpsPerDayOut,
+			withRewardsRole,
+			isUpdate
+		);
+	}
+
+	/**
+	 * @notice helper to update the current day, used to reset rewards role daily limit
+	 */
+	function _updateCurrentDay() internal {
+		currentDay = uint128(block.timestamp / 1 days);
+	}
+
+	/**
+	 * @notice helper for mint/sendOrMint action
+	 */
+	function _mint(address to, uint256 amount)
+		internal
+		whenNotPaused(PAUSE_MINT_ROLE)
+	{
+		require(to != address(this), "mint to self");
+
+		require(
+			minterSupply[msg.sender].maxIn == 0 ||
+				amount <= minterSupply[msg.sender].maxIn,
+			"minter max exceeded"
+		);
+		require(
+			minterSupply[msg.sender].dailyCapIn == 0 ||
+				minterSupply[msg.sender].dailyCapIn >=
+				(minterSupply[msg.sender].mintedToday + amount),
+			"minter daily cap exceeded"
+		);
+
+		minterSupply[msg.sender].mintedToday += uint128(amount);
+		minterSupply[msg.sender].totalIn += amount;
+		require(
+			minterSupply[msg.sender].capIn == 0 ||
+				minterSupply[msg.sender].totalIn <= minterSupply[msg.sender].capIn,
+			"minter cap exceeded"
+		);
+
+		totalMinted += amount;
+
+		if (minterOutLimits[msg.sender].totalOut >= amount) {
+			minterOutLimits[msg.sender].totalOut -= amount;
+		} else {
+			minterOutLimits[msg.sender].totalOut = 0;
+		}
+
+		bool ok = dao.mintTokens(amount, to, avatar);
+		require(ok, "mint failed");
+	}
+
+	/**
+	 * @notice helper for burn action
+	 */
+	function _burn(address from, uint256 amount)
+		internal
+		whenNotPaused(PAUSE_BURN_ROLE)
+	{
+		require(
+			minterOutLimits[msg.sender].maxOut == 0 ||
+				amount <= minterOutLimits[msg.sender].maxOut,
+			"minter burn max exceeded"
+		);
+		require(
+			minterOutLimits[msg.sender].dailyCapOut == 0 ||
+				minterOutLimits[msg.sender].dailyCapOut >=
+				(minterOutLimits[msg.sender].burnedToday + amount),
+			"minter burn daily cap exceeded"
+		);
+
+		minterOutLimits[msg.sender].burnedToday += uint128(amount);
+		minterOutLimits[msg.sender].totalOut += amount;
+		require(
+			minterOutLimits[msg.sender].capOut == 0 ||
+				minterOutLimits[msg.sender].totalOut <=
+				minterOutLimits[msg.sender].capOut,
+			"minter cap exceeded"
+		);
+
+		//update stats correctly, but dont fail if it tries to transfer tokens minted elsewhere as long as we burn some
+		if (totalMinted >= amount) {
+			totalMinted -= amount;
+		} else {
+			totalMinted = 0;
+		}
+
+		if (minterSupply[msg.sender].totalIn >= amount) {
+			minterSupply[msg.sender].totalIn -= amount;
+		} else {
+			minterSupply[msg.sender].totalIn = 0;
+		}
+
+		//handle onTokenTransfer (ERC677), assume tokens has been transfered
+		if (from == address(this)) {
+			TokenOperation.safeBurnSelf(token, amount);
+		} else {
+			TokenOperation.safeBurnFrom(token, from, amount);
+		}
+	}
+
+	/**
+	 * @notice helper for sendOrMint action to burn from balance to cover minting debt
+	 */
+	function _balanceDebt() internal {
+		uint256 toBurn = Math.min(
+			totalMintDebt,
+			IERC20Upgradeable(token).balanceOf(address(this))
+		);
+
+		if (toBurn > 0) {
+			totalMintDebt -= uint128(toBurn);
+			totalMinted -= toBurn;
+			ERC20(token).burn(toBurn); //from DAOUpgradableContract -> Interfaces
+		}
+	}
+
+	/**
+	 * @notice helper for sendOrMint action to update the rewarder daily limit if updateFrequency passed
+	 */
+	function _updateDailyLimitCap(address minter) internal {
+		uint256 secondsPassed = block.timestamp - minterSupply[minter].lastUpdate;
+		uint256 totalSupply = IERC20Upgradeable(token).totalSupply();
+		if (secondsPassed >= updateFrequency) {
+			minterSupply[minter].dailyCapIn = uint128(
+				(totalSupply * minterSupply[minter].bpsPerDayIn) / 10000
+			);
+			minterOutLimits[minter].dailyCapOut = uint128(
+				(totalSupply * minterOutLimits[minter].bpsPerDayOut) / 10000
+			);
+			minterSupply[minter].lastUpdate = uint128(block.timestamp);
+			// console.log(
+			// 	"secondsPassed %s %s %s",
+			// 	secondsPassed,
+			// 	minter.dailyCap,
+			// 	minter.lastUpdate
+			// );
+		}
+
+		//check if daily limit needs reset
+		_updateCurrentDay();
+		if (currentDay != minterSupply[minter].lastDayReset) {
+			minterSupply[minter].mintedToday = 0;
+			minterOutLimits[minter].burnedToday = 0;
+			minterSupply[minter].lastDayReset = currentDay;
+		}
+	}
+}

package/contracts/utils/MultichainBridgeHelper.sol

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: MIT
+/**
+ ethereum only helper to use transferAndCall for single tx (without user approve) to bridge over multichain
+ */
+
+pragma solidity ^0.8;
+
+import "../Interfaces.sol";
+
+contract MultichainBridgeHelper {
+	IMultichainRouter public constant multiChainBridge =
+		IMultichainRouter(0x765277EebeCA2e31912C9946eAe1021199B39C61);
+	address public constant anyGoodDollar =
+		address(0xD17652350Cfd2A37bA2f947C910987a3B1A1c60d);
+	address public constant goodDollar =
+		address(0x67C5870b4A41D4Ebef24d2456547A03F1f3e094B);
+
+	function onTokenTransfer(
+		address sender,
+		uint256 amount,
+		bytes calldata data
+	) external returns (bool) {
+		require(msg.sender == goodDollar); //verify this was called from a token transfer
+		(address bindaddr, uint256 chainId) = abi.decode(data, (address, uint256));
+		require(chainId != 0, "zero chainId");
+		bindaddr = bindaddr != address(0) ? bindaddr : sender;
+
+		ERC20(goodDollar).approve(address(multiChainBridge), amount);
+
+		multiChainBridge.anySwapOutUnderlying(
+			anyGoodDollar,
+			bindaddr,
+			amount,
+			chainId
+		);
+
+		return true;
+	}
+}

package/hardhat.config.ts

@@ -79,7 +79,7 @@ const hhconfig: HardhatUserConfig = {
       accounts: {
         accountsBalance: "10000000000000000000000000"
       },
-      initialDate: "2021-12-01"
+      initialDate: "2021-12-01" //required for DAO tests like guardian
     },
     test: {
       allowUnlimitedContractSize: true,
@@ -292,7 +292,9 @@ task(
 task("cleanflat", "Cleans multiple SPDX and Pragma from flattened file")
   .addPositionalParam("file", "flattened sol file")
   .setAction(async ({ file }, { run }) => {
-    let flattened = readFileSync(file).toString();
+    let flattened = await run("flatten:get-flattened-sources", {
+      files: [file]
+    });
 
     // Remove every line started with "// SPDX-License-Identifier:"
     flattened = flattened.replace(
@@ -319,5 +321,5 @@ task("cleanflat", "Cleans multiple SPDX and Pragma from flattened file")
     );
 
     flattened = flattened.trim();
-    writeFileSync(file, flattened);
+    writeFileSync("flat.sol", flattened);
   });