@gooddollar/goodprotocol 1.0.30-beta.2 → 1.0.31-beta.0

package/scripts/multichain-deploy/helpers.ts

@@ -1,14 +1,20 @@
 import { Contract, ContractFactory, Signer } from "ethers";
 import { network, ethers, upgrades, run } from "hardhat";
-import { Contract } from "ethers";
+import * as safeethers from "ethers";
 import { TransactionResponse } from "@ethersproject/providers";
+import Safe from "@gnosis.pm/safe-core-sdk";
+import EthersAdapter from "@gnosis.pm/safe-ethers-lib";
+import { MetaTransactionData } from "@gnosis.pm/safe-core-sdk-types";
+import SafeClient from "@gnosis.pm/safe-service-client";
+
 import dao from "../../releases/deployment.json";
 
-const networkName = network.name;
+const networkName =
+  network.name === "localhost" ? "production-mainnet" : network.name;
 let totalGas = 0;
 const gasUsage = {};
 const GAS_SETTINGS = { gasLimit: 5000000 };
-let release: { [key: string]: any } = dao[network.name];
+let release: { [key: string]: any } = dao[networkName];
 
 export const printDeploy = async (
   c: Contract | TransactionResponse
@@ -42,7 +48,7 @@ export const deployDeterministic = async (
 ) => {
   try {
     let proxyFactory;
-    if (network.name.startsWith("develop")) {
+    if (networkName.startsWith("develop")) {
       proxyFactory = await (
         await ethers.getContractFactory("ProxyFactory1967")
       ).deploy();
@@ -152,10 +158,140 @@ export const executeViaGuardian = async (
         .sendTransaction({ to: contract, data: encoded })
         .then(printDeploy);
     } else {
-      console.log("executing genericCall:", sigHash, encoded);
+      const simulationResult = await ctrl.callStatic.genericCall(
+        contract,
+        encoded,
+        release.Avatar,
+        ethValues[i],
+        { from: await guardian.getAddress() }
+      );
+      console.log("executing genericCall:", {
+        sigHash,
+        encoded,
+        simulationResult
+      });
       await ctrl
         .genericCall(contract, encoded, release.Avatar, ethValues[i])
         .then(printDeploy);
     }
   }
 };
+
+export const executeViaSafe = async (
+  contracts,
+  ethValues,
+  functionSigs,
+  functionInputs,
+  safeAddress: string,
+  safeSigner: Signer,
+  txServiceUrl = "https://safe-transaction-mainnet.safe.global"
+) => {
+  const ethAdapter = new EthersAdapter({
+    ethers: safeethers,
+    signerOrProvider: safeSigner
+  });
+
+  const safeService = new SafeClient({
+    txServiceUrl,
+    ethAdapter
+  });
+
+  const safeSdk = await Safe.create({ ethAdapter, safeAddress });
+
+  let release: { [key: string]: any } = dao[networkName];
+  const ctrl = await ethers.getContractAt(
+    "Controller",
+    release.Controller,
+    null
+  );
+
+  const safeTransactionData: MetaTransactionData[] = [];
+
+  for (let i = 0; i < contracts.length; i++) {
+    const contract = contracts[i];
+
+    const sigHash = ethers.utils
+      .keccak256(ethers.utils.toUtf8Bytes(functionSigs[i]))
+      .slice(0, 10);
+    const encoded = ethers.utils.solidityPack(
+      ["bytes4", "bytes"],
+      [sigHash, functionInputs[i]]
+    );
+    console.log(
+      "creating tx:",
+      contracts[i],
+      functionSigs[i],
+      functionInputs[i],
+      encoded
+    );
+    if (contract === ctrl.address) {
+      const simulationResult = await ctrl.callStatic[functionSigs[i]](
+        ...functionInputs[i],
+        { from: safeAddress, value: ethValues[i] }
+      );
+      console.log("executing controller call:", {
+        sigHash,
+        encoded,
+        simulationResult
+      });
+      safeTransactionData.push({
+        to: ctrl.address,
+        value: ethValues[i],
+        data: encoded
+      });
+    } else {
+      console.log("executing genericCall:", {
+        sigHash,
+        encoded,
+        contract,
+        avatar: release.Avatar,
+        value: ethValues[i]
+      });
+      const simulationResult = await ctrl.callStatic.genericCall(
+        contract,
+        encoded,
+        release.Avatar,
+        ethValues[i],
+        { from: safeAddress }
+      );
+      console.log("executing genericCall:", {
+        sigHash,
+        simulationResult
+      });
+      const genericEncode = ctrl.interface.encodeFunctionData("genericCall", [
+        contract,
+        encoded,
+        release.Avatar,
+        ethValues[i]
+      ]);
+      safeTransactionData.push({
+        to: ctrl.address,
+        value: ethValues[i],
+        data: genericEncode
+      });
+    }
+  }
+
+  const safeTransaction = await safeSdk.createTransaction({
+    safeTransactionData
+  });
+
+  const safeTxHash = await safeSdk.getTransactionHash(safeTransaction);
+  const signedHash = await safeSdk.signTransactionHash(safeTxHash);
+
+  const senderAddress = await safeSigner.getAddress();
+  console.log("propose safe transaction", {
+    safeAddress,
+    safeTransactionData: safeTransaction.data,
+    safeTxHash,
+    senderSignature: signedHash,
+    senderAddress
+  });
+  await safeService.proposeTransaction({
+    safeAddress,
+    safeTransactionData: safeTransaction.data,
+    safeTxHash,
+    senderSignature: signedHash.data,
+    senderAddress
+  });
+};

package/scripts/multichain-deploy/v3-fix.ts

@@ -0,0 +1,120 @@
+/***
+ * This script will deploy a fixed goodfundmanager that doenst disable staking contracts if rewards=0
+ * It will also then re submit the staking contracts
+ */
+
+import { network, ethers } from "hardhat";
+
+import {
+  executeViaGuardian,
+  executeViaSafe
+} from "../multichain-deploy/helpers";
+
+import releaser from "../releaser";
+import dao from "../../releases/deployment.json";
+const { name: networkName } = network;
+
+export const deployMainnet = async () => {
+  let [root, ...signers] = await ethers.getSigners();
+
+  let executionMethod = networkName === "localhost" ? "guardians" : "safe";
+
+  const networkKey =
+    networkName === "localhost" ? "production-mainnet" : networkName;
+  let release: { [key: string]: any } = dao[networkKey];
+
+  let safeOwner = new ethers.Wallet(
+    process.env.SAFEOWNER_PRIVATE_KEY || ethers.constants.HashZero,
+    ethers.provider
+  );
+
+  //test with guardians safe on hardhat mainnet fork
+  if (network.name === "localhost") {
+    root = await ethers.getImpersonatedSigner(
+      "0xE0c5daa7CC6F88d29505f702a53bb5E67600e7Ec"
+    );
+    await signers[0].sendTransaction({
+      to: root.address,
+      value: ethers.constants.WeiPerEther
+    });
+  }
+
+  console.log("got signers:", {
+    networkName,
+    networkKey,
+    root: root.address,
+    safeOwner: safeOwner.address,
+    balance: await ethers.provider
+      .getBalance(root.address)
+      .then(_ => _.toString())
+  });
+
+  console.log("deploying goodfundmanager implementation");
+  const gfmImpl = await (
+    await ethers.getContractFactory("GoodFundManager")
+  ).deploy();
+
+  const proposalContracts = [
+    release.GoodFundManager, //Fundmanager -> upgrade to new version
+    release.GoodFundManager, //Fundmanager -> set staking rewards compound to 0
+    release.GoodFundManager //Fundmanager -> set staking rewards aave to 0
+  ];
+
+  const proposalEthValues = proposalContracts.map(_ => 0);
+
+  const proposalFunctionSignatures = [
+    "upgradeTo(address)",
+    "setStakingReward(uint32,address,uint32,uint32,bool)",
+    "setStakingReward(uint32,address,uint32,uint32,bool)"
+  ];
+
+  const proposalFunctionInputs = [
+    ethers.utils.defaultAbiCoder.encode(["address"], [gfmImpl.address]), //upgradeTo(address)
+    ethers.utils.defaultAbiCoder.encode(
+      ["uint32", "address", "uint32", "uint32", "bool"],
+      [
+        "0",
+        "0x7b7246c78e2f900d17646ff0cb2ec47d6ba10754",
+        "14338692",
+        "4294967295",
+        false
+      ]
+    ), //setstakingrewards to 0
+    ethers.utils.defaultAbiCoder.encode(
+      ["uint32", "address", "uint32", "uint32", "bool"],
+      [
+        "0",
+        "0x3ff2d8eb2573819a9ef7167d2ba6fd6d31b17f4f",
+        "14338692",
+        "4294967295",
+        false
+      ]
+    ) //setstakingrewards to 0
+  ];
+
+  if (executionMethod === "safe") {
+    return executeViaSafe(
+      proposalContracts,
+      proposalEthValues,
+      proposalFunctionSignatures,
+      proposalFunctionInputs,
+      networkName === "localhost"
+        ? "0xE0c5daa7CC6F88d29505f702a53bb5E67600e7Ec"
+        : release.GuardiansSafe,
+      safeOwner
+    );
+  } else {
+    return executeViaGuardian(
+      proposalContracts,
+      proposalEthValues,
+      proposalFunctionSignatures,
+      proposalFunctionInputs,
+      root
+    );
+  }
+};
+
+export const main = async () => {
+  await deployMainnet().catch(console.log);
+};
+if (process.argv[1].includes("v3-fix")) main();

package/scripts/multichain-deploy/v3-upgrade.ts

@@ -0,0 +1,219 @@
+/***
+ * This script will deploy a reserve upgrade and the DistributionHelper so that some of the expansion can be allocated
+ * for non-ubi purposes
+ * Upgrade process:
+ * mainnet:
+ * - deploy reserve
+ * - deploy distributionHelper
+ * - create proposal that:
+ *  - upgrades the reserve
+ *  - sets the distributionHelper at reserve with the agreed bps
+ *  - add to the distributionHelper the contracts addresses to receive part of the UBI
+ */
+
+import { network, ethers } from "hardhat";
+
+import {
+  deployDeterministic,
+  printDeploy,
+  executeViaGuardian,
+  executeViaSafe
+} from "../multichain-deploy/helpers";
+
+import releaser from "../releaser";
+import dao from "../../releases/deployment.json";
+import {
+  CompoundVotingMachine,
+  DistributionHelper,
+  Controller,
+  NameService
+} from "../../types";
+const { name: networkName } = network;
+
+export const deployMainnet = async () => {
+  let [root, ...signers] = await ethers.getSigners();
+
+  let executionMethod = "safe";
+  let communitySafe = "0x5Eb5f5fE13d1D5e6440DbD5913412299Bc5B5564";
+
+  const networkKey =
+    networkName === "localhost" ? "production-mainnet" : networkName;
+  let release: { [key: string]: any } = dao[networkKey];
+
+  let safeOwner = new ethers.Wallet(
+    process.env.SAFEOWNER_PRIVATE_KEY || ethers.constants.HashZero,
+    ethers.provider
+  );
+  //test with guardians safe on hardhat mainnet fork
+  if (network.name === "localhost") {
+    root = await ethers.getImpersonatedSigner(
+      "0xE0c5daa7CC6F88d29505f702a53bb5E67600e7Ec"
+    );
+    await signers[0].sendTransaction({
+      to: root.address,
+      value: ethers.constants.WeiPerEther
+    });
+  }
+
+  console.log("got signers:", {
+    networkName,
+    networkKey,
+    root: root.address,
+    safeOwner: safeOwner.address,
+    balance: await ethers.provider
+      .getBalance(root.address)
+      .then(_ => _.toString())
+  });
+
+  console.log("deploying reserve implementation");
+  const reserveImpl = await (
+    await ethers.getContractFactory("GoodReserveCDai")
+  ).deploy();
+
+  console.log("deploying DistributionHelper");
+
+  let DHelper: DistributionHelper;
+  if (!release.DistributionHelper) {
+    DHelper = (await deployDeterministic(
+      {
+        name: "DistributionHelper",
+        salt: "DistributionHelper",
+        isUpgradeable: true
+      },
+      [release.NameService]
+    ).then(printDeploy)) as DistributionHelper;
+
+    let torelease = {
+      DistributionHelper: DHelper.address
+    };
+
+    await releaser(torelease, networkName, "deployment", false);
+  } else {
+    DHelper = (await ethers.getContractAt(
+      "DistributionHelper",
+      release.DistributionHelper
+    )) as DistributionHelper;
+  }
+  DHelper;
+
+  const ns = (await ethers.getContractAt(
+    "NameService",
+    release.NameService
+  )) as NameService;
+
+  const proposalContracts = [
+    ns.address, //nameservice add DistributionHelper,MultiChainRouter,MultiChain AnyGoodDollar,
+    DHelper.address, //update addresses from nameservice
+    DHelper.address, //distribution helper -> add fuse community pool as recipient with 100%
+    release.GoodReserveCDai, //upgradeTo
+    release.GoodReserveCDai, //Reserve -> set distribution helper + non ubi bps
+    release.GoodReserveCDai, //Reserve -> set new decline rate
+    release.GoodFundManager, //Fundmanager -> set staking rewards compound to 0
+    release.GoodFundManager //Fundmanager -> set staking rewards aave to 0
+  ];
+
+  const proposalEthValues = proposalContracts.map(_ => 0);
+
+  const proposalFunctionSignatures = [
+    "setAddresses(bytes32[],address[])",
+    "updateAddresses()",
+    "addOrUpdateRecipient((uint32,uint32,address,uint8))",
+    "upgradeTo(address)",
+    "setDistributionHelper(address,uint32)",
+    "setReserveRatioDailyExpansion(uint256,uint256)",
+    "setStakingReward(uint32,address,uint32,uint32,bool)",
+    "setStakingReward(uint32,address,uint32,uint32,bool)"
+  ];
+
+  const proposalFunctionInputs = [
+    ethers.utils.defaultAbiCoder.encode(
+      ["bytes32[]", "address[]"],
+      [
+        [
+          ethers.utils.keccak256(
+            ethers.utils.toUtf8Bytes("DISTRIBUTION_HELPER")
+          ),
+          ethers.utils.keccak256(ethers.utils.toUtf8Bytes("MULTICHAIN_ROUTER")),
+          ethers.utils.keccak256(
+            ethers.utils.toUtf8Bytes("MULTICHAIN_ANYGOODDOLLAR")
+          )
+        ],
+        [DHelper.address, release.MultichainRouter, release.AnyGoodDollar]
+      ]
+    ), //setAddresses(bytes32[],address[])"
+    ethers.utils.defaultAbiCoder.encode([], []), //updateAddresses()
+    ethers.utils.defaultAbiCoder.encode(
+      ["uint32", "uint32", "address", "uint8"],
+      [
+        10000, //100% bps
+        122, //chainid
+        communitySafe, //recipient address,
+        0 //recipient type via fuse bridge
+      ]
+    ), //addOrUpdateRecipient((uint32,uint32,address,uint8))
+    ethers.utils.defaultAbiCoder.encode(["address"], [reserveImpl.address]), //upgradeTo(address)
+    ethers.utils.defaultAbiCoder.encode(
+      ["address", "uint32"],
+      [DHelper.address, 1000]
+    ), //setDistributionHelper(address,uint32)
+    ethers.utils.defaultAbiCoder.encode(
+      ["uint256", "uint256"],
+      ["999554841771249", "1000000000000000"] //15% a year
+    ), //setReserveRatioDailyExpansion(uint,uint)
+    ethers.utils.defaultAbiCoder.encode(
+      ["uint32", "address", "uint32", "uint32", "bool"],
+      [
+        "0",
+        "0x7b7246c78e2f900d17646ff0cb2ec47d6ba10754",
+        "14338692",
+        "4294967295",
+        false
+      ]
+    ), //setstakingrewards to 0
+    ethers.utils.defaultAbiCoder.encode(
+      ["uint32", "address", "uint32", "uint32", "bool"],
+      [
+        "0",
+        "0x3ff2d8eb2573819a9ef7167d2ba6fd6d31b17f4f",
+        "14338692",
+        "4294967295",
+        false
+      ]
+    ) //setstakingrewards to 0
+  ];
+
+  //make sure rewards accumulated before we set them to 0
+  const staking = await ethers.getContractAt(
+    "SimpleStakingV2",
+    "0x7b7246c78e2f900d17646ff0cb2ec47d6ba10754"
+  );
+  (await staking.withdrawRewards()).wait();
+  staking.attach("0x3ff2d8eb2573819a9ef7167d2ba6fd6d31b17f4f");
+  (await staking.withdrawRewards()).wait();
+
+  if (executionMethod === "safe") {
+    return executeViaSafe(
+      proposalContracts,
+      proposalEthValues,
+      proposalFunctionSignatures,
+      proposalFunctionInputs,
+      networkName === "localhost"
+        ? "0xE0c5daa7CC6F88d29505f702a53bb5E67600e7Ec"
+        : release.GuardiansSafe,
+      safeOwner
+    );
+  } else {
+    return executeViaGuardian(
+      proposalContracts,
+      proposalEthValues,
+      proposalFunctionSignatures,
+      proposalFunctionInputs,
+      root
+    );
+  }
+};
+
+export const main = async () => {
+  await deployMainnet().catch(console.log);
+};
+if (process.argv[1].includes("v3-upgrade")) main();

package/scripts/staking/stakersGdRewardsCalculation.ts

@@ -2,52 +2,63 @@ 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"; 
+import { BigNumber } from "ethers";
 
-const ZERO = BigNumber.from("0"); 
+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};
-}
+  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 };
+};

package/test/staking/FuseStaking.test.ts

@@ -71,10 +71,8 @@ describe("FuseStakingV3", () => {
       await ethers.getContractFactory("FuseStakingV3")
     ).deploy()) as FuseStakingV3;
 
-    await staking.initialize();
-    await staking.upgrade0();
-    await staking.upgrade1(NULL_ADDRESS, ubiMock.address, uniswap.address);
-    await staking.upgrade2();
+    await staking.initialize(uniswap.address, NULL_ADDRESS);
+    await staking.setUBIScheme(ubiMock.address);
   });
 
   it("should have owner", async () => {