@gooddollar/goodprotocol 2.0.5-beta.0 → 2.0.5-beta.10

package/contracts/utils/OneTimePaymentsV2.sol

@@ -0,0 +1,172 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0;
+
+import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
+
+import "../Interfaces.sol";
+import "./DAOContract.sol";
+import "../utils/NameService.sol";
+
+/* @title One Time payment scheme
+ * Scheme that allows address to deposit tokens for any address to withdraw
+ */
+contract OneTimePaymentsV2 is DAOContract {
+	struct Payment {
+		bool hasPayment;
+		uint256 paymentAmount;
+		address paymentSender;
+		address asset;
+	}
+
+	mapping(address => Payment) public payments;
+
+	event PaymentDeposit(
+		address indexed from,
+		address paymentId,
+		uint256 amount,
+		address asset
+	);
+	event PaymentCancel(
+		address indexed from,
+		address paymentId,
+		uint256 amount,
+		address asset
+	);
+	event PaymentWithdraw(
+		address indexed from,
+		address indexed to,
+		address indexed paymentId,
+		uint256 amount,
+		address asset
+	);
+
+	/* @dev Constructor
+	 * @param _avatar The avatar of the DAO
+	 * @param _identity The identity contract
+	 * @param _gasLimit The gas limit
+	 */
+	constructor(INameService _ns) {
+		setDAO(_ns);
+	}
+
+	function depositAsset(
+		address paymentId,
+		address asset,
+		uint value
+	) external payable {
+		require(!payments[paymentId].hasPayment, "paymentId already in use");
+		if (asset != address(0)) {
+			require(
+				ERC20(asset).transferFrom(msg.sender, address(this), value),
+				"asset deposit failed"
+			);
+		} else {
+			require(msg.value > 0, "native deposit failed");
+			value = msg.value;
+		}
+		payments[paymentId] = Payment(true, value, msg.sender, asset);
+
+		emit PaymentDeposit(msg.sender, paymentId, value, asset);
+	}
+
+	/* @dev ERC677 on token transfer function. When transferAndCall is called on this contract,
+	 * this function is called, depositing the payment amount under the hash of the given bytes.
+	 * Reverts if hash is already in use. Can only be called by token contract.
+	 * @param sender the address of the sender
+	 * @param value the amount to deposit
+	 * @param data The given paymentId which should be a fresh address of a wallet
+	 */
+	function onTokenTransfer(
+		address sender,
+		uint256 value,
+		bytes calldata data
+	) external returns (bool) {
+		address paymentId = abi.decode(data, (address));
+
+		require(!payments[paymentId].hasPayment, "paymentId already in use");
+		require(msg.sender == address(nativeToken()), "Only callable by this");
+
+		payments[paymentId] = Payment(true, value, sender, msg.sender);
+
+		emit PaymentDeposit(sender, paymentId, value, msg.sender);
+
+		return true;
+	}
+
+	/* @dev Withdrawal function.
+	 * allows the sender that proves ownership of paymentId to withdraw
+	 * @param paymentId the address of the public key that the
+	 *   rightful receiver of the payment knows the private key to
+	 * @param signature the signature of a the message containing the msg.sender address signed
+	 *   with the private key.
+	 */
+	function withdraw(address paymentId, bytes memory signature) public {
+		address signer = signerOfAddress(msg.sender, signature);
+		require(signer == paymentId, "Signature is not correct");
+
+		uint256 value = payments[paymentId].paymentAmount;
+		address sender = payments[paymentId].paymentSender;
+		address asset = payments[paymentId].asset;
+		_withdraw(paymentId, value, asset);
+		emit PaymentWithdraw(sender, msg.sender, paymentId, value, asset);
+	}
+
+	/* @dev Cancel function
+	 * allows only creator of payment to cancel
+	 * @param paymentId The paymentId of the payment to cancelæ
+	 */
+	function cancel(address paymentId) public {
+		require(
+			payments[paymentId].paymentSender == msg.sender,
+			"Can only be called by creator"
+		);
+
+		uint256 value = payments[paymentId].paymentAmount;
+		address asset = payments[paymentId].asset;
+
+		_withdraw(paymentId, value, asset);
+		emit PaymentCancel(msg.sender, paymentId, value, asset);
+	}
+
+	/* @dev Internal withdraw function
+	 * @param paymentId the paymentId of the payment
+	 * @param value the amopunt in the payment
+	 */
+	function _withdraw(address paymentId, uint256 value, address asset) internal {
+		require(payments[paymentId].hasPayment, "paymentId not in use");
+
+		payments[paymentId].hasPayment = false;
+
+		if (asset == address(0)) {
+			(bool success, ) = payable(msg.sender).call{ value: value }("");
+			require(success, "withdraw native failed");
+		} else {
+			require(
+				ERC20(asset).transfer(msg.sender, value),
+				"withdraw transfer failed"
+			);
+		}
+	}
+
+	/* @dev function to check if a payment hash is in use
+	 * @param paymentId the given paymentId
+	 */
+	function hasPayment(address paymentId) public view returns (bool) {
+		return payments[paymentId].hasPayment;
+	}
+
+	/* @dev gives the signer address of the signature and the message
+	 * @param message the plain-text message that is signed by the signature
+	 * @param signature the signature of the plain-text message
+	 */
+	function signerOfAddress(
+		address message,
+		bytes memory signature
+	) internal pure returns (address) {
+		bytes32 signedMessage = ECDSA.toEthSignedMessageHash(
+			keccak256(abi.encodePacked(message))
+		);
+		address signer = ECDSA.recover(signedMessage, signature);
+		return signer;
+	}
+}

package/hardhat.config.ts

@@ -35,6 +35,13 @@ const ethplorer_key = process.env.ETHPLORER_KEY;
 
 const MAINNET_URL = "https://mainnet.infura.io/v3/" + infura_api;
 
+const goerli = {
+  accounts: { mnemonic },
+  url: "https://rpc.ankr.com/eth_goerli",
+  gas: 3000000,
+  chainId: 5
+};
+
 // console.log({ mnemonic: sha3(mnemonic) });
 const hhconfig: HardhatUserConfig = {
   solidity: {
@@ -216,7 +223,10 @@ const hhconfig: HardhatUserConfig = {
       gas: 3000000,
       gasPrice: 500000000,
       chainId: 100
-    }
+    },
+    goerli,
+    "development-goerli": goerli,
+    "staging-goerli": goerli
   },
   mocha: {
     timeout: 6000000

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@gooddollar/goodprotocol",
-  "version": "2.0.5-beta.0",
+  "version": "2.0.5-beta.10",
   "description": "GoodDollar Protocol",
   "scripts": {
     "prepack": "npm run minimize",
     "build": "scripts/build.sh deploy",
-    "coverage:report": "export COVERALLS_REPO_TOKEN='qiXNelh1HXMAsoPah9yRD2yG2WlqrDfLh' && cat ../coverage/lcov.info coverage/lcov.info | coveralls",
-    "coverage": "export CODE_COVERAGE=true; hardhat --max-memory 6096 coverage",
+    "coverage:report": "COVERALLS_REPO_TOKEN='qiXNelh1HXMAsoPah9yRD2yG2WlqrDfLh' cat ../coverage/lcov.info coverage/lcov.info | coveralls",
+    "coverage": "CODE_COVERAGE=true hardhat --max-memory 6096 coverage",
     "minimize": "./scripts/minimize.sh 'artifacts/contracts'",
     "test": "hardhat test",
     "test:parallel": "mocha --require hardhat/register --extension ts --recursive --parallel --exit",
@@ -60,9 +60,10 @@
     "@jsier/retrier": "^1.2.4",
     "@openzeppelin/contracts": "^4.8.0",
     "@openzeppelin/contracts-upgradeable": "^4.8.0",
+    "@openzeppelin/upgrades-core": "1.18.0",
     "@superfluid-finance/ethereum-contracts": "^1.4.3",
     "@superfluid-finance/sdk-core": "^0.5.8",
-    "@typechain/hardhat": "^6.1.2",
+    "@typechain/hardhat": "^6.1.5",
     "async-promise-pool": "^1.0.4",
     "openzeppelin-solidity": "^4.3.2",
     "patch-package": "latest",
@@ -79,7 +80,7 @@
     "@gnosis.pm/safe-core-sdk-types": "^1.7.0",
     "@gnosis.pm/safe-ethers-lib": "^1.7.0",
     "@gnosis.pm/safe-service-client": "^1.4.0",
-    "@nomicfoundation/hardhat-network-helpers": "^1.0.6",
+    "@nomicfoundation/hardhat-network-helpers": "^1.0.8",
     "@nomiclabs/hardhat-ethers": "^2.2.1",
     "@nomiclabs/hardhat-etherscan": "^3.1.0",
     "@nomiclabs/hardhat-waffle": "^2.0.3",
@@ -103,7 +104,7 @@
     "fs-extra": "9.0.0",
     "graphql": "^15.5.0",
     "graphql-request": "^3.4.0",
-    "hardhat": "^2.10.2",
+    "hardhat": "^2.13.0",
     "hardhat-contract-sizer": "^2.6.1",
     "hardhat-gas-reporter": "^1.0.8",
     "hardhat-storage-layout": "^0.1.7",
@@ -116,12 +117,13 @@
     "prompt": "^1.3.0",
     "regenerator-runtime": "^0.13.9",
     "solhint": "*",
-    "solidity-coverage": "^0.7.21",
-    "truffle": "^5.3.12",
+    "solidity-coverage": "^0.8.2",
+    "truffle": "^5.9.3",
     "truffle-hdwallet-provider": "*",
     "ts-generator": "^0.1.1",
     "ts-node": "^10.8.0",
     "typechain": "^6.0.2",
     "typescript": "*"
-  }
+  },
+  "packageManager": "yarn@3.6.0"
 }

package/releases/deploy-settings.json

@@ -207,6 +207,12 @@
     },
     "uniswapRouter": "0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D"
   },
+  "development-goerli": {
+    "superfluidHost": "0x22ff293e14F1EC3A09B137e9e06084AFd63adDF9"
+  },
+  "staging-goerli": {
+    "superfluidHost": "0x22ff293e14F1EC3A09B137e9e06084AFd63adDF9"
+  },
   "production": {
     "governance": {
       "gdaoAirdrop": "0x2feece0e9bc03b54e63e6eb7abb81a128f6bc7ce9a3bafd5ca2bea0c40e3634b",

package/releases/deployment.json

@@ -159,6 +159,7 @@
         "FuseFaucet": "0x09Ad3430D146aa662eA8c20cBEBceBC0bbB3FB0a",
         "Invites": "0x187fc9fB37DF0fbf75149913a97B17c968Fc90d0",
         "OneTimePayments": "0x184C1F83b3eB75a2dac483D4a6b9FBD59Df961f8",
+        "OneTimePaymentsV2": "0x140A43d46F5445cdfC38E8C6f40F0a4541Fe933f",
         "AdminWallet": "0xC1526892198796d30D33355cfF9Af10EED5B86A0",
         "AdminWalletOld": "0x14204288286823042263156146334B1a4d61227c",
         "network": "fuse",
@@ -267,6 +268,7 @@
         "AdminWalletOld": "0x2961a6C2Fe39F0FFC4f4b1D9E037CD95f4e9C993",
         "UpgradeScheme": "0xfC9F6F5E3ff7BAAB3fEf82e66f56917D625ba38B",
         "OneTimePayments": "0x7912636D68E5d92708862b38698f764BF1EC297C",
+        "OneTimePaymentsV2": "0xEa6E73f5Ef1EC677FE2551128a22cDf27667a5Cd",
         "network": "staging",
         "networkId": 122,
         "ProxyFactory": "0x240d844AdA767bE0AB08F9BcCcB6D8a04aE370EC",
@@ -437,7 +439,8 @@
         "GuardiansSafe": "0x5878123fe880881f1Ecc92D5fd31e5D3F5Fba2e9",
         "IdentityOld": "0xFa8d865A962ca8456dF331D78806152d3aC5B84F",
         "MultichainRouter": "0x735aBE48e8782948a37C7765ECb76b98CdE97B0F",
-        "GoodDollarMintBurnWrapper": "0x031b2B7C7854dd8EE9C4A644D7e54aD17F56e3cB"
+        "GoodDollarMintBurnWrapper": "0x031b2B7C7854dd8EE9C4A644D7e54aD17F56e3cB",
+        "CommunitySafe": "0x5Eb5f5fE13d1D5e6440DbD5913412299Bc5B5564"
     },
     "pre-production-celo": {
         "ProxyFactory": "0x99C22e78A579e2176311c736C4c9F0b0D5A47806",
@@ -475,7 +478,8 @@
         "Faucet": "0x4F93Fa058b03953C851eFaA2e4FC5C34afDFAb84",
         "Invites": "0x36829D1Cda92FFF5782d5d48991620664FC857d3",
         "UBIScheme": "0x43d72Ff17701B2DA814620735C39C620Ce0ea4A1",
-        "OneTimePayments": "0xB27D247f5C2a61D2Cb6b6E67FEE51d839447e97d"
+        "OneTimePayments": "0xB27D247f5C2a61D2Cb6b6E67FEE51d839447e97d",
+        "SwapHelper": "0xE45CaB86609a16dFaDec112FDd61E4EA80EdaA8D"
     },
     "gnosis": {
         "GuardiansSafe": "0x84c10b45fe51bfb4f86c19a47fdbc187d4572fb8"
@@ -501,7 +505,8 @@
         "ClaimersDistribution": "0x6e3c0ad79FA7ccDFa27bE14C2630511415A2F635",
         "CompoundVotingMachine": "0xC2C303131939370ed75c95686F691f290b56Be66",
         "GuardiansSafe": "0x84C10B45fE51bfB4f86c19A47Fdbc187d4572Fb8",
-        "OneTimePayments": "0xB23e54fd8c2f35F9d38884Fc1611F5e9004f10ea"
+        "OneTimePayments": "0xB23e54fd8c2f35F9d38884Fc1611F5e9004f10ea",
+        "OneTimePaymentsV2": "0x2cb1c7d50371e277d7a36B171c0ACe9B157518EE"
     },
     "staging-celo": {
         "network": "staging-celo",
@@ -524,6 +529,19 @@
         "ClaimersDistribution": "0x671123F1c7a5B5445467Ff765a5E2Bc86878B245",
         "CompoundVotingMachine": "0xCd25fB84AB22582F1034bcd80c399a3126f2E775",
         "GuardiansSafe": "0x84C10B45fE51bfB4f86c19A47Fdbc187d4572Fb8",
-        "OneTimePayments": "0x514820Af2DaE5F537dE16E576471528176318113"
+        "OneTimePayments": "0x514820Af2DaE5F537dE16E576471528176318113",
+        "OneTimePaymentsV2": "0x963E7B4c970626Bb103c61fA16b002AFf6E6c2C7"
+    },
+    "development-goerli": {
+        "ProxyFactory": "0x65D8eACBCd9618b8780C4b444081915a5D54D611",
+        "GoodDollar": "0x70044867217EC9C46ecDe49C1f7fCA3b5Ed2f5C4",
+        "Avatar": "0xE0e3BFb1A1850bdFe36ED1563CC2abB6A8B6De78",
+        "Controller": "0x6717A1948328C8eCCb5C933Fae90e0631C2486fE",
+        "Identity": "0x53A537b6917fAFC6bFE1Ae0d54874A225Ce25bA1",
+        "NameService": "0xbd8297847F9De15409Dc0441560b2114c5e7b662",
+        "GReputation": "0x0abF3D20fCb33FC03bdF25b042E77edfAeDBBDD3",
+        "FeeFormula": "0x5fAA779cF74a1Ba51909DEeaA0e8900474DA77Cf",
+        "DAOCreator": "0xc66c970a6d99da587a7d7fa7d5383b401c3e87f4",
+        "OneTimePaymentsV2": "0x4E8112430974b4CE87283221a11BDC52097e7e2e"
     }
 }

package/scripts/analytics/activeUsersCount.ts

@@ -3,14 +3,14 @@ import { ethers as Ethers } from "hardhat";
 import fetch from "node-fetch";
 
 const ONE_DAY = 24 * 60 * 60;
+const ONE_HOUR = 60 * 60;
 
 const main = async () => {
   const signer = (await Ethers.getSigners())[0];
   console.log("signer:", signer.address);
-  const ubiScheme = new Ethers.Contract(
-    "0xD7aC544F8A570C4d8764c3AAbCF6870CBD960D0D",
-    ["function fishMulti(address[] tofish)"]
-  ).connect(signer);
+  const ubiScheme = new Ethers.Contract("0xD7aC544F8A570C4d8764c3AAbCF6870CBD960D0D", [
+    "function fishMulti(address[] tofish)"
+  ]).connect(signer);
   const twoWeeksAgo = parseInt((Date.now() / 1000).toFixed(0)); //
   //parseInt((Date.now() / 1000).toFixed(0)) - 24 * 60 * 60 * 14;
 
@@ -28,21 +28,14 @@ const main = async () => {
     }
   `;
 
-    console.log(
-      "fetching inactive users since:",
-      { curDay, day },
-      JSON.stringify({ query })
-    );
+    console.log("fetching inactive users since:", { curDay, day }, JSON.stringify({ query }));
     const {
       data: { walletStats }
-    } = await fetch(
-      "https://api.thegraph.com/subgraphs/name/gooddollar/gooddollarfuse",
-      {
-        method: "post",
-        body: JSON.stringify({ query }),
-        headers: { "Content-Type": "application/json" }
-      }
-    ).then(_ => _.json());
+    } = await fetch("https://api.thegraph.com/subgraphs/name/gooddollar/gooddollarfuse", {
+      method: "post",
+      body: JSON.stringify({ query }),
+      headers: { "Content-Type": "application/json" }
+    }).then(_ => _.json());
 
     console.log("got inactive wallets:", walletStats.length);
     if (walletStats) {
@@ -62,4 +55,49 @@ const main = async () => {
   console.log("active claimers:", unique.length);
 };
 
-main();
+const countActive = async () => {
+  const twoWeeksAgo = parseInt((Date.now() / 1000).toFixed(0)); //
+
+  const hoursAgo: number[] = range(0, 24 * 14, 1);
+  let curDay = twoWeeksAgo;
+  const allActive = [];
+  for (let hour of hoursAgo) {
+    const query = `
+      { 
+        walletStats(first:1000, where: { lastClaimed_lte: ${curDay},lastClaimed_gt: ${
+      curDay - ONE_HOUR
+    } isActiveUser: true }) {
+        id        
+      }
+    }
+  `;
+
+    console.log("fetching active users since:", { curDay, hour }, JSON.stringify({ query }));
+    const {
+      data: { walletStats }
+    } = await fetch("https://api.thegraph.com/subgraphs/name/gooddollar/gooddollarfuse", {
+      method: "post",
+      body: JSON.stringify({ query }),
+      headers: { "Content-Type": "application/json" }
+    }).then(_ => _.json());
+
+    console.log("got active wallets:", walletStats.length);
+    if (walletStats) {
+      const accounts = walletStats.map(_ => _.id);
+      allActive.push(...accounts);
+    }
+    // for (let tofish of chunk(accounts, 50)) {
+    //   const tx = await ubiScheme.fishMulti(tofish, { gasLimit: 2000000 });
+    //   console.log("fishing tx:", tx, tofish);
+    //   const res = await tx.wait();
+    //   console.log("fishing tx result:", res);
+    // }
+
+    curDay = curDay - ONE_HOUR;
+  }
+  const unique = uniq(allActive);
+  console.log("active claimers:", unique.length);
+};
+
+//main();
+countActive();

package/scripts/analytics/whitelistsyncIssue.ts

@@ -0,0 +1,87 @@
+import { range, chunk, uniq } from "lodash";
+import { ethers } from "hardhat";
+import { Contract, Provider, setMulticallAddress } from "ethers-multicall";
+import fs from "fs";
+import { Retrier } from "@jsier/retrier";
+
+setMulticallAddress(122, "0x3CE6158b7278Bf6792e014FA7B4f3c6c46fe9410");
+setMulticallAddress(42220, "0x75F59534dd892c1f8a7B172D639FA854D529ada3");
+const celoProvider = new ethers.providers.JsonRpcBatchProvider("https://forno.celo.org");
+const ethcallProvider = new Provider(celoProvider, 42220);
+const ethcallFuseProvider = new Provider(new ethers.providers.JsonRpcProvider("https://rpc.fuse.io"), 122);
+
+const ONE_DAY = 24 * 60 * 60;
+/**
+ * find accounts that where whitelisted on celo with diff authentication date than on fuse
+ */
+const main = async () => {
+  const identity = await ethers.getContractAt("IdentityV2", "0xC361A6E67822a0EDc17D899227dd9FC50BD62F42");
+  const abi = identity.interface.format(ethers.utils.FormatTypes.full);
+  const multiIdentity = new Contract(identity.address, abi as string[]);
+  const multiIdentityFuse = new Contract("0x2F9C28de9e6d44b71B91b8BA337A5D82e308E7BE", abi as string[]);
+
+  const celoStartBlock = 18003118;
+  const step = 10000;
+  const celoLastBlock = await ethers.provider.getBlockNumber();
+  const notFuse = [],
+    notCelo = [],
+    toFixCelo = [],
+    toFixFuse = [],
+    notBoth = [];
+  for (let i = 0; celoStartBlock + step * i < celoLastBlock; i++) {
+    try {
+      const options = { limit: 3, delay: 2000 };
+      const retrier = new Retrier(options);
+
+      const lastBlock = celoStartBlock + step * (i + 1) + 1;
+      await retrier.resolve(async attempt => {
+        const events = await identity
+          .connect(celoProvider)
+          .queryFilter(
+            identity.filters["WhitelistedAdded"](),
+            celoStartBlock + step * i,
+            Math.min(celoLastBlock, lastBlock)
+          );
+        console.log("found events:", events.length);
+        const whitelisted = events.map(_ => _.args?.account);
+        let found = 0;
+        const ps = chunk(whitelisted, 400).map(async addrChunk => {
+          const results = await ethcallProvider.all(addrChunk.map(addr => multiIdentity.lastAuthenticated(addr)));
+          const resultsFuse = await ethcallFuseProvider.all(
+            addrChunk.map(addr => multiIdentityFuse.lastAuthenticated(addr))
+          );
+          results.forEach((v, i) => {
+            const diff = v.toNumber() - resultsFuse[i].toNumber();
+            if (v.eq(0) || diff > 3600) {
+              found++;
+              // console.log("diff:", { i, addr: whitelisted[i], celo: v, fuse: resultsFuse[i] });
+              if (v.eq(0) && resultsFuse[i].eq(0)) {
+                // notBoth.push(addrChunk[i]);
+              } else if (v.eq(0)) {
+                notCelo.push(addrChunk[i]);
+              } else if (resultsFuse[i].eq(0)) {
+                notFuse.push([addrChunk[i], v.toNumber()]);
+              } else if (diff > 0) {
+                // console.log("mismatch:", addrChunk[i], { diff });
+                toFixCelo.push([addrChunk[i], resultsFuse[i].toNumber()]);
+              } else {
+                toFixFuse.push([addrChunk[i], v.toNumber()]);
+              }
+            }
+          });
+        });
+        await Promise.all(ps);
+        console.log("done day:", { i, attempt, found });
+      });
+    } catch (e) {
+      console.log("failed day:", i, e.message.slice(0, 100));
+    }
+  }
+  fs.writeFileSync("whitelistissue.json", JSON.stringify({ toFixCelo, toFixFuse, notCelo, notFuse }));
+  console.log({ toFixFuse: toFixFuse.length, toFixCelo: toFixCelo.length, notCelo, notFuse });
+};
+
+const fix = async () => {
+  const { toFix, notFuse } = JSON.parse(fs.readFileSync("whitelistissue.json").toString());
+};
+main();