@gooddollar/goodprotocol 1.0.31-beta.0 → 2.0.1

package/scripts/upgradeToV3/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/upgradeToV3/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/upgrades/celo-defi-ubi-deploy.ts

@@ -0,0 +1,165 @@
+/**
+ * Step 1:
+ * - upgrade Identity on Fuse to support whitelisting with chainid
+ *
+ * Step 2:
+ * - upgrade AdminWallet+Invites+Faucet on Fuse to support whitelisting chainid
+ * - upgrade backend server to support whitelisting with chainid
+ *
+ * Step 3:
+ * 0. deploy 3_gdStaking, deploy 4_ubi
+ * 1. guardians vote send X% to celo ubi pool
+ * 2. guardians vote on celo set new GOOD distribution for gdstaking + claiming ubi
+ * 3. guardians vote on fuse set new GOOD distribution for gdstaking + claiming ubi
+ *
+ * NOTICE: decide if to remove "upgrade" method from gdStaking before deploying it. based on GOOD distribution decision
+ */
+
+import { network, ethers, upgrades } from "hardhat";
+import { defaultsDeep } from "lodash";
+import prompt from "prompt";
+
+import {
+  executeViaGuardian,
+  executeViaSafe,
+  verifyProductionSigner,
+  verifyContract
+} from "../multichain-deploy/helpers";
+import ProtocolSettings from "../../releases/deploy-settings.json";
+import dao from "../../releases/deployment.json";
+import { upgrade as identityUpgrade } from "./identity-upgrade";
+import { SignerWithAddress } from "@nomiclabs/hardhat-ethers/signers";
+
+const { name: networkName } = network;
+const isProduction = networkName.includes("production");
+
+let settings = defaultsDeep({}, ProtocolSettings[networkName], ProtocolSettings["default"]);
+
+const step1 = async () => {
+  await identityUpgrade();
+};
+
+const step2 = async () => {
+  let release: { [key: string]: any } = dao[networkName];
+  let [root] = await ethers.getSigners();
+
+  if (isProduction) verifyProductionSigner(root);
+
+  const adminimpl = await (await ethers.getContractFactory("AdminWalletFuse")).deploy();
+  const curadmin = adminimpl.attach(release.AdminWallet);
+  const upgradetx = await (await curadmin.upgradeTo(adminimpl.address)).wait();
+  const impl = adminimpl.address;
+  console.log("AdminWallet upgraded", { impl, txhash: upgradetx.transactionHash });
+  await verifyContract(impl, "AdminWalletFuse", networkName);
+
+  const faucetimpl = await (await ethers.getContractFactory("FuseFaucetV2")).deploy();
+  const proxyAdmin = await ethers.getContractAt("ProxyAdmin", release.ProxyAdmin);
+  const encoded = faucetimpl.interface.encodeFunctionData("upgrade", [release.AdminWallet, root.address]);
+  const faucettx = await (await proxyAdmin.upgradeAndCall(release.FuseFaucet, faucetimpl.address, encoded)).wait();
+  console.log("Faucet upgraded", faucettx.transactionHash);
+  await verifyContract(faucetimpl.address, "FuseFaucetV2", networkName);
+
+  const invitesimpl = await (await ethers.getContractFactory("InvitesFuseV2")).deploy();
+  const invitestx = await (await proxyAdmin.upgrade(release.Invites, invitesimpl.address)).wait();
+  console.log("Invites upgraded", invitestx.transactionHash);
+  await verifyContract(invitesimpl.address, "InvitesFuseV2", networkName);
+
+  console.log("upgrade backend contracts abi + call whitelist with chainid....");
+};
+
+const step3 = async () => {
+  //   let [root, ...signers] = await ethers.getSigners();
+
+  const isSafeSimulation = process.env.SAFE_SIMULATION === "true";
+  const celoSigner = ethers.Wallet.fromMnemonic(process.env.MNEMONIC)
+    .connect(ethers.provider)
+    .connect(new ethers.providers.JsonRpcProvider("https://forno.celo.org"));
+  const fuseSigner = ethers.Wallet.fromMnemonic(process.env.MNEMONIC)
+    .connect(ethers.provider)
+    .connect(new ethers.providers.JsonRpcProvider("https://rpc.fuse.io"));
+  let networkEnv = networkName.split("-")[0];
+  if (networkEnv === "fuse") networkEnv = "development";
+
+  const celoNetwork = networkEnv + "-celo";
+  const mainnetNetwork = "production-mainnet"; //simulate production on localhost requires running hardhat node in fork mode
+
+  console.log("updating dao on networks:", { isSafeSimulation, celoNetwork, mainnetNetwork, networkName });
+  let release: { [key: string]: any } = dao[networkName];
+
+  const mainnetDeploy: [any, any, any, any] = [
+    [dao[mainnetNetwork].DistributionHelper],
+    [0],
+    ["addOrUpdateRecipient((uint32,uint32,address,uint8))"],
+    [
+      ethers.utils.defaultAbiCoder.encode(
+        ["uint32", "uint32", "address", "uint8"],
+        [1000, 42220, dao[celoNetwork].UBIScheme, 1]
+      )
+    ]
+  ];
+  const fuseDeploy: [any, any, any, any] = [
+    [release.ClaimersDistribution, release.GovernanceStakingV2 || release.GovernanceStaking],
+    [0, 0],
+    ["setMonthlyReputationDistribution(uint256)", "setMonthlyRewards(uint256)"],
+    [
+      ethers.utils.defaultAbiCoder.encode(["uint256"], [settings.governance.claimersGOODMonthly]),
+      ethers.utils.defaultAbiCoder.encode(["uint256"], [settings.governance.stakersGOODMonthly])
+    ]
+  ];
+  const celoDeploy: [any, any, any, any] = [
+    [dao[celoNetwork].ClaimersDistribution, dao[celoNetwork].GoodDollarStaking],
+    [0, 0],
+    ["setMonthlyReputationDistribution(uint256)", "setMonthlyGOODRewards(uint256)"],
+    [
+      ethers.utils.defaultAbiCoder.encode(["uint256"], [ProtocolSettings[celoNetwork].governance.claimersGOODMonthly]),
+      ethers.utils.defaultAbiCoder.encode(["uint256"], [ProtocolSettings[celoNetwork].governance.stakersGOODMonthly])
+    ]
+  ];
+  if (isProduction || isSafeSimulation) {
+    console.log("executing dao updates on mainnet via guardianssafe...", { isProduction, isSafeSimulation });
+    await executeViaSafe(
+      ...mainnetDeploy,
+      isSafeSimulation ? "0xF0652a820dd39EC956659E0018Da022132f2f40a" : dao[mainnetNetwork].GuardiansSafe,
+      "mainnet",
+      isSafeSimulation
+    );
+    console.log("executing dao updates on fuse via guardianssafe...", dao[networkName].GuardiansSafe);
+    await executeViaSafe(...fuseDeploy, dao[networkName].GuardiansSafe, "fuse", isSafeSimulation);
+    console.log("executing dao updates on celo via guardianssafe...", dao[celoNetwork].GuardiansSafe);
+    await executeViaSafe(...celoDeploy, dao[celoNetwork].GuardiansSafe, "celo", isSafeSimulation);
+  } else {
+    const forkProvider = new ethers.providers.JsonRpcProvider("http://localhost:8545");
+    const ethSigner = await SignerWithAddress.create(
+      forkProvider.getSigner("0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266")
+    );
+    await forkProvider.send("hardhat_impersonateAccount", [dao[mainnetNetwork].GuardiansSafe]);
+    const guardiansSigner = await SignerWithAddress.create(forkProvider.getSigner(dao[mainnetNetwork].GuardiansSafe));
+    await ethSigner.sendTransaction({ value: ethers.constants.WeiPerEther, to: guardiansSigner.address });
+
+    console.log("executing dao updates on mainnet...");
+    await executeViaGuardian(...mainnetDeploy, guardiansSigner, "production-mainnet"); //simulate production on localhost requires running hardhat node in fork mode
+    console.log("executing dao updates on fuse...");
+    await executeViaGuardian(...fuseDeploy, fuseSigner, networkName);
+    console.log("executing dao updates on celo...");
+    await executeViaGuardian(...celoDeploy, celoSigner, celoNetwork);
+  }
+};
+
+const main = async () => {
+  prompt.start();
+  const { stepNumber } = await prompt.get(["stepNumber"]);
+
+  console.log("running step:", { stepNumber });
+  switch (stepNumber) {
+    case "1":
+      await step1();
+      break;
+    case "2":
+      await step2();
+      break;
+    case "3":
+      await step3();
+      break;
+  }
+};
+main().catch(e => console.error(e));

package/scripts/upgrades/identity-upgrade.ts

@@ -0,0 +1,109 @@
+/***
+ * Upgrade Fuse to support whitelisting with orgchain
+ * Upgrade Plan:
+ * - deploy Identity
+ * - give adminWallet admin permissions
+ * - revoke deployer permissions
+ * - replace pointers to old identity contract in:
+ *    - GoodDollar token
+ *    - NameService
+ */
+
+import { network, ethers } from "hardhat";
+import { Contract, Signer } from "ethers";
+import { defaultsDeep } from "lodash";
+import { getImplementationAddress } from "@openzeppelin/upgrades-core";
+
+import {
+  deployDeterministic,
+  printDeploy,
+  executeViaGuardian,
+  executeViaSafe,
+  verifyProductionSigner
+} from "../multichain-deploy/helpers";
+
+import releaser from "../../scripts/releaser";
+import ProtocolSettings from "../../releases/deploy-settings.json";
+
+import dao from "../../releases/deployment.json";
+import { verifyContract } from "../multichain-deploy/helpers";
+const { name: networkName } = network;
+
+export const upgrade = async () => {
+  let release: { [key: string]: any } = dao[networkName];
+  const isProduction = networkName.includes("production");
+  let [root, ...signers] = await ethers.getSigners();
+
+  if (isProduction) verifyProductionSigner(root);
+
+  let protocolSettings = defaultsDeep({}, ProtocolSettings[network.name], ProtocolSettings["default"]);
+
+  console.log("got signers:", {
+    networkName,
+    root: root.address,
+    balance: await ethers.provider.getBalance(root.address).then(_ => _.toString())
+  });
+
+  // let Identity = await ethers.getContractAt("IdentityV2", release.Identity);
+  // Identity = await ethers.getContractAt("IdentityV2", "0xb0cD4828Cc90C5BC28f4920Adf2Fd8F025003D7E");
+  console.log("deploying new identity...");
+  let Identity = (await deployDeterministic(
+    {
+      name: "IdentityV2",
+      salt: "IdentityV2",
+      isUpgradeable: true
+    },
+    [root.address, release.Identity]
+  ).then(printDeploy)) as Contract;
+
+  let torelease = {
+    Identity: Identity.address,
+    IdentityOld: release.Identity
+  };
+
+  await releaser(torelease, networkName, "deployment", false);
+
+  console.log("calling initDAO...");
+  const tx = await (await Identity.initDAO(release.NameService)).wait();
+  const impl = await getImplementationAddress(ethers.provider, Identity.address);
+  await verifyContract(impl, "IdentityV2", networkName);
+
+  const proposalContracts = [
+    release.GoodDollar, //controller -> set new identity in G$
+    release.NameService //nameservice modify to new Identity
+  ];
+
+  const proposalEthValues = proposalContracts.map(_ => 0);
+
+  const proposalFunctionSignatures = [
+    "setIdentity(address)", //set Identity on GoodDollar token
+    "setAddress(string,address)" //set new identity address in nameservice
+  ];
+
+  const proposalFunctionInputs = [
+    ethers.utils.defaultAbiCoder.encode(["address"], [Identity.address]),
+    ethers.utils.defaultAbiCoder.encode(["string", "address"], ["IDENTITY", Identity.address])
+  ];
+  if (isProduction) {
+    await executeViaSafe(
+      proposalContracts,
+      proposalEthValues,
+      proposalFunctionSignatures,
+      proposalFunctionSignatures,
+      protocolSettings.guardiansSafe
+    );
+  } else {
+    await executeViaGuardian(
+      proposalContracts,
+      proposalEthValues,
+      proposalFunctionSignatures,
+      proposalFunctionInputs,
+      root
+    );
+  }
+};
+
+export const main = async () => {
+  await upgrade().catch(console.log);
+};
+if (process.argv[1].includes("identity-upgrade")) main();

package/scripts/upgrades/transferDaoToGuardians.ts

@@ -0,0 +1,80 @@
+/***
+ * give genericcall to gaurdian safe, unregister deployer as scheme
+ */
+import { network, ethers, upgrades, run } from "hardhat";
+import { defaultsDeep } from "lodash";
+
+import {
+  deployDeterministic,
+  deploySuperGoodDollar,
+  executeViaGuardian,
+  printDeploy,
+  verifyProductionSigner
+} from "../multichain-deploy/helpers";
+import releaser from "../releaser";
+import ProtocolSettings from "../../releases/deploy-settings.json";
+import dao from "../../releases/deployment.json";
+import { Controller } from "../../types";
+
+const main = async () => {
+  let protocolSettings = defaultsDeep(
+    {},
+    ProtocolSettings[network.name],
+    ProtocolSettings["default"]
+  );
+
+  let release: { [key: string]: any } = dao[network.name];
+  const isProduction = network.name.includes("production");
+
+  let [root] = await ethers.getSigners();
+  const daoOwner = root.address;
+  if (isProduction) verifyProductionSigner(root);
+
+  console.log("got signers:", {
+    network,
+    daoOwner,
+    root: root.address,
+    balance: await ethers.provider
+      .getBalance(root.address)
+      .then(_ => _.toString()),
+    release
+  });
+
+  if (isProduction) {
+    const ctrl = (await ethers.getContractAt(
+      "Controller",
+      release.Controller
+    )) as Controller;
+    await ctrl
+      .registerScheme(
+        protocolSettings.guardiansSafe,
+        ethers.constants.HashZero,
+        "0x0000001f",
+        release.Avatar
+      )
+      .then(printDeploy);
+    await ctrl.unregisterSelf(release.Avatar).then(printDeploy);
+  } else {
+    console.log("simulating transfer...");
+    const ctrl = (await ethers.getContractAt(
+      "Controller",
+      release.Controller
+    )) as Controller;
+    console.log(
+      "register safe result:",
+      await ctrl.callStatic.registerScheme(
+        protocolSettings.guardiansSafe,
+        ethers.constants.HashZero,
+        "0x0000001f",
+        release.Avatar
+      )
+    );
+
+    console.log(
+      "unregister result",
+      await ctrl.callStatic.unregisterSelf(release.Avatar)
+    );
+  }
+};
+
+main();