@gooddollar/goodprotocol 1.0.31-beta.0 → 2.0.1

package/scripts/multichain-deploy/helpers.ts

@@ -6,19 +6,25 @@ import Safe from "@gnosis.pm/safe-core-sdk";
 import EthersAdapter from "@gnosis.pm/safe-ethers-lib";
 import { MetaTransactionData } from "@gnosis.pm/safe-core-sdk-types";
 import SafeClient from "@gnosis.pm/safe-service-client";
-
+import util from "util";
 import dao from "../../releases/deployment.json";
 
-const networkName =
-  network.name === "localhost" ? "production-mainnet" : network.name;
+const exec = util.promisify(require("child_process").exec);
+
+const networkName = network.name === "localhost" ? "production-mainnet" : network.name;
 let totalGas = 0;
 const gasUsage = {};
-const GAS_SETTINGS = { gasLimit: 5000000 };
+const GAS_SETTINGS = { gasLimit: 10000000 };
 let release: { [key: string]: any } = dao[networkName];
 
-export const printDeploy = async (
-  c: Contract | TransactionResponse
-): Promise<Contract | TransactionResponse> => {
+export const verifyProductionSigner = signer => {
+  if (signer.address.toLowerCase() !== "0x5128E3C1f8846724cc1007Af9b4189713922E4BB".toLowerCase()) {
+    throw new Error(
+      "signer not 0x5128E3C1f8846724cc1007Af9b4189713922E4BB to get same deployed addresses on production"
+    );
+  }
+};
+export const printDeploy = async (c: Contract | TransactionResponse): Promise<Contract | TransactionResponse> => {
   if (c instanceof Contract) {
     await c.deployed();
     console.log("deployed to: ", c.address);
@@ -41,30 +47,45 @@ export const countTotalGas = async (tx, name) => {
   } else console.log("no gas data", { res, tx });
 };
 
-export const deployDeterministic = async (
-  contract,
-  args: any[],
-  factoryOpts = {}
-) => {
+export const deploySuperGoodDollar = async (superfluidHost, tokenArgs) => {
+  const SuperGoodDollar = (await deployDeterministic(
+    {
+      name: "SuperGoodDollar",
+      salt: "SuperGoodDollarLogic"
+    },
+    [superfluidHost]
+  ).then(printDeploy)) as Contract;
+
+  const uupsFactory = await ethers.getContractFactory("UUPSProxy");
+  const GoodDollarProxy = (await deployDeterministic(
+    {
+      name: "SuperGoodDollar",
+      factory: uupsFactory
+    },
+    []
+  ).then(printDeploy)) as Contract;
+
+  await GoodDollarProxy.initializeProxy(SuperGoodDollar.address);
+
+  await SuperGoodDollar.attach(GoodDollarProxy.address)[
+    "initialize(string,string,uint256,address,address,address,address)"
+  ](...tokenArgs);
+
+  const GoodDollar = await ethers.getContractAt("ISuperGoodDollar", GoodDollarProxy.address);
+  return GoodDollar;
+};
+
+export const deployDeterministic = async (contract, args: any[], factoryOpts = {}, redeployProxyFactory = false) => {
   try {
     let proxyFactory;
-    if (networkName.startsWith("develop")) {
-      proxyFactory = await (
-        await ethers.getContractFactory("ProxyFactory1967")
-      ).deploy();
-    } else
-      proxyFactory = await ethers.getContractAt(
-        "ProxyFactory1967",
-        release.ProxyFactory
-      );
+    if (networkName.startsWith("develop") && redeployProxyFactory) {
+      proxyFactory = await (await ethers.getContractFactory("ProxyFactory1967")).deploy();
+    } else proxyFactory = await ethers.getContractAt("ProxyFactory1967", release.ProxyFactory);
     const Contract =
-      (contract.factory as ContractFactory) ||
-      (await ethers.getContractFactory(contract.name, factoryOpts));
+      (contract.factory as ContractFactory) || (await ethers.getContractFactory(contract.name, factoryOpts));
 
     const salt = ethers.BigNumber.from(
-      ethers.utils.keccak256(
-        ethers.utils.toUtf8Bytes(contract.salt || contract.name)
-      )
+      ethers.utils.keccak256(ethers.utils.toUtf8Bytes(contract.salt || contract.name))
     );
 
     if (contract.isUpgradeable === true) {
@@ -72,30 +93,19 @@ export const deployDeterministic = async (
         args,
         proxyFactory: proxyFactory.address
       });
-      const encoded = Contract.interface.encodeFunctionData(
-        contract.initializer || "initialize",
-        args
-      );
+      const encoded = Contract.interface.encodeFunctionData(contract.initializer || "initialize", args);
       const tx = await Contract.deploy(GAS_SETTINGS);
       const impl = await tx.deployed();
       console.log("implementation deployed:", contract.name, impl.address);
       await countTotalGas(tx, contract.name);
 
-      const tx2 = await proxyFactory.deployProxy(
+      const tx2 = await proxyFactory.deployProxy(salt, impl.address, encoded, GAS_SETTINGS);
+      await countTotalGas(tx2, contract.name);
+      const deployTx = await tx2.wait().catch(e => console.error("failed to deploy proxy, assuming it exists...", e));
+      const proxyAddr = await proxyFactory["getDeploymentAddress(uint256,address)"](
         salt,
-        impl.address,
-        encoded,
-        GAS_SETTINGS
+        await proxyFactory.signer.getAddress()
       );
-      await countTotalGas(tx2, contract.name);
-      const deployTx = await tx2
-        .wait()
-        .catch(e =>
-          console.error("failed to deploy proxy, assuming it exists...", e)
-        );
-      const proxyAddr = await proxyFactory[
-        "getDeploymentAddress(uint256,address)"
-      ](salt, await proxyFactory.signer.getAddress());
       console.log("proxy deployed:", contract.name, proxyAddr);
       return Contract.attach(proxyAddr);
     } else {
@@ -104,17 +114,10 @@ export const deployDeterministic = async (
         args
       });
       const constructor = Contract.interface.encodeDeploy(args);
-      const bytecode = ethers.utils.solidityPack(
-        ["bytes", "bytes"],
-        [Contract.bytecode, constructor]
-      );
-      const deployTx = await (
-        await proxyFactory.deployCode(salt, bytecode, GAS_SETTINGS)
-      ).wait();
+      const bytecode = ethers.utils.solidityPack(["bytes", "bytes"], [Contract.bytecode, constructor]);
+      const deployTx = await (await proxyFactory.deployCode(salt, bytecode, GAS_SETTINGS)).wait();
 
-      const proxyAddr = await proxyFactory[
-        "getDeploymentAddress(uint256,address,bytes32)"
-      ](
+      const proxyAddr = await proxyFactory["getDeploymentAddress(uint256,address,bytes32)"](
         salt,
         await proxyFactory.signer.getAddress(),
         ethers.utils.keccak256(bytecode)
@@ -134,45 +137,32 @@ export const executeViaGuardian = async (
   ethValues,
   functionSigs,
   functionInputs,
-  guardian: Signer
+  guardian: Signer,
+  network?: string
 ) => {
-  let release: { [key: string]: any } = dao[networkName];
-  const ctrl = await (
-    await ethers.getContractAt("Controller", release.Controller)
-  ).connect(guardian);
+  let release: { [key: string]: any } = dao[network || networkName];
+  const ctrl = await (await ethers.getContractAt("Controller", release.Controller)).connect(guardian);
 
   for (let i = 0; i < contracts.length; i++) {
     const contract = contracts[i];
     console.log("executing:", contracts[i], functionSigs[i], functionInputs[i]);
-    const sigHash = ethers.utils
-      .keccak256(ethers.utils.toUtf8Bytes(functionSigs[i]))
-      .slice(0, 10);
-    const encoded = ethers.utils.solidityPack(
-      ["bytes4", "bytes"],
-      [sigHash, functionInputs[i]]
-    );
+    const sigHash = ethers.utils.keccak256(ethers.utils.toUtf8Bytes(functionSigs[i])).slice(0, 10);
+    const encoded = ethers.utils.solidityPack(["bytes4", "bytes"], [sigHash, functionInputs[i]]);
     if (contract === ctrl.address) {
       console.log("executing directly on controller:", sigHash, encoded);
 
-      await guardian
-        .sendTransaction({ to: contract, data: encoded })
-        .then(printDeploy);
+      await guardian.sendTransaction({ to: contract, data: encoded }).then(printDeploy);
     } else {
-      const simulationResult = await ctrl.callStatic.genericCall(
-        contract,
-        encoded,
-        release.Avatar,
-        ethValues[i],
-        { from: await guardian.getAddress() }
-      );
+      const simulationResult = await ctrl.callStatic.genericCall(contract, encoded, release.Avatar, ethValues[i], {
+        from: await guardian.getAddress()
+      });
       console.log("executing genericCall:", {
         sigHash,
         encoded,
         simulationResult
       });
-      await ctrl
-        .genericCall(contract, encoded, release.Avatar, ethValues[i])
-        .then(printDeploy);
+      if (simulationResult[0] === false) throw new Error("simulation failed:" + contract);
+      await ctrl.genericCall(contract, encoded, release.Avatar, ethValues[i]).then(printDeploy);
     }
   }
 };
@@ -183,13 +173,52 @@ export const executeViaSafe = async (
   functionSigs,
   functionInputs,
   safeAddress: string,
-  safeSigner: Signer,
-  txServiceUrl = "https://safe-transaction-mainnet.safe.global"
+  safeSignerOrNetwork?: Signer | string,
+  isSimulation = false
 ) => {
+  if (typeof safeSignerOrNetwork !== "object" && !process.env.SAFEOWNER_PRIVATE_KEY) {
+    throw new Error("safe signer is missing");
+  }
+
+  let safeSigner = new ethers.Wallet(process.env.SAFEOWNER_PRIVATE_KEY, new ethers.providers.CloudflareProvider());
+  if (typeof safeSignerOrNetwork === "string") {
+    switch (safeSignerOrNetwork) {
+      case "mainnet":
+        break;
+      case "celo":
+        safeSigner = new ethers.Wallet(process.env.SAFEOWNER_PRIVATE_KEY).connect(
+          new ethers.providers.JsonRpcProvider("https://forno.celo.org")
+        );
+        break;
+      case "fuse":
+        safeSigner = new ethers.Wallet(process.env.SAFEOWNER_PRIVATE_KEY).connect(
+          new ethers.providers.JsonRpcProvider("https://rpc.fuse.io")
+        );
+        break;
+    }
+  } else if (safeSignerOrNetwork) {
+    safeSigner = safeSignerOrNetwork as any;
+  }
+  const chainId = await safeSigner.getChainId();
+  console.log("safeSigner:", safeSigner.address, { chainId });
+  let txServiceUrl;
+  switch (chainId) {
+    case 1:
+      txServiceUrl = "https://safe-transaction-mainnet.safe.global";
+      break;
+    case 122:
+      txServiceUrl = "https://gateway.safe.fuse.io";
+      break;
+    case 42220:
+      txServiceUrl = "https://mainnet-tx-svc.celo-safe-prod.celo-networks-dev.org";
+      break;
+  }
+  console.log("creating safe adapter", { txServiceUrl });
   const ethAdapter = new EthersAdapter({
     ethers: safeethers,
     signerOrProvider: safeSigner
   });
+  console.log("creating safe client", { txServiceUrl });
 
   const safeService = new SafeClient({
     txServiceUrl,
@@ -199,36 +228,23 @@ export const executeViaSafe = async (
   const safeSdk = await Safe.create({ ethAdapter, safeAddress });
 
   let release: { [key: string]: any } = dao[networkName];
-  const ctrl = await ethers.getContractAt(
-    "Controller",
-    release.Controller,
-    null
-  );
+  const ctrl = await ethers.getContractAt("Controller", release.Controller, null);
 
   const safeTransactionData: MetaTransactionData[] = [];
 
   for (let i = 0; i < contracts.length; i++) {
     const contract = contracts[i];
 
-    const sigHash = ethers.utils
-      .keccak256(ethers.utils.toUtf8Bytes(functionSigs[i]))
-      .slice(0, 10);
-    const encoded = ethers.utils.solidityPack(
-      ["bytes4", "bytes"],
-      [sigHash, functionInputs[i]]
-    );
-    console.log(
-      "creating tx:",
-      contracts[i],
-      functionSigs[i],
-      functionInputs[i],
-      encoded
-    );
+    const sigHash = ethers.utils.keccak256(ethers.utils.toUtf8Bytes(functionSigs[i])).slice(0, 10);
+    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 = await ctrl.callStatic[functionSigs[i]](
-        ...functionInputs[i],
-        { from: safeAddress, value: ethValues[i] }
-      );
+      const simulationResult =
+        isSimulation === false &&
+        (await ctrl.callStatic[functionSigs[i]](...functionInputs[i], {
+          from: safeAddress,
+          value: ethValues[i]
+        }));
       console.log("executing controller call:", {
         sigHash,
         encoded,
@@ -247,17 +263,17 @@ export const executeViaSafe = async (
         avatar: release.Avatar,
         value: ethValues[i]
       });
-      const simulationResult = await ctrl.callStatic.genericCall(
-        contract,
-        encoded,
-        release.Avatar,
-        ethValues[i],
-        { from: safeAddress }
-      );
-      console.log("executing genericCall:", {
+
+      const simulationResult =
+        isSimulation === false &&
+        (await ctrl.callStatic.genericCall(contract, encoded, release.Avatar, ethValues[i], {
+          from: safeAddress
+        }));
+      console.log("executing genericCall simulation result:", {
         sigHash,
         simulationResult
       });
+      if (isSimulation === false && simulationResult[0] === false) throw new Error("simulation failed:" + contract);
       const genericEncode = ctrl.interface.encodeFunctionData("genericCall", [
         contract,
         encoded,
@@ -295,3 +311,25 @@ export const executeViaSafe = async (
     senderAddress
   });
 };
+
+export const verifyContract = async (
+  address,
+  contractName,
+  networkName,
+  proxyName?: string,
+  forcedConstructorArguments?: string
+) => {
+  let networkProvider = network.name.includes("-") ? network.name.split("-")[1] : "fuse";
+  networkProvider = networkProvider === "mainnet" ? "ethereum" : networkProvider;
+  console.log("truffle compile...");
+  await exec("npx truffle compile");
+  const cmd = `npx truffle run verify ${proxyName ? "--custom-proxy " + proxyName : ""} ${contractName}@${address} ${
+    forcedConstructorArguments ? "--forceConstructorArgs string:" + forcedConstructorArguments.slice(2) : ""
+  } --network ${networkProvider}`;
+  console.log("running...:", cmd);
+  await exec(cmd).then(({ stdout, stderr }) => {
+    console.log("Result for:", cmd);
+    console.log(stdout);
+    console.log(stderr);
+  });
+};

package/scripts/multichain-deploy/verifyEtherscan.ts

@@ -0,0 +1,197 @@
+import { run, network, ethers } from "hardhat";
+import { omit, pick, defaultsDeep } from "lodash";
+import dao from "../../releases/deployment.json";
+import ProtocolSettings from "../../releases/deploy-settings.json";
+import util from "util";
+
+const exec = util.promisify(require("child_process").exec);
+
+const delay = ms => new Promise(res => setTimeout(res, 1000));
+
+const getImplementationAddress = async addr => {
+  console.log("finding impl for:", addr);
+  let proxy = await ethers.provider.getStorageAt(
+    addr,
+    "0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc"
+  );
+  let res = addr;
+  if (proxy != ethers.constants.HashZero) res = "0x" + proxy.slice(-40);
+  else {
+    const code = await ethers.getDefaultProvider().getCode(addr);
+    if (code.startsWith("0x363d3d373d3d3d363d73"))
+      res = "0x" + code.slice(22, 62);
+  }
+  console.log("impl address for:", addr, res);
+  return res;
+};
+
+const main = async () => {
+  let withTruffle = true;
+  let ps = [];
+  const release = dao[network.name];
+  let settings = defaultsDeep(
+    {},
+    ProtocolSettings[network.name],
+    ProtocolSettings["default"]
+  );
+
+  const networkProvider = network.name.includes("-")
+    ? network.name.split("-")[1]
+    : network.name;
+
+  //   const impl = await getImplementationAddress(release.AdminWallet);
+  //   console.log({ impl, aw: release.AdminWallet });
+
+  let toVerify = omit(release, [
+    "Avatar",
+    "Controller",
+    "DAOCreator",
+    "AddFounders",
+    "FeeFormula",
+    "network",
+    "networkId",
+    "GuardiansSafe",
+    "GuardiansSafeOld",
+    "MultichainRouter"
+  ]);
+
+  if (withTruffle) {
+    console.log("truffle compile....");
+    const { stdout, stderr } = await exec("npx truffle compile");
+  } else {
+    //verify the first proxy
+    const identityProxy = toVerify["Identity"];
+    await run("verify:verify", {
+      address: identityProxy,
+      contract: "contracts/utils/ProxyFactory1967.sol:ERC1967Proxy"
+    }).catch(e =>
+      console.log("failed verifying proxy:", identityProxy, e.message)
+    );
+
+    const uupsProxy = toVerify["GoodDollar"];
+    await run("verify:verify", {
+      address: uupsProxy,
+      contract: "contracts/token/superfluid/UUPSProxy.sol:UUPSProxy"
+    }).catch(e =>
+      console.log("failed verifying uups proxy:", uupsProxy, e.message)
+    );
+  }
+  // toVerify = pick(release, ["GoodDollarStaking"]);
+  for (let key in toVerify) {
+    let constructorArguments = [];
+    let forcedConstructorArguments = "";
+    const address = toVerify[key];
+    //   }
+    //   const ps = Object.entries(toVerify).map(([key, address]) => {
+    let contract;
+    let contractName = key;
+    let proxy = "--custom-proxy ERC1967Proxy";
+    switch (key) {
+      case "AdminWallet":
+        contract = "contracts/utils/AdminWallet.sol:AdminWallet";
+        break;
+      case "Faucet":
+        contract = "contracts/fuseFaucet/Faucet.sol:Faucet";
+        break;
+      case "Invites":
+        contractName = "InvitesV2";
+        contract = "contracts/invite/InvitesV2.sol:InvitesV2";
+        break;
+      case "ProxyFactory":
+        proxy = "";
+        contractName = "ProxyFactory1967";
+        contract = "contracts/utils/ProxyFactory1967.sol:ProxyFactory1967";
+        break;
+      case "NameService":
+        contract = "contracts/utils/NameService.sol:NameService";
+        break;
+      case "GReputation":
+        contract = "contracts/governance/GReputation.sol:GReputation";
+        break;
+      case "Identity":
+        contractName = "IdentityV2";
+        contract = "contracts/identity/IdentityV2.sol:IdentityV2";
+        break;
+      case "GoodDollarStaking":
+        proxy = "";
+        contract =
+          "contracts/governance/GoodDollarStaking.sol:GoodDollarStaking";
+        constructorArguments = [
+          release.NameService,
+          ethers.BigNumber.from(settings.savings.blockAPY),
+          ethers.BigNumber.from(settings.savings.blocksPerYear),
+          settings.savings.daysUntilUpgrade
+        ];
+        forcedConstructorArguments = ethers.utils.defaultAbiCoder.encode(
+          ["address", "uint128", "uint128", "uint32"],
+          constructorArguments
+        );
+        break;
+      case "GoodDollar":
+        proxy = "--custom-proxy UUPSProxy";
+        contractName = "SuperGoodDollar";
+        contract =
+          "contracts/token/superfluid/SuperGoodDollar.sol:SuperGoodDollar";
+        constructorArguments = [settings.superfluidHost];
+        forcedConstructorArguments = ethers.utils.defaultAbiCoder.encode(
+          ["address"],
+          constructorArguments
+        );
+        break;
+      default:
+        contract = undefined;
+    }
+
+    if (withTruffle) {
+      if (key === "GoodDollar") {
+        //verify the proxy first without constructor args (truffle verify plugin bug)
+        const cmd = `npx truffle run verify ${proxy} ${contractName}@${address} --network ${networkProvider}`;
+        console.log("running...:", cmd);
+        await exec(cmd).then(({ stdout, stderr }) => {
+          console.log("Result for:", cmd);
+          console.log(stdout);
+          console.log(stderr);
+        });
+      }
+      const cmd = `npx truffle run verify ${proxy} ${contractName}@${address} ${
+        forcedConstructorArguments
+          ? "--forceConstructorArgs string:" +
+            forcedConstructorArguments.slice(2)
+          : ""
+      } --network ${networkProvider}`;
+
+      console.log("running...:", cmd);
+
+      ps.push(
+        exec(cmd).then(({ stdout, stderr }) => {
+          console.log("Result for:", cmd);
+          console.log(stdout);
+          console.log(stderr);
+        })
+      );
+      await delay(1000);
+    } else {
+      let task = "verify";
+      let params = {
+        address,
+        contract
+      };
+      if (
+        constructorArguments.length > 0 &&
+        contract.includes("SuperGoodDollar") === false
+      ) {
+        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)
+      );
+    }
+  }
+
+  await Promise.all(ps);
+};
+
+main().catch(e => console.log(e));

package/scripts/test/localOldDaoDeploy.ts

@@ -23,6 +23,7 @@ import FundManager from "@gooddollar/goodcontracts/stakingModel/build/contracts/
 import SimpleDAIStaking from "@gooddollar/goodcontracts/stakingModel/build/contracts/SimpleDAIStaking.json";
 import BridgeMock from "@gooddollar/goodcontracts/stakingModel/build/contracts/BridgeMock.json";
 import DonationsStaking from "@gooddollar/goodcontracts/upgradables/build/contracts/DonationsStaking.json";
+import AdminWalletABI from "@gooddollar/goodcontracts/build/contracts/AdminWallet.json";
 import OTPABI from "@gooddollar/goodcontracts/build/contracts/OneTimePayments.json";
 
 import releaser from "../releaser";
@@ -106,9 +107,15 @@ export const deploy = async (networkName = name, single = false) => {
 
 const deployAdminWallet = async dao => {
   const signers = await ethers.getSigners();
-  const adminWallet = await upgrades.deployProxy(
-    await ethers.getContractFactory("AdminWallet"),
-    [signers.slice(0, 20).map(_ => _.address), signers[0].address, dao.identity]
+  const adminWallet = await new ethers.ContractFactory(
+    AdminWalletABI.abi,
+    AdminWalletABI.bytecode,
+    signers[0]
+  ).deploy(
+    signers.slice(0, 10).map(_ => _.address),
+    ethers.utils.parseUnits("1000000", "gwei"),
+    4,
+    dao.identity
   );
 
   const id = await ethers.getContractAt("IIdentity", dao.identity);