@gooddollar/goodprotocol 2.0.25-beta.8 → 2.0.25

package/scripts/multichain-deploy/0_proxyFactory-deploy.ts

@@ -23,6 +23,9 @@ export const deployUniversalProxyFactory = async () => {
     s: "0x2222222222222222222222222222222222222222222222222222222222222222"
   };
   //modify tx data a little so we get different contract address for different envs
+  if (name.includes("development-base")) {
+    deployTx.gasPrice = 7e7;
+  }
   if (name.includes("staging")) {
     deployTx.gasLimit = 892000;
   } else if (name.includes("production")) {
@@ -34,12 +37,18 @@ export const deployUniversalProxyFactory = async () => {
   const deployer = ethers.utils.recoverAddress(txHash, signer);
   let [funder] = await ethers.getSigners();
 
-  let tx = await (
-    await funder.sendTransaction({
-      to: deployer,
-      value: ethers.BigNumber.from(deployTx.gasPrice).mul(deployTx.gasLimit)
-    })
-  ).wait();
+  const curBalance = await ethers.provider.getBalance(deployer);
+  const deployCost = ethers.BigNumber.from(deployTx.gasPrice).mul(deployTx.gasLimit);
+
+  let tx = {};
+  if (curBalance.lt(deployCost)) {
+    tx = await (
+      await funder.sendTransaction({
+        to: deployer,
+        value: deployCost.sub(curBalance)
+      })
+    ).wait();
+  }
 
   if (isProduction) verifyProductionSigner(funder);
 
@@ -47,23 +56,19 @@ export const deployUniversalProxyFactory = async () => {
     fundingTx: tx.transactionHash,
     deployer,
     funder: funder.address,
-    deployerBalance: ethers.utils.formatUnits(
-      await ethers.provider.getBalance(deployer)
-    )
+    deployerBalance: ethers.utils.formatUnits(await ethers.provider.getBalance(deployer))
   });
   const signedTx = ethers.utils.serializeTransaction(deployTx, signer);
-  const result = await (await ethers.provider.sendTransaction(signedTx)).wait();
-  console.log({ result });
+  const proxyTx = await ethers.provider.sendTransaction(signedTx);
+  console.log({ proxyTx });
+  const result = await proxyTx.wait();
   return ethers.getContractAt("ProxyFactory1967", result.contractAddress);
 };
 
 export const deployProxy = async (defaultAdmin = null) => {
   let release: { [key: string]: any } = dao[network.name] || {};
 
-  if (
-    network.name.match(/production|staging|fuse|development/) &&
-    release.ProxyFactory
-  ) {
+  if (network.name.match(/production|staging|fuse|development/) && release.ProxyFactory) {
     throw new Error("ProxyFactory already exists for env");
   }
   // let [root] = await ethers.getSigners();

package/scripts/multichain-deploy/7_superfluidfaucet-deploy.ts

@@ -0,0 +1,96 @@
+/***
+ * Deploy helper contracts
+ * AdminWallet, Faucet, Invites
+ */
+import { network, ethers, upgrades, run } from "hardhat";
+import { Contract } from "ethers";
+import { defaultsDeep } from "lodash";
+import { getImplementationAddress } from "@openzeppelin/upgrades-core";
+import { deployDeterministic, verifyProductionSigner, verifyContract } from "./helpers";
+import releaser from "../releaser";
+import ProtocolSettings from "../../releases/deploy-settings.json";
+import dao from "../../releases/deployment.json";
+import { TransactionResponse } from "@ethersproject/providers";
+
+const { name } = network;
+
+const printDeploy = async (c: Contract | TransactionResponse): Promise<Contract | TransactionResponse> => {
+  if (c instanceof Contract) {
+    await c.deployed();
+    console.log("deployed to: ", c.address);
+  }
+  if (c.wait) {
+    await c.wait();
+    console.log("tx done:", c.hash);
+  }
+  return c;
+};
+
+export const deployHelpers = async () => {
+  let release: { [key: string]: any } = dao[network.name] || {};
+
+  let [root] = await ethers.getSigners();
+  const isProduction = network.name.includes("production");
+
+  if (isProduction) verifyProductionSigner(root);
+
+  //generic call permissions
+  let schemeMock = root;
+
+  console.log("got signers:", {
+    network,
+    root: root.address,
+    schemeMock: schemeMock.address,
+    balance: await ethers.provider.getBalance(root.address).then(_ => _.toString())
+  });
+
+  const walletAdmins = [];
+  for (let i = 0; i < 10; i++) {
+    const wallet = ethers.Wallet.fromMnemonic(process.env.ADMIN_WALLET_MNEMONIC, `m/44'/60'/0'/0/${i}`);
+    walletAdmins.push(wallet.address);
+  }
+
+  const gasprice = 1e8;
+  console.log("deploying adminwallet", { walletAdmins });
+  const AdminWallet = release.AdminWallet
+    ? await ethers.getContractAt("AdminWallet", release.AdminWallet)
+    : ((await deployDeterministic(
+        {
+          //   address payable[] memory _admins,
+          // NameService _ns,
+          // address _owner,
+          // uint256 _gasPrice
+          name: "AdminWallet",
+          salt: "AdminWallet",
+          isUpgradeable: true
+        },
+        [walletAdmins, ethers.constants.AddressZero, root.address, gasprice]
+      ).then(printDeploy)) as Contract);
+
+  const Faucet = release.SuperfluidFaucet
+    ? await ethers.getContractAt("SuperfluidFaucet", release.SuperfluidFaucet)
+    : ((await deployDeterministic(
+        {
+          name: "SuperfluidFaucet",
+          salt: "SuperfluidFaucet",
+          isUpgradeable: true
+        },
+        [ethers.utils.parseEther("0.000003"), ethers.utils.parseEther("0.000003"), 30]
+      ).then(printDeploy)) as Contract);
+
+  const torelease = {
+    SuperfluidFaucet: Faucet.address,
+    AdminWallet: AdminWallet.address
+  };
+  await releaser(torelease, network.name, "deployment", false);
+
+  let impl = await getImplementationAddress(ethers.provider, AdminWallet.address);
+  await verifyContract(impl, "contracts/utils/AdminWallet.sol:AdminWallet", network.name);
+  impl = await getImplementationAddress(ethers.provider, Faucet.address);
+  await verifyContract(impl, "contracts/fuseFaucet/SuperfluidFaucet.sol:SuperfluidFaucet", network.name);
+};
+
+export const main = async () => {
+  await deployHelpers();
+};
+if (process.argv[1].includes("7_superfluidfaucet")) main();

package/scripts/multichain-deploy/helpers.ts

@@ -193,6 +193,10 @@ export const executeViaGuardian = async (
   const results = [];
   for (let i = 0; i < contracts.length; i++) {
     const contract = contracts[i];
+    if (!contract) {
+      console.warn("skipping executing missing contract", i, contracts[i], functionSigs[i], functionInputs[i]);
+      continue;
+    }
     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]]);
@@ -395,18 +399,14 @@ export const executeViaSafe = async (
 
 export const verifyContract = async (
   address,
-  contractName,
+  contractPath,
   networkName = network.name,
   proxyName?: string,
   forcedConstructorArguments?: string
 ) => {
-  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) : ""
-  } --network ${networkProvider}`;
+  const cmd = `yarn hardhat verify --contract ${contractPath} ${address} ${
+    forcedConstructorArguments ?? ""
+  } --network ${networkName}`;
   console.log("running...:", cmd);
   await exec(cmd).then(({ stdout, stderr }) => {
     console.log("Result for:", cmd);

package/scripts/proposals/identityAuthPeriod.ts

@@ -0,0 +1,229 @@
+/***
+ * Bring UBI distribution to a temporary working state
+ * Celo:
+ *  - upgrade bridge to be able to prevent UBI bridge transfers as result of the hack
+ *  - mark unexecuted bridge transfers as executed
+ *  - set UBI with new cycle params
+ *  - unpause ubi contract
+ * Fuse:
+ *  - withdraw ubi to avatar and bridge ubi to contract on celo
+ *  - burn excess UBI tokens
+ *  - set UBI with new cycle params
+ *  - unpause ubi contract
+ * Mainnet:
+ *  - withdraw excess UBI from bridge to avatar
+ *  - burn excess UBI from bridge
+ *
+ */
+
+import { network, ethers } from "hardhat";
+import { defaultsDeep, last } from "lodash";
+import prompt from "prompt";
+
+import { executeViaGuardian, executeViaSafe, verifyProductionSigner } from "../multichain-deploy/helpers";
+
+import ProtocolSettings from "../../releases/deploy-settings.json";
+
+import dao from "../../releases/deployment.json";
+let { name: networkName } = network;
+
+export const upgradeCelo = async () => {
+    const isProduction = networkName.includes("production");
+    let [root, ...signers] = await ethers.getSigners();
+
+    if (isProduction) verifyProductionSigner(root);
+
+    let guardian = root;
+
+    //simulate produciton on fork
+    if (network.name === "hardhat" || network.name === "fork" || network.name === "localhost") {
+        networkName = "production-celo";
+    }
+
+    let release: { [key: string]: any } = dao[networkName];
+    let protocolSettings = defaultsDeep({}, ProtocolSettings[networkName], ProtocolSettings["default"]);
+
+    //simulate on fork, make sure safe has enough eth to simulate txs
+    if (network.name === "hardhat" || network.name === "fork" || network.name === "localhost") {
+        guardian = await ethers.getImpersonatedSigner(protocolSettings.guardiansSafe);
+
+        await root.sendTransaction({
+            value: ethers.constants.WeiPerEther.mul(3),
+            to: protocolSettings.guardiansSafe
+        });
+    }
+
+    const rootBalance = await ethers.provider.getBalance(root.address).then(_ => _.toString());
+    const guardianBalance = await ethers.provider.getBalance(guardian.address).then(_ => _.toString());
+
+
+    console.log("got signers:", {
+        networkName,
+        root: root.address,
+        guardian: guardian.address,
+        balance: rootBalance,
+        guardianBalance: guardianBalance
+    });
+
+    const reducerContract = await ethers.deployContract("LastauthReduction", [release.NameService])
+    console.log("executing proposals");
+
+    const proposalContracts = [
+        release.Controller,
+    ];
+
+    const proposalEthValues = proposalContracts.map(_ => 0);
+
+    const proposalFunctionSignatures = [
+        "registerScheme(address,bytes32,bytes4,address)", //make sure mpb is a registered scheme so it can mint G$ tokens
+    ];
+
+    const proposalFunctionInputs = [
+        ethers.utils.defaultAbiCoder.encode(["address", "bytes32", "bytes4", "address"], [reducerContract.address, ethers.constants.HashZero, "0x0000001f", release.Avatar]),
+    ];
+
+    if (isProduction) {
+        await executeViaSafe(
+            proposalContracts,
+            proposalEthValues,
+            proposalFunctionSignatures,
+            proposalFunctionInputs,
+            protocolSettings.guardiansSafe,
+            "celo"
+        );
+    } else {
+        //simulation or dev envs
+        await executeViaGuardian(
+            proposalContracts,
+            proposalEthValues,
+            proposalFunctionSignatures,
+            proposalFunctionInputs,
+            guardian,
+            networkName
+        );
+    }
+
+    //perform sanity checks on fork, for production we need to wait until everything executed
+    if (!isProduction) {
+        try {
+            while (true) {
+                await reducerContract.reduce()
+                let id = await ethers.getContractAt("IdentityV2", release.Identity);
+                console.log("authperiod", await id.authenticationPeriod());
+            }
+        } catch (error) {
+            console.log("reduce reverted:", error)
+        }
+
+    }
+};
+
+export const upgradeFuse = async () => {
+    const isProduction = networkName.includes("production");
+
+    let [root] = await ethers.getSigners();
+
+    //simulate produciton on fork
+    if (network.name === "hardhat" || network.name === "fork" || network.name === "localhost") {
+        networkName = "production";
+    }
+
+    let networkEnv = networkName.split("-")[0];
+
+
+    if (networkEnv === "fuse") networkEnv = "development";
+
+    let release: { [key: string]: any } = dao[networkEnv];
+
+    let guardian = root;
+    console.log({ networkEnv })
+    //simulate on fork, make sure safe has enough eth to simulate txs
+    if (network.name === "hardhat" || network.name === "localhost" || network.name === "fork") {
+        guardian = await ethers.getImpersonatedSigner(release.GuardiansSafe);
+
+        await root.sendTransaction({
+            value: ethers.constants.WeiPerEther.mul(3),
+            to: guardian.address
+        });
+    }
+
+
+    console.log({
+        networkEnv,
+        guardian: guardian.address,
+        isProduction,
+        avatarBalance: await ethers.provider.getBalance(root.address).then(_ => _.toString())
+    });
+
+    const reducerContract = await ethers.deployContract("LastauthReduction", [release.NameService])
+
+    const proposalContracts = [
+        release.Controller,
+    ];
+
+    const proposalEthValues = proposalContracts.map(_ => 0);
+
+    const proposalFunctionSignatures = [
+        "registerScheme(address,bytes32,bytes4,address)", //make sure mpb is a registered scheme so it can mint G$ tokens
+    ];
+
+    const proposalFunctionInputs = [
+        ethers.utils.defaultAbiCoder.encode(["address", "bytes32", "bytes4", "address"], [reducerContract.address, ethers.constants.HashZero, "0x0000001f", release.Avatar]),
+    ];
+
+    if (isProduction) {
+        await executeViaSafe(
+            proposalContracts,
+            proposalEthValues,
+            proposalFunctionSignatures,
+            proposalFunctionInputs,
+            release.GuardiansSafe,
+            "fuse"
+        );
+    } else {
+        //simulation or dev envs
+        await executeViaGuardian(
+            proposalContracts,
+            proposalEthValues,
+            proposalFunctionSignatures,
+            proposalFunctionInputs,
+            guardian,
+            networkName
+        );
+    }
+
+    //perform sanity checks on fork, for production we need to wait until everything executed
+    if (!isProduction) {
+        try {
+            while (true) {
+                await reducerContract.reduce()
+                let id = await ethers.getContractAt("IdentityV2", release.Identity);
+                let idOld = await ethers.getContractAt("IdentityV2", release.IdentityOld);
+
+                console.log("authperiod", await id.authenticationPeriod(), await idOld.authenticationPeriod());
+            }
+        } catch (error) {
+            console.log("reduce reverted:", error)
+        }
+    }
+
+
+};
+
+
+export const main = async () => {
+    prompt.start();
+    const { network } = await prompt.get(["network"]);
+
+    console.log("running step:", { network });
+    switch (network) {
+        case "celo":
+            await upgradeCelo();
+            break;
+        case "fuse":
+            await upgradeFuse();
+            break;
+    }
+};
+
+main().catch(console.log);