@gooddollar/goodprotocol 2.0.3-beta.0 → 2.0.4

package/contracts/utils/OneTimePayments.sol

@@ -0,0 +1,135 @@
+// 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 OneTimePayments is DAOContract {
+	struct Payment {
+		bool hasPayment;
+		uint256 paymentAmount;
+		address paymentSender;
+	}
+
+	mapping(address => Payment) public payments;
+
+	event PaymentDeposit(address indexed from, address paymentId, uint256 amount);
+	event PaymentCancel(address indexed from, address paymentId, uint256 amount);
+	event PaymentWithdraw(
+		address indexed from,
+		address indexed to,
+		address indexed paymentId,
+		uint256 amount
+	);
+
+	/* @dev Constructor
+	 * @param _avatar The avatar of the DAO
+	 * @param _identity The identity contract
+	 * @param _gasLimit The gas limit
+	 */
+	constructor(INameService _ns) {
+		setDAO(_ns);
+	}
+
+	/* @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);
+
+		emit PaymentDeposit(sender, paymentId, value);
+
+		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;
+
+		_withdraw(paymentId, value);
+		emit PaymentWithdraw(sender, msg.sender, paymentId, value);
+	}
+
+	/* @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;
+
+		_withdraw(paymentId, value);
+		emit PaymentCancel(msg.sender, paymentId, value);
+	}
+
+	/* @dev Internal withdraw function
+	 * @param paymentId the paymentId of the payment
+	 * @param value the amopunt in the payment
+	 */
+	function _withdraw(address paymentId, uint256 value) internal {
+		require(payments[paymentId].hasPayment, "paymentId not in use");
+
+		payments[paymentId].hasPayment = false;
+
+		require(
+			nativeToken().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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gooddollar/goodprotocol",
-  "version": "2.0.3-beta.0",
+  "version": "2.0.4",
   "description": "GoodDollar Protocol",
   "scripts": {
     "prepack": "npm run minimize",

package/releases/deployment.json

@@ -409,6 +409,7 @@
         "DistributionHelper": "0xAcadA0C9795fdBb6921AE96c4D7Db2F8B8c52Fd0"
     },
     "production": {
+        "ProxyFactory": "0xDa85fceD9Bd193526b7667F2AD1fD4A0F900d3A7",
         "NameService": "0xec6dcE387B1616a0c44fF2E4fA9E90E53Cf14eb0",
         "GReputation": "0x603B8C0F110E037b51A381CBCacAbb8d6c6E4543",
         "CompoundVotingMachine": "0x57Ee6Ceff51CB30Ecb1245934a882c500Fbec1e9",
@@ -425,7 +426,7 @@
         "Invites": "0xCa2F09c3ccFD7aD5cB9276918Bd1868f2b922ea0",
         "AdminWallet": "0x9A34822112BC73BDc941C62dCc311Ca905Aef2a3",
         "AdminWalletOld": "0x9F75dAcB77419b87f568d417eBc84346e134144E",
-        "Identity": "0xFa8d865A962ca8456dF331D78806152d3aC5B84F",
+        "Identity": "0x2F9C28de9e6d44b71B91b8BA337A5D82e308E7BE",
         "GoodDollar": "0x495d133B938596C9984d462F007B676bDc57eCEC",
         "Controller": "0xBcE053b99e22158f8B62f4DBFbEdE1f936b2D4e4",
         "Avatar": "0xf96dADc6D71113F6500e97590760C924dA1eF70e",
@@ -433,7 +434,10 @@
         "ProxyAdmin": "0x57179b2A8eB019157b0C3E761cdB26c82C982a3B",
         "FuseFaucet": "0x01ab5966C1d742Ae0CFF7f14cC0F4D85156e83d9",
         "FuseStaking": "0xA199F0C353E25AdF022378B0c208D600f39a6505",
-        "GuardiansSafe": "0x5878123fe880881f1Ecc92D5fd31e5D3F5Fba2e9"
+        "GuardiansSafe": "0x5878123fe880881f1Ecc92D5fd31e5D3F5Fba2e9",
+        "IdentityOld": "0xFa8d865A962ca8456dF331D78806152d3aC5B84F",
+        "MultichainRouter": "0x735aBE48e8782948a37C7765ECb76b98CdE97B0F",
+        "GoodDollarMintBurnWrapper": "0x031b2B7C7854dd8EE9C4A644D7e54aD17F56e3cB"
     },
     "pre-production-celo": {
         "ProxyFactory": "0x99C22e78A579e2176311c736C4c9F0b0D5A47806",
@@ -466,7 +470,12 @@
         "GoodDollarMintBurnWrapper": "0x5566b6E4962BA83e05a426Ad89031ec18e9CadD3",
         "GuardiansSafeOld": "0xC9D09BA972B4EB6Bb7347F2229FB6d50434fFCa6",
         "GuardiansSafe": "0xa2521e8F5A990903fdD8Afa6570C52526e7E0D5E",
-        "MultichainRouter": "0xf27Ee99622C3C9b264583dACB2cCE056e194494f"
+        "MultichainRouter": "0xf27Ee99622C3C9b264583dACB2cCE056e194494f",
+        "AdminWallet": "0x7119CD89D4792aF90277d84cDffa3F2Ab22a0022",
+        "Faucet": "0x4F93Fa058b03953C851eFaA2e4FC5C34afDFAb84",
+        "Invites": "0x36829D1Cda92FFF5782d5d48991620664FC857d3",
+        "UBIScheme": "0x43d72Ff17701B2DA814620735C39C620Ce0ea4A1",
+        "OneTimePayments": "0xB27D247f5C2a61D2Cb6b6E67FEE51d839447e97d"
     },
     "gnosis": {
         "GuardiansSafe": "0x84c10b45fe51bfb4f86c19a47fdbc187d4572fb8"
@@ -491,7 +500,8 @@
         "UBIScheme": "0x6B86F82293552C3B9FE380FC038A89e0328C7C5f",
         "ClaimersDistribution": "0x6e3c0ad79FA7ccDFa27bE14C2630511415A2F635",
         "CompoundVotingMachine": "0xC2C303131939370ed75c95686F691f290b56Be66",
-        "GuardiansSafe": "0x84C10B45fE51bfB4f86c19A47Fdbc187d4572Fb8"
+        "GuardiansSafe": "0x84C10B45fE51bfB4f86c19A47Fdbc187d4572Fb8",
+        "OneTimePayments": "0xB23e54fd8c2f35F9d38884Fc1611F5e9004f10ea"
     },
     "staging-celo": {
         "network": "staging-celo",
@@ -513,6 +523,7 @@
         "UBIScheme": "0x2881d417dA066600372753E73A3570F0781f18cB",
         "ClaimersDistribution": "0x671123F1c7a5B5445467Ff765a5E2Bc86878B245",
         "CompoundVotingMachine": "0xCd25fB84AB22582F1034bcd80c399a3126f2E775",
-        "GuardiansSafe": "0x84C10B45fE51bfB4f86c19A47Fdbc187d4572Fb8"
+        "GuardiansSafe": "0x84C10B45fE51bfB4f86c19A47Fdbc187d4572Fb8",
+        "OneTimePayments": "0x514820Af2DaE5F537dE16E576471528176318113"
     }
 }

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

@@ -5,7 +5,8 @@
 import { network, ethers, upgrades, run } from "hardhat";
 import { Contract } from "ethers";
 import { defaultsDeep } from "lodash";
-import { deployDeterministic, verifyProductionSigner } from "./helpers";
+import { getImplementationAddress } from "@openzeppelin/upgrades-core";
+import { deployDeterministic, verifyProductionSigner, verifyContract } from "./helpers";
 import releaser from "../releaser";
 import ProtocolSettings from "../../releases/deploy-settings.json";
 import dao from "../../releases/deployment.json";
@@ -51,33 +52,32 @@ export const deployHelpers = async () => {
     walletAdmins.push(wallet.address);
   }
 
-  console.log("deploying adminwallet", { walletAdmins });
+  console.log("deploying adminwallet", { walletAdmins, gasprice: protocolSettings.gasPrice });
   const AdminWallet = (await deployDeterministic(
     {
       //   address payable[] memory _admins,
+      // NameService _ns,
       // address _owner,
-      // IIdentityV2 _identity
+      // uint256 _gasPrice
       name: "AdminWallet",
       salt: "AdminWallet",
       isUpgradeable: true
     },
     [walletAdmins, release.NameService, root.address, protocolSettings.gasPrice]
   ).then(printDeploy)) as Contract;
+  // const AdminWallet = await ethers.getContractAt("AdminWallet", release.AdminWallet);
 
-  console.log("giving AdminWallet identity_admin permissions");
   const gd = await ethers.getContractAt("IGoodDollar", release.GoodDollar);
 
   const decimals = await gd.decimals();
 
-  const identity = await ethers.getContractAt("IdentityV2", release.Identity);
-  await identity.grantRole(ethers.utils.keccak256(ethers.utils.toUtf8Bytes("identity_admin")), AdminWallet.address);
-
   const Faucet = await deployDeterministic({ name: "Faucet", salt: "Faucet", isUpgradeable: true }, [
     release.NameService,
     protocolSettings.gasPrice,
     AdminWallet.address,
     root.address
   ]);
+  // const Faucet = await ethers.getContractAt("Faucet", release.Faucet);
 
   const Invites = await deployDeterministic({ name: "InvitesV2", salt: "InvitesV2", isUpgradeable: true }, [
     release.NameService,
@@ -85,18 +85,42 @@ export const deployHelpers = async () => {
     root.address
   ]);
 
+  // const Invites = await ethers.getContractAt("AdminWallet", release.Invites);
+
+  const torelease = {
+    AdminWallet: AdminWallet.address,
+    Faucet: Faucet.address,
+    Invites: Invites.address
+  };
+  await releaser(torelease, network.name, "deployment", false);
+
   const adminWalletOwner = await AdminWallet.hasRole(ethers.constants.HashZero, root.address);
   const faucetOwner = await Faucet.hasRole(ethers.constants.HashZero, root.address);
 
+  console.log("giving AdminWallet identity_admin permissions");
+  const identity = await ethers.getContractAt("IdentityV2", release.Identity);
+  await identity
+    .grantRole(ethers.utils.keccak256(ethers.utils.toUtf8Bytes("identity_admin")), AdminWallet.address)
+    .then(printDeploy);
+
+  const walletIsIdentityAdmin = await identity.hasRole(
+    ethers.utils.keccak256(ethers.utils.toUtf8Bytes("identity_admin")),
+    AdminWallet.address
+  );
+
   console.log("topping adminwallet and faucet with 1 native token");
-  await root.sendTransaction({
-    to: AdminWallet.address,
-    value: ethers.constants.WeiPerEther
-  });
-  await root.sendTransaction({
-    to: Faucet.address,
-    value: ethers.constants.WeiPerEther
-  });
+  await root
+    .sendTransaction({
+      to: AdminWallet.address,
+      value: ethers.constants.WeiPerEther
+    })
+    .then(printDeploy);
+  await root
+    .sendTransaction({
+      to: Faucet.address,
+      value: ethers.constants.WeiPerEther
+    })
+    .then(printDeploy);
 
   if (!network.name.includes("production")) {
     console.log("minting G$s to invites on dev envs");
@@ -104,16 +128,17 @@ export const deployHelpers = async () => {
   }
 
   console.log({
+    walletIsIdentityAdmin,
     adminWalletOwner,
     faucetOwner
   });
 
-  release = {
-    AdminWallet: AdminWallet.address,
-    Faucet: Faucet.address,
-    Invites: Invites.address
-  };
-  await releaser(release, network.name, "deployment", false);
+  let impl = await getImplementationAddress(ethers.provider, AdminWallet.address);
+  await verifyContract(impl, "AdminWallet", network.name);
+  impl = await getImplementationAddress(ethers.provider, Faucet.address);
+  await verifyContract(impl, "Faucet", network.name);
+  impl = await getImplementationAddress(ethers.provider, Invites.address);
+  await verifyContract(impl, "InvitesV2", network.name);
 };
 
 export const main = async () => {

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

@@ -0,0 +1,73 @@
+/***
+ * Deploy helper contracts
+ * AdminWallet, Faucet, Invites
+ */
+import { network, ethers, upgrades, run } from "hardhat";
+import { Contract } from "ethers";
+import { defaultsDeep } from "lodash";
+import { getImplementationAddress } from "@openzeppelin/upgrades-core";
+import { deployDeterministic, verifyProductionSigner, verifyContract } from "./helpers";
+import releaser from "../releaser";
+import ProtocolSettings from "../../releases/deploy-settings.json";
+import dao from "../../releases/deployment.json";
+import { TransactionResponse } from "@ethersproject/providers";
+
+const { name } = network;
+
+const printDeploy = async (c: Contract | TransactionResponse): Promise<Contract | TransactionResponse> => {
+  if (c instanceof Contract) {
+    await c.deployed();
+    console.log("deployed to: ", c.address);
+  }
+  if (c.wait) {
+    await c.wait();
+    console.log("tx done:", c.hash);
+  }
+  return c;
+};
+
+export const deployHelpers = async () => {
+  let protocolSettings = defaultsDeep({}, ProtocolSettings[network.name], ProtocolSettings["default"]);
+
+  let release: { [key: string]: any } = dao[network.name];
+
+  let [root] = await ethers.getSigners();
+  const isProduction = network.name.includes("production");
+
+  if (isProduction) verifyProductionSigner(root);
+
+  //generic call permissions
+  let schemeMock = root;
+
+  console.log("got signers:", {
+    network,
+    root: root.address,
+    schemeMock: schemeMock.address,
+    balance: await ethers.provider.getBalance(root.address).then(_ => _.toString())
+  });
+
+  console.log("deploying onetime payments", { gasprice: protocolSettings.gasPrice });
+  const OTP = (await deployDeterministic(
+    {
+      name: "OneTimePayments",
+      salt: "OneTimePayments",
+      isUpgradeable: false
+    },
+    [release.NameService]
+  ).then(printDeploy)) as Contract;
+
+  // const OTP = await ethers.getContractAt("OneTimePayments", release.OneTimePayments);
+
+  const torelease = {
+    OneTimePayments: OTP.address
+  };
+  await releaser(torelease, network.name, "deployment", false);
+
+  const constructorArgs = ethers.utils.defaultAbiCoder.encode(["address"], [release.NameService]);
+  await verifyContract(OTP.address, "OneTimePayments", network.name, undefined, constructorArgs);
+};
+
+export const main = async () => {
+  await deployHelpers();
+};
+if (process.argv[1].includes("2b_otp-deploy")) main();

package/scripts/multichain-deploy/4_ubi-deploy.ts

@@ -5,24 +5,23 @@
 import { network, ethers, upgrades, run } from "hardhat";
 import { Contract } from "ethers";
 import { defaultsDeep } from "lodash";
+import { getImplementationAddress } from "@openzeppelin/upgrades-core";
 import {
   deployDeterministic,
   executeViaGuardian,
   executeViaSafe,
+  verifyContract,
   verifyProductionSigner
 } from "./helpers";
 import releaser from "../releaser";
 import ProtocolSettings from "../../releases/deploy-settings.json";
 import dao from "../../releases/deployment.json";
 import { TransactionResponse } from "@ethersproject/providers";
-import { InvitesV1__factory } from "../../types";
 import { keccak256, toUtf8Bytes } from "ethers/lib/utils";
 
 const { name } = network;
 
-const printDeploy = async (
-  c: Contract | TransactionResponse
-): Promise<Contract | TransactionResponse> => {
+const printDeploy = async (c: Contract | TransactionResponse): Promise<Contract | TransactionResponse> => {
   if (c instanceof Contract) {
     await c.deployed();
     console.log("deployed to: ", c.address);
@@ -35,16 +34,14 @@ const printDeploy = async (
 };
 
 export const deployHelpers = async () => {
-  let protocolSettings = defaultsDeep(
-    {},
-    ProtocolSettings[network.name],
-    ProtocolSettings["default"]
-  );
+  const viaGuardians = false;
+
+  let protocolSettings = defaultsDeep({}, ProtocolSettings[network.name], ProtocolSettings["default"]);
   let release: { [key: string]: any } = dao[network.name];
 
   let [root, ...signers] = await ethers.getSigners();
   const isProduction = network.name.includes("production");
-  const viaGuardians = false;
+
   if (isProduction) verifyProductionSigner(root);
   //generic call permissions
   let schemeMock = root;
@@ -53,9 +50,7 @@ export const deployHelpers = async () => {
     network,
     root: root.address,
     schemeMock: schemeMock.address,
-    balance: await ethers.provider
-      .getBalance(root.address)
-      .then(_ => _.toString())
+    balance: await ethers.provider.getBalance(root.address).then(_ => _.toString())
   });
 
   console.log("deploying ubi pool");
@@ -64,19 +59,14 @@ export const deployHelpers = async () => {
       name: "UBIScheme",
       isUpgradeable: true
     },
-    [
-      release.NameService,
-      ethers.constants.AddressZero,
-      protocolSettings.ubi.maxInactiveDays
-    ]
+    [release.NameService, ethers.constants.AddressZero, protocolSettings.ubi.maxInactiveDays]
   ).then(printDeploy)) as Contract;
 
   console.log("deploying claimers distribution");
 
-  const ClaimersDistribution = (await deployDeterministic(
-    { name: "ClaimersDistribution", isUpgradeable: true },
-    [release.NameService]
-  ).then(printDeploy)) as Contract;
+  const ClaimersDistribution = (await deployDeterministic({ name: "ClaimersDistribution", isUpgradeable: true }, [
+    release.NameService
+  ]).then(printDeploy)) as Contract;
 
   console.log("setting nameservice addresses via guardian");
   const proposalContracts = [
@@ -93,10 +83,7 @@ export const deployHelpers = async () => {
     ethers.utils.defaultAbiCoder.encode(
       ["bytes32[]", "address[]"],
       [
-        [
-          keccak256(toUtf8Bytes("UBISCHEME")),
-          keccak256(toUtf8Bytes("GDAO_CLAIMERS"))
-        ],
+        [keccak256(toUtf8Bytes("UBISCHEME")), keccak256(toUtf8Bytes("GDAO_CLAIMERS"))],
         [UBIScheme.address, ClaimersDistribution.address]
       ]
     )
@@ -106,17 +93,14 @@ export const deployHelpers = async () => {
     console.log("minting G$s to pool on dev envs");
     const gd = await ethers.getContractAt("IGoodDollar", release.GoodDollar);
     const decimals = await gd.decimals();
-    await gd.mint(
-      UBIScheme.address,
-      ethers.BigNumber.from(1e6).mul(ethers.BigNumber.from("10").pow(decimals))
-    ); //1million GD
+    await gd.mint(UBIScheme.address, ethers.BigNumber.from(1e6).mul(ethers.BigNumber.from("10").pow(decimals))); //1million GD
   }
 
-  release = {
-    UBIScheme: UBIScheme.address,
-    ClaimersDistribution: ClaimersDistribution.address
-  };
-  await releaser(release, network.name, "deployment", false);
+  let impl = await getImplementationAddress(ethers.provider, UBIScheme.address);
+  await verifyContract(impl, "UBIScheme", network.name);
+
+  impl = await getImplementationAddress(ethers.provider, ClaimersDistribution.address);
+  await verifyContract(impl, "ClaimersDistribution", network.name);
 
   try {
     if (viaGuardians) {

package/scripts/multichain-deploy/helpers.ts

@@ -207,7 +207,7 @@ export const executeViaSafe = async (
       txServiceUrl = "https://safe-transaction-mainnet.safe.global";
       break;
     case 122:
-      txServiceUrl = "https://gateway.safe.fuse.io";
+      txServiceUrl = "https://transaction-fuse.safe.fuse.io";
       break;
     case 42220:
       txServiceUrl = "https://mainnet-tx-svc.celo-safe-prod.celo-networks-dev.org";
@@ -236,8 +236,8 @@ export const executeViaSafe = async (
     const contract = contracts[i];
 
     const sigHash = ethers.utils.keccak256(ethers.utils.toUtf8Bytes(functionSigs[i])).slice(0, 10);
+    console.log("creating tx:", contracts[i], functionSigs[i], functionInputs[i]);
     const encoded = ethers.utils.solidityPack(["bytes4", "bytes"], [sigHash, functionInputs[i]]);
-    console.log("creating tx:", contracts[i], functionSigs[i], functionInputs[i], encoded);
     if (contract === ctrl.address) {
       const simulationResult =
         isSimulation === false &&

package/scripts/multichain-deploy/multichainWrapper-deploy.ts

@@ -1,7 +1,8 @@
 import { network, ethers, upgrades, run } from "hardhat";
 import { Contract } from "ethers";
+import { getImplementationAddress } from "@openzeppelin/upgrades-core";
 
-import { deployDeterministic, printDeploy } from "./helpers";
+import { deployDeterministic, printDeploy, verifyContract } from "./helpers";
 import releaser from "../../scripts/releaser";
 import ProtocolSettings from "../../releases/deploy-settings.json";
 import dao from "../../releases/deployment.json";
@@ -20,9 +21,7 @@ export const deployWrapper = async (defaultAdmin = null) => {
     network,
     root: root.address,
     schemeMock: schemeMock.address,
-    balance: await ethers.provider
-      .getBalance(root.address)
-      .then(_ => _.toString())
+    balance: await ethers.provider.getBalance(root.address).then(_ => _.toString())
   });
 
   console.log("MintBurnWrapper deploy params:", [
@@ -44,6 +43,10 @@ export const deployWrapper = async (defaultAdmin = null) => {
     GoodDollarMintBurnWrapper: Wrapper.address
   };
   await releaser(release, network.name, "deployment", false);
+
+  const impl = await getImplementationAddress(ethers.provider, Wrapper.address);
+  await verifyContract(impl, "GoodDollarMintBurnWrapper", network.name);
+
   return Wrapper;
 };