@gooddollar/goodprotocol 1.0.30 → 2.0.1

package/contracts/token/GoodDollar.sol

@@ -0,0 +1,243 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8;
+import "./ERC677.sol";
+import "./FeesFormula.sol";
+import "../Interfaces.sol";
+import "./ERC20PresetMinterPauserUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";
+
+/**
+ * @title The GoodDollar V2 ERC677 token contract
+ */
+
+contract GoodDollar is
+	UUPSUpgradeable,
+	ERC677,
+	ERC20PresetMinterPauserUpgradeable
+{
+	address public feeRecipient;
+
+	IFeesFormula public formula;
+
+	IIdentity public identity;
+
+	uint256 public cap;
+
+	/**
+	 * @dev constructor
+	 * @param _name The name of the token
+	 * @param _symbol The symbol of the token
+	 * @param _cap the cap of the token. no cap if 0
+	 * @param _formula the fee formula contract
+	 * @param _identity the identity contract
+	 * @param _feeRecipient the address that receives transaction fees
+	 */
+	function initialize(
+		string memory _name,
+		string memory _symbol,
+		uint256 _cap,
+		IFeesFormula _formula,
+		IIdentity _identity,
+		address _feeRecipient,
+		address _owner
+	) public initializer {
+		__ERC20PresetMinterPauser_init(_name, _symbol);
+		feeRecipient = _feeRecipient;
+		identity = _identity;
+		formula = _formula;
+		cap = _cap;
+		if (_owner != _msgSender()) {
+			transferOwnership(_owner);
+			renounceRole(MINTER_ROLE, _msgSender());
+			renounceRole(PAUSER_ROLE, _msgSender());
+		}
+	}
+
+	modifier onlyOwner() {
+		require(hasRole(DEFAULT_ADMIN_ROLE, msg.sender), "not owner");
+		_;
+	}
+
+	function _authorizeUpgrade(address newImplementation)
+		internal
+		override
+		onlyOwner
+	{}
+
+	function decimals() public view virtual override returns (uint8) {
+		return 2;
+	}
+
+	function setFormula(IFeesFormula _formula) external onlyOwner {
+		formula = _formula;
+	}
+
+	function setIdentity(IIdentityV2 _identity) external onlyOwner {
+		identity = _identity;
+	}
+
+	function transferOwnership(address _owner) public onlyOwner {
+		grantRole(DEFAULT_ADMIN_ROLE, _owner);
+		renounceRole(DEFAULT_ADMIN_ROLE, _msgSender());
+	}
+
+	function owner() external view returns (address) {
+		return getRoleMember(DEFAULT_ADMIN_ROLE, 0);
+	}
+
+	function isMinter(address _minter) external view returns (bool) {
+		return hasRole(MINTER_ROLE, _minter);
+	}
+
+	function addMinter(address _minter) external {
+		grantRole(MINTER_ROLE, _minter);
+	}
+
+	function renounceMinter() external {
+		renounceRole(MINTER_ROLE, _msgSender());
+	}
+
+	function addPauser(address _pauser) external {
+		grantRole(PAUSER_ROLE, _pauser);
+	}
+
+	function isPauser(address _pauser) external view returns (bool) {
+		return hasRole(PAUSER_ROLE, _pauser);
+	}
+
+	/**
+	 * @dev Processes fees from given value and sends
+	 * remainder to given address
+	 * @param to the address to be sent to
+	 * @param value the value to be processed and then
+	 * transferred
+	 * @return a boolean that indicates if the operation was successful
+	 */
+	function transfer(address to, uint256 value)
+		public
+		override(ERC20Upgradeable, ERC677)
+		returns (bool)
+	{
+		uint256 bruttoValue = _processFees(msg.sender, to, value);
+		return ERC20Upgradeable.transfer(to, bruttoValue);
+	}
+
+	/**
+	 * @dev Transfer tokens from one address to another
+	 * @param from The address which you want to send tokens from
+	 * @param to The address which you want to transfer to
+	 * @param value the amount of tokens to be transferred
+	 * @return a boolean that indicates if the operation was successful
+	 */
+	function transferFrom(
+		address from,
+		address to,
+		uint256 value
+	) public override returns (bool) {
+		uint256 bruttoValue = _processFees(from, to, value);
+		return super.transferFrom(from, to, bruttoValue);
+	}
+
+	/**
+	 * @dev Processes transfer fees and calls ERC677Token transferAndCall function
+	 * @param to address to transfer to
+	 * @param value the amount to transfer
+	 * @param data The data to pass to transferAndCall
+	 * @return a bool indicating if transfer function succeeded
+	 */
+	function transferAndCall(
+		address to,
+		uint256 value,
+		bytes calldata data
+	) external returns (bool) {
+		uint256 bruttoValue = _processFees(msg.sender, to, value);
+		bool res = ERC20Upgradeable.transfer(to, bruttoValue);
+		emit Transfer(msg.sender, to, bruttoValue, data);
+
+		if (isContract(to)) {
+			require(
+				contractFallback(to, bruttoValue, data),
+				"Contract fallback failed"
+			);
+		}
+		return res;
+	}
+
+	/**
+	 * @dev Minting function
+	 * @param to the address that will receive the minted tokens
+	 * @param value the amount of tokens to mint
+	 */
+	function mint(address to, uint256 value) public override returns (bool) {
+		if (cap > 0) {
+			require(
+				totalSupply() + value <= cap,
+				"Cannot increase supply beyond cap"
+			);
+		}
+		return super.mint(to, value);
+	}
+
+	/**
+	 * @dev Gets the current transaction fees
+	 * @return fee senderPays  that represents the current transaction fees and bool true if sender pays the fee or receiver
+	 */
+	function getFees(uint256 value)
+		public
+		view
+		returns (uint256 fee, bool senderPays)
+	{
+		return formula.getTxFees(value, address(0), address(0));
+	}
+
+	/**
+	 * @dev Gets the current transaction fees
+	 * @return fee senderPays  that represents the current transaction fees and bool true if sender pays the fee or receiver
+	 */
+	function getFees(
+		uint256 value,
+		address sender,
+		address recipient
+	) public view returns (uint256 fee, bool senderPays) {
+		return formula.getTxFees(value, sender, recipient);
+	}
+
+	/**
+	 * @dev Sets the address that receives the transactional fees.
+	 * can only be called by owner
+	 * @param _feeRecipient The new address to receive transactional fees
+	 */
+	function setFeeRecipient(address _feeRecipient) public onlyOwner {
+		feeRecipient = _feeRecipient;
+	}
+
+	/**
+	 * @dev Sends transactional fees to feeRecipient address from given address
+	 * @param account The account that sends the fees
+	 * @param value The amount to subtract fees from
+	 * @return an uint256 that represents the given value minus the transactional fees
+	 */
+	function _processFees(
+		address account,
+		address recipient,
+		uint256 value
+	) internal returns (uint256) {
+		(uint256 txFees, bool senderPays) = getFees(value, account, recipient);
+		if (txFees > 0 && !identity.isDAOContract(msg.sender)) {
+			require(
+				senderPays == false || value + txFees <= balanceOf(account),
+				"Not enough balance to pay TX fee"
+			);
+			if (account == msg.sender) {
+				super.transfer(feeRecipient, txFees);
+			} else {
+				super.transferFrom(account, feeRecipient, txFees);
+			}
+
+			return senderPays ? value : value - txFees;
+		}
+		return value;
+	}
+}

package/contracts/token/superfluid/ERC20Permit.sol

@@ -0,0 +1,101 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8;
+
+import "@openzeppelin/contracts-upgradeable/utils/cryptography/draft-EIP712Upgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/token/ERC20/extensions/draft-IERC20PermitUpgradeable.sol";
+
+import "./SuperToken.sol";
+
+interface SelfApprove {
+	function selfApproveFor(
+		address account,
+		address spender,
+		uint256 amount
+	) external;
+}
+
+abstract contract ERC20Permit is IERC20PermitUpgradeable, EIP712Upgradeable {
+	mapping(address => uint256) private _nonces;
+
+	// solhint-disable-next-line var-name-mixedcase
+	bytes32 private _PERMIT_TYPEHASH;
+
+	/**
+	 * @dev Initializes the {EIP712} domain separator using the `name` parameter, and setting `version` to `"1"`.
+	 *
+	 * It's a good idea to use the same `name` that is defined as the ERC20 token name.
+	 */
+	function __ERC20Permit_init(string memory name) internal onlyInitializing {
+		__EIP712_init_unchained(name, "1");
+		__ERC20Permit_init_unchained(name);
+	}
+
+	function __ERC20Permit_init_unchained(string memory name)
+		internal
+		onlyInitializing
+	{
+		_PERMIT_TYPEHASH = keccak256(
+			"Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"
+		);
+	}
+
+	/**
+	 * @dev See {IERC20Permit-permit}.
+	 */
+	function permit(
+		address owner,
+		address spender,
+		uint256 value,
+		uint256 deadline,
+		uint8 v,
+		bytes32 r,
+		bytes32 s
+	) public virtual {
+		require(block.timestamp <= deadline, "ERC20Permit: expired deadline");
+
+		bytes32 structHash = keccak256(
+			abi.encode(
+				_PERMIT_TYPEHASH,
+				owner,
+				spender,
+				value,
+				_useNonce(owner),
+				deadline
+			)
+		);
+
+		bytes32 hash = _hashTypedDataV4(structHash);
+
+		address signer = ECDSAUpgradeable.recover(hash, v, r, s);
+		require(signer == owner, "ERC20Permit: invalid signature");
+
+		SelfApprove(address(this)).selfApproveFor(owner, spender, value);
+	}
+
+	/**
+	 * @dev See {IERC20Permit-nonces}.
+	 */
+	function nonces(address owner) public view virtual returns (uint256) {
+		return _nonces[owner];
+	}
+
+	/**
+	 * @dev See {IERC20Permit-DOMAIN_SEPARATOR}.
+	 */
+	// solhint-disable-next-line func-name-mixedcase
+	function DOMAIN_SEPARATOR() external view returns (bytes32) {
+		return _domainSeparatorV4();
+	}
+
+	/**
+	 * @dev "Consume a nonce": return the current value and increment.
+	 *
+	 * _Available since v4.1._
+	 */
+
+	function _useNonce(address owner) internal virtual returns (uint256 current) {
+		current = _nonces[owner];
+		_nonces[owner]++;
+	}
+}

package/contracts/token/superfluid/ISuperGoodDollar.sol

@@ -0,0 +1,84 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8;
+
+import "@openzeppelin/contracts-upgradeable/token/ERC20/extensions/draft-IERC20PermitUpgradeable.sol";
+import { ISuperToken } from "@superfluid-finance/ethereum-contracts/contracts/interfaces/superfluid/CustomSuperTokenBase.sol";
+import "../FeesFormula.sol";
+import "../../Interfaces.sol";
+
+// GoodDollar specific functions
+interface IGoodDollarCustom {
+	// view functions
+	function feeRecipient() external view returns (address);
+
+	function getFees(uint256 value)
+		external
+		view
+		returns (uint256 fee, bool senderPays);
+
+	function getFees(
+		uint256 value,
+		address sender,
+		address recipient
+	) external view returns (uint256 fee, bool senderPays);
+
+	function formula() external view returns (IFeesFormula);
+
+	function identity() external view returns (IIdentity);
+
+	function cap() external view returns (uint256);
+
+	function isMinter(address _minter) external view returns (bool);
+
+	function isPauser(address _pauser) external view returns (bool);
+
+	function owner() external view returns (address);
+
+	// state changing functions
+	function setFeeRecipient(address _feeRecipient) external;
+
+	function setFormula(IFeesFormula _formula) external;
+
+	function setIdentity(IIdentityV2 _identity) external;
+
+	function transferOwnership(address _owner) external;
+
+	function transferAndCall(
+		address to,
+		uint256 value,
+		bytes calldata data
+	) external returns (bool);
+
+	function mint(address to, uint256 amount) external returns (bool);
+
+	function burn(uint256 amount) external;
+
+	function burnFrom(address account, uint256 amount) external;
+
+	function addMinter(address _minter) external;
+
+	function renounceMinter() external;
+
+	function addPauser(address _pauser) external;
+
+	function pause() external;
+
+	function unpause() external;
+}
+
+interface ISuperGoodDollar is
+	IGoodDollarCustom,
+	ISuperToken,
+	IERC20PermitUpgradeable
+{
+	function initialize(
+		string calldata name,
+		string calldata symbol,
+		uint256 _cap,
+		IFeesFormula _formula,
+		IIdentity _identity,
+		address _feeRecipient,
+		address _owner
+	) external;
+}