@gooddollar/goodprotocol 1.0.15 → 1.0.16

package/scripts/bulkProof.ts

@@ -0,0 +1,207 @@
+import fs from "fs";
+import { chunk } from "lodash";
+import { ethers, upgrades, network } from "hardhat";
+import { networkNames } from "@openzeppelin/upgrades-core";
+import GReputationABI from "../artifacts/contracts/governance/GReputation.sol/GReputation.json";
+import BulkProofABI from "../artifacts/contracts/utils/BulkProof.sol/BulkProof.json";
+
+import MerkleTree, {
+  checkProof,
+  checkProofOrdered
+} from "merkle-tree-solidity";
+import { BigNumber } from "ethers";
+
+console.log({
+  networkNames,
+  network: network.name,
+  upgrade: process.env.UPGRADE
+});
+const { name: networkName } = network;
+networkNames[1] = networkName;
+networkNames[122] = networkName;
+networkNames[3] = networkName;
+
+export const bulkProof = async () => {
+  console.log("signer", await ethers.getSigners());
+  const fuseProvider = new ethers.providers.JsonRpcProvider(
+    "https://rpc.fuse.io"
+  );
+
+  const fuseGDProvider = new ethers.providers.JsonRpcProvider(
+    "https://gooddollar-rpc.fuse.io"
+  );
+
+  const goodFuse = new ethers.Contract(
+    "0x3A9299BE789ac3730e4E4c49d6d2Ad1b8BC34DFf",
+    GReputationABI.abi,
+    fuseGDProvider
+  );
+
+  const START_BLOCK_FUSE = 14149729;
+
+  const LAST_BLOCK = await goodFuse.provider.getBlockNumber();
+
+  const claimedLogs = await goodFuse.queryFilter(
+    goodFuse.filters.StateHashProof(),
+    START_BLOCK_FUSE,
+    LAST_BLOCK
+  );
+  console.log("found logs:", claimedLogs.length);
+  console.log(claimedLogs.filter(_ => !_.args?.user));
+
+  const addrs = claimedLogs.map(_ => _.args?.user);
+
+  const { treeData, merkleRoot } = JSON.parse(
+    fs.readFileSync("airdrop/airdrop.json").toString()
+  );
+
+  let entries = Object.entries(treeData);
+
+  let elements = entries.map((e: any) =>
+    Buffer.from(e[1].hash.slice(2), "hex")
+  );
+
+  console.log("creating merkletree...", elements.length);
+  const merkleTree = new MerkleTree(elements, true);
+
+  const calcMerkleRoot = merkleTree.getRoot().toString("hex");
+  console.log("merkleroots:", {
+    fromFile: merkleRoot,
+    calculated: calcMerkleRoot
+  });
+
+  const proofs = addrs => {
+    return addrs.map(addr => {
+      if (!addr) {
+        console.log("missing", addr);
+        return;
+      }
+      const addrData = treeData[addr] || treeData[addr.toLowerCase()];
+      const proofFor = Buffer.from(addrData.hash.slice(2), "hex");
+
+      const proof = merkleTree.getProof(proofFor);
+      const proofIndex =
+        entries.findIndex((_: any) => _[1].hash === addrData.hash) + 1;
+
+      // console.log(
+      //   "checkProof:",
+      //   checkProofOrdered(proof, merkleTree.getRoot(), proofFor, proofIndex)
+      // );
+
+      const hexProof = proof.map(_ => "0x" + _.toString("hex"));
+      // console.log({
+      //   proofIndex,
+      //   rep: BigNumber.from(addrData.rep).toString(),
+      //   //   hexProof,
+      //   addr
+      // });
+
+      return {
+        index: proofIndex,
+        balance: BigNumber.from(addrData.rep).toString(),
+        proof: hexProof,
+        account: addr
+      };
+    });
+  };
+
+  const bulkProofContract = await ethers.getContractAt(
+    "BulkProof",
+    "0x8449bb7BDa431F76c21bcCDEce2794D8aD24D8a8"
+  );
+  for (let addrChunk of chunk(addrs, 50)) {
+    console.log("calling bulk proof");
+    const proofsChunk = proofs(addrChunk);
+    await (
+      await bulkProofContract.bulkProof(proofsChunk, { gasLimit: 10000000 })
+    ).wait();
+  }
+};
+
+export const bulkProofGDX = async () => {
+  const signers = await ethers.getSigners();
+  console.log("signer", await ethers.getSigners());
+  //   const signer = signers[0].connect(new ethers.providers.InfuraProvider());
+  const reserve = await ethers.getContractAt(
+    "GoodReserveCDai",
+    "0xa150a825d425B36329D8294eeF8bD0fE68f8F6E0"
+  );
+
+  const { treeData, merkleRoot } = JSON.parse(
+    fs.readFileSync("airdrop/gdxAirdropRecovery.json").toString()
+  );
+
+  let entries = Object.entries(treeData);
+
+  let elements = entries.map((e: any) =>
+    Buffer.from(e[1].hash.slice(2), "hex")
+  );
+
+  let addrs = Object.keys(treeData);
+
+  console.log("creating merkletree...", elements.length, addrs);
+  const merkleTree = new MerkleTree(elements, false);
+
+  const calcMerkleRoot = merkleTree.getRoot().toString("hex");
+  console.log("merkleroots:", {
+    fromFile: merkleRoot,
+    calculated: calcMerkleRoot
+  });
+
+  const proofs = addrs => {
+    return addrs.map(addr => {
+      if (!addr) {
+        console.log("missing", addr);
+        return;
+      }
+      const addrData = treeData[addr] || treeData[addr.toLowerCase()];
+      const proofFor = Buffer.from(addrData.hash.slice(2), "hex");
+
+      const proof = merkleTree.getProof(proofFor);
+
+      // console.log(
+      //   "checkProof:",
+      //   checkProofOrdered(proof, merkleTree.getRoot(), proofFor, proofIndex)
+      // );
+
+      const hexProof = proof.map(_ => "0x" + _.toString("hex"));
+      // console.log({
+      //   proofIndex,
+      //   rep: BigNumber.from(addrData.rep).toString(),
+      //   //   hexProof,
+      //   addr
+      // });
+
+      return {
+        balance: BigNumber.from(addrData.gdx).toString(),
+        proof: hexProof,
+        account: addr
+      };
+    });
+  };
+
+  const bulkProofContract = await ethers.getContractAt(
+    "BulkProof",
+    "0xDB8563287ecF1484228951804eC6bf241f884099"
+  );
+  for (let addrChunk of chunk(addrs, 60)) {
+    const proofsChunk = proofs(addrChunk);
+    console.log("calling bulk proof");
+    const tx = await bulkProofContract.callStatic.bulkProof(proofsChunk, {
+      gasLimit: 5000000,
+      maxPriorityFeePerGas: 1000000000,
+      maxFeePerGas: 40000000000
+    });
+    console.log(tx);
+    await (
+      await bulkProofContract.bulkProof(proofsChunk, {
+        gasLimit: 5000000,
+        maxPriorityFeePerGas: 1000000000,
+        maxFeePerGas: 40000000000
+      })
+    ).wait();
+  }
+};
+
+// bulkProof().catch(console.log);
+bulkProofGDX().catch(console.log);

package/scripts/gdx/gdxAirdropCalculation.ts

@@ -3,6 +3,7 @@ import fs from "fs";
 import MerkleTree from "merkle-tree-solidity";
 import stakingContracts from "@gooddollar/goodcontracts/stakingModel/releases/deployment.json";
 import { ethers as Ethers } from "hardhat";
+import { BigNumber } from "ethereum-waffle/node_modules/ethers";
 
 type Tree = {
   [key: string]: {
@@ -21,6 +22,17 @@ const quantile = (sorted, q) => {
   return sum;
 };
 
+const quantileBN = (sorted, q) => {
+  const pos = (sorted.length - 1) * q;
+  const base = Math.floor(pos);
+  
+  let sum = BigNumber.from("0");
+  for (let i = 0; i < base; i++) 
+    sum = BigNumber.from(sum).add(BigNumber.from(sorted[i]));
+
+  return sum.toString();
+};
+
 let ETH_SNAPSHOT_BLOCK = 13320531; //first blocka after 12pm Sep-29-2021 12:00:20 PM +UTC
 
 export const airdrop = (ethers: typeof Ethers, ethSnapshotBlock) => {
@@ -198,3 +210,214 @@ export const airdrop = (ethers: typeof Ethers, ethSnapshotBlock) => {
 
   return { buildMerkleTree, collectAirdropData, getProof };
 };
+
+export const airdropRecover = (ethers: typeof Ethers) => {
+
+  const ZERO = ethers.BigNumber.from("0");
+
+  const getHoldersInformation = async (newAddresses = {}, newIsContracts = {}) => {
+    const provider = new ethers.providers.InfuraProvider();
+
+    const eventsABI = [
+      "event TokenPurchased(address indexed caller,address indexed inputToken,uint256 inputAmount,uint256 actualReturn,address indexed receiverAddress)",
+      "event TokenSold(address indexed caller,address indexed outputToken,uint256 gdAmount,uint256 contributionAmount,uint256 actualReturn,address indexed receiverAddress)"
+    ];
+
+    let newReserve = await ethers.getContractAt(eventsABI, "0x6C35677206ae7FF1bf753877649cF57cC30D1c42");
+    let exchangeHelper = await ethers.getContractAt(eventsABI, "0x0a8c6bB832801454F6CC21761D0A293Caa003296");
+
+    exchangeHelper = exchangeHelper.connect(provider);
+    newReserve = newReserve.connect(provider);
+
+    const step = 100000;
+    const START_BLOCK = 13683748; // Reserve was created
+    const END_BLOCK = 14296271;   // Following reserve created
+    const blocks = range(START_BLOCK, END_BLOCK, step);
+
+    const reserveTokenPurchasedFilter = newReserve.filters.TokenPurchased();
+    const reserveTokenSoldFilter = newReserve.filters.TokenSold();
+
+    const exchangeHelperTokenPurchasedFilter = exchangeHelper.filters.TokenPurchased();
+    const exchangeHelperTokenSoldFilter = exchangeHelper.filters.TokenSold();
+
+    const populateListOfAddressesAndBalances = async (contractInstance, purchaseFilter, soldFilter) => {
+      for (let blockChunk of chunk(blocks, 10)) {
+        // Get the filter (the second null could be omitted)
+        const processedChunks = blockChunk.map(async bc => {
+          // Query the filter (the latest could be omitted)
+          const purchaseEvents = await contractInstance
+            .queryFilter(purchaseFilter, bc, Math.min(bc + step - 1, END_BLOCK))
+            .catch(e => {
+              console.log("block transfer logs failed retrying...", bc);
+              return contractInstance.queryFilter(
+                purchaseFilter,
+                bc,
+                Math.min(bc + step - 1, END_BLOCK)
+              );
+            });
+
+          // console.log({purchaseEvents});
+
+          const soldEvents = await contractInstance
+            .queryFilter(soldFilter, bc, Math.min(bc + step - 1, END_BLOCK))
+            .catch(e => {
+              console.log("block swaphelper logs failed retrying...", bc);
+              return contractInstance.queryFilter(
+                soldFilter,
+                bc,
+                Math.min(bc + step - 1, END_BLOCK)
+              );
+            });
+
+          // console.log(
+          //   "found transfer logs in block:",
+          //   { bc },
+          //   { purchaseEvents: purchaseEvents.length, soldEvents: soldEvents.length }
+          // );
+
+          const isContract = async (log, role) => {
+            const possibleCodeStateOfAddress = await contractInstance.provider.getCode(log.args[role])
+              .catch(e => "0x");
+            return possibleCodeStateOfAddress !== "0x";
+          };
+
+          // Print out all the values:
+          const purchasedEventsMapped = purchaseEvents.map(async log => {
+            let balance = newAddresses[log.args.receiverAddress] || ZERO;
+            // console.log({balance});
+            // console.log(`actualReturn: ${log.args.actualReturn.toString()}`);
+            newAddresses[log.args.receiverAddress] =
+              balance.add(log.args.actualReturn);
+            newIsContracts[log.args.receiverAddress] = await isContract(
+              log, "receiverAddress"
+            );
+          });
+          const soldEventsMapped = soldEvents.map(async log => {
+            let balance = newAddresses[log.args.caller] || ZERO;
+            newAddresses[log.args.caller] = balance.sub(log.args.gdAmount);
+            newIsContracts[log.args.caller] = await isContract(
+              log, "caller"
+            );
+          });
+
+          await Promise.all([...purchasedEventsMapped, ...soldEventsMapped]);
+        });
+        await Promise.all(processedChunks);
+      }
+    };
+
+    await populateListOfAddressesAndBalances(newReserve, reserveTokenPurchasedFilter, reserveTokenSoldFilter);
+    await populateListOfAddressesAndBalances(exchangeHelper, exchangeHelperTokenPurchasedFilter, exchangeHelperTokenSoldFilter);
+
+    // console.log({ newAddresses, newIsContracts });
+    return { newAddresses, newIsContracts };
+  };
+
+  const buildMerkleTree = () => {
+    const { addressesCombined } = JSON.parse(
+      fs.readFileSync("airdrop/buyBalancesCombined.json").toString()
+    );
+    
+    let toTree: Array<[string, BigNumber]> = Object.entries(addressesCombined).map(
+      ([addr, gdx]) => {
+        return [addr, gdx as BigNumber];
+      }
+    );
+    
+    // console.log(`Before sorting`);
+    // toTree.forEach((a,_) => { console.log(`${a[0].toString()}:${ethers.BigNumber.from(a[1]).toString()}\n`)}); 
+    
+    toTree.sort((a, b) => BigNumber.from(b[1]).gt(a[1]) ? 0 : -1 );
+
+    // console.log(`After sorting`);
+    // toTree.forEach((a,_) => { console.log(`${a[0].toString()}:${ethers.BigNumber.from(a[1]).toString()}\n`)}); 
+    
+    let totalGDX = ZERO;
+    toTree.forEach((a,_) => totalGDX = totalGDX.add(a[1]))
+    console.log({
+      toTree: toTree.forEach((a,_) => console.log({address: a[0].toString(), balance: BigNumber.from(a[1]).toString()})),
+      numberOfAccounts: toTree.length,
+      TotalGDX: totalGDX.toString()
+    });
+
+    // Print statistics
+    const sorted = toTree.map(_ => _[1]);
+    console.log("GDX Distribution\n");
+    [0.001, 0.01, 0.1, 0.5].forEach(q =>
+      console.log({
+        precentile: q * 100 + "%",
+        gdx: quantileBN(sorted, q)
+      })
+    );
+
+    const treeData = {};
+    const elements = toTree.map(e => {
+      const hash = ethers.utils.keccak256(
+        ethers.utils.defaultAbiCoder.encode(
+          ["address", "uint256"],
+          [e[0], e[1]]
+        )
+      );
+      treeData[e[0]] = {
+        gdx: e[1],
+        hash
+      };
+      return Buffer.from(hash.slice(2), "hex");
+    });
+
+    console.log(elements);
+    const merkleTree = new MerkleTree(elements, false);
+    // get the merkle root
+    // returns 32 byte buffer
+    const merkleRoot = merkleTree.getRoot().toString("hex");
+    // generate merkle proof
+    // returns array of 32 byte buffers
+    const proof = merkleTree.getProof(elements[0]).map(_ => _.toString("hex"));
+    console.log({ merkleRoot, proof, sampleProofFor: toTree[0] });
+    fs.writeFileSync(
+      "airdrop/gdxAirdropRecovery.json",
+      JSON.stringify({ treeData, merkleRoot })
+    );
+  };
+
+  const addCalculationsToPreviousData = async () => {
+    // get previous airdrop and turn it into BigNumbers
+    const gdxAirdropData = JSON.parse(
+      fs.readFileSync("airdrop/gdxairdrop.json").toString()
+    );
+    const addressesCombined = {}
+    for (const [address, balance] of Object.entries(gdxAirdropData.treeData)) {
+      addressesCombined[address] = BigNumber.from(balance['gdx']);
+    }
+
+    // get new holders info and turn into array
+    const { newAddresses, }  = await getHoldersInformation();
+
+    let newAddressesArray: Array<[string, BigNumber]> = Object.entries(newAddresses).map(
+      ([addr, gdx]) => {
+        return [addr, gdx as BigNumber];
+      }
+    );
+
+
+    // Unite previous airdrop with current information 
+    for (const newAddressEntry of newAddressesArray) {
+      const address = newAddressEntry[0];
+      const addition = newAddressEntry[1];
+      
+      if (addition<=ZERO)
+        continue;
+
+      // console.log({address})
+      // console.log({before: BigNumber.from(addressesCombined[address] || "0").toString() })
+      // console.log({addition: addition.toString()})
+      addressesCombined[address] = ethers.BigNumber.from(addressesCombined[address] || 0).add(addition.toString()).toString();
+      // console.log({total: addressesCombined[address].toString()})
+      // console.log(`\n`);
+    }
+    
+    fs.writeFileSync("airdrop/buyBalancesCombined.json", JSON.stringify({ addressesCombined }));
+  };
+
+  return { buildMerkleTree, addCalculationsToPreviousData };
+};