@gooddollar/goodprotocol 2.0.13 → 2.0.14-beta.0

package/scripts/multichain-deploy/helpers.ts

@@ -1,37 +1,46 @@
 import { Contract, ContractFactory, Signer } from "ethers";
 import { network, ethers, upgrades, run } from "hardhat";
 import * as safeethers from "ethers";
-import { TransactionResponse } from "@ethersproject/providers";
+import { TransactionResponse, TransactionReceipt } 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 util from "util";
 import dao from "../../releases/deployment.json";
 
 const exec = util.promisify(require("child_process").exec);
 
-const networkName = network.name === "localhost" ? "production-mainnet" : network.name;
+const networkName =
+  network.name === "localhost" ? "production-mainnet" : network.name;
 let totalGas = 0;
 const gasUsage = {};
 const GAS_SETTINGS = { gasLimit: 10000000 };
 let release: { [key: string]: any } = dao[networkName];
 
 export const verifyProductionSigner = signer => {
-  if (signer.address.toLowerCase() !== "0x5128E3C1f8846724cc1007Af9b4189713922E4BB".toLowerCase()) {
+  if (
+    signer.address.toLowerCase() !==
+    "0x5128E3C1f8846724cc1007Af9b4189713922E4BB".toLowerCase()
+  ) {
     throw new Error(
       "signer not 0x5128E3C1f8846724cc1007Af9b4189713922E4BB to get same deployed addresses on production"
     );
   }
 };
-export const printDeploy = async (c: Contract | TransactionResponse): Promise<Contract | TransactionResponse> => {
+export const printDeploy = async (
+  c: Contract | TransactionResponse
+): Promise<Contract | TransactionReceipt | TransactionResponse> => {
   if (c instanceof Contract) {
     await c.deployed();
     console.log("deployed to: ", c.address);
+    return c.deployed();
   }
   if (c.wait) {
     await c.wait();
     console.log("tx done:", c.hash);
+    return c.wait();
   }
   return c;
 };
@@ -47,7 +56,10 @@ export const countTotalGas = async (tx, name) => {
   } else console.log("no gas data", { res, tx });
 };
 
-export const deploySuperGoodDollar = async (superfluidHost, tokenArgs) => {
+export const deploySuperGoodDollar = async (
+  { superfluidHost, superfluidInflowNFTLogic, superfluidOutflowNFTLogic },
+  tokenArgs
+) => {
   const SuperGoodDollar = (await deployDeterministic(
     {
       name: "SuperGoodDollar",
@@ -65,27 +77,91 @@ export const deploySuperGoodDollar = async (superfluidHost, tokenArgs) => {
     []
   ).then(printDeploy)) as Contract;
 
-  await GoodDollarProxy.initializeProxy(SuperGoodDollar.address).then(printDeploy);
+  await GoodDollarProxy.initializeProxy(SuperGoodDollar.address).then(
+    printDeploy
+  );
+
+  const OutFlowNFT = (await deployDeterministic(
+    {
+      name: "SuperGoodDollar OutflowNFT",
+      factory: uupsFactory
+    },
+    []
+  ).then(printDeploy)) as Contract;
+
+  const InFlowNFT = (await deployDeterministic(
+    {
+      name: "SuperGoodDollar InflowNFT",
+      factory: uupsFactory
+    },
+    []
+  ).then(printDeploy)) as Contract;
+
+  await OutFlowNFT.initializeProxy(superfluidOutflowNFTLogic);
+  await InFlowNFT.initializeProxy(superfluidInflowNFTLogic);
+
+  await SuperGoodDollar.attach(GoodDollarProxy.address)[
+    "initialize(string,string,uint256,address,address,address,address,address,address)"
+  ](...tokenArgs, OutFlowNFT.address, InFlowNFT.address);
 
-  await SuperGoodDollar.attach(GoodDollarProxy.address)
-    ["initialize(string,string,uint256,address,address,address,address)"](...tokenArgs)
-    .then(printDeploy);
+  const GoodDollar = await ethers.getContractAt(
+    "ISuperGoodDollar",
+    GoodDollarProxy.address
+  );
+
+  const constantInflowNFT = await ethers.getContractAt(
+    "ConstantInflowNFT",
+    InFlowNFT.address
+  );
+
+  const constantOutflowNFT = await ethers.getContractAt(
+    "ConstantOutflowNFT",
+    OutFlowNFT.address
+  );
+
+  await constantOutflowNFT
+    .attach(OutFlowNFT.address)
+    .initialize(
+      GoodDollarProxy.address,
+      (await GoodDollar.symbol()) + " Outflow NFT",
+      (await GoodDollar.symbol()) + " COF"
+    );
+  await constantInflowNFT
+    .attach(InFlowNFT.address)
+    .initialize(
+      GoodDollarProxy.address,
+      (await GoodDollar.symbol()) + " Inflow NFT",
+      (await GoodDollar.symbol()) + " CIF"
+    );
 
-  const GoodDollar = await ethers.getContractAt("ISuperGoodDollar", GoodDollarProxy.address);
   return GoodDollar;
 };
 
-export const deployDeterministic = async (contract, args: any[], factoryOpts = {}, redeployProxyFactory = false) => {
+export const deployDeterministic = async (
+  contract,
+  args: any[],
+  factoryOpts = {},
+  redeployProxyFactory = false
+) => {
   try {
     let proxyFactory;
     if (networkName.startsWith("develop") && redeployProxyFactory) {
-      proxyFactory = await (await ethers.getContractFactory("ProxyFactory1967")).deploy();
-    } else proxyFactory = await ethers.getContractAt("ProxyFactory1967", release.ProxyFactory);
+      proxyFactory = await (
+        await ethers.getContractFactory("ProxyFactory1967")
+      ).deploy();
+    } else
+      proxyFactory = await ethers.getContractAt(
+        "ProxyFactory1967",
+        release.ProxyFactory
+      );
     const Contract =
-      (contract.factory as ContractFactory) || (await ethers.getContractFactory(contract.name, factoryOpts));
+      (contract.factory as ContractFactory) ||
+      (await ethers.getContractFactory(contract.name, factoryOpts));
 
     const salt = ethers.BigNumber.from(
-      ethers.utils.keccak256(ethers.utils.toUtf8Bytes(contract.salt || contract.name))
+      ethers.utils.keccak256(
+        ethers.utils.toUtf8Bytes(contract.salt || contract.name)
+      )
     );
 
     if (contract.isUpgradeable === true) {
@@ -93,19 +169,30 @@ export const deployDeterministic = async (contract, args: any[], factoryOpts = {
         args,
         proxyFactory: proxyFactory.address
       });
-      const encoded = Contract.interface.encodeFunctionData(contract.initializer || "initialize", args);
+      const encoded = Contract.interface.encodeFunctionData(
+        contract.initializer || "initialize",
+        args
+      );
       const tx = await Contract.deploy(GAS_SETTINGS);
       const impl = await tx.deployed();
       console.log("implementation deployed:", contract.name, impl.address);
       await countTotalGas(tx, contract.name);
 
-      const tx2 = await proxyFactory.deployProxy(salt, impl.address, encoded, GAS_SETTINGS);
-      await countTotalGas(tx2, contract.name);
-      const deployTx = await tx2.wait().catch(e => console.error("failed to deploy proxy, assuming it exists...", e));
-      const proxyAddr = await proxyFactory["getDeploymentAddress(uint256,address)"](
+      const tx2 = await proxyFactory.deployProxy(
         salt,
-        await proxyFactory.signer.getAddress()
+        impl.address,
+        encoded,
+        GAS_SETTINGS
       );
+      await countTotalGas(tx2, contract.name);
+      const deployTx = await tx2
+        .wait()
+        .catch(e =>
+          console.error("failed to deploy proxy, assuming it exists...", e)
+        );
+      const proxyAddr = await proxyFactory[
+        "getDeploymentAddress(uint256,address)"
+      ](salt, await proxyFactory.signer.getAddress());
       console.log("proxy deployed:", contract.name, proxyAddr);
       return Contract.attach(proxyAddr);
     } else {
@@ -114,10 +201,17 @@ export const deployDeterministic = async (contract, args: any[], factoryOpts = {
         args
       });
       const constructor = Contract.interface.encodeDeploy(args);
-      const bytecode = ethers.utils.solidityPack(["bytes", "bytes"], [Contract.bytecode, constructor]);
-      const deployTx = await (await proxyFactory.deployCode(salt, bytecode, GAS_SETTINGS)).wait();
+      const bytecode = ethers.utils.solidityPack(
+        ["bytes", "bytes"],
+        [Contract.bytecode, constructor]
+      );
+      const deployTx = await (
+        await proxyFactory.deployCode(salt, bytecode, GAS_SETTINGS)
+      ).wait();
 
-      const proxyAddr = await proxyFactory["getDeploymentAddress(uint256,address,bytes32)"](
+      const proxyAddr = await proxyFactory[
+        "getDeploymentAddress(uint256,address,bytes32)"
+      ](
         salt,
         await proxyFactory.signer.getAddress(),
         ethers.utils.keccak256(bytecode)
@@ -141,7 +235,9 @@ export const executeViaGuardian = async (
   network?: string
 ) => {
   let release: { [key: string]: any } = dao[network || networkName];
-  const ctrl = await (await ethers.getContractAt("Controller", release.Controller)).connect(guardian);
+  const ctrl = await (
+    await ethers.getContractAt("Controller", release.Controller)
+  ).connect(guardian);
 
   const results = [];
   for (let i = 0; i < contracts.length; i++) {
@@ -149,29 +245,36 @@ export const executeViaGuardian = async (
     console.log("executing:", contracts[i], functionSigs[i], functionInputs[i]);
     const sigHash = ethers.utils.keccak256(ethers.utils.toUtf8Bytes(functionSigs[i])).slice(0, 10);
     const encoded = ethers.utils.solidityPack(["bytes4", "bytes"], [sigHash, functionInputs[i]]);
-    if (contract === ctrl.address) {
+    if (contract.toLowerCase().startsWith((await guardian.getAddress()).toLocaleLowerCase())) {
+      const [, target] = contract.split("_");
+      console.log("executing directly on target contract:", sigHash, encoded);
+
+      const tx = await guardian.sendTransaction({ to: target, data: encoded }).then(printDeploy);
+      results.push(tx);
+    } else if (contract === ctrl.address) {
       console.log("executing directly on controller:", sigHash, encoded);
 
-      const tx = await guardian
-        .sendTransaction({ to: contract, data: encoded })
-        .then(printDeploy)
-        .then(_ => _.wait());
+      const tx = await guardian.sendTransaction({ to: contract, data: encoded }).then(printDeploy);
+
       results.push(tx);
     } else {
-      const simulationResult = await ctrl.callStatic.genericCall(contract, encoded, release.Avatar, ethValues[i], {
-        from: await guardian.getAddress(),
-        value: ethValues[i]
-      });
+      const simulationResult = await ctrl.callStatic.genericCall(
+        contract,
+        encoded,
+        release.Avatar,
+        ethValues[i],
+        {
+          from: await guardian.getAddress(),
+          value: ethValues[i]
+        }
+      );
       console.log("executing genericCall:", {
         sigHash,
         encoded,
         simulationResult
       });
       if (simulationResult[0] === false) throw new Error("simulation failed:" + contract);
-      const tx = await ctrl
-        .genericCall(contract, encoded, release.Avatar, ethValues[i])
-        .then(printDeploy)
-        .then(_ => _.wait());
+      const tx = await ctrl.genericCall(contract, encoded, release.Avatar, ethValues[i]).then(printDeploy);
       // console.log("generic call events:", tx.events);
       results.push(tx);
     }
@@ -188,24 +291,32 @@ export const executeViaSafe = async (
   safeSignerOrNetwork?: Signer | string,
   isSimulation = false
 ) => {
-  if (typeof safeSignerOrNetwork !== "object" && !process.env.SAFEOWNER_PRIVATE_KEY) {
+  if (
+    typeof safeSignerOrNetwork !== "object" &&
+    !process.env.SAFEOWNER_PRIVATE_KEY
+  ) {
     throw new Error("safe signer is missing");
   }
 
-  let safeSigner = new ethers.Wallet(process.env.SAFEOWNER_PRIVATE_KEY, new ethers.providers.CloudflareProvider());
+  let safeSigner = new ethers.Wallet(
+    process.env.SAFEOWNER_PRIVATE_KEY,
+    new ethers.providers.CloudflareProvider()
+  );
   if (typeof safeSignerOrNetwork === "string") {
     switch (safeSignerOrNetwork) {
       case "mainnet":
         break;
       case "celo":
-        safeSigner = new ethers.Wallet(process.env.SAFEOWNER_PRIVATE_KEY).connect(
+        safeSigner = new ethers.Wallet(
+          process.env.SAFEOWNER_PRIVATE_KEY
+        ).connect(
           new ethers.providers.JsonRpcProvider("https://forno.celo.org")
         );
         break;
       case "fuse":
-        safeSigner = new ethers.Wallet(process.env.SAFEOWNER_PRIVATE_KEY).connect(
-          new ethers.providers.JsonRpcProvider("https://rpc.fuse.io")
-        );
+        safeSigner = new ethers.Wallet(
+          process.env.SAFEOWNER_PRIVATE_KEY
+        ).connect(new ethers.providers.JsonRpcProvider("https://rpc.fuse.io"));
         break;
     }
   } else if (safeSignerOrNetwork) {
@@ -222,7 +333,7 @@ export const executeViaSafe = async (
       txServiceUrl = "https://transaction-fuse.safe.fuse.io";
       break;
     case 42220:
-      txServiceUrl = "https://mainnet-tx-svc.celo-safe-prod.celo-networks-dev.org";
+      txServiceUrl = "https://safe-transaction-celo.safe.global";
       break;
   }
   console.log("creating safe adapter", { txServiceUrl });
@@ -240,7 +351,11 @@ export const executeViaSafe = async (
   const safeSdk = await Safe.create({ ethAdapter, safeAddress });
 
   let release: { [key: string]: any } = dao[networkName];
-  const ctrl = await ethers.getContractAt("Controller", release.Controller, null);
+  const ctrl = await ethers.getContractAt(
+    "Controller",
+    release.Controller,
+    null
+  );
 
   const safeTransactionData: MetaTransactionData[] = [];
 
@@ -250,13 +365,32 @@ export const executeViaSafe = async (
     const sigHash = ethers.utils.keccak256(ethers.utils.toUtf8Bytes(functionSigs[i])).slice(0, 10);
     console.log("creating tx:", contracts[i], functionSigs[i], functionInputs[i]);
     const encoded = ethers.utils.solidityPack(["bytes4", "bytes"], [sigHash, functionInputs[i]]);
-    if (contract === ctrl.address) {
-      const simulationResult =
-        isSimulation === true &&
-        (await ctrl.callStatic[functionSigs[i]](...functionInputs[i], {
-          from: safeAddress,
-          value: ethValues[i]
-        }));
+    if (contract.toLowerCase().startsWith(safeAddress.toLocaleLowerCase())) {
+      const [, target] = contract.split("_");
+      const simulationResult = await ethers.provider.call({
+        to: target,
+        value: ethValues[i],
+        data: encoded,
+        from: safeAddress
+      });
+
+      console.log("executing from guardians safe:", {
+        sigHash,
+        encoded,
+        simulationResult
+      });
+      safeTransactionData.push({
+        to: target,
+        value: ethValues[i],
+        data: encoded
+      });
+    } else if (contract === ctrl.address) {
+      const simulationResult = await ethers.provider.call({
+        to: ctrl.address,
+        data: encoded,
+        from: safeAddress,
+        value: ethValues[i]
+      });
       console.log("executing controller call:", {
         sigHash,
         encoded,
@@ -276,17 +410,16 @@ export const executeViaSafe = async (
         value: ethValues[i]
       });
 
-      const simulationResult =
-        isSimulation === true &&
-        (await ctrl.callStatic.genericCall(contract, encoded, release.Avatar, ethValues[i], {
-          from: safeAddress,
-          value: ethValues[i]
-        }));
+      const simulationResult = await ctrl.callStatic.genericCall(contract, encoded, release.Avatar, ethValues[i], {
+        from: safeAddress,
+        value: ethValues[i]
+      });
       console.log("executing genericCall simulation result:", {
         sigHash,
         simulationResult
       });
-      if (isSimulation === true && simulationResult[0] === false) throw new Error("simulation failed:" + contract);
+      if (isSimulation === true && simulationResult[0] === false)
+        throw new Error("simulation failed:" + contract);
       const genericEncode = ctrl.interface.encodeFunctionData("genericCall", [
         contract,
         encoded,
@@ -332,12 +465,19 @@ export const verifyContract = async (
   proxyName?: string,
   forcedConstructorArguments?: string
 ) => {
-  let networkProvider = networkName.includes("-") ? networkName.split("-")[1] : "fuse";
-  networkProvider = networkProvider === "mainnet" ? "ethereum" : networkProvider;
+  let networkProvider = networkName.includes("-")
+    ? networkName.split("-")[1]
+    : "fuse";
+  networkProvider =
+    networkProvider === "mainnet" ? "ethereum" : networkProvider;
   console.log("truffle compile...");
   await exec("npx truffle compile");
-  const cmd = `npx truffle run verify ${proxyName ? "--custom-proxy " + proxyName : ""} ${contractName}@${address} ${
-    forcedConstructorArguments ? "--forceConstructorArgs string:" + forcedConstructorArguments.slice(2) : ""
+  const cmd = `npx truffle run verify ${
+    proxyName ? "--custom-proxy " + proxyName : ""
+  } ${contractName}@${address} ${
+    forcedConstructorArguments
+      ? "--forceConstructorArgs string:" + forcedConstructorArguments.slice(2)
+      : ""
   } --network ${networkProvider}`;
   console.log("running...:", cmd);
   await exec(cmd).then(({ stdout, stderr }) => {