@gooddollar/goodprotocol 1.0.15 → 1.0.16-beta.0

package/hardhat.config.ts

@@ -13,7 +13,7 @@ import { task, types } from "hardhat/config";
 import { sha3 } from "web3-utils";
 import { config } from "dotenv";
 import { airdrop } from "./scripts/governance/airdropCalculation";
-import { airdrop as gdxAirdrop } from "./scripts/gdx/gdxAirdropCalculation";
+import { airdrop as gdxAirdrop, airdropRecover as gdxAirdropRecover} from "./scripts/gdx/gdxAirdropCalculation";
 import { verify } from "./scripts/verify";
 import { ethers } from "ethers";
 config();
@@ -197,6 +197,22 @@ task("gdxAirdrop", "Calculates airdrop data")
     }
   });
 
+task("gdxAirdropRecover", "Calculates new airdrop data for recovery")
+  .addParam("action", "calculate/tree/proof")
+  .addOptionalPositionalParam("address", "proof for address")
+  .addOptionalParam("ethsnapshotblock", "eth block for calculate")
+  .setAction(async (taskArgs, hre) => {
+    const actions = gdxAirdropRecover(hre.ethers);
+    switch (taskArgs.action) {
+      case "addition":
+        return actions.addCalculationsToPreviousData();
+      case "tree":
+        return actions.buildMerkleTree();
+      default:
+        console.log("unknown action use calculate or tree");
+    }
+  });
+
 task("verifyjson", "verify contracts on etherscan").setAction(
   async (taskArgs, hre) => {
     return verify(hre);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gooddollar/goodprotocol",
-  "version": "1.0.15",
+  "version": "1.0.16-beta.0",
   "description": "GoodDollar Protocol",
   "scripts": {
     "build": "scripts/build.sh deploy",

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 };
+};