@gooddollar/goodprotocol 1.0.29-beta.3 → 1.0.29-beta.5

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
+	) private 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,234 @@
+// 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);
+		return super._transferAndCall(to, bruttoValue, data);
+	}
+
+	/**
+	 * @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/hardhat.config.ts

@@ -129,20 +129,20 @@ const hhconfig: HardhatUserConfig = {
       url: "https://rpc.fuse.io/",
       chainId: 122,
       gas: 6000000,
-      gasPrice: 1000000000
+      gasPrice: 10000000000
     },
     fuseexplorer: {
       accounts: { mnemonic },
       url: "https://explorer-node.fuse.io/",
       chainId: 122,
       gas: 6000000,
-      gasPrice: 1000000000
+      gasPrice: 10000000000
     },
     fusespark: {
       accounts: { mnemonic },
       url: "https://rpc.fusespark.io/",
       gas: 3000000,
-      gasPrice: 1000000000,
+      gasPrice: 10000000000,
       chainId: 123
     },
     "fuse-mainnet": {
@@ -157,7 +157,7 @@ const hhconfig: HardhatUserConfig = {
       url: "https://rpc.fuse.io/",
       chainId: 122,
       gas: 6000000,
-      gasPrice: 1000000000
+      gasPrice: 10000000000
     },
     "staging-mainnet": {
       accounts: { mnemonic },
@@ -170,7 +170,7 @@ const hhconfig: HardhatUserConfig = {
       accounts: [deployerPrivateKey],
       url: "https://rpc.fuse.io/",
       gas: 3000000,
-      gasPrice: 1000000000,
+      gasPrice: 10000000000,
       chainId: 122
     },
     "production-mainnet": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gooddollar/goodprotocol",
-  "version": "1.0.29-beta.3",
+  "version": "1.0.29-beta.5",
   "description": "GoodDollar Protocol",
   "scripts": {
     "prepack": "npm run minimize",
@@ -56,7 +56,7 @@
   },
   "homepage": "https://gooddollar.org",
   "dependencies": {
-    "@gooddollar/goodcontracts": "^2.6.4",
+    "@gooddollar/goodcontracts": "^2.6.6",
     "@jsier/retrier": "^1.2.4",
     "@openzeppelin/contracts": "^4.5.0",
     "@openzeppelin/contracts-upgradeable": "^4.3.2",
@@ -74,6 +74,7 @@
     "@babel/polyfill": "*",
     "@babel/preset-env": "*",
     "@babel/register": "*",
+    "@nomicfoundation/hardhat-network-helpers": "^1.0.6",
     "@nomiclabs/hardhat-ethers": "^2.1.1",
     "@nomiclabs/hardhat-etherscan": "^3.1.0",
     "@nomiclabs/hardhat-waffle": "^2.0.3",

package/releases/deployment.json

@@ -336,7 +336,7 @@
         "cDAI": "0x0000000000000000000000000000000000000000",
         "COMP": "0x0000000000000000000000000000000000000000",
         "GoodDollarMintBurnWrapper": "0x08CaFF2331040c9998a91B50eEee85c4AE953ece",
-        "GoodDollarStaking": "0xff64BD8b7d730737B39AE831abbc7Afbee13BD8b"
+        "GoodDollarStaking": "0x66846F27F86f02b079e9176C7aCc10Cc32d839b2"
     },
     "test": {
         "ProxyFactory": "0x36dE29DB57062A583436Ae071e141404dFE2311C",
@@ -579,10 +579,12 @@
         "Faucet": "0x256AFcfEcB5C7f62CE46b54492Bb8ac38163672f",
         "Invites": "0xdC8F0da3f29A3C419a8EEf36665ba2a3EF737B8f",
         "GoodDollarMintBurnWrapper": "0x3fa553a5a044D5c4f5C70878148568410305f953",
-        "GoodDollarStaking": "0xCfa54Ad5a00b0AAd3873B4E269Feb331e6293682",
         "UBIScheme": "0x2d42e6220af2485d1e6E5B4d3661A74671AA9a79",
         "ClaimersDistribution": "0x80018e6Dd79f6B892Fca6b592746136a3aa5ef6d",
-        "CompoundVotingMachine": "0x00e44d746F3931cAB775099F4C6451f893BB9378"
+        "CompoundVotingMachine": "0x00e44d746F3931cAB775099F4C6451f893BB9378",
+        "network": "development-celo",
+        "networkId": 42220,
+        "GoodDollarStaking": "0x0b13807334C1618D71E5FCe792f40A22007c433A"
     },
     "staging-celo": {
         "ProxyFactory": "0x7e8292481EA8EbEb49e486B7e99c00C50fBa2689",
@@ -599,9 +601,11 @@
         "Faucet": "0x9803B5811260Bfd1F5b0b0c9eC9aD4bF96D7ea94",
         "Invites": "0x4E094c2e35e57c90667AbD6D8FE25CE63F4ae00B",
         "GoodDollarMintBurnWrapper": "0x156Fd9563973EFB94a297B76CFac32CdC92a8d1A",
-        "GoodDollarStaking": "0xDcB36664440937E4f11002C2471a456AEeD9b7DC",
         "UBIScheme": "0x04f2Cf8865e2ddfEf0047FdfA7A1b05ade614288",
         "ClaimersDistribution": "0x83186CE77ef296BA6561096447938AE05D1F026e",
-        "CompoundVotingMachine": "0xEdde78b850a08B6b8AB3E84f61cD6dC70Cc7f156"
+        "CompoundVotingMachine": "0xEdde78b850a08B6b8AB3E84f61cD6dC70Cc7f156",
+        "network": "staging-celo",
+        "networkId": 42220,
+        "GoodDollarStaking": "0x1eF9D3Ed46D4B82E7e8089BDdd00a493e9930f46"
     }
 }

package/scripts/multichain-deploy/1_basicdao-deploy.ts

@@ -8,10 +8,9 @@ import { network, ethers, upgrades, run } from "hardhat";
 import { Contract } from "ethers";
 import { defaultsDeep } from "lodash";
 // import DAOCreatorABI from "@gooddollar/goodcontracts/build/contracts/DaoCreatorGoodDollar.json";
-import DAOCreatorABI from "../../../GoodBootstrap/packages/contracts/build/contracts/DaoCreatorGoodDollarWithRep.json";
+import DAOCreatorABI from "@gooddollar/goodcontracts/build/contracts/DaoCreatorGoodDollarWithTokens.json";
 // import IdentityABI from "@gooddollar/goodcontracts/build/contracts/Identity.json";
 import FeeFormulaABI from "@gooddollar/goodcontracts/build/contracts/FeeFormula.json";
-import AddFoundersABI from "@gooddollar/goodcontracts/build/contracts/AddFoundersGoodDollarWithRep.json";
 
 import { deployDeterministic } from "./helpers";
 import releaser from "../releaser";
@@ -60,7 +59,8 @@ export const createDAO = async () => {
     release
   });
 
-  if (network.name.includes("production")) {
+  const isProduction = network.name.includes("production");
+  if (isProduction) {
     const txCount = await root.getTransactionCount();
     if (txCount !== 7) {
       console.error(
@@ -82,15 +82,6 @@ export const createDAO = async () => {
     FeeFormulaABI.bytecode,
     root
   );
-  const AddFoundersFactory = new ethers.ContractFactory(
-    AddFoundersABI.abi,
-    AddFoundersABI.bytecode,
-    root
-  );
-
-  const AddFounders = (await AddFoundersFactory.deploy().then(
-    printDeploy
-  )) as Contract;
 
   const proxyFactory = await ethers.getContractAt(
     "ProxyFactory1967",
@@ -112,13 +103,31 @@ export const createDAO = async () => {
     [daoOwner, ethers.constants.AddressZero]
   ).then(printDeploy)) as Contract;
 
-  const daoCreator = await DAOCreatorFactory.deploy(AddFounders.address);
+  const daoCreator = await DAOCreatorFactory.deploy();
 
   const FeeFormula = (await deployDeterministic(
     { name: "FeeFormula", factory: FeeFormulaFactory },
     [0]
   ).then(printDeploy)) as Contract;
 
+  const GoodDollar = (await deployDeterministic(
+    {
+      name: "GoodDollar",
+      isUpgradeable: true,
+      initializer:
+        "initialize(string, string, uint256, address, address, address,address)"
+    },
+    [
+      isProduction ? "GoodDollar" : "GoodDollar Dev",
+      "G$",
+      0,
+      FeeFormula.address,
+      Identity.address,
+      ethers.constants.AddressZero,
+      daoCreator.address
+    ]
+  ).then(printDeploy)) as Contract;
+
   const GReputation = (await deployDeterministic(
     {
       name: "GReputation",
@@ -138,17 +147,7 @@ export const createDAO = async () => {
 
   console.log("creating dao");
   await daoCreator
-    .forgeOrg(
-      "GoodDollar",
-      "G$",
-      0,
-      FeeFormula.address,
-      Identity.address,
-      GReputation.address,
-      [],
-      0,
-      []
-    )
+    .forgeOrg(GoodDollar.address, GReputation.address, [], 0, [])
     .then(printDeploy);
   console.log("forgeOrg done ");
   const Avatar = new ethers.Contract(
@@ -199,9 +198,8 @@ export const createDAO = async () => {
 
   //verifications
   const Controller = await ethers.getContractAt("Controller", controller);
-  const GoodDollar = await ethers.getContractAt("IGoodDollar", gd);
 
-  if (network.name.includes("production")) {
+  if (isProduction) {
     console.log("renouncing minting rights on production env");
     await GoodDollar.renounceMinter().then(printDeploy);
   }
@@ -213,8 +211,12 @@ export const createDAO = async () => {
 
   const deployerIsNotGDMinter =
     (await GoodDollar.isMinter(root.address)) === false;
+
   const avatarIsGDMinter = await GoodDollar.isMinter(Avatar.address);
 
+  const deployerIsNotGDPauser =
+    (await GoodDollar.isPauser(root.address)) === false;
+
   const deployerIsNotRepMinter =
     (await GReputation.hasRole(GReputation.MINTER_ROLE(), root.address)) ===
     false;
@@ -233,10 +235,26 @@ export const createDAO = async () => {
   const grepHasDAOSet =
     (await GReputation.nameService()) === NameService.address;
 
+  const factoryIsNotGoodOwner =
+    (await GReputation.hasRole(
+      ethers.constants.HashZero,
+      proxyFactory.address
+    )) === false;
+
+  const factoryIsNotGDMinter =
+    (await GoodDollar.isMinter(proxyFactory.address)) === false;
+
+  const factoryIsNotGDPauser =
+    (await GoodDollar.isPauser(root.address)) === false;
+
   console.log({
     daoOwnerDaoPermissions,
     deployerIsNotGDMinter,
     deployerIsNotRepMinter,
+    deployerIsNotGDPauser,
+    factoryIsNotGoodOwner,
+    factoryIsNotGDMinter,
+    factoryIsNotGDPauser,
     avatarIsRepMinter,
     daoOwnerIsIdentityOwner,
     avatarIsGDMinter,
@@ -252,8 +270,7 @@ export const createDAO = async () => {
     NameService: NameService.address,
     GReputation: GReputation.address,
     FeeFormula: FeeFormula.address,
-    DAOCreator: daoCreator.address,
-    AddFounders: AddFounders.address
+    DAOCreator: daoCreator.address
   };
   await releaser(release, network.name, "deployment", false);
 };

package/scripts/multichain-deploy/2_helpers-deploy.ts

@@ -90,13 +90,7 @@ export const deployHelpers = async () => {
 
   const Invites = await deployDeterministic(
     { name: "InvitesV2", salt: "InvitesV2", isUpgradeable: true },
-    [
-      release.Avatar,
-      release.NameService,
-      release.GoodDollar,
-      10000,
-      root.address
-    ]
+    [release.NameService, release.GoodDollar, 10000, root.address]
   );
 
   const adminWalletOwner = await AdminWallet.hasRole(

package/scripts/multichain-deploy/verifyEtherscan.ts

@@ -1,6 +1,7 @@
 import { run, network, ethers } from "hardhat";
-import { omit } from "lodash";
+import { omit, pick, defaultsDeep } from "lodash";
 import dao from "../../releases/deployment.json";
+import ProtocolSettings from "../../releases/deploy-settings.json";
 
 const getImplementationAddress = async addr => {
   console.log("finding impl for:", addr);
@@ -21,9 +22,15 @@ const getImplementationAddress = async addr => {
 
 const main = async () => {
   const release = dao[network.name];
+  let settings = defaultsDeep(
+    {},
+    ProtocolSettings[network.name],
+    ProtocolSettings["default"]
+  );
+
   //   const impl = await getImplementationAddress(release.AdminWallet);
   //   console.log({ impl, aw: release.AdminWallet });
-  const toVerify = omit(release, [
+  let toVerify = omit(release, [
     "GoodDollar",
     "Avatar",
     "Controller",
@@ -39,7 +46,10 @@ const main = async () => {
   }).catch(e =>
     console.log("failed verifying proxy:", identityProxy, e.message)
   );
+
+  // toVerify = pick(release, ["GoodDollarStaking"]);
   for (let key in toVerify) {
+    let constructorArguments = [];
     const address = toVerify[key];
     //   }
     //   const ps = Object.entries(toVerify).map(([key, address]) => {
@@ -66,14 +76,32 @@ const main = async () => {
       case "Identity":
         contract = "contracts/identity/IdentityV2.sol:IdentityV2";
         break;
+      case "GoodDollarStaking":
+        contract =
+          "contracts/governance/GoodDollarStaking.sol:GoodDollarStaking";
+        constructorArguments = [
+          release.NameService,
+          ethers.BigNumber.from(settings.savings.blockAPY),
+          ethers.BigNumber.from(settings.savings.blocksPerYear),
+          settings.savings.daysUntilUpgrade
+        ];
+        break;
       default:
         contract = undefined;
     }
-    console.log("verifying:", address, contract);
-    await run("verify", {
+
+    let task = "verify";
+    let params = {
       address,
       contract
-    }).catch(e =>
+    };
+    if (constructorArguments.length > 0) {
+      task = "verify:verify";
+      params["constructorArguments"] = constructorArguments;
+    }
+    console.log("verifying:", task, params);
+
+    await run(task, params).catch(e =>
       console.log("failed verifying:", address, contract, e.message)
     );
   }