@gooddollar/goodprotocol 2.0.13 → 2.0.14-beta.0

package/scripts/upgrades/superfluid-nft-celo-gas-token.ts

@@ -0,0 +1,159 @@
+/***
+ * Upgrade celo's supergooddollar with support for superfluid nfts + celo gas token requirements
+ * Upgrade Plan:
+ * - deploy implementation
+ * - call updateCode
+ * - once nfts are deployed create and nft and set it
+ */
+
+import { network, ethers } from "hardhat";
+import { Contract } from "ethers";
+import { defaultsDeep } from "lodash";
+import { getImplementationAddress } from "@openzeppelin/upgrades-core";
+// import OutNFT from "@superfluid-finance/ethereum-contracts/artifacts/contracts/superfluid/ConstantOutflowNFT.sol/ConstantOutflowNFT.json";
+// import InNFT from "@superfluid-finance/ethereum-contracts/artifacts/contracts/superfluid/ConstantInflowNFT.sol/ConstantInflowNFT.json";
+import {
+  deployDeterministic,
+  printDeploy,
+  executeViaGuardian,
+  executeViaSafe,
+  verifyProductionSigner
+} from "../multichain-deploy/helpers";
+
+import ProtocolSettings from "../../releases/deploy-settings.json";
+
+import dao from "../../releases/deployment.json";
+import { verifyContract } from "../multichain-deploy/helpers";
+let { name: networkName } = network;
+
+networkName = networkName.replace("-fork", "");
+
+export const upgrade = async () => {
+  const isProduction = networkName.includes("production");
+  let [root, ...signers] = await ethers.getSigners();
+  let withNFTs = true;
+
+  if (isProduction) verifyProductionSigner(root);
+  // simulate on fork
+  if (network.name === "localhost") {
+    await root.sendTransaction({
+      to: "0xecA109A2686F074c9461bcb05656b19EF61FbC9e",
+      value: ethers.constants.WeiPerEther
+    });
+    root = await ethers.getImpersonatedSigner(
+      "0xecA109A2686F074c9461bcb05656b19EF61FbC9e"
+    );
+    networkName = "production-celo";
+  } else withNFTs = true;
+
+  let release: { [key: string]: any } = dao[networkName];
+
+  let protocolSettings = defaultsDeep(
+    {},
+    ProtocolSettings[networkName],
+    ProtocolSettings["default"]
+  );
+
+  console.log("got signers:", {
+    withNFTs,
+    networkName,
+    root: root.address,
+    balance: await ethers.provider
+      .getBalance(root.address)
+      .then(_ => _.toString())
+  });
+
+  const supergd = await ethers.getContractAt(
+    "SuperGoodDollar",
+    release.GoodDollar
+  );
+  const owner = await supergd.owner();
+  const host = await supergd.getHost();
+  const name = await supergd.name();
+  const symbol = await supergd.symbol();
+  console.log({ supergd: supergd.address, owner, host, symbol, name });
+  let impl = await ethers
+    .deployContract("SuperGoodDollar", [host])
+    .then(printDeploy);
+
+  await verifyContract(impl.address, "SuperGoodDollar", networkName);
+
+  let outnftProxy, innftProxy;
+  if (withNFTs) {
+    outnftProxy = await ethers.deployContract("UUPSProxy").then(printDeploy);
+    innftProxy = await ethers.deployContract("UUPSProxy").then(printDeploy);
+
+    const outnftimpl = (await ethers
+      .deployContract("ConstantOutflowNFT", [host, innftProxy.address])
+      .then(printDeploy)) as Contract;
+
+    const innftimpl = (await ethers
+      .deployContract("ConstantInflowNFT", [host, outnftProxy.address])
+      .then(printDeploy)) as Contract;
+
+    await verifyContract(outnftimpl.address, "ConstantOutflowNFT", networkName);
+
+    await verifyContract(innftimpl.address, "ConstantInflowNFT", networkName);
+
+    await outnftProxy.initializeProxy(outnftimpl.address).then(printDeploy);
+    await outnftimpl
+      .attach(outnftProxy.address)
+      .initialize(name + "-OutFlowNFT", symbol + "-OutFlowNFT")
+      .then(printDeploy);
+
+    await innftProxy.initializeProxy(innftimpl.address).then(printDeploy);
+    await innftimpl
+      .attach(innftProxy.address)
+      .initialize(name + "-InFlowNFT", symbol + "-InFlowNFT")
+      .then(printDeploy);
+  }
+  const proposalContracts = [
+    release.GoodDollar, //upgrade
+    release.GoodDollar //optionally set NFTs
+  ];
+
+  const proposalEthValues = proposalContracts.map(_ => 0);
+
+  const proposalFunctionSignatures = [
+    "updateCode(address)",
+    "setNFTProxyContracts(address,address,address,address)"
+  ];
+
+  const proposalFunctionInputs = [
+    ethers.utils.defaultAbiCoder.encode(["address"], [impl.address]),
+    ethers.utils.defaultAbiCoder.encode(
+      ["address", "address", "address", "address"],
+      [
+        outnftProxy.address,
+        innftProxy.address,
+        ethers.constants.AddressZero,
+        ethers.constants.AddressZero
+      ]
+    )
+  ];
+
+  if (isProduction) {
+    await executeViaSafe(
+      proposalContracts.slice(0, withNFTs ? 2 : 1),
+      proposalEthValues.slice(0, withNFTs ? 2 : 1),
+      proposalFunctionSignatures.slice(0, withNFTs ? 2 : 1),
+      proposalFunctionInputs.slice(0, withNFTs ? 2 : 1),
+      "0xecA109A2686F074c9461bcb05656b19EF61FbC9e",
+      "celo"
+    );
+  } else {
+    await executeViaGuardian(
+      proposalContracts.slice(0, withNFTs ? 2 : 1),
+      proposalEthValues.slice(0, withNFTs ? 2 : 1),
+      proposalFunctionSignatures.slice(0, withNFTs ? 2 : 1),
+      proposalFunctionInputs.slice(0, withNFTs ? 2 : 1),
+      root,
+      networkName
+    );
+  }
+};
+
+export const main = async () => {
+  await upgrade().catch(console.log);
+};
+if (process.argv[1].includes("superfluid-nft-celo-gas-token")) main();

package/scripts/utils.ts

@@ -0,0 +1,15 @@
+import { Contract, Provider, setMulticallAddress } from "ethers-multicall";
+import Identity from "../artifacts/contracts/Interfaces.sol/IIdentity.json";
+import { ethers } from "hardhat";
+
+export const bulkIsWhitelisted = async (accounts: Array<String>) => {
+  setMulticallAddress(122, "0x3CE6158b7278Bf6792e014FA7B4f3c6c46fe9410");
+  setMulticallAddress(42220, "0x75F59534dd892c1f8a7B172D639FA854D529ada3");
+  const celoProvider = new ethers.providers.JsonRpcProvider("https://forno.celo.org");
+  const ethcallProvider = new Provider(celoProvider, 42220);
+  const identityContract = new Contract("0xC361A6E67822a0EDc17D899227dd9FC50BD62F42", Identity.abi);
+  const calls = accounts.map(d => identityContract.isWhitelisted(d));
+  const result = await ethcallProvider.all(calls);
+  const whitelisted = accounts.filter((v, i) => result[i]);
+  return whitelisted;
+};

package/test/helpers.ts

@@ -14,7 +14,7 @@ import WETH9 from "@uniswap/v2-periphery/build/WETH9.json";
 import UniswapV2Router02 from "@uniswap/v2-periphery/build/UniswapV2Router02.json";
 import { GoodMarketMaker, CompoundVotingMachine } from "../types";
 import { Contract } from "ethers";
-import frameworkDeployer from "@superfluid-finance/ethereum-contracts/scripts/deploy-test-framework";
+import testDeployer from "@superfluid-finance/ethereum-contracts/dev-scripts/deploy-test-framework";
 
 export const getStakingFactory = async (
   factory:
@@ -38,9 +38,9 @@ export const getStakingFactory = async (
 
 export const deploySuperFluid = async () => {
   // This deploys the whole framework with various contracts
-  const sfDeployer = await frameworkDeployer.deployTestFramework();
+  const { frameworkDeployer } = await testDeployer.deployTestFramework();
   // returns contract addresses as a struct, see https://github.com/superfluid-finance/protocol-monorepo/blob/dev/packages/ethereum-contracts/contracts/utils/SuperfluidFrameworkDeployer.sol#L48
-  const contractsFramework = await sfDeployer.getFramework();
+  const contractsFramework = await frameworkDeployer.getFramework();
 
   return contractsFramework;
 };
@@ -49,20 +49,59 @@ export const deploySuperGoodDollar = async (sfContracts, tokenArgs) => {
   const SuperGoodDollarFactory = await ethers.getContractFactory(
     "SuperGoodDollar"
   );
-  const SuperGoodDollar = await SuperGoodDollarFactory.deploy(sfContracts.host);
 
-  const GoodDollarProxyFactory = await ethers.getContractFactory("UUPSProxy");
+  console.log("deploying supergooddollar logic");
+  const SuperGoodDollar = await SuperGoodDollarFactory.deploy(sfContracts.host);
 
+  console.log("deploying supergooddollar proxy");
+  const GoodDollarProxyFactory = await ethers.getContractFactory(
+    "contracts/token/superfluid/UUPSProxy.sol:UUPSProxy"
+  );
   const GoodDollarProxy = await GoodDollarProxyFactory.deploy();
+
+  console.log("deploying flow nfts...");
+
+  const outNftProxy = await GoodDollarProxyFactory.deploy();
+  const inNftProxy = await GoodDollarProxyFactory.deploy();
+
+  const constantInflowNFT = await ethers.deployContract("ConstantInflowNFT", [
+    sfContracts.host,
+    outNftProxy.address
+  ]);
+
+  const constantOutflowNFT = await ethers.deployContract("ConstantOutflowNFT", [
+    sfContracts.host,
+    inNftProxy.address
+  ]);
+  await outNftProxy.initializeProxy(constantOutflowNFT.address);
+  await inNftProxy.initializeProxy(constantInflowNFT.address);
+
+  console.log("deployed supergooddollar proxy, initializing proxy...");
   await GoodDollarProxy.initializeProxy(SuperGoodDollar.address);
 
+  console.log("initializing supergooddollar....");
   await SuperGoodDollar.attach(GoodDollarProxy.address)[
-    "initialize(string,string,uint256,address,address,address,address)"
-  ](...tokenArgs);
+    "initialize(string,string,uint256,address,address,address,address,address,address)"
+  ](...tokenArgs, outNftProxy.address, inNftProxy.address);
   const GoodDollar = await ethers.getContractAt(
-    "ISuperGoodDollar",
+    "SuperGoodDollar",
     GoodDollarProxy.address
   );
+  console.log("supergooddollar created successfully");
+
+  await constantOutflowNFT
+    .attach(outNftProxy.address)
+    .initialize(
+      (await GoodDollar.symbol()) + " Outflow NFT",
+      (await GoodDollar.symbol()) + " COF"
+    );
+  await constantInflowNFT
+    .attach(inNftProxy.address)
+    .initialize(
+      (await GoodDollar.symbol()) + " Inflow NFT",
+      (await GoodDollar.symbol()) + " CIF"
+    );
+
   return GoodDollar;
 };
 export const createDAO = async (tokenType: "super" | "regular" = "super") => {
@@ -100,7 +139,9 @@ export const createDAO = async (tokenType: "super" | "regular" = "super") => {
   const Identity = await upgrades.deployProxy(
     IdentityFactory,
     [root.address, ethers.constants.AddressZero],
-    { kind: "uups" }
+    {
+      kind: "uups"
+    }
   );
 
   const daoCreator = await DAOCreatorFactory.deploy();
@@ -258,6 +299,14 @@ export const createDAO = async (tokenType: "super" | "regular" = "super") => {
       kind: "uups"
     }
   );
+  let distHelper = await upgrades.deployProxy(
+    await ethers.getContractFactory("DistributionHelper"),
+    [nameService.address],
+    {
+      initializer: "initialize(address)",
+      kind: "uups"
+    }
+  );
   console.log("deploying marketMaker...");
 
   const MM = await ethers.getContractFactory("GoodMarketMaker");
@@ -265,7 +314,9 @@ export const createDAO = async (tokenType: "super" | "regular" = "super") => {
   let marketMaker = (await upgrades.deployProxy(
     MM,
     [nameService.address, 999388834642296, 1e15],
-    { kind: "uups" }
+    {
+      kind: "uups"
+    }
   )) as unknown as GoodMarketMaker;
 
   await (await reputation.updateDAO(nameService.address)).wait();
@@ -350,6 +401,18 @@ export const createDAO = async (tokenType: "super" | "regular" = "super") => {
   ).interface.encodeFunctionData("addMinter", [goodReserve.address]);
 
   await ictrl.genericCall(gd, encoded, Avatar.address, 0);
+
+  console.log("Setting reserve distribution helper...");
+
+  await ictrl.genericCall(
+    goodReserve.address,
+    goodReserve.interface.encodeFunctionData("setDistributionHelper", [
+      distHelper.address
+    ]),
+    Avatar.address,
+    0
+  );
+
   const gasFeeMockFactory = await ethers.getContractFactory(
     "GasPriceMockOracle"
   );