@gooddollar/goodprotocol 1.0.28 → 1.0.29-beta.1

package/scripts/analytics/faucetStats.ts

@@ -0,0 +1,103 @@
+import { range, sortBy, toPairs } from "lodash";
+import fetch from "node-fetch";
+import PromisePool from "async-promise-pool";
+import fs from "fs";
+import { ethers } from "hardhat";
+import { start } from "repl";
+import { JsonRpcProvider } from "@ethersproject/providers";
+import { off } from "process";
+
+function arrayToCsv(data) {
+  return data
+    .map(
+      row =>
+        row
+          .map(String) // convert every value to String
+          .map(v => v.replaceAll('"', '""')) // escape double colons
+          .map(v => `"${v}"`) // quote it
+          .join(",") // comma-separated
+    )
+    .join("\r\n"); // rows starting on new lines
+}
+
+const main = async () => {
+  const archive = new JsonRpcProvider("https://explorer-node.fuse.io");
+  const blockStep = 10000;
+  const pool = new PromisePool({ concurrency: 10 });
+
+  let faucet = await ethers.getContractAt(
+    ["event WalletTopped(address indexed user, uint256 amount)"],
+    "0x01ab5966C1d742Ae0CFF7f14cC0F4D85156e83d9"
+  );
+  const endBlock = Number(await ethers.provider.getBlockNumber());
+  const daysBack = 30;
+  const dayBlocks = 12 * 60 * 24;
+  const startBlock = endBlock - dayBlocks * daysBack;
+  const days = range(startBlock, endBlock, dayBlocks);
+  const dailyBalance = [];
+  for (let day of days) {
+    dailyBalance.push(
+      (
+        await archive.getBalance(
+          "0x01ab5966C1d742Ae0CFF7f14cC0F4D85156e83d9",
+          day
+        )
+      )
+        .div(1e10)
+        .toNumber() / 1e8
+    );
+  }
+  let curBlock = startBlock;
+
+  const toppingsByAddress = {};
+  const toppingsByAmount = {};
+  let totalToppings = 0;
+  let totalAmount = 0;
+  console.log({ dailyBalance });
+  console.log({ startBlock, endBlock });
+  while (curBlock <= endBlock) {
+    const fromBlock = curBlock;
+    const toBlock = Math.min(fromBlock + blockStep, endBlock);
+    pool.add(async () => {
+      const f = faucet.filters.WalletTopped();
+      const events = await faucet
+        .queryFilter(f, fromBlock, toBlock)
+        .catch(e => {
+          console.log("failed", { fromBlock, toBlock });
+          return [];
+        });
+      events.forEach(e => {
+        totalToppings += 1;
+        totalAmount += Number(e.args.amount);
+        toppingsByAddress[e.args.user] =
+          (toppingsByAddress[e.args.user] || 0) + 1;
+        toppingsByAmount[e.args.amount] =
+          (toppingsByAmount[e.args.amount] || 0) + 1;
+      });
+      console.log("fetched events", {
+        fromBlock,
+        toBlock,
+        events: events.length
+      });
+    });
+    curBlock += blockStep;
+  }
+  await pool.all();
+
+  const topToppers = sortBy(toPairs(toppingsByAddress), "1").reverse();
+  const topAmounts = sortBy(toPairs(toppingsByAmount), "1").reverse();
+  const totalWallets = topToppers.length;
+
+  const avgToppingsPerWallet = totalToppings / totalWallets;
+  const avgToppingAmount = totalAmount / totalToppings;
+
+  fs.writeFileSync("topToppers.csv", arrayToCsv(topToppers));
+  fs.writeFileSync("topAmounts.csv", arrayToCsv(topAmounts));
+  console.log({
+    totalAmount,
+    totalToppings,
+    avgToppingsPerWallet,
+    avgToppingAmount
+  });
+};
+main().catch(e => console.log(e));

package/scripts/analytics/goodHolders.ts

@@ -0,0 +1,50 @@
+import { last, range, sortBy } from "lodash";
+import fetch from "node-fetch";
+import PromisePool from "async-promise-pool";
+import fs from "fs";
+import { ethers } from "hardhat";
+
+const main = async () => {
+  let result = [];
+  let balances = {};
+  let lastAddr = ethers.constants.AddressZero;
+
+  const graphQuery = async (start, skip) => {
+    const query = `{
+      goodBalances(first:1000 orderBy:id orderDirection: asc where:{id_gt:"${start}" }) {
+          id
+          coreBalance
+          totalVotes
+        }
+      }`;
+    // console.log({ query });
+    try {
+      const { data = {}, errors } = await fetch(
+        "https://api.thegraph.com/subgraphs/name/gooddollar/gooddollarfuse2",
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({ query })
+        }
+      ).then(_ => _.json());
+      errors && console.log({ errors });
+      if (data?.goodBalances?.length === 1000) {
+        const nextAddr = last(data?.goodBalances).id;
+        console.log("fetching next page:", nextAddr);
+        return data.goodBalances.concat(await graphQuery(nextAddr, 0));
+      }
+      return data.goodBalances || [];
+    } catch (error) {
+      console.log({ query, error });
+      return [];
+    }
+  };
+  const goodBalances = await graphQuery(lastAddr, 0);
+  console.log("goodBalances:", goodBalances.length);
+  fs.writeFileSync("goodBalances.json", JSON.stringify(goodBalances));
+  //   console.log({ lastUsed });
+};
+
+main().catch(e => console.log(e));

package/scripts/governance/airdropCalculation.ts

@@ -1209,6 +1209,7 @@ export const airdrop = (
   const getProof = addr => {
     const { treeData, merkleRoot } = JSON.parse(
       fs.readFileSync("airdrop/airdrop.json").toString()
+      // fs.readFileSync("airdrop/airdropPrev.json").toString()
     );
 
     let entries = Object.entries(treeData as Tree);

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

@@ -1,13 +1,17 @@
+/***
+ * to get same addresses as on Celo
+ * deploy proxyfactory with 0x271cd5391016eb621aB3f9c0c70F5cF91DFd3FB0 with nonce 2
+ * create a gnosissafe with 0x3de7216149f12d8f51540d9a870149560fc11bfb with nonce 3
+ * run this script with 0x3de7216149f12d8f51540d9a870149560fc11bfb with nonce 7
+ */
 import { network, ethers, upgrades, run } from "hardhat";
-import pressAnyKey from "press-any-key";
 import { Contract } from "ethers";
 // import DAOCreatorABI from "@gooddollar/goodcontracts/build/contracts/DaoCreatorGoodDollar.json";
 import DAOCreatorABI from "../../../GoodBootstrap/packages/contracts/build/contracts/DaoCreatorGoodDollarWithRep.json";
 // import IdentityABI from "@gooddollar/goodcontracts/build/contracts/Identity.json";
 import IdentityABI from "../../../GoodBootstrap/packages/contracts/build/contracts/IdentityWithOwner.json";
 import FeeFormulaABI from "@gooddollar/goodcontracts/build/contracts/FeeFormula.json";
-// import AddFoundersABI from "@gooddollar/goodcontracts/build/contracts/AddFoundersGoodDollar.json";
-import AddFoundersABI from "../../../GoodBootstrap/packages/contracts/build/contracts/AddFoundersGoodDollarWithRep.json";
+import AddFoundersABI from "@gooddollar/goodcontracts/contracts/build/contracts/AddFoundersGoodDollarWithRep.json";
 
 import { deployDeterministic } from "./helpers";
 import releaser from "../../scripts/releaser";
@@ -50,6 +54,17 @@ export const createDAO = async () => {
       .then(_ => _.toString())
   });
 
+  if (network.name.includes("production")) {
+    const txCount = await root.getTransactionCount();
+    if (txCount !== 7) {
+      console.error(
+        "nonce doesnt match expected 7, to have same contract address",
+        { txCount }
+      );
+      return;
+    }
+  }
+
   const DAOCreatorFactory = new ethers.ContractFactory(
     DAOCreatorABI.abi,
     DAOCreatorABI.bytecode,
@@ -103,7 +118,7 @@ export const createDAO = async () => {
   const GReputation = (await deployDeterministic(
     {
       name: "GReputation",
-      isUpgradable: true,
+      isUpgradeable: true,
       initializer: "initialize(address, string, bytes32, uint256)"
     },
     [
@@ -173,7 +188,7 @@ export const createDAO = async () => {
     .then(printDeploy);
 
   const NameService = await deployDeterministic(
-    { name: "NameService", isUpgradable: true },
+    { name: "NameService", isUpgradeable: true },
     [
       controller,
       ["CONTROLLER", "AVATAR", "IDENTITY", "GOODDOLLAR"].map(_ =>

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

@@ -0,0 +1,232 @@
+/***
+ * complete deploy of the new G$ savings concept
+ * steps required:
+ * sidechain
+ * 1. deploy GoodDollarMintBurnWrapper
+ * 2. deploy G$Savings
+ * 3. create proposal to:
+ *  - add G$Savings as rewards minter on GoodDollarMintBurnWraper
+ *  - register GoodDollarMintBurnWrapper as scheme so it can call mint on controller
+ *  - register G$Savings as scheme so it can handle upgrade from GovernanceStaking
+ *  - add GoodDollarMintBurnWraper to name service
+ *
+ * mainnet:
+ * 1. deploy new reserve implementation
+ * 2. deploy DistributionHelper
+ * 3. create proposal to upgrade reserve
+ *
+ */
+
+import { network, ethers, upgrades, run } from "hardhat";
+import { Contract, Signer } from "ethers";
+
+import { deployDeterministic, printDeploy } from "./helpers";
+import releaser from "../../scripts/releaser";
+import ProtocolSettings from "../../releases/deploy-settings.json";
+import dao from "../../releases/deployment.json";
+import { deployWrapper } from "./multichainWrapper-deploy";
+import {
+  CompoundVotingMachine,
+  GoodDollarMintBurnWrapper,
+  Controller,
+  NameService
+} from "../../types";
+const { name: networkName } = network;
+
+const BLOCKS_PER_YEAR = (12 * 60 * 24 * 365).toString();
+const BLOCK_APY = "1000000007735630000";
+
+export const deploySidechain = async () => {
+  const isProduction = networkName.includes("production");
+  let release: { [key: string]: any } = dao[networkName];
+
+  let [root, ...signers] = await ethers.getSigners();
+  const proposer =
+    networkName !== "fuse"
+      ? new ethers.Wallet(process.env.PROPOSER_KEY, ethers.provider)
+      : root; //need proposer with 0.3% of GOOD tokens
+
+  console.log("got signers:", {
+    networkName,
+    root: root.address,
+    balance: await ethers.provider
+      .getBalance(root.address)
+      .then(_ => _.toString())
+  });
+
+  let Wrapper;
+  if (!release.GoodDollarMintBurnWrapper)
+    Wrapper = (await deployWrapper(
+      release.Avatar
+    )) as GoodDollarMintBurnWrapper;
+  else {
+    Wrapper = await ethers.getContractAt(
+      "GoodDollarMintBurnWrapper",
+      release.GoodDollarMintBurnWrapper
+    );
+  }
+
+  console.log("deploying savings...");
+
+  let GDSavings;
+  if (!release.GoodDollarStaking) {
+    GDSavings = (await deployDeterministic(
+      {
+        name: "GoodDollarStaking",
+        salt: isProduction ? "GoodDollarStaking" : "GoodDollarStakingV3",
+        isUpgradeable: false
+      },
+      [
+        release.NameService,
+        ethers.BigNumber.from(BLOCK_APY),
+        ethers.BigNumber.from(BLOCKS_PER_YEAR),
+        networkName === "fuse" ? 7 : 30 //days until upgrade
+      ]
+    ).then(printDeploy)) as Contract;
+
+    let torelease = {
+      GoodDollarStaking: GDSavings.address
+    };
+
+    await releaser(torelease, networkName, "deployment", false);
+  } else {
+    GDSavings = await ethers.getContractAt(
+      "GoodDollarStaking",
+      release.GoodDollarStaking
+    );
+  }
+
+  //create proposal
+  const vm = (await ethers.getContractAt(
+    "CompoundVotingMachine",
+    release.CompoundVotingMachine
+  )) as CompoundVotingMachine;
+
+  const ctrl = (await ethers.getContractAt(
+    "Controller",
+    release.Controller
+  )) as Controller;
+
+  const ns = (await ethers.getContractAt(
+    "NameService",
+    release.NameService
+  )) as NameService;
+
+  const proposalContracts = [
+    Wrapper.address, //MinterWrapper -> add GDSavings
+    ctrl.address, //controller -> add MinterWrapper as scheme
+    ctrl.address, // controller -> add GDSavings as scheme
+    ns.address //nameservice add MinterWrapper
+  ];
+
+  const proposalEthValues = proposalContracts.map(_ => 0);
+
+  const proposalFunctionSignatures = [
+    "addMinter(address,uint256,uint256,uint32,uint256,uint256,uint32,bool)",
+    "registerScheme(address,bytes32,bytes4,address)",
+    "registerScheme(address,bytes32,bytes4,address)",
+    "setAddress(string,address)"
+  ];
+
+  const proposalFunctionInputs = [
+    ethers.utils.defaultAbiCoder.encode(
+      [
+        "address",
+        "uint256",
+        "uint256",
+        "uint32",
+        "uint256",
+        "uint256",
+        "uint32",
+        "bool"
+      ],
+      [GDSavings.address, 0, 0, 30, 0, 0, 0, true]
+    ), //function addMinter(
+    ethers.utils.defaultAbiCoder.encode(
+      ["address", "bytes32", "bytes4", "address"],
+      [
+        Wrapper.address, //scheme
+        ethers.constants.HashZero, //paramshash
+        "0x00000001", //permissions - minimal
+        release.Avatar
+      ]
+    ),
+    ethers.utils.defaultAbiCoder.encode(
+      ["address", "bytes32", "bytes4", "address"],
+      [
+        GDSavings.address, //scheme
+        ethers.constants.HashZero, //paramshash
+        "0x000000f1", //permissions - genericcall
+        release.Avatar
+      ]
+    ),
+    ethers.utils.defaultAbiCoder.encode(
+      ["string", "address"],
+      ["MINTBURN_WRAPPER", Wrapper.address]
+    )
+  ];
+
+  if (networkName === "fuse") {
+    return executeViaGuardian(
+      proposalContracts,
+      proposalEthValues,
+      proposalFunctionSignatures,
+      proposalFunctionInputs,
+      root
+    );
+  }
+
+  console.log("creating proposal...");
+  await vm
+    .connect(proposer)
+    ["propose(address[],uint256[],string[],bytes[],string)"](
+      proposalContracts,
+      proposalEthValues,
+      proposalFunctionSignatures,
+      proposalFunctionInputs,
+      "https://discourse.gooddollar.org/t/gip-5-allocating-part-of-ubi-inflation-towards-g-savings-account/114/20"
+    )
+    .then(printDeploy);
+};
+
+const executeViaGuardian = async (
+  contracts,
+  ethValues,
+  functionSigs,
+  functionInputs,
+  guardian: Signer
+) => {
+  let release: { [key: string]: any } = dao[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]]
+    );
+    if (contract === ctrl.address) {
+      console.log("executing directly on controller:", sigHash, encoded);
+
+      await guardian
+        .sendTransaction({ to: contract, data: encoded })
+        .then(printDeploy);
+    } else {
+      console.log("executing genericCall:", sigHash, encoded);
+      await ctrl
+        .genericCall(contract, encoded, release.Avatar, ethValues[i])
+        .then(printDeploy);
+    }
+  }
+};
+
+export const main = async () => {
+  await deploySidechain().catch(console.log);
+};
+if (process.argv[1].includes("gdSavings")) main();

package/scripts/multichain-deploy/helpers.ts

@@ -1,9 +1,29 @@
-import { ContractFactory } from "ethers";
+import { Contract, ContractFactory, Signer } from "ethers";
 import { network, ethers, upgrades, run } from "hardhat";
+import { Contract } from "ethers";
+import { TransactionResponse } from "@ethersproject/providers";
+import dao from "../../releases/deployment.json";
 
+const networkName = network.name;
 let totalGas = 0;
 const gasUsage = {};
-const GAS_SETTINGS = {};
+const GAS_SETTINGS = { gasLimit: 5000000 };
+let release: { [key: string]: any } = dao[network.name];
+
+export 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 countTotalGas = async (tx, name) => {
   let res = tx;
   if (tx.deployTransaction) tx = tx.deployTransaction;
@@ -22,25 +42,30 @@ export const deployDeterministic = async (
 ) => {
   try {
     let proxyFactory;
-    if (!network.name.startsWith("production")) {
+    if (network.name.startsWith("develop")) {
       proxyFactory = await (
         await ethers.getContractFactory("ProxyFactory1967")
       ).deploy();
     } else
       proxyFactory = await ethers.getContractAt(
         "ProxyFactory1967",
-        "0x99C22e78A579e2176311c736C4c9F0b0D5A47806"
+        release.ProxyFactory
       );
     const Contract =
       (contract.factory as ContractFactory) ||
       (await ethers.getContractFactory(contract.name, factoryOpts));
 
     const salt = ethers.BigNumber.from(
-      ethers.utils.keccak256(ethers.utils.toUtf8Bytes(contract.name))
+      ethers.utils.keccak256(
+        ethers.utils.toUtf8Bytes(contract.salt || contract.name)
+      )
     );
 
-    if (contract.isUpgradable === true) {
-      console.log("Deploying:", contract.name, "using proxyfactory");
+    if (contract.isUpgradeable === true) {
+      console.log("Deploying:", contract.name, "using proxyfactory", {
+        args,
+        proxyFactory: proxyFactory.address
+      });
       const encoded = Contract.interface.encodeFunctionData(
         contract.initializer || "initialize",
         args
@@ -68,7 +93,10 @@ export const deployDeterministic = async (
       console.log("proxy deployed:", contract.name, proxyAddr);
       return Contract.attach(proxyAddr);
     } else {
-      console.log("Deploying:", contract.name, "using proxyfactory code");
+      console.log("Deploying:", contract.name, "using proxyfactory code", {
+        proxyFactory: proxyFactory.address,
+        args
+      });
       const constructor = Contract.interface.encodeDeploy(args);
       const bytecode = ethers.utils.solidityPack(
         ["bytes", "bytes"],
@@ -94,3 +122,40 @@ export const deployDeterministic = async (
     throw e;
   }
 };
+
+export const executeViaGuardian = async (
+  contracts,
+  ethValues,
+  functionSigs,
+  functionInputs,
+  guardian: Signer
+) => {
+  let release: { [key: string]: any } = dao[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]]
+    );
+    if (contract === ctrl.address) {
+      console.log("executing directly on controller:", sigHash, encoded);
+
+      await guardian
+        .sendTransaction({ to: contract, data: encoded })
+        .then(printDeploy);
+    } else {
+      console.log("executing genericCall:", sigHash, encoded);
+      await ctrl
+        .genericCall(contract, encoded, release.Avatar, ethValues[i])
+        .then(printDeploy);
+    }
+  }
+};

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

@@ -0,0 +1,56 @@
+import { network, ethers, upgrades, run } from "hardhat";
+import { Contract } from "ethers";
+
+import { deployDeterministic, printDeploy } from "./helpers";
+import releaser from "../../scripts/releaser";
+import ProtocolSettings from "../../releases/deploy-settings.json";
+import dao from "../../releases/deployment.json";
+
+const INITIAL_CAP = 100000000000; //1B G$s
+const { name } = network;
+
+export const deployWrapper = async (defaultAdmin = null) => {
+  let release: { [key: string]: any } = dao[network.name];
+
+  let [root, ...signers] = await ethers.getSigners();
+  //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("MintBurnWrapper deploy params:", [
+    release.GoodDollar,
+    defaultAdmin || release.GuardiansSafe,
+    release.NameService
+  ]);
+
+  const Wrapper = (await deployDeterministic(
+    {
+      name: "GoodDollarMintBurnWrapper",
+      salt: "MintBurnWrapper",
+      isUpgradeable: true
+    },
+    [defaultAdmin || release.GuardiansSafe, release.NameService]
+  ).then(printDeploy)) as Contract;
+
+  release = {
+    GoodDollarMintBurnWrapper: Wrapper.address
+  };
+  await releaser(release, network.name, "deployment", false);
+  return Wrapper;
+};
+
+export const main = async (networkName = name) => {
+  await deployWrapper().catch(console.log);
+};
+
+if (process.argv[1].includes("multichainWrapper")) {
+  main();
+}