@gooddollar/goodprotocol 1.0.30-beta.2 → 1.0.30-beta.3

package/scripts/multichain-deploy/helpers.ts

@@ -1,15 +1,31 @@
 import { Contract, ContractFactory, Signer } from "ethers";
 import { network, ethers, upgrades, run } from "hardhat";
-import { Contract } from "ethers";
+import * as safeethers from "ethers";
 import { TransactionResponse } from "@ethersproject/providers";
+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 dao from "../../releases/deployment.json";
 
-const networkName = network.name;
+const networkName =
+  network.name === "localhost" ? "production-mainnet" : network.name;
 let totalGas = 0;
 const gasUsage = {};
-const GAS_SETTINGS = { gasLimit: 5000000 };
-let release: { [key: string]: any } = dao[network.name];
+const GAS_SETTINGS = { gasLimit: 10000000 };
+let release: { [key: string]: any } = dao[networkName];
 
+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> => {
@@ -35,14 +51,46 @@ export const countTotalGas = async (tx, name) => {
   } else console.log("no gas data", { res, tx });
 };
 
+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 = {}
+  factoryOpts = {},
+  redeployProxyFactory = false
 ) => {
   try {
     let proxyFactory;
-    if (network.name.startsWith("develop")) {
+    if (networkName.startsWith("develop") && redeployProxyFactory) {
       proxyFactory = await (
         await ethers.getContractFactory("ProxyFactory1967")
       ).deploy();
@@ -152,10 +200,160 @@ export const executeViaGuardian = async (
         .sendTransaction({ to: contract, data: encoded })
         .then(printDeploy);
     } else {
-      console.log("executing genericCall:", sigHash, encoded);
+      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);
     }
   }
 };
+
+export const executeViaSafe = async (
+  contracts,
+  ethValues,
+  functionSigs,
+  functionInputs,
+  safeAddress: string,
+  safeSigner?: Signer
+) => {
+  if (!safeSigner && !process.env.SAFEOWNER_PRIVATE_KEY) {
+    throw new Error("safe signer is missing");
+  }
+  safeSigner =
+    safeSigner ||
+    new ethers.Wallet(process.env.SAFEOWNER_PRIVATE_KEY, ethers.provider);
+
+  const chainId = await safeSigner.getChainId();
+  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://client-gateway.celo-safe-prod.celo-networks-dev.org/";
+      break;
+  }
+  const ethAdapter = new EthersAdapter({
+    ethers: safeethers,
+    signerOrProvider: safeSigner
+  });
+
+  const safeService = new SafeClient({
+    txServiceUrl,
+    ethAdapter
+  });
+
+  const safeSdk = await Safe.create({ ethAdapter, safeAddress });
+
+  let release: { [key: string]: any } = dao[networkName];
+  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
+    );
+    if (contract === ctrl.address) {
+      const simulationResult = await ctrl.callStatic[functionSigs[i]](
+        ...functionInputs[i],
+        { from: safeAddress, value: ethValues[i] }
+      );
+      console.log("executing controller call:", {
+        sigHash,
+        encoded,
+        simulationResult
+      });
+      safeTransactionData.push({
+        to: ctrl.address,
+        value: ethValues[i],
+        data: encoded
+      });
+    } else {
+      console.log("executing genericCall:", {
+        sigHash,
+        encoded,
+        contract,
+        avatar: release.Avatar,
+        value: ethValues[i]
+      });
+      const simulationResult = await ctrl.callStatic.genericCall(
+        contract,
+        encoded,
+        release.Avatar,
+        ethValues[i],
+        { from: safeAddress }
+      );
+      console.log("executing genericCall:", {
+        sigHash,
+        simulationResult
+      });
+      const genericEncode = ctrl.interface.encodeFunctionData("genericCall", [
+        contract,
+        encoded,
+        release.Avatar,
+        ethValues[i]
+      ]);
+      safeTransactionData.push({
+        to: ctrl.address,
+        value: ethValues[i],
+        data: genericEncode
+      });
+    }
+  }
+
+  const safeTransaction = await safeSdk.createTransaction({
+    safeTransactionData
+  });
+
+  const safeTxHash = await safeSdk.getTransactionHash(safeTransaction);
+  const signedHash = await safeSdk.signTransactionHash(safeTxHash);
+
+  const senderAddress = await safeSigner.getAddress();
+  console.log("propose safe transaction", {
+    safeAddress,
+    safeTransactionData: safeTransaction.data,
+    safeTxHash,
+    senderSignature: signedHash,
+    senderAddress
+  });
+  await safeService.proposeTransaction({
+    safeAddress,
+    safeTransactionData: safeTransaction.data,
+    safeTxHash,
+    senderSignature: signedHash.data,
+    senderAddress
+  });
+};

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/staking/stakersGdRewardsCalculation.ts

@@ -2,52 +2,63 @@ import { range, chunk } from "lodash";
 import fs from "fs";
 import stakingContracts from "../../releases/deployment.json";
 import { ethers as Ethers } from "hardhat";
-import { BigNumber } from "ethereum-waffle/node_modules/ethers"; 
+import { BigNumber } from "ethers";
 
-const ZERO = BigNumber.from("0"); 
+const ZERO = BigNumber.from("0");
 
 export const sumStakersGdRewards = (ethers: typeof Ethers) => {
-    
-    const getStakersGdRewards = async (stakersToGdRewards = {}) => {
-        const provider = new ethers.providers.InfuraProvider();
-        
-        let goodFundManager = await ethers.getContractAt("GoodFundManager",stakingContracts["production-mainnet-bug"].GoodFundManager);
-        goodFundManager = goodFundManager.connect(provider);
-        const filter = goodFundManager.filters.StakingRewardMinted();
-
-        const step = 100000;
-        const ETH_START_BLOCK = 14291923; 
-        const ETH_END_BLOCK = await provider.getBlockNumber();
-        const blocks = range(ETH_START_BLOCK, ETH_END_BLOCK, step);
-
-        for (let blockChunk of chunk(blocks, 10)) {
-            const processedChunks = blockChunk.map(async bc => {
-                const stakingRewardsEvents = await goodFundManager
-                    .queryFilter(filter, bc, Math.min(bc + step - 1, ETH_END_BLOCK))
-                    .catch(e => {
-                    console.log("block transfer logs failed retrying...", bc);
-                    return goodFundManager.queryFilter(
-                        filter, bc, Math.min(bc + step - 1, ETH_END_BLOCK));
-                    });
-
-                const stakingRewardsEventsMapped = stakingRewardsEvents.map(async log => {
-                    const initBalance = stakersToGdRewards[log.args.staker] || ZERO;
-                    stakersToGdRewards[log.args.staker] = initBalance.add(log.args.gdReward);
-                    // console.log(`TransactionHash:\t${log.transactionHash}`);
-                    // console.log(`Staking contract:\t${log.args.stakingContract}`);
-                    // console.log(`Previous Balance:\t${initBalance.toString()} for address ${log.args.staker}`);
-                    // console.log(`Addition:\t\t${log.args.gdReward.toString()} for address ${log.args.staker}`);
-                    // console.log(`New Balance:\t\t${stakersToGdRewards[log.args.staker].toString()} for address ${log.args.staker}\n`);
-                    });
-                await Promise.all([...stakingRewardsEventsMapped]);
-            });
-            await Promise.all(processedChunks);
-        }   
-
-        console.log(`All stakers minted rewards:\n`);
-        Object.entries(stakersToGdRewards).forEach(a => { console.log(`${a[0].toString()}:${BigNumber.from(a[1]).toString()}\n`)}); 
-        // fs.writeFileSync("scripts/staking/stakersToGdRewards.json", JSON.stringify(stakersToGdRewards))
-    };
-    
-    return { getStakersGdRewards};
-}
+  const getStakersGdRewards = async (stakersToGdRewards = {}) => {
+    const provider = new ethers.providers.InfuraProvider();
+
+    let goodFundManager = await ethers.getContractAt(
+      "GoodFundManager",
+      stakingContracts["production-mainnet-bug"].GoodFundManager
+    );
+    goodFundManager = goodFundManager.connect(provider);
+    const filter = goodFundManager.filters.StakingRewardMinted();
+
+    const step = 100000;
+    const ETH_START_BLOCK = 14291923;
+    const ETH_END_BLOCK = await provider.getBlockNumber();
+    const blocks = range(ETH_START_BLOCK, ETH_END_BLOCK, step);
+
+    for (let blockChunk of chunk(blocks, 10)) {
+      const processedChunks = blockChunk.map(async bc => {
+        const stakingRewardsEvents = await goodFundManager
+          .queryFilter(filter, bc, Math.min(bc + step - 1, ETH_END_BLOCK))
+          .catch(e => {
+            console.log("block transfer logs failed retrying...", bc);
+            return goodFundManager.queryFilter(
+              filter,
+              bc,
+              Math.min(bc + step - 1, ETH_END_BLOCK)
+            );
+          });
+
+        const stakingRewardsEventsMapped = stakingRewardsEvents.map(
+          async log => {
+            const initBalance = stakersToGdRewards[log.args.staker] || ZERO;
+            stakersToGdRewards[log.args.staker] = initBalance.add(
+              log.args.gdReward
+            );
+            // console.log(`TransactionHash:\t${log.transactionHash}`);
+            // console.log(`Staking contract:\t${log.args.stakingContract}`);
+            // console.log(`Previous Balance:\t${initBalance.toString()} for address ${log.args.staker}`);
+            // console.log(`Addition:\t\t${log.args.gdReward.toString()} for address ${log.args.staker}`);
+            // console.log(`New Balance:\t\t${stakersToGdRewards[log.args.staker].toString()} for address ${log.args.staker}\n`);
+          }
+        );
+        await Promise.all([...stakingRewardsEventsMapped]);
+      });
+      await Promise.all(processedChunks);
+    }
+
+    console.log(`All stakers minted rewards:\n`);
+    Object.entries(stakersToGdRewards).forEach(a => {
+      console.log(`${a[0].toString()}:${BigNumber.from(a[1]).toString()}\n`);
+    });
+    // fs.writeFileSync("scripts/staking/stakersToGdRewards.json", JSON.stringify(stakersToGdRewards))
+  };
+
+  return { getStakersGdRewards };
+};

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);