@gooddollar/goodprotocol 2.1.4 → 2.2.0-beta.1

package/scripts/analytics/checkActiveWallets.ts

@@ -1,60 +0,0 @@
-import { countBy, chunk, difference, flatten, sortBy } from "lodash";
-import fs from "fs";
-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");
-
-setMulticallAddress(42220, "0x188C1bf697B66474dC3eaa119Ae691a8352537e3");
-
-const fuseProvider = new ethers.providers.JsonRpcBatchProvider(
-  "https://explorer-node.fuse.io/"
-  // "https://rpc.fuse.io"
-);
-const celoProvider = new ethers.providers.JsonRpcBatchProvider(
-  "https://forno.celo.org"
-  // "https://rpc.fuse.io"
-);
-const ethcallProvider = new Provider(fuseProvider, 122);
-const ethcallProviderCelo = new Provider(celoProvider, 42220);
-
-const GD_FUSE = "0x495d133b938596c9984d462f007b676bdc57ecec";
-const GD_CELO = "0x62B8B11039FcfE5aB0C56E502b1C372A3d2a9c7A";
-
-const gdMulti = new Contract(GD_FUSE, [
-  "event Transfer(address indexed from, address indexed to, uint amount)",
-  "function balanceOf(address) view returns(uint256)"
-]);
-const gdMultiCelo = new Contract(GD_CELO, [
-  "event Transfer(address indexed from, address indexed to, uint amount)",
-  "function balanceOf(address) view returns(uint256)"
-]);
-
-const hasBalance = async wallets => {
-  console.log("checking balances for:", wallets.length);
-  const chunks = chunk(wallets, 100);
-  let balances = {};
-  let users = [];
-  for (let batch of chunks) {
-    const calls = batch.map(a => gdMultiCelo.balanceOf(a));
-    const result = await ethcallProviderCelo.all(calls);
-    const found = batch.filter((d, i) => result[i] > 0);
-    console.log("batch:", batch.length, calls.length, result.length, found.length);
-    users = users.concat(found);
-  }
-  console.log("got balances for:", Object.entries(balances).length, "found users:", users.length);
-  console.log(users);
-};
-
-const main = async () => {
-  const wallets = fs
-    .readFileSync("accounts.csv")
-    .toString()
-    .split("\n")
-    .map(l => l.split(",")[0])
-    .filter(a => a.startsWith("0x"));
-
-  const refunded = await hasBalance(wallets);
-};
-main().catch(e => console.log(e));

package/scripts/analytics/checkBridgeBalances.ts

@@ -1,442 +0,0 @@
-import { groupBy, range, sortBy } from "lodash";
-import PromisePool from "async-promise-pool";
-import fs from "fs";
-import { Provider, setMulticallAddress } from "ethers-multicall";
-
-import { ethers } from "hardhat";
-import { Retrier } from "@jsier/retrier";
-import { BigNumber } from "ethers";
-import EthDater from "ethereum-block-by-date";
-
-setMulticallAddress(122, "0x3CE6158b7278Bf6792e014FA7B4f3c6c46fe9410");
-// "https://celo-mainnet-archive.allthatnode.com" : "https://explorer-node.fuse.io"
-
-const celoProvider = new ethers.providers.JsonRpcProvider("https://celo-mainnet-archive.allthatnode.com");
-const fuseProvider = new ethers.providers.JsonRpcProvider("https://explorer-node.fuse.io");
-const ethProvider = new ethers.providers.JsonRpcProvider("https://ethereum-mainnet-archive.allthatnode.com");
-
-const GD_CELO = "0x62B8B11039FcfE5aB0C56E502b1C372A3d2a9c7A";
-const GD_FUSE = "0x495d133B938596C9984d462F007B676bDc57eCEC";
-const GD_ETH = "0x67C5870b4A41D4Ebef24d2456547A03F1f3e094B";
-const ETH_BRIDGES = [
-  "0xd17652350cfd2a37ba2f947c910987a3b1a1c60d",
-  "0xa3247276DbCC76Dd7705273f766eB3E8a5ecF4a5",
-  "0xD5D11eE582c8931F336fbcd135e98CEE4DB8CCB0",
-  "0x17B09b22823F00BB9b8ee2d4632E332cadC29458"
-];
-
-const CELO_MULTIBRIDGE = "0xf27Ee99622C3C9b264583dACB2cCE056e194494f";
-const CELO_MPBBRIDGE = "0xa3247276DbCC76Dd7705273f766eB3E8a5ecF4a5";
-let gd = new ethers.Contract(
-  GD_CELO,
-  [
-    "event Transfer(address indexed from, address indexed to, uint amount)",
-    "function balanceOf(address) view returns(uint256)",
-    "function totalSupply() view returns(uint256)"
-  ],
-  celoProvider
-);
-
-const multiBridge = new ethers.Contract(
-  CELO_MULTIBRIDGE,
-  [
-    "event LogAnySwapOut(address indexed token,address indexed from,address indexed to,uint256 amount,uint256 fromChainID,uint256 toChainID)",
-    "event LogAnySwapIn(bytes32 indexed txhash,address indexed token,address indexed to,uint256 amount,uint256 fromChainID, uint256 toChainID)"
-  ],
-  celoProvider
-);
-
-const mpbBridge = new ethers.Contract(
-  CELO_MPBBRIDGE,
-  [
-    "event BridgeRequest(address indexed from,address indexed to,uint256 targetChainId,uint256 normalizedAmount,uint256 timestamp,uint8 bridge,uint256 indexed id)",
-    "event ExecutedTransfer(address indexed from,address indexed to,uint256 normalizedAmount,uint256 fee,uint256 sourceChainId,uint8 bridge,uint256 indexed id)"
-  ],
-  celoProvider
-);
-const main = async () => {
-  console.log("starting...");
-
-  //   let mintFuse = await getTransferEvents(
-  //     gd.connect(new ethers.providers.JsonRpcProvider("https://rpc.fuse.io")).attach(GD_FUSE),
-  //     ethers.constants.AddressZero,
-  //     6000000,
-  //     undefined
-  //   );
-  //   fs.writeFileSync("mintFuse.json", JSON.stringify(mintFuse, null, 2));
-  //   mintFuse.forEach(log => (log.amount = log.args.amount.toString()));
-
-  //   const mintFuse = JSON.parse(fs.readFileSync("mintFuse.json").toString());
-
-  //   let mintCelo = await getTransferEvents(gd, ethers.constants.AddressZero, 17000000, undefined);
-  //   fs.writeFileSync("mintCelo.json", JSON.stringify(mintCelo, null, 2));
-
-  if (false) {
-    let multiOut = await fetch(
-      "https://explorer.celo.org/mainnet/api?module=logs&action=getLogs&fromBlock=0&toBlock=latest&address=0xf27Ee99622C3C9b264583dACB2cCE056e194494f&topic0=0x97116cf6cd4f6412bb47914d6db18da9e16ab2142f543b86e207c24fbd16b23a&topic1=0x0000000000000000000000005566b6e4962ba83e05a426ad89031ec18e9cadd3&topic0_1_opr=and"
-    )
-      .then(_ => _.json())
-      .then(_ => _.result);
-
-    console.log("multiOut");
-    let multiIn = await fetch(
-      "https://explorer.celo.org/mainnet/api?module=logs&action=getLogs&fromBlock=0&toBlock=latest&address=0xf27Ee99622C3C9b264583dACB2cCE056e194494f&topic0=0xaac9ce45fe3adf5143598c4f18a369591a20a3384aedaf1b525d29127e1fcd55&topic2=0x0000000000000000000000005566b6e4962ba83e05a426ad89031ec18e9cadd3&topic0_2_opr=and"
-    )
-      .then(_ => _.json())
-      .then(_ => _.result);
-
-    console.log("multiIn");
-    let multiInFuse = await fetch(
-      "https://explorer.fuse.io/api?module=logs&action=getLogs&fromBlock=0&toBlock=latest&address=0x735aBE48e8782948a37C7765ECb76b98CdE97B0F&topic0=0xaac9ce45fe3adf5143598c4f18a369591a20a3384aedaf1b525d29127e1fcd55&topic2=0x000000000000000000000000031b2b7c7854dd8ee9c4a644d7e54ad17f56e3cb&topic0_2_opr=and"
-    )
-      .then(_ => _.json())
-      .then(_ => _.result);
-
-    console.log("multiInFuse");
-    let multiOutFuse = await fetch(
-      "https://explorer.fuse.io/api?module=logs&action=getLogs&fromBlock=0&toBlock=latest&address=0x735aBE48e8782948a37C7765ECb76b98CdE97B0F&topic0=0x97116cf6cd4f6412bb47914d6db18da9e16ab2142f543b86e207c24fbd16b23a&topic1=0x000000000000000000000000031b2b7c7854dd8ee9c4a644d7e54ad17f56e3cb&topic0_1_opr=and"
-    )
-      .then(_ => _.json())
-      .then(_ => _.result);
-
-    console.log("multiOutFuse");
-    let mpbOut = await fetch(
-      "https://explorer.celo.org/mainnet/api?module=logs&action=getLogs&fromBlock=0&toBlock=latest&address=0xa3247276DbCC76Dd7705273f766eB3E8a5ecF4a5&topic0=0xabeeb7182c7294cd8efcd40e9ff952c1b759c2165b3634aac589429de5d55ad0"
-    )
-      .then(_ => _.json())
-      .then(_ => _.result);
-
-    console.log("mpbOut");
-    let mpbIn = await fetch(
-      "https://explorer.celo.org/mainnet/api?module=logs&action=getLogs&fromBlock=0&toBlock=latest&address=0xa3247276DbCC76Dd7705273f766eB3E8a5ecF4a5&topic0=0x6cf712ce908185c8c38a073b7315f79687e7440fb057d9d1ca76a2509a1282ee"
-    )
-      .then(_ => _.json())
-      .then(_ => _.result);
-
-    console.log("mpbIn");
-    let mpbOutFuse = await fetch(
-      "https://explorer.fuse.io/api?module=logs&action=getLogs&fromBlock=0&toBlock=latest&address=0xa3247276DbCC76Dd7705273f766eB3E8a5ecF4a5&topic0=0xabeeb7182c7294cd8efcd40e9ff952c1b759c2165b3634aac589429de5d55ad0"
-    )
-      .then(_ => _.json())
-      .then(_ => _.result);
-
-    console.log("mpbOutFuse");
-    let mpbInFuse = await fetch(
-      "https://explorer.fuse.io/api?module=logs&action=getLogs&fromBlock=0&toBlock=latest&address=0xa3247276DbCC76Dd7705273f766eB3E8a5ecF4a5&topic0=0x6cf712ce908185c8c38a073b7315f79687e7440fb057d9d1ca76a2509a1282ee"
-    )
-      .then(_ => _.json())
-      .then(_ => _.result);
-
-    console.log("mpbInFuse");
-    let outFuse = await fetch(
-      "https://explorer.fuse.io/api?module=logs&action=getLogs&fromBlock=0&toBlock=latest&address=0x495d133B938596C9984d462F007B676bDc57eCEC&topic0=0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef&topic1=0x000000000000000000000000d39021db018e2caeadb4b2e6717d31550e7918d0&topic2=0x0000000000000000000000000000000000000000000000000000000000000000&topic1_2_opr=and&topic0_1_opr=and&topic0_2_opr=and"
-    )
-      .then(_ => _.json())
-      .then(_ => _.result);
-
-    console.log("outFuse");
-    let inFuse = await fetch(
-      "https://explorer.fuse.io/api?module=logs&action=getLogs&fromBlock=0&toBlock=latest&address=0xD39021DB018E2CAEadb4B2e6717D31550e7918D0&topic0=0x2f9a6098d4503a127779ba975f5f6b04f842362b1809f346989e9abc0b4dedb6"
-    )
-      .then(_ => _.json())
-      .then(_ => _.result);
-
-    console.log("inFuse");
-
-    let outFuse2 = await fetch(
-      "https://explorer.fuse.io/api?module=logs&action=getLogs&fromBlock=0&toBlock=latest&address=0x495d133B938596C9984d462F007B676bDc57eCEC&topic0=0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef&topic1=0x000000000000000000000000e24957CB0f0001A03314C72E6EBC331436e2f7F60&topic2=0x0000000000000000000000000000000000000000000000000000000000000000&topic1_2_opr=and&topic0_1_opr=and&topic0_2_opr=and"
-    )
-      .then(_ => _.json())
-      .then(_ => _.result);
-
-    console.log("outFuse");
-    let inFuse2 = await fetch(
-      "https://explorer.fuse.io/api?module=logs&action=getLogs&fromBlock=0&toBlock=latest&address=0xe24957CB0f0001A03314C72E6EBC331436e2f7F6&topic0=0x6fc115a803b8703117d9a3956c5a15401cb42401f91630f015eb6b043fa76253"
-    )
-      .then(_ => _.json())
-      .then(_ => _.result);
-
-    mpbIn.forEach(log => {
-      log.params = ethers.utils.defaultAbiCoder.decode(["uint256", "uint256", "uint256", "uint8"], log.data);
-      log.amount = log.params[0];
-    });
-    mpbOut.forEach(log => {
-      log.params = ethers.utils.defaultAbiCoder.decode(["uint256", "uint256", "uint256", "uint8"], log.data);
-      log.amountOut = log.params[1];
-    });
-    mpbInFuse.forEach(log => {
-      log.params = ethers.utils.defaultAbiCoder.decode(["uint256", "uint256", "uint256", "uint8"], log.data);
-      log.amount = log.params[0];
-    });
-    mpbOutFuse.forEach(log => {
-      log.params = ethers.utils.defaultAbiCoder.decode(["uint256", "uint256", "uint256", "uint8"], log.data);
-      log.amountOut = log.params[1];
-    });
-
-    multiIn.forEach(log => {
-      log.params = ethers.utils.defaultAbiCoder.decode(["uint256", "uint256", "uint256"], log.data);
-      log.amount = log.params[0];
-    });
-    multiOut.forEach(log => {
-      log.params = ethers.utils.defaultAbiCoder.decode(["uint256", "uint256", "uint256"], log.data);
-      log.amountOut = log.params[0];
-    });
-
-    multiInFuse.forEach(log => {
-      log.params = ethers.utils.defaultAbiCoder.decode(["uint256", "uint256", "uint256"], log.data);
-      log.amount = log.params[0];
-    });
-    multiOutFuse.forEach(log => {
-      log.params = ethers.utils.defaultAbiCoder.decode(["uint256", "uint256", "uint256"], log.data);
-      log.amountOut = log.params[0];
-    });
-
-    inFuse.forEach(log => {
-      log.params = ethers.utils.defaultAbiCoder.decode(["uint256"], log.data);
-      log.amount = log.params[0];
-    });
-    outFuse.forEach(log => {
-      log.params = ethers.utils.defaultAbiCoder.decode(["uint256"], log.data);
-      log.amountOut = log.params[0];
-    });
-
-    outFuse2.forEach(log => {
-      log.params = ethers.utils.defaultAbiCoder.decode(["uint256"], log.data);
-      log.amountOut = log.params[0];
-    });
-    inFuse2.forEach(log => {
-      log.params = ethers.utils.defaultAbiCoder.decode(["address", "uint256", "bytes32"], log.data);
-      log.amount = log.params[1];
-    });
-
-    //   console.log({
-    //     mpbOut: mpbOut.length,
-    //     mpbIn: mpbIn.length,
-    //     multiOut: multiOut.length,
-    //     multiIn: multiIn.length,
-    //     multiInFuse: multiInFuse.length,
-    //     multiOutFuse: multiOutFuse.length,
-    //     mpbInFuse: mpbInFuse.length,
-    //     mpbOutFuse: mpbOutFuse.length,
-    //     inFuse: inFuse.length,
-    //     outFuse: outFuse.length,
-    //     inFuse2: inFuse2.length,
-    //     outFuse2: outFuse2.length
-    //     // mintFuse: mintFuse.length
-    //   });
-
-    //   //   const found = []
-    //   //     .concat(mpbIn, multiIn, multiInFuse, mpbInFuse, inFuse)
-    //   //     .filter(_ => _.params[0].gt(ethers.constants.WeiPerEther.mul(180000000)));
-
-    //   const found = [].concat(mpbIn, multiIn, multiInFuse, mpbInFuse, inFuse, inFuse2);
-
-    //   const bytx = Object.entries(groupBy(found, _ => _.transactionHash)).filter((k, v) => (v as any).length > 1);
-
-    //   console.log({ bytx });
-
-    //   //   const bridgeMintsTxs = found.map(_ => _.transactionHash);
-    //   //   const nonBridgeMints = mintCelo.filter(l => !bridgeMintsTxs.includes(l.transactionHash));
-    //   //   console.log(
-    //   //     "nonbridgemints celo:",
-    //   //     nonBridgeMints.map(_ => _.transactionHash)
-    //   //   );
-    //   //   return;
-
-    //   let totalMpbOut = mpbOut
-    //     .filter(_ => _.params[0].eq(1))
-    //     .reduce((prev, cur) => prev.add(ethers.BigNumber.from(cur.params[1])), ethers.constants.Zero);
-
-    //   let totalMpbIn = mpbIn
-    //     .filter(_ => _.params[2].eq(1))
-    //     .reduce((prev, cur) => prev.add(ethers.BigNumber.from(cur.params[0])), ethers.constants.Zero);
-
-    //   totalMpbOut = mpbOutFuse
-    //     .filter(_ => _.params[0].eq(1))
-    //     .reduce((prev, cur) => prev.add(ethers.BigNumber.from(cur.params[1])), totalMpbOut);
-
-    //   totalMpbIn = mpbInFuse
-    //     .filter(_ => _.params[2].eq(1))
-    //     .reduce((prev, cur) => prev.add(ethers.BigNumber.from(cur.params[0])), totalMpbIn);
-
-    //   let totalMultiOut = multiOut
-    //     .filter(l => l.params[2].eq(1))
-    //     .reduce((prev, cur) => prev.add(ethers.BigNumber.from(cur.params[0])), ethers.constants.Zero);
-
-    //   let totalMultiIn = multiIn
-    //     .filter(l => l.params[1].eq(1))
-    //     .reduce((prev, cur) => prev.add(ethers.BigNumber.from(cur.params[0])), ethers.constants.Zero);
-
-    //   totalMultiOut = multiOutFuse
-    //     .filter(l => l.params[2].eq(1))
-    //     .reduce((prev, cur) => prev.add(ethers.BigNumber.from(cur.params[0])), totalMultiOut);
-    //   totalMultiIn = multiInFuse
-    //     .filter(l => l.params[1].eq(1))
-    //     .reduce((prev, cur) => prev.add(ethers.BigNumber.from(cur.params[0])), totalMultiIn);
-
-    //   let totalInFuse = inFuse.reduce((prev, cur) => prev.add(ethers.BigNumber.from(cur.params[0])), ethers.constants.Zero);
-
-    //   let totalOutFuse = outFuse.reduce(
-    //     (prev, cur) => prev.add(ethers.BigNumber.from(cur.params[0])),
-    //     ethers.constants.Zero
-    //   );
-
-    //   let totalInFuse2 = inFuse2.reduce(
-    //     (prev, cur) => prev.add(ethers.BigNumber.from(cur.params[0])),
-    //     ethers.constants.Zero
-    //   );
-
-    //   let totalOutFuse2 = outFuse2.reduce(
-    //     (prev, cur) => prev.add(ethers.BigNumber.from(cur.params[1])),
-    //     ethers.constants.Zero
-    //   );
-
-    //   console.log({
-    //     totalMpbOut,
-    //     totalMpbIn,
-    //     totalMultiOut,
-    //     totalMultiIn,
-    //     totalInFuse,
-    //     totalOutFuse,
-    //     totalInFuse2,
-    //     totalOutFuse2
-    //   });
-
-    //   const all = [].concat(
-    //     mpbIn.filter(_ => _.params[2].eq(1)),
-    //     mpbOut.filter(_ => _.params[0].eq(1)),
-    //     multiIn.filter(l => l.params[1].eq(1)),
-    //     multiOut.filter(l => l.params[2].eq(1)),
-    //     multiInFuse.filter(l => l.params[1].eq(1)),
-    //     multiOutFuse.filter(l => l.params[2].eq(1)),
-    //     mpbInFuse.filter(_ => _.params[2].eq(1)),
-    //     mpbOutFuse.filter(_ => _.params[0].eq(1)),
-    //     inFuse,
-    //     outFuse,
-    //     outFuse2,
-    //     inFuse2
-    //   );
-
-    //   fs.writeFileSync("allBridgeEvents.json", JSON.stringify(all));
-  }
-  const all = JSON.parse(fs.readFileSync("allBridgeEvents.json").toString());
-
-  let counter = 0;
-  let total = ethers.constants.Zero;
-  const gdEth = gd.connect(ethProvider).attach(GD_ETH);
-  const sorted = sortBy(all, _ => Number(_.timeStamp));
-  console.log(sorted.slice(0, 10));
-
-  const ethDater = new EthDater(ethProvider);
-  const fuseDater = new EthDater(fuseProvider);
-  const celoDater = new EthDater(celoProvider);
-
-  for (let log of sorted) {
-    if (log.amountOut) {
-      log.amountOut = ethers.BigNumber.from(log.amountOut.hex);
-      total = total.sub(
-        log.amountOut.gte(ethers.constants.WeiPerEther)
-          ? log.amountOut.div(ethers.constants.WeiPerEther)
-          : log.amountOut.div(100)
-      );
-    }
-    if (log.amount) {
-      log.amount = ethers.BigNumber.from(log.amount.hex);
-      total = total.add(
-        log.amount.gte(ethers.constants.WeiPerEther)
-          ? log.amount.div(ethers.constants.WeiPerEther)
-          : log.amount.div(100)
-      );
-    }
-    counter++;
-    if (
-      counter >= 1040 ||
-      (counter >= 950 && counter % 10 === 0) ||
-      counter % 100 === 0 ||
-      counter >= sorted.length - 1
-    ) {
-      //   const [tx, tx2] = await Promise.all([
-      //     fuseProvider.getTransaction(log.transactionHash),
-      //     celoProvider.getTransaction(log.transactionHash)
-      //   ]);
-      const timestamp = Number(log.timeStamp);
-      const [ethBlock, fuseBlock, celoBlock] = await Promise.all([
-        ethDater.getDate(timestamp * 1000, false, false),
-        fuseDater.getDate(timestamp * 1000, true, false),
-        celoDater.getDate(timestamp * 1000, true, false)
-      ]);
-      console.log("counter:", counter, timestamp, { ethBlock, fuseBlock, celoBlock });
-
-      const res = await Promise.all(
-        ETH_BRIDGES.map(b => gdEth.balanceOf(b, { blockTag: ethBlock.block }).catch(_ => ethers.constants.Zero))
-      );
-      const [onFuse, onCelo] = await Promise.all([
-        gd
-          .connect(fuseProvider)
-          .attach(GD_FUSE)
-          .totalSupply({ blockTag: fuseBlock.block })
-          .catch(_ => ethers.constants.Zero),
-        gd.totalSupply({ blockTag: celoBlock.block }).catch(_ => ethers.constants.Zero)
-      ]);
-      const onBridges = res.reduce((prev, cur) => prev.add(cur), ethers.constants.Zero).div(100);
-      console.log(
-        "bridged:" + total.toString(),
-        "on bridges:" + onBridges.toString(),
-        "on chains:",
-        onCelo.div(ethers.constants.WeiPerEther).add(onFuse.div(100)).toString(),
-        "time:",
-        timestamp,
-        {
-          onFuse,
-          onCelo
-        },
-        res.map(_ => _.toString())
-      );
-    }
-  }
-  //
-
-  //   console.log(txs.length);
-  //   fs.writeFileSync("stuckgd.json", JSON.stringify(txs));
-};
-
-const getTransferEvents = async (gd, from, fromBlock, toBlock) => {
-  const curBlock = toBlock || (await gd.provider.getBlockNumber());
-  let txs = [];
-  const f = gd.filters.Transfer(from, null);
-  const STEP_SIZE = 10000;
-  const fromBlocks = range(fromBlock, curBlock, STEP_SIZE);
-  const pool = new PromisePool({ concurrency: 2 });
-  console.log({ curBlock });
-  fromBlocks.forEach(start => {
-    pool.add(async () => {
-      const options = { limit: 3, delay: 2000 };
-      const retrier = new Retrier(options);
-
-      const results = await retrier
-        .resolve(() => gd.queryFilter(f, start, start + STEP_SIZE))
-        .catch(e => console.warn("queryfilter failed:", { start }));
-      if (!results) return;
-
-      txs = txs.concat(results);
-      console.log({ start }, results.length);
-    });
-  });
-
-  await pool.all();
-  return txs;
-};
-
-// const analyze = () => {
-//   const txs = JSON.parse(fs.readFileSync("stuckgd.json").toString());
-//   let value = 0;
-//   console.log(txs[0]);
-//   txs.forEach(tx => {
-//     value += Number(tx.args[2].hex);
-//     console.log(`erc20,${GD_CELO},${tx.args[0]},${Number(tx.args[2].hex) / 1e18},`);
-//   });
-//   console.log(txs.length, { value });
-// };
-// analyze();
-
-main().catch(e => console.error("Error:", e.message));

package/scripts/analytics/claimIncidentStats.ts

@@ -1,98 +0,0 @@
-import { countBy, chunk, difference, flatten, sortBy } from "lodash";
-import fs from "fs";
-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));