@gooddollar/goodprotocol 1.0.29-beta.0 → 1.0.29-beta.2

package/scripts/analytics/activeUsersCount.ts

@@ -0,0 +1,65 @@
+import { range, chunk, uniq } from "lodash";
+import { ethers as Ethers } from "hardhat";
+import fetch from "node-fetch";
+
+const ONE_DAY = 24 * 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 twoWeeksAgo = parseInt((Date.now() / 1000).toFixed(0)); //
+  //parseInt((Date.now() / 1000).toFixed(0)) - 24 * 60 * 60 * 14;
+
+  const daysAgo: number[] = range(0, 180, 1);
+  let curDay = twoWeeksAgo;
+  const allActive = [];
+  for (let day of daysAgo) {
+    const query = `
+      { 
+        walletStats(first:1000, where: { lastClaimed_lte: ${curDay},lastClaimed_gt: ${
+      curDay - ONE_DAY
+    } isActiveUser: true }) {
+        id        
+      }
+    }
+  `;
+
+    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());
+
+    console.log("got inactive 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_DAY;
+  }
+  const unique = uniq(allActive);
+  console.log("active claimers:", unique.length);
+};
+
+main();

package/scripts/analytics/activeWalletsStats.ts

@@ -0,0 +1,150 @@
+import { 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 curPage = 1;
+  let maxResult;
+  //   do {
+  //     const pages = range(curPage, curPage + 5, 1);
+  //     curPage += 5;
+  //     const ps = pages.map(p =>
+  //       fetch(
+  //         `https://explorer.fuse.io/api?module=token&action=getTokenHolders&contractaddress=0x495d133B938596C9984d462F007B676bDc57eCEC&page=${p}&offset=10000`
+  //       )
+  //         .then(_ => _.json())
+  //         .then(_ => _.result)
+  //     );
+  //     const results = await Promise.all(ps);
+  //     result = result.concat(...results);
+  //     maxResult = maxBy(results, "length");
+  //     console.log(maxResult.length, result.length);
+  //   } while (maxResult.length === 10000);
+  //   result.forEach(
+  //     r => (balances[r.address.toLowerCase()] = { balance: r.value, lastSeen: 0 })
+  //   );
+  //   fs.writeFileSync("activeWalletsBalances.json", JSON.stringify(balances));
+
+  balances = JSON.parse(
+    fs.readFileSync("activeWalletsBalances.json").toString()
+  );
+
+  const EPOCH = 60 * 60 * 6;
+  const pool = new PromisePool({ concurrency: 30 });
+  const lastUsed = {};
+  const epochs = range(1596045730, (Date.now() / 1000).toFixed(0), EPOCH);
+
+  const graphQuery = async (start, skip) => {
+    const query = `{
+        walletStats(first: 1000 skip:${skip} where: { dateAppeared_gte: ${start} dateAppeared_lt:${
+      start + EPOCH
+    } }) {
+          id
+          dateAppeared
+          balance
+          lastTransactionTo
+          lastTransactionFrom
+          lastClaimed
+        }
+      }`;
+    // console.log({ query });
+    try {
+      const { data = {}, errors } = await fetch(
+        "https://api.thegraph.com/subgraphs/name/gooddollar/gooddollarfuse",
+        {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({ query })
+        }
+      ).then(_ => _.json());
+      errors && console.log({ errors });
+      if (data?.walletStats?.length === 1000) {
+        return data.walletStats.concat(await graphQuery(start, skip + 1000));
+      }
+      return data.walletStats || [];
+    } catch (error) {
+      console.log({ query, error });
+      return [];
+    }
+  };
+  epochs.forEach(e => {
+    pool.add(async () => {
+      const walletStats = await graphQuery(e, 0);
+      walletStats.forEach(w => {
+        balances[w.id.toLowerCase()] = {
+          lastSeen: Math.max(
+            Number(w.lastClaimed),
+            Number(w.lastTransactionFrom),
+            Number(w.lastTransactionTo),
+            Number(w.dateAppeared)
+          ),
+          balance: balances[w.id.toLowerCase()]?.balance || w.balance
+        };
+      });
+      console.log({ curDate: e, records: walletStats.length });
+    });
+  });
+
+  await pool.all();
+  fs.writeFileSync("activeWalletsLastUsed.json", JSON.stringify(balances));
+  //   console.log({ lastUsed });
+};
+
+const etl = async () => {
+  /** Convert a 2D array into a CSV string
+   */
+  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 balances = JSON.parse(
+    fs.readFileSync("activeWalletsLastUsed.json").toString()
+  );
+
+  let result = [];
+
+  for (let addr in balances) {
+    const r = balances[addr];
+    if (!r.balance) {
+      continue;
+    }
+    result.push([addr, r.balance / 100, r.lastSeen, false]);
+  }
+  const top100 = result.slice(0, 100);
+  const pool = new PromisePool({ concurrency: 30 });
+  const provider = new ethers.providers.JsonRpcBatchProvider(
+    "https://rpc.fuse.io"
+  );
+
+  for (let idx in top100) {
+    pool.add(async () => {
+      const record = top100[idx];
+      let isContract =
+        (await provider.getCode(record[0]).catch(e => "0x")) !== "0x";
+      record[3] = isContract;
+    });
+  }
+  await pool.all();
+  console.log({ top100 });
+  fs.writeFileSync(
+    "activeWalletsLastUsed.csv",
+    arrayToCsv(sortBy(result, _ => -Number(_[1])))
+  );
+};
+// main().catch(e => console.log(e));
+etl();

package/scripts/analytics/claimIncidentStats.ts

@@ -0,0 +1,117 @@
+import { countBy, chunk, difference, flatten, sortBy } from "lodash";
+import fs from "fs";
+import fetch from "node-fetch";
+import { network, ethers, upgrades } from "hardhat";
+import { Contract, Provider, setMulticallAddress } from "ethers-multicall";
+import Identity from "../../artifacts/contracts/Interfaces.sol/IIdentity.json";
+
+setMulticallAddress(122, "0x3CE6158b7278Bf6792e014FA7B4f3c6c46fe9410");
+const CLAIM_START_BLOCK = 17896430;
+
+const fuseProvider = new ethers.providers.JsonRpcBatchProvider(
+  "https://explorer-node.fuse.io/"
+  // "https://rpc.fuse.io"
+);
+const ethcallProvider = new Provider(fuseProvider, 122);
+
+const GD_FUSE = "0x495d133b938596c9984d462f007b676bdc57ecec";
+const IDENTITY_FUSE = "0xFa8d865A962ca8456dF331D78806152d3aC5B84F";
+
+let gd = new ethers.Contract(
+  GD_FUSE,
+  [
+    "event Transfer(address indexed from, address indexed to, uint amount)",
+    "function balanceOf(address) view returns(uint256)"
+  ],
+  fuseProvider
+);
+const gdMulti = new Contract(GD_FUSE, [
+  "event Transfer(address indexed from, address indexed to, uint amount)",
+  "function balanceOf(address) view returns(uint256)"
+]);
+
+const hasBalanceToRefund = async wallets => {
+  const chunks = chunk(wallets, 1000);
+  let balances = {};
+  for (let batch of chunks) {
+    const calls = batch.map(a => gdMulti.balanceOf(a));
+    const result = await ethcallProvider.all(calls);
+    console.log("batch:", batch.length, calls.length, result.length);
+    batch.forEach((d, i) => (balances[d] = result[i]));
+  }
+  console.log("got balances for:", Object.entries(balances).length);
+  const hasBalance = countBy(balances, v => v >= 9622260);
+  const noBalance = Object.entries(balances).filter(([k, v]) => v < 9622260);
+  console.log({ hasBalance });
+  return noBalance.map(_ => _[0]);
+};
+
+const hasRefunded = async wallets => {
+  const curBlock = (await gd.provider.getBlockNumber()) - 1;
+  console.log({ curBlock });
+  let toBlock = CLAIM_START_BLOCK + 50000;
+  let refunded = [];
+  let startBlock = CLAIM_START_BLOCK;
+  while (startBlock <= curBlock) {
+    const events = await gd.queryFilter(
+      gd.filters.Transfer(
+        undefined,
+        "0xd253A5203817225e9768C05E5996d642fb96bA86"
+      ),
+      startBlock,
+      toBlock
+    );
+    const accounts = events
+      .filter(e => e.args.amount >= 9622260)
+      .map(_ => _.args.from.toLowerCase());
+    refunded.push(...accounts);
+    console.log("has refunded:", {
+      startBlock,
+      toBlock,
+      accounts: accounts.length
+    });
+    toBlock = Math.min(curBlock, toBlock + 50000);
+    startBlock += 50000;
+  }
+  return refunded;
+};
+
+const whereIsTheMoney = async noBalance => {
+  let targets = [];
+  for (let batch of chunk(noBalance, 100)) {
+    const tos = await Promise.all(
+      batch.map(async a => {
+        const e = await gd.queryFilter(
+          gd.filters.Transfer(a),
+          CLAIM_START_BLOCK
+        );
+        const tos = e.filter(_ => _.args.amount > 1000000).map(_ => _.args.to);
+        return tos;
+      })
+    );
+    targets.push(...flatten(tos));
+  }
+  const targetCounter = countBy(targets, _ => _);
+  console.log(
+    "transfer targets:",
+    sortBy(Object.entries(targetCounter), "1").reverse()
+  );
+};
+const main = async () => {
+  const wallets = JSON.parse(fs.readFileSync("torefund.json").toString()).map(
+    _ => _.toLowerCase()
+  );
+  console.log("Total Claimed:", wallets.length);
+  const refunded = await hasRefunded(wallets);
+  const notRefunded = difference(wallets, refunded);
+  console.log(
+    "refunded:",
+    refunded.length,
+    "not refunded:",
+    notRefunded.length
+  );
+
+  const noBalanceToRefund = await hasBalanceToRefund(notRefunded);
+  await whereIsTheMoney(noBalanceToRefund);
+};
+main().catch(e => console.log(e));

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/0_proxyFactory-deploy.ts

@@ -0,0 +1,45 @@
+import { network, ethers, upgrades, run } from "hardhat";
+import { Contract } from "ethers";
+
+import { deployDeterministic, printDeploy } from "./helpers";
+import releaser from "../../scripts/releaser";
+import dao from "../../releases/deployment.json";
+
+const { name } = network;
+
+export const deployProxy = async (defaultAdmin = null) => {
+  let release: { [key: string]: any } = dao[network.name] || {};
+
+  if (network.name.match(/production|staging|fuse/) && release.ProxyFactory) {
+    throw new Error("ProxyFactory already exists for env");
+  }
+  let [root] = 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())
+  });
+
+  const proxyFactory = await (
+    await ethers.getContractFactory("ProxyFactory1967")
+  ).deploy();
+
+  release = {
+    ProxyFactory: proxyFactory.address
+  };
+  await releaser(release, network.name, "deployment", false);
+};
+
+export const main = async (networkName = name) => {
+  await deployProxy().catch(console.log);
+};
+
+if (process.argv[1].includes("proxyFactory-deploy")) {
+  main();
+}