@gooddollar/goodprotocol 1.0.30 → 2.0.1

package/contracts/mocks/cDAINonMintableMock.sol

@@ -14,7 +14,7 @@ contract cDAINonMintableMock is DSMath, ERC20PresetMinterPauserUpgradeable {
 
 	uint256 exchangeRate = uint256(100e28).div(99);
 
-	constructor(ERC20PresetMinterPauserUpgradeable _dai) {
+	constructor(ERC20PresetMinterPauserUpgradeable _dai) initializer {
 		__ERC20PresetMinterPauser_init("Compound DAI", "cDAI");
 		dai = _dai;
 	}
@@ -22,19 +22,15 @@ contract cDAINonMintableMock is DSMath, ERC20PresetMinterPauserUpgradeable {
 	function mint(uint256 daiAmount) public returns (uint256) {
 		dai.transferFrom(msg.sender, address(this), daiAmount);
 		//mul by 1e10 to match to precision of 1e28 of the exchange rate
-		_mint(
-			msg.sender,
-			rdiv(daiAmount * 1e10, exchangeRateStored()).div(1e19)
-		); //div to reduce precision from RAY 1e27 to 1e8 precision of cDAI
+		_mint(msg.sender, rdiv(daiAmount * 1e10, exchangeRateStored()).div(1e19)); //div to reduce precision from RAY 1e27 to 1e8 precision of cDAI
 		return 1;
 	}
 
 	function redeem(uint256 cdaiAmount) public returns (uint256) {
-		uint256 daiAmount =
-			rmul(
-				cdaiAmount * 1e10, //bring cdai 8 decimals to rdai precision
-				exchangeRateStored().div(10)
-			);
+		uint256 daiAmount = rmul(
+			cdaiAmount * 1e10, //bring cdai 8 decimals to rdai precision
+			exchangeRateStored().div(10)
+		);
 		//div to reduce precision from 1e28 of exchange rate to 1e27 that DSMath works on
 		// uint256 daiAmount = cdaiAmount.mul(100).div(99);
 		_burn(msg.sender, cdaiAmount);
@@ -43,8 +39,7 @@ contract cDAINonMintableMock is DSMath, ERC20PresetMinterPauserUpgradeable {
 	}
 
 	function redeemUnderlying(uint256 daiAmount) public returns (uint256) {
-		uint256 cdaiAmount =
-			rdiv(daiAmount * 1e10, exchangeRateStored()).div(1e19);
+		uint256 cdaiAmount = rdiv(daiAmount * 1e10, exchangeRateStored()).div(1e19);
 		_burn(msg.sender, cdaiAmount);
 		dai.transfer(msg.sender, daiAmount);
 		return 0;

package/contracts/mocks/cDecimalsMock.sol

@@ -15,7 +15,7 @@ contract cDecimalsMock is DSMath, ERC20PresetMinterPauserUpgradeable {
 	uint256 exchangeRate = 20000000000000000; // initial exchange rate 0.02 from original cToken
 	uint256 mantissa = 18;
 
-	constructor(ERC20PresetMinterPauserUpgradeable _edt) {
+	constructor(ERC20PresetMinterPauserUpgradeable _edt) initializer {
 		__ERC20PresetMinterPauser_init("Compound EDT", "cEDT");
 		edt = _edt;
 		mantissa = 18 + _edt.decimals() - 8;

package/contracts/mocks/cSDTMock.sol

@@ -14,7 +14,7 @@ contract cSDTMock is DSMath, ERC20PresetMinterPauserUpgradeable {
 	uint256 exchangeRate = 2000000000000000000000000; // initial exchange rate 0.02 from original cToken
 	uint256 mantissa = 26;
 
-	constructor(ERC20PresetMinterPauserUpgradeable _edt) {
+	constructor(ERC20PresetMinterPauserUpgradeable _edt) initializer {
 		__ERC20PresetMinterPauser_init("Compound SDT", "cSDT");
 		edt = _edt;
 	}
@@ -38,8 +38,8 @@ contract cSDTMock is DSMath, ERC20PresetMinterPauserUpgradeable {
 	}
 
 	function redeemUnderlying(uint256 edtAmount) public returns (uint256) {
-		uint256 cEdtAmount =
-			((edtAmount / 1e8) * (10**mantissa)) / exchangeRateStored(); // based on https://compound.finance/docs#protocol-math
+		uint256 cEdtAmount = ((edtAmount / 1e8) * (10**mantissa)) /
+			exchangeRateStored(); // based on https://compound.finance/docs#protocol-math
 		_burn(msg.sender, cEdtAmount);
 		edt.transfer(msg.sender, edtAmount);
 		return 0;

package/contracts/mocks/cUSDCMock.sol

@@ -15,7 +15,7 @@ contract cUSDCMock is DSMath, ERC20PresetMinterPauserUpgradeable {
 	uint256 exchangeRate = 200000000000000; // initial exchange rate 0.02 from original cToken
 	uint256 mantissa = 16;
 
-	constructor(ERC20PresetMinterPauserUpgradeable _usdc) {
+	constructor(ERC20PresetMinterPauserUpgradeable _usdc) initializer {
 		__ERC20PresetMinterPauser_init("Compound USDC", "cUSDC");
 		usdc = _usdc;
 	}
@@ -31,8 +31,8 @@ contract cUSDCMock is DSMath, ERC20PresetMinterPauserUpgradeable {
 	}
 
 	function redeem(uint256 cUsdcAmount) public returns (uint256) {
-		uint256 usdcAmount =
-			((cUsdcAmount / 1e2) * exchangeRateStored()) / 10**mantissa; // based on https://compound.finance/docs#protocol-math
+		uint256 usdcAmount = ((cUsdcAmount / 1e2) * exchangeRateStored()) /
+			10**mantissa; // based on https://compound.finance/docs#protocol-math
 
 		_burn(msg.sender, cUsdcAmount);
 		usdc.transfer(msg.sender, usdcAmount);
@@ -40,8 +40,8 @@ contract cUSDCMock is DSMath, ERC20PresetMinterPauserUpgradeable {
 	}
 
 	function redeemUnderlying(uint256 usdcAmount) public returns (uint256) {
-		uint256 cUsdcAmount =
-			(usdcAmount * 1e2 * (10**mantissa)) / exchangeRateStored(); // based on https://compound.finance/docs#protocol-math
+		uint256 cUsdcAmount = (usdcAmount * 1e2 * (10**mantissa)) /
+			exchangeRateStored(); // based on https://compound.finance/docs#protocol-math
 		_burn(msg.sender, cUsdcAmount);
 		usdc.transfer(msg.sender, usdcAmount);
 		return 0;

package/contracts/reserve/DistributionHelper.sol

@@ -8,7 +8,7 @@ import "@openzeppelin/contracts/utils/math/Math.sol";
 
 import "../utils/DAOUpgradeableContract.sol";
 
-import "hardhat/console.sol";
+// import "hardhat/console.sol";
 
 /***
  * @dev DistributionHelper receives funds and distributes them to recipients

package/contracts/reserve/GoodReserveCDai.sol

@@ -13,7 +13,7 @@ import "../Interfaces.sol";
 import "./GoodMarketMaker.sol";
 import "./DistributionHelper.sol";
 
-import "hardhat/console.sol";
+// import "hardhat/console.sol";
 
 interface ContributionCalc {
 	function calculateContribution(

package/contracts/staking/FuseStakingV3.sol

@@ -98,12 +98,27 @@ contract FuseStakingV3 is Initializable, OwnableUpgradeable {
 	/**
 	 * @dev initialize
 	 */
-	function initialize() public initializer {
+	function initialize(address _uniswap, address _gd) public initializer {
 		__Ownable_init_unchained();
-		consensus = IConsensus(
-			address(0x3014ca10b91cb3D0AD85fEf7A3Cb95BCAc9c0f79)
-		);
+		consensus = IConsensus(address(0x3014ca10b91cb3D0AD85fEf7A3Cb95BCAc9c0f79));
 		validators.push(address(0xcb876A393F05a6677a8a029f1C6D7603B416C0A6));
+		stakeBackRatio = 33333; //%33
+		communityPoolRatio = 33333; //%33
+		maxSlippageRatio = 3000; //3%
+		keeperFeeRatio = 30; //0.03%
+		RATIO_BASE = 100000; //100%
+		uniswap = Uniswap(
+			_uniswap == address(0)
+				? 0xE3F85aAd0c8DD7337427B9dF5d0fB741d65EEEB5
+				: _uniswap
+		);
+
+		GD = IGoodDollar(_gd);
+		uniswapFactory = UniswapFactory(uniswap.factory());
+		uniswapPair = UniswapPair(uniswapFactory.getPair(uniswap.WETH(), _gd));
+		pegSwap = PegSwap(0xdfE016328E7BcD6FA06614fE3AF3877E931F7e0a);
+		USDC = address(0x620fd5fa44BE6af63715Ef4E65DDFA0387aD13F5);
+		fUSD = address(0x249BE57637D8B013Ad64785404b24aeBaE9B098B);
 	}
 
 	modifier notPaused() {
@@ -116,79 +131,13 @@ contract FuseStakingV3 is Initializable, OwnableUpgradeable {
 		_;
 	}
 
-	function upgrade0() external {
-		if (RATIO_BASE == 0) {
-			stakeBackRatio = 33333; //%33
-			communityPoolRatio = 33333; //%33
-			maxSlippageRatio = 3000; //3%
-			keeperFeeRatio = 30; //0.03%
-			RATIO_BASE = 100000; //100%
-		}
-	}
-
-	function upgrade1(
-		address _gd,
-		address _ubischeme,
-		address _uniswap
-	) external {
-		if (address(uniswapPair) == address(0)) {
-			uniswap = Uniswap(
-				_uniswap == address(0)
-					? 0xFB76e9E7d88E308aB530330eD90e84a952570319
-					: _uniswap
-			);
-			GD = IGoodDollar(_gd);
-			ubischeme = UBIScheme(_ubischeme);
-
-			uniswapFactory = UniswapFactory(uniswap.factory());
-			uniswapPair = UniswapPair(
-				uniswapFactory.getPair(uniswap.WETH(), _gd)
-			);
-		}
-	}
-
-	function upgrade2() external {
-		if (USDC == address(0)) {
-			USDC = address(0x620fd5fa44BE6af63715Ef4E65DDFA0387aD13F5);
-			fUSD = address(0x249BE57637D8B013Ad64785404b24aeBaE9B098B);
-		}
-	}
-
-	function upgrade3() external {
-		if (guardian == address(0)) {
-			paused = true;
-			guardian = address(0x5128E3C1f8846724cc1007Af9b4189713922E4BB);
-		}
-	}
-
-	function upgrade4() external {
-		if (address(pegSwap) == address(0)) {
-			pegSwap = PegSwap(0xdfE016328E7BcD6FA06614fE3AF3877E931F7e0a);
-			paused = false;
-		}
-	}
-
-	function upgrade5() external {
+	function approve() external {
 		cERC20(fUSD).approve(address(pegSwap), type(uint256).max);
 		cERC20(USDC).approve(address(uniswap), type(uint256).max);
 	}
 
-	function upgrade6() external {
-		//switch to voltage
-		uniswap = Uniswap(0xE3F85aAd0c8DD7337427B9dF5d0fB741d65EEEB5);
-		uniswapFactory = UniswapFactory(uniswap.factory());
-		uniswapPair = UniswapPair(
-			uniswapFactory.getPair(uniswap.WETH(), address(GD))
-		);
-	}
-
-	function setContracts(address _gd, address _ubischeme) public onlyOwner {
-		if (_gd != address(0)) {
-			GD = IGoodDollar(_gd);
-		}
-		if (_ubischeme != address(0)) {
-			ubischeme = UBIScheme(_ubischeme);
-		}
+	function setUBIScheme(address _ubischeme) public onlyOwner {
+		ubischeme = UBIScheme(_ubischeme);
 	}
 
 	function stake() public payable returns (bool) {
@@ -230,17 +179,15 @@ contract FuseStakingV3 is Initializable, OwnableUpgradeable {
 
 	function withdrawAll() public onlyGuardian {
 		for (uint256 i = 0; i < validators.length; i++) {
-			uint256 cur = consensus.delegatedAmount(
-				address(this),
-				validators[i]
-			);
+			uint256 cur = consensus.delegatedAmount(address(this), validators[i]);
 			if (cur == 0) continue;
 			undelegateWithCatch(validators[i], cur);
 		}
 		uint256 effectiveBalance = balance(); //use only undelegated funds
 		pendingFuseEarnings = 0;
 		if (effectiveBalance > 0) {
-			msg.sender.call{ value: effectiveBalance }("");
+			(bool ok, ) = msg.sender.call{ value: effectiveBalance }("");
+			require(ok, "transfer failed");
 		}
 	}
 
@@ -254,10 +201,7 @@ contract FuseStakingV3 is Initializable, OwnableUpgradeable {
 		);
 		uint256 perValidator = _value.div(validators.length);
 		for (uint256 i = 0; i < validators.length; i++) {
-			uint256 cur = consensus.delegatedAmount(
-				address(this),
-				validators[i]
-			);
+			uint256 cur = consensus.delegatedAmount(address(this), validators[i]);
 			if (cur == 0) continue;
 			if (cur <= perValidator) {
 				undelegateWithCatch(validators[i], cur);
@@ -296,10 +240,7 @@ contract FuseStakingV3 is Initializable, OwnableUpgradeable {
 		uint256 perValidator = (totalDelegated() + _value) / validators.length;
 		uint256 left = _value;
 		for (uint256 i = 0; i < validators.length && left > 0; i++) {
-			uint256 cur = consensus.delegatedAmount(
-				address(this),
-				validators[i]
-			);
+			uint256 cur = consensus.delegatedAmount(address(this), validators[i]);
 
 			if (cur < perValidator) {
 				uint256 toDelegate = perValidator.sub(cur);
@@ -319,20 +260,14 @@ contract FuseStakingV3 is Initializable, OwnableUpgradeable {
 	function totalDelegated() public view returns (uint256) {
 		uint256 total = 0;
 		for (uint256 i = 0; i < validators.length; i++) {
-			uint256 cur = consensus.delegatedAmount(
-				address(this),
-				validators[i]
-			);
+			uint256 cur = consensus.delegatedAmount(address(this), validators[i]);
 			total += cur;
 		}
 		return total;
 	}
 
 	function removeValidator(address _validator) public onlyOwner {
-		uint256 delegated = consensus.delegatedAmount(
-			address(this),
-			_validator
-		);
+		uint256 delegated = consensus.delegatedAmount(address(this), _validator);
 		if (delegated > 0) {
 			uint256 prevBalance = balance();
 			undelegateWithCatch(_validator, delegated);
@@ -356,18 +291,13 @@ contract FuseStakingV3 is Initializable, OwnableUpgradeable {
 
 	function collectUBIInterest() public notPaused {
 		uint256 curDay = ubischeme.currentDay();
-		require(
-			curDay != lastDayCollected,
-			"can collect only once in a ubi cycle"
-		);
+		require(curDay != lastDayCollected, "can collect only once in a ubi cycle");
 
 		uint256 earnings = balance() - pendingFuseEarnings;
 		require(pendingFuseEarnings + earnings > 0, "no earnings to collect");
 
 		lastDayCollected = curDay;
-		uint256 fuseUBI = earnings.mul(RATIO_BASE - stakeBackRatio).div(
-			RATIO_BASE
-		);
+		uint256 fuseUBI = earnings.mul(RATIO_BASE - stakeBackRatio).div(RATIO_BASE);
 		uint256 stakeBack = earnings - fuseUBI;
 
 		uint256[] memory fuseswapResult = _buyGD(fuseUBI + pendingFuseEarnings); //buy GD with X% of earnings
@@ -378,9 +308,9 @@ contract FuseStakingV3 is Initializable, OwnableUpgradeable {
 		uint256 keeperFee = gdBought.mul(keeperFeeRatio).div(RATIO_BASE);
 		if (keeperFee > 0) GD.transfer(msg.sender, keeperFee);
 		gdBought -= keeperFee;
-		uint256 communityPoolContribution = gdBought
-			.mul(communityPoolRatio)
-			.div(RATIO_BASE); //subtract fee // * ommunityPoolRatio // = G$ after fee * communityPoolRatio%
+		uint256 communityPoolContribution = gdBought.mul(communityPoolRatio).div(
+			RATIO_BASE
+		); //subtract fee // * ommunityPoolRatio // = G$ after fee * communityPoolRatio%
 
 		uint256 ubiAfterFeeAndPool = gdBought.sub(communityPoolContribution);
 
@@ -407,13 +337,10 @@ contract FuseStakingV3 is Initializable, OwnableUpgradeable {
 	function _buyGD(uint256 _value) internal returns (uint256[] memory) {
 		//buy from uniwasp
 		require(_value > 0, "buy value should be > 0");
-		(uint256 maxFuse, uint256 fuseGDOut) = calcMaxFuseWithPriceImpact(
+		(uint256 maxFuse, uint256 fuseGDOut) = calcMaxFuseWithPriceImpact(_value);
+		(uint256 maxFuseUSDC, uint256 usdcGDOut) = calcMaxFuseUSDCWithPriceImpact(
 			_value
 		);
-		(
-			uint256 maxFuseUSDC,
-			uint256 usdcGDOut
-		) = calcMaxFuseUSDCWithPriceImpact(_value);
 		address[] memory path;
 		if (maxFuse >= maxFuseUSDC) {
 			path = new address[](2);
@@ -471,9 +398,12 @@ contract FuseStakingV3 is Initializable, OwnableUpgradeable {
 		address[] memory path = new address[](2);
 		path[1] = fUSD;
 		path[0] = uniswap.WETH();
-		uint256[] memory result = uniswap.swapExactETHForTokens{
-			value: maxFuse
-		}((tokenOut * 95) / 100, path, address(this), block.timestamp);
+		uint256[] memory result = uniswap.swapExactETHForTokens{ value: maxFuse }(
+			(tokenOut * 95) / 100,
+			path,
+			address(this),
+			block.timestamp
+		);
 
 		pegSwap.swap(result[1], fUSD, USDC);
 		usedFuse = result[0];

package/contracts/staking/GoodFundManager.sol

@@ -194,10 +194,10 @@ contract GoodFundManager is DAOUpgradeableContract, DSMath {
 			}
 		}
 
-		if (exist && (_isBlackListed || _rewardsPerBlock == 0)) {
+		if (exist && _isBlackListed) {
 			activeContracts[i] = activeContracts[activeContracts.length - 1];
 			activeContracts.pop();
-		} else if (!exist && !(_isBlackListed || _rewardsPerBlock == 0)) {
+		} else if (!exist && !_isBlackListed) {
 			activeContracts.push(_stakingAddress);
 		}
 		emit StakingRewardSet(

package/contracts/token/ERC20PresetMinterPauserUpgradeable.sol

@@ -0,0 +1,140 @@
+// SPDX-License-Identifier: MIT
+// we use a custom file and not openzeppelin directly since the DAOStack Controller expects `mint` to return bool
+// we also add the erc20 permit
+
+pragma solidity ^0.8.0;
+
+import "@openzeppelin/contracts-upgradeable/token/ERC20/extensions/draft-ERC20PermitUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/token/ERC20/extensions/ERC20BurnableUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/token/ERC20/extensions/ERC20PausableUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/access/AccessControlEnumerableUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+
+/**
+ * @dev {ERC20} token, including:
+ *
+ *  - ability for holders to burn (destroy) their tokens
+ *  - a minter role that allows for token minting (creation)
+ *  - a pauser role that allows to stop all token transfers
+ *
+ * This contract uses {AccessControl} to lock permissioned functions using the
+ * different roles - head to its documentation for details.
+ *
+ * The account that deploys the contract will be granted the minter and pauser
+ * roles, as well as the default admin role, which will let it grant both minter
+ * and pauser roles to other accounts.
+ */
+contract ERC20PresetMinterPauserUpgradeable is
+	Initializable,
+	ContextUpgradeable,
+	AccessControlEnumerableUpgradeable,
+	ERC20PermitUpgradeable,
+	ERC20BurnableUpgradeable,
+	ERC20PausableUpgradeable
+{
+	function initialize(string memory name, string memory symbol)
+		public
+		virtual
+		initializer
+	{
+		__ERC20PresetMinterPauser_init(name, symbol);
+	}
+
+	bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
+	bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
+
+	/**
+	 * @dev Grants `DEFAULT_ADMIN_ROLE`, `MINTER_ROLE` and `PAUSER_ROLE` to the
+	 * account that deploys the contract.
+	 *
+	 * See {ERC20-constructor}.
+	 */
+	function __ERC20PresetMinterPauser_init(
+		string memory name,
+		string memory symbol
+	) internal initializer {
+		__Context_init_unchained();
+		__ERC165_init_unchained();
+		__AccessControl_init_unchained();
+		__AccessControlEnumerable_init_unchained();
+		__ERC20_init_unchained(name, symbol);
+		__ERC20Burnable_init_unchained();
+		__Pausable_init_unchained();
+		__ERC20Pausable_init_unchained();
+		__ERC20PresetMinterPauser_init_unchained(name, symbol);
+		__ERC20Permit_init_unchained(name);
+	}
+
+	function __ERC20PresetMinterPauser_init_unchained(
+		string memory name,
+		string memory symbol
+	) internal initializer {
+		_setupRole(DEFAULT_ADMIN_ROLE, _msgSender());
+
+		_setupRole(MINTER_ROLE, _msgSender());
+		_setupRole(PAUSER_ROLE, _msgSender());
+	}
+
+	/**
+	 * @dev Creates `amount` new tokens for `to`.
+	 *
+	 * See {ERC20-_mint}.
+	 *
+	 * Requirements:
+	 *
+	 * - the caller must have the `MINTER_ROLE`.
+	 */
+	function mint(address to, uint256 amount) public virtual returns (bool) {
+		require(
+			hasRole(MINTER_ROLE, _msgSender()),
+			"ERC20PresetMinterPauser: must have minter role to mint"
+		);
+		_mint(to, amount);
+		return true;
+	}
+
+	/**
+	 * @dev Pauses all token transfers.
+	 *
+	 * See {ERC20Pausable} and {Pausable-_pause}.
+	 *
+	 * Requirements:
+	 *
+	 * - the caller must have the `PAUSER_ROLE`.
+	 */
+	function pause() public virtual {
+		require(
+			hasRole(PAUSER_ROLE, _msgSender()),
+			"ERC20PresetMinterPauser: must have pauser role to pause"
+		);
+		_pause();
+	}
+
+	/**
+	 * @dev Unpauses all token transfers.
+	 *
+	 * See {ERC20Pausable} and {Pausable-_unpause}.
+	 *
+	 * Requirements:
+	 *
+	 * - the caller must have the `PAUSER_ROLE`.
+	 */
+	function unpause() public virtual {
+		require(
+			hasRole(PAUSER_ROLE, _msgSender()),
+			"ERC20PresetMinterPauser: must have pauser role to unpause"
+		);
+		_unpause();
+	}
+
+	function _beforeTokenTransfer(
+		address from,
+		address to,
+		uint256 amount
+	) internal virtual override(ERC20Upgradeable, ERC20PausableUpgradeable) {
+		super._beforeTokenTransfer(from, to, amount);
+	}
+
+	uint256[50] private __gap;
+}

package/contracts/token/ERC677.sol

@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8;
+
+/* @title ERC677Receiver interface
+ */
+interface ERC677Receiver {
+	function onTokenTransfer(
+		address _from,
+		uint256 _value,
+		bytes calldata _data
+	) external returns (bool);
+}
+
+abstract contract ERC677 {
+	event Transfer(
+		address indexed from,
+		address indexed to,
+		uint256 value,
+		bytes data
+	);
+
+	function transfer(address to, uint256 value) public virtual returns (bool);
+
+	/**
+	 * @dev transfer token to a contract address with additional data if the recipient is a contact.
+	 * @param _to The address to transfer to.
+	 * @param _value The amount to be transferred.
+	 * @param _data The extra data to be passed to the receiving contract.
+	 * @return true if transfer is successful
+	 */
+	function _transferAndCall(
+		address _to,
+		uint256 _value,
+		bytes memory _data
+	) internal returns (bool) {
+		bool res = transfer(_to, _value);
+		emit Transfer(msg.sender, _to, _value, _data);
+
+		if (isContract(_to)) {
+			require(contractFallback(_to, _value, _data), "Contract fallback failed");
+		}
+		return res;
+	}
+
+	/* @dev Contract fallback function. Is called if transferAndCall is called
+	 * to a contract
+	 */
+	function contractFallback(
+		address _to,
+		uint256 _value,
+		bytes memory _data
+	) internal virtual returns (bool) {
+		ERC677Receiver receiver = ERC677Receiver(_to);
+		require(
+			receiver.onTokenTransfer(msg.sender, _value, _data),
+			"Contract Fallback failed"
+		);
+		return true;
+	}
+
+	/* @dev Function to check if given address is a contract
+	 * @param _addr Address to check
+	 * @return true if given address is a contract
+	 */
+
+	function isContract(address _addr) internal view returns (bool) {
+		uint256 length;
+		assembly {
+			length := extcodesize(_addr)
+		}
+		return length > 0;
+	}
+}

package/contracts/token/FeesFormula.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8;
+
+interface IFeesFormula {
+	function getTxFees(
+		uint256 value,
+		address sender,
+		address recipient
+	) external view returns (uint256 fee, bool senderPays);
+}