@gooddollar/goodprotocol 1.0.31-beta.0 → 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/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);
+}

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]++;
+	}
+}