@gooddollar/goodprotocol 1.0.17 → 1.0.18-beta.0

package/hardhat.config.ts

@@ -18,6 +18,7 @@ import {
   airdrop as gdxAirdrop,
   airdropRecover as gdxAirdropRecover
 } from "./scripts/gdx/gdxAirdropCalculation";
+import { sumStakersGdRewards } from "./scripts/staking/stakersGdRewardsCalculation";
 import { verify } from "./scripts/verify";
 import { ethers } from "ethers";
 config();
@@ -223,8 +224,6 @@ task("gdxAirdrop", "Calculates airdrop data")
 
 task("gdxAirdropRecover", "Calculates new airdrop data for recovery")
   .addParam("action", "addition/tree")
-  .addOptionalPositionalParam("address", "proof for address")
-  .addOptionalParam("ethsnapshotblock", "eth block for calculate")
   .setAction(async (taskArgs, hre) => {
     const actions = gdxAirdropRecover(hre.ethers);
     switch (taskArgs.action) {
@@ -243,3 +242,10 @@ task("verifyjson", "verify contracts on etherscan").setAction(
   }
 );
 export default hhconfig;
+
+task("sumStakersGdRewards", "Sums the GoodDollar reward for each staker")
+  .setAction(async (taskArgs, hre) => {
+    const actions = sumStakersGdRewards(hre.ethers);
+        return actions.getStakersGdRewards();
+    }
+);

package/package.json

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

package/releases/deployment.json

@@ -463,6 +463,7 @@
         "StakersDistribution": "0x5766cf4b2fdb09d986eb1783d276013c224e28c8",
         "GoodFundManager": "0x0c6c80d2061afa35e160f3799411d83bdeea0a5a",
         "GReputation": "0x603b8c0f110e037b51a381cbcacabb8d6c6e4543",
+        "CompoundVotingMachine": "0x57ee6ceff51cb30ecb1245934a882c500fbec1e9",
         "ProtocolUpgradeRecover": "0x6f1b4dFDd7156FC5752541Ef35EDF57B48E74475",
         "network": "production-mainnet",
         "networkId": 1,
@@ -502,8 +503,7 @@
                 "0x3ff2d8eb2573819a9ef7167d2ba6fd6d31b17f4f",
                 6944
             ]
-        ],
-        "CompoundVotingMachine": "0xc2Ff55b896e3c42f9e1c2f7467C51b93F1C23dFD"
+        ]
     },
     "production": {
         "NameService": "0xec6dcE387B1616a0c44fF2E4fA9E90E53Cf14eb0",

package/scripts/gdx/gdxAirdropCalculation.ts

@@ -25,9 +25,9 @@ const quantile = (sorted, q) => {
 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++) 
+  for (let i = 0; i < base; i++)
     sum = BigNumber.from(sum).add(BigNumber.from(sorted[i]));
 
   return sum.toString();
@@ -212,35 +212,54 @@ export const airdrop = (ethers: typeof Ethers, ethSnapshotBlock) => {
 };
 
 export const airdropRecover = (ethers: typeof Ethers) => {
-
   const ZERO = ethers.BigNumber.from("0");
 
-  const getHoldersInformation = async (newAddresses = {}, newIsContracts = {}) => {
+  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(
+      "GoodReserveCDai",
+      "0x6C35677206ae7FF1bf753877649cF57cC30D1c42"
+    );
+
+    let recoveredReserve = await ethers.getContractAt(
+      "GoodReserveCDai",
+      "0xa150a825d425B36329D8294eeF8bD0fE68f8F6E0"
+    );
 
-    let newReserve = await ethers.getContractAt(eventsABI, "0x6C35677206ae7FF1bf753877649cF57cC30D1c42");
-    let exchangeHelper = await ethers.getContractAt(eventsABI, "0x0a8c6bB832801454F6CC21761D0A293Caa003296");
+    // let exchangeHelper = await ethers.getContractAt(
+    //   eventsABI,
+    //   "0x0a8c6bB832801454F6CC21761D0A293Caa003296"
+    // );
 
-    exchangeHelper = exchangeHelper.connect(provider);
+    // 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 END_BLOCK = 14296271; // Following reserve created
+    const END_BLOCK = await ethers.provider.getBlockNumber();
     const blocks = range(START_BLOCK, END_BLOCK, step);
 
-    const reserveTokenPurchasedFilter = newReserve.filters.TokenPurchased();
-    const reserveTokenSoldFilter = newReserve.filters.TokenSold();
+    const reserveTokenPurchasedFilter = newReserve.filters.Transfer(
+      ethers.constants.AddressZero
+    );
+    const reserveTokenSoldFilter = newReserve.filters.Transfer(
+      undefined,
+      ethers.constants.AddressZero
+    );
 
-    const exchangeHelperTokenPurchasedFilter = exchangeHelper.filters.TokenPurchased();
-    const exchangeHelperTokenSoldFilter = exchangeHelper.filters.TokenSold();
+    // const exchangeHelperTokenPurchasedFilter = exchangeHelper.filters.TokenPurchased();
+    // const exchangeHelperTokenSoldFilter = exchangeHelper.filters.TokenSold();
 
-    const populateListOfAddressesAndBalances = async (contractInstance, purchaseFilter, soldFilter) => {
+    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 => {
@@ -256,7 +275,7 @@ export const airdropRecover = (ethers: typeof Ethers) => {
               );
             });
 
-          // console.log({purchaseEvents});
+          // console.log({ purchaseEvents });
 
           const soldEvents = await contractInstance
             .queryFilter(soldFilter, bc, Math.min(bc + step - 1, END_BLOCK))
@@ -276,28 +295,27 @@ export const airdropRecover = (ethers: typeof Ethers) => {
           // );
 
           const isContract = async (log, role) => {
-            const possibleCodeStateOfAddress = await contractInstance.provider.getCode(log.args[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});
+            let balance = newAddresses[log.args.to] || ZERO;
+            // console.log(log.blockNumber);
             // console.log(`actualReturn: ${log.args.actualReturn.toString()}`);
-            newAddresses[log.args.receiverAddress] =
-              balance.add(log.args.actualReturn);
-            newIsContracts[log.args.receiverAddress] = await isContract(
-              log, "receiverAddress"
-            );
+            newAddresses[log.args.to] =
+              log.blockNumber === 14358516 //airdrop reimburse
+                ? balance.sub(log.args.value)
+                : balance.add(log.args.value);
+            newIsContracts[log.args.to] = await isContract(log, "to");
           });
           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"
-            );
+            let balance = newAddresses[log.args.from] || ZERO;
+            newAddresses[log.args.from] = balance.sub(log.args.value);
+            newIsContracts[log.args.from] = await isContract(log, "from");
           });
 
           await Promise.all([...purchasedEventsMapped, ...soldEventsMapped]);
@@ -306,8 +324,17 @@ export const airdropRecover = (ethers: typeof Ethers) => {
       }
     };
 
-    await populateListOfAddressesAndBalances(newReserve, reserveTokenPurchasedFilter, reserveTokenSoldFilter);
-    await populateListOfAddressesAndBalances(exchangeHelper, exchangeHelperTokenPurchasedFilter, exchangeHelperTokenSoldFilter);
+    await populateListOfAddressesAndBalances(
+      newReserve,
+      reserveTokenPurchasedFilter,
+      reserveTokenSoldFilter
+    );
+    await populateListOfAddressesAndBalances(
+      recoveredReserve,
+      reserveTokenPurchasedFilter,
+      reserveTokenSoldFilter
+    );
+    // await populateListOfAddressesAndBalances(exchangeHelper, exchangeHelperTokenPurchasedFilter, exchangeHelperTokenSoldFilter);
 
     // console.log({ newAddresses, newIsContracts });
     return { newAddresses, newIsContracts };
@@ -317,25 +344,30 @@ export const airdropRecover = (ethers: typeof Ethers) => {
     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];
-      }
-    );
-    
+
+    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 );
+    // 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`)}); 
-    
+    // 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]))
+    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()})),
+      toTree: toTree.forEach((a, _) =>
+        console.log({
+          address: a[0].toString(),
+          balance: BigNumber.from(a[1]).toString()
+        })
+      ),
       numberOfAccounts: toTree.length,
       TotalGDX: totalGDX.toString()
     });
@@ -385,38 +417,63 @@ export const airdropRecover = (ethers: typeof Ethers) => {
     const gdxAirdropData = JSON.parse(
       fs.readFileSync("airdrop/gdxairdrop.json").toString()
     );
-    const addressesCombined = {}
+    const addressesCombined = {};
     for (const [address, balance] of Object.entries(gdxAirdropData.treeData)) {
-      addressesCombined[address] = BigNumber.from(balance['gdx']);
+      addressesCombined[address] = BigNumber.from(balance["gdx"]).toString();
     }
 
     // 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];
-      }
-    );
+    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 
+    // Unite previous airdrop with current information
     for (const newAddressEntry of newAddressesArray) {
       const address = newAddressEntry[0];
       const addition = newAddressEntry[1];
-      
-      if (addition<=ZERO)
-        continue;
+
+      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();
+      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 }));
+
+    let newReserve = await ethers.getContractAt(
+      "GoodReserveCDai",
+      "0xa150a825d425B36329D8294eeF8bD0fE68f8F6E0"
+    );
+
+    const ps = Object.entries(addressesCombined).map(async ([addr, amount]) => {
+      console.log(addr, amount);
+      const balance = await newReserve.balanceOf(addr);
+      const diff = balance.sub(amount);
+      if (diff.lt(0)) {
+        console.log({
+          addr,
+          balance: balance.toString(),
+          amount,
+          diff: diff.toString()
+        });
+      }
+    });
+
+    await Promise.all(ps);
+    fs.writeFileSync(
+      "airdrop/buyBalancesCombined.json",
+      JSON.stringify({ addressesCombined })
+    );
   };
 
   return { buildMerkleTree, addCalculationsToPreviousData };

package/scripts/staking/stakersGdRewardsCalculation.ts

@@ -0,0 +1,53 @@
+import { range, chunk } from "lodash";
+import fs from "fs";
+import stakingContracts from "../../releases/deployment.json";
+import { ethers as Ethers } from "hardhat";
+import { BigNumber } from "ethereum-waffle/node_modules/ethers"; 
+
+const ZERO = BigNumber.from("0"); 
+
+export const sumStakersGdRewards = (ethers: typeof Ethers) => {
+    
+    const getStakersGdRewards = async (stakersToGdRewards = {}) => {
+        const provider = new ethers.providers.InfuraProvider();
+        
+        let goodFundManager = await ethers.getContractAt("GoodFundManager",stakingContracts["production-mainnet-bug"].GoodFundManager);
+        goodFundManager = goodFundManager.connect(provider);
+        const filter = goodFundManager.filters.StakingRewardMinted();
+
+        const step = 100000;
+        const ETH_START_BLOCK = 14291923; 
+        const ETH_END_BLOCK = await provider.getBlockNumber();
+        const blocks = range(ETH_START_BLOCK, ETH_END_BLOCK, step);
+
+        for (let blockChunk of chunk(blocks, 10)) {
+            const processedChunks = blockChunk.map(async bc => {
+                const stakingRewardsEvents = await goodFundManager
+                    .queryFilter(filter, bc, Math.min(bc + step - 1, ETH_END_BLOCK))
+                    .catch(e => {
+                    console.log("block transfer logs failed retrying...", bc);
+                    return goodFundManager.queryFilter(
+                        filter, bc, Math.min(bc + step - 1, ETH_END_BLOCK));
+                    });
+
+                const stakingRewardsEventsMapped = stakingRewardsEvents.map(async log => {
+                    const initBalance = stakersToGdRewards[log.args.staker] || ZERO;
+                    stakersToGdRewards[log.args.staker] = initBalance.add(log.args.gdReward);
+                    // console.log(`TransactionHash:\t${log.transactionHash}`);
+                    // console.log(`Staking contract:\t${log.args.stakingContract}`);
+                    // console.log(`Previous Balance:\t${initBalance.toString()} for address ${log.args.staker}`);
+                    // console.log(`Addition:\t\t${log.args.gdReward.toString()} for address ${log.args.staker}`);
+                    // console.log(`New Balance:\t\t${stakersToGdRewards[log.args.staker].toString()} for address ${log.args.staker}\n`);
+                    });
+                await Promise.all([...stakingRewardsEventsMapped]);
+            });
+            await Promise.all(processedChunks);
+        }   
+
+        console.log(`All stakers minted rewards:\n`);
+        Object.entries(stakersToGdRewards).forEach(a => { console.log(`${a[0].toString()}:${BigNumber.from(a[1]).toString()}\n`)}); 
+        // fs.writeFileSync("scripts/staking/stakersToGdRewards.json", JSON.stringify(stakersToGdRewards))
+    };
+    
+    return { getStakersGdRewards};
+}