@gooddollar/goodprotocol 2.0.34-beta.1 → 2.0.34-beta.3

package/scripts/multichain-deploy/1_basicdao-deploy.ts

@@ -24,6 +24,7 @@ import ProtocolSettings from "../../releases/deploy-settings.json";
 import dao from "../../releases/deployment.json";
 import { TransactionResponse } from "@ethersproject/providers";
 import { getImplementationAddress } from "@openzeppelin/upgrades-core";
+import { IdentityV3 } from "../../types";
 const printDeploy = async (c: Contract | TransactionResponse): Promise<Contract | TransactionResponse> => {
   if (c instanceof Contract) {
     await c.deployed();
@@ -60,8 +61,8 @@ export const createDAO = async () => {
   const FeeFormulaFactory = new ethers.ContractFactory(FeeFormulaABI.abi, FeeFormulaABI.bytecode, root);
 
   console.log("deploying identity");
-  let Identity;
-  if (release.Identity) Identity = await ethers.getContractAt("IdentityV3", release.Identity);
+  let Identity: IdentityV3;
+  if (release.Identity) Identity = (await ethers.getContractAt("IdentityV3", release.Identity)) as IdentityV3;
   else
     Identity = (await deployDeterministic(
       {
@@ -70,7 +71,7 @@ export const createDAO = async () => {
         isUpgradeable: true
       },
       [root.address, ethers.constants.AddressZero]
-    ).then(printDeploy)) as Contract;
+    ).then(printDeploy)) as IdentityV3;
 
   let daoCreator;
   if (release.DAOCreator) daoCreator = await DAOCreatorFactory.attach(release.DAOCreator);
@@ -131,10 +132,7 @@ export const createDAO = async () => {
     ).then(printDeploy)) as Contract;
   }
 
-  // console.log("setting identity auth period");
-  // await Identity.setAuthenticationPeriod(365).then(printDeploy);
-
-  const avatar = await daoCreator.avatar();
+  const avatar = release.Avatar || (await daoCreator.avatar());
   let Avatar = new ethers.Contract(
     avatar,
     ["function owner() view returns (address)", "function nativeToken() view returns (address)"],
@@ -151,7 +149,7 @@ export const createDAO = async () => {
       ["function owner() view returns (address)", "function nativeToken() view returns (address)"],
       root
     );
-    let schemes = [daoOwner, Identity.address];
+    let schemes = [daoOwner, release.GuardiansSafe];
 
     console.log("setting schemes", schemes);
 
@@ -160,7 +158,7 @@ export const createDAO = async () => {
         Avatar.address,
         schemes,
         schemes.map(_ => ethers.constants.HashZero),
-        ["0x0000001f", "0x00000001"],
+        ["0x0000001f", "0x0000001f"],
         ""
       )
       .then(printDeploy);
@@ -172,6 +170,7 @@ export const createDAO = async () => {
 
   const controller = await Avatar.owner();
 
+  console.log("deploying nameservice");
   const NameService = await deployDeterministic({ name: "NameService", isUpgradeable: true }, [
     controller,
     ["CONTROLLER", "AVATAR", "IDENTITY", "GOODDOLLAR"].map(_ => ethers.utils.keccak256(ethers.utils.toUtf8Bytes(_))),
@@ -189,6 +188,16 @@ export const createDAO = async () => {
   if (isProduction) {
     console.log("renouncing minting rights on production env");
     await GoodDollar.renounceMinter().then(printDeploy);
+    const ctrl = await ethers.getContractAt("Controller", await Avatar.owner());
+    console.log("setting identity authentication period to 180 days");
+    await ctrl
+      .genericCall(
+        Identity.address,
+        Identity.interface.encodeFunctionData("setAuthenticationPeriod", [180]),
+        Avatar.address,
+        0
+      )
+      .then(printDeploy);
   }
 
   const daoOwnerDaoPermissions = await Controller.getSchemePermissions(daoOwner, Avatar.address);

package/scripts/multichain-deploy/4_ubi-deploy.ts

@@ -60,7 +60,7 @@ export const deployHelpers = async () => {
       factory: await ethers.getContractFactory("UBISchemeV2"),
       isUpgradeable: true
     },
-    [release.NameService]
+    [release.NameService, protocolSettings.ubi.minActiveUsers]
   ).then(printDeploy)) as Contract;
 
   const torelease = {

package/scripts/multichain-deploy/8_disthelper-deploy.ts

@@ -0,0 +1,152 @@
+/***
+ * 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,
+  executeViaGuardian,
+  executeViaSafe,
+  verifyContract,
+  verifyProductionSigner
+} from "./helpers";
+import releaser from "../releaser";
+import ProtocolSettings from "../../releases/deploy-settings.json";
+import dao from "../../releases/deployment.json";
+import { TransactionResponse } from "@ethersproject/providers";
+import { keccak256, toUtf8Bytes } from "ethers/lib/utils";
+
+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 () => {
+  const viaGuardians = false;
+
+  let protocolSettings = defaultsDeep({}, ProtocolSettings[network.name], ProtocolSettings["default"]);
+  let release: { [key: string]: any } = dao[network.name];
+
+  let [root, ...signers] = await ethers.getSigners();
+  const isProduction = network.name.includes("production");
+  let networkEnv = network.name.split("-")[0];
+  const celoNetwork = networkEnv + "-celo";
+
+  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())
+  });
+
+  console.log("deploying dist helper");
+  const DistHelper = (await deployDeterministic(
+    {
+      name: "DistributionHelper",
+      factory: await ethers.getContractFactory("GenericDistributionHelper"),
+      isUpgradeable: true
+    },
+    [
+      release.NameService,
+      release.StaticOracle,
+      protocolSettings.reserve.gasToken,
+      protocolSettings.reserve.reserveToken,
+      release.UniswapV3Router,
+      [ethers.utils.parseEther("100"), ethers.utils.parseEther("100"), 5, 5]
+    ]
+  ).then(printDeploy)) as Contract;
+
+  const torelease = {
+    DistributionHelper: DistHelper.address
+  };
+  release = {
+    ...release,
+    ...torelease
+  };
+  await releaser(torelease, network.name, "deployment", false);
+
+  console.log("setting nameservice addresses via guardian");
+  const proposalActions = [
+    [
+      release.NameService, //nameservice
+      "setAddresses(bytes32[],address[])", //add ubischeme
+      ethers.utils.defaultAbiCoder.encode(
+        ["bytes32[]", "address[]"],
+        [[keccak256(toUtf8Bytes("DISTRIBUTION_HELPER"))], [DistHelper.address]]
+      ),
+      0
+    ],
+    [
+      DistHelper.address,
+      "addOrUpdateRecipient((uint32,uint32,address,uint8))",
+      ethers.utils.defaultAbiCoder.encode(
+        ["uint32", "uint32", "address", "uint8"],
+        [dao[celoNetwork].CommunitySafe ? 9000 : 10000, network.config.chainId, release.UBIScheme, 1] //90% to ubi scheme
+      ),
+      0
+    ]
+  ];
+
+  if (dao[celoNetwork].CommunitySafe) {
+    proposalActions.push([
+      DistHelper.address,
+      "addOrUpdateRecipient((uint32,uint32,address,uint8))",
+      ethers.utils.defaultAbiCoder.encode(
+        ["uint32", "uint32", "address", "uint8"],
+        [1000, 42220, dao[celoNetwork].CommunitySafe, network.name === celoNetwork ? 1 : 0] //10% to celo community safe, use LZ bridge if not on celo
+      ),
+      0
+    ]);
+  }
+  const [proposalContracts, proposalFunctionSignatures, proposalFunctionInputs, proposalEthValues] = [
+    proposalActions.map(_ => _[0]),
+    proposalActions.map(_ => _[1]),
+    proposalActions.map(_ => _[2]),
+    proposalActions.map(_ => _[3])
+  ];
+  try {
+    if (viaGuardians) {
+      await executeViaSafe(
+        proposalContracts,
+        proposalEthValues,
+        proposalFunctionSignatures,
+        proposalFunctionInputs,
+        protocolSettings.guardiansSafe
+      );
+    } else {
+      await executeViaGuardian(
+        proposalContracts,
+        proposalEthValues,
+        proposalFunctionSignatures,
+        proposalFunctionInputs,
+        root
+      );
+    }
+  } catch (e) {
+    console.error("proposal execution failed...", e.message);
+  }
+
+  let impl = await getImplementationAddress(ethers.provider, DistHelper.address);
+  await verifyContract(impl, "contracts/reserve/GenericDistributionHelper.sol:GenericDistributionHelper", network.name);
+};
+
+export const main = async (networkName = name) => {
+  await deployHelpers();
+};
+main();

package/scripts/multichain-deploy/createUniswapTestPools.ts

@@ -0,0 +1,163 @@
+import { network, ethers, upgrades, run } from "hardhat";
+import ProtocolSettings from "../../releases/deploy-settings.json";
+import dao from "../../releases/deployment.json";
+import { defaultsDeep } from "lodash";
+
+import { IUniswapV3Factory, IUniswapV3Pool, INonfungiblePositionManager, IERC20 } from "../../types";
+const V3Factory = "0x30f317a9ec0f0d06d5de0f8d248ec3506b7e4a8a";
+const NFPM = "0x6d22833398772d7da9a7cbcfdee98342cce154d4";
+const STABLE_DECIMALS = 6; //USDC
+const GASPRICE_STABLE = 0.08;
+const POOL_FEE = 100; // 0.01%
+const main = async () => {
+  let protocolSettings = defaultsDeep({}, ProtocolSettings[network.name], ProtocolSettings["default"]);
+  let release: { [key: string]: any } = dao[network.name];
+  let [root] = await ethers.getSigners();
+  console.log("got signers:", {
+    root: root.address,
+    balance: await ethers.provider.getBalance(root.address).then(_ => _.toString())
+  });
+
+  const v3Factory = (await ethers.getContractAt("IUniswapV3Factory", V3Factory)) as IUniswapV3Factory;
+  const nfpm = (await ethers.getContractAt("INonfungiblePositionManager", NFPM)) as INonfungiblePositionManager;
+
+  // create G$<>Stable pool
+  console.log("creating G$<>Stable pool", {
+    gd: release.GoodDollar,
+    stable: protocolSettings.reserve.reserveToken,
+    fee: POOL_FEE
+  });
+  const poolExists = await v3Factory.getPool(protocolSettings.reserve.reserveToken, release.GoodDollar, POOL_FEE);
+  if (poolExists !== ethers.constants.AddressZero) {
+    console.log("pool already exists at:", poolExists);
+  } else {
+    await (
+      await v3Factory.createPool(protocolSettings.reserve.reserveToken, release.GoodDollar, POOL_FEE, {
+        gasLimit: 5000000
+      })
+    ).wait();
+  }
+  const gdstablePool = (await ethers.getContractAt(
+    "IUniswapV3Pool",
+    await v3Factory.getPool(release.GoodDollar, protocolSettings.reserve.reserveToken, POOL_FEE)
+  )) as IUniswapV3Pool;
+
+  //get pool price
+  const { sqrtPriceX96 } = await gdstablePool.slot0();
+
+  const existingPrice = (Number(sqrtPriceX96.toString()) / 2 ** 96) ** 2;
+  console.log("created pool at:", gdstablePool.address, { existingPrice });
+  let price = BigInt(Math.sqrt(10000 * (10 ** (18 - STABLE_DECIMALS))) * 2 ** 96); //1 G$ = 0.0001 Stable
+  let amount1 = ethers.utils.parseUnits("50000", 18);
+  let amount0 = ethers.utils.parseUnits("5", STABLE_DECIMALS);
+
+  if ((await gdstablePool.token0()).toLowerCase() === release.GoodDollar.toLowerCase()) {
+    price = BigInt(Math.sqrt(0.0001 * (10 ** (STABLE_DECIMALS - 18))) * 2 ** 96);
+    amount0 = ethers.utils.parseUnits("50000", 18);
+    amount1 = ethers.utils.parseUnits("5", STABLE_DECIMALS);
+  }
+
+  if (existingPrice > 0) {
+    console.log("pool already initialized");
+    price = BigInt(Math.sqrt(existingPrice) * 2 ** 96); //1 G$ = 0.0001 Stable
+  } else {
+    await (await gdstablePool.initialize(price)).wait();
+    console.log("initialized pool with price:", price.toString(), { amount0, amount1 });
+  }
+
+  // print allowance for nfpm
+  const stable = (await ethers.getContractAt("IERC20", protocolSettings.reserve.reserveToken)) as IERC20;
+  const gd = (await ethers.getContractAt("IERC20", release.GoodDollar)) as IERC20;
+  let stableAllowance = await stable.allowance(root.address, NFPM);
+  const gdAllowance = await gd.allowance(root.address, NFPM);
+  console.log("stable allowance for NFPM:", ethers.utils.formatUnits(stableAllowance, STABLE_DECIMALS));
+  console.log("G$ allowance for NFPM:", ethers.utils.formatUnits(gdAllowance, 18));
+
+  await (
+    await nfpm.mint({
+      token0: await gdstablePool.token0(),
+      token1: await gdstablePool.token1(),
+      fee: POOL_FEE,
+      tickLower: -887220,
+      tickUpper: 887220,
+      amount0Desired: amount0,
+      amount1Desired: amount1,
+      amount0Min: amount0.mul(8).div(10),
+      amount1Min: amount1.mul(8).div(10),
+      recipient: root.address,
+      deadline: Math.floor(Date.now() / 1000) + 60 * 10
+    })
+  ).wait();
+
+  console.log("creating gastoken<>Stable pool", {
+    gasToken: protocolSettings.reserve.gasToken,
+    stable: protocolSettings.reserve.reserveToken,
+    fee: POOL_FEE
+  });
+  const gaspoolExists = await v3Factory.getPool(
+    protocolSettings.reserve.gasToken,
+    protocolSettings.reserve.reserveToken,
+    POOL_FEE
+  );
+  if (gaspoolExists !== ethers.constants.AddressZero) {
+    console.log("pool already exists at:", gaspoolExists);
+  } else {
+    await (
+      await v3Factory.createPool(protocolSettings.reserve.gasToken, protocolSettings.reserve.reserveToken, POOL_FEE, {
+        gasLimit: 5000000
+      })
+    ).wait();
+  }
+  const gasstablePool = (await ethers.getContractAt(
+    "IUniswapV3Pool",
+    await v3Factory.getPool(protocolSettings.reserve.gasToken, protocolSettings.reserve.reserveToken, POOL_FEE)
+  )) as IUniswapV3Pool;
+
+  //get pool price
+  const { sqrtPriceX96: gasSqrtPriceX96 } = await gasstablePool.slot0();
+
+  const gasexistingPrice = (Number(gasSqrtPriceX96.toString()) / 2 ** 96) ** 2;
+  console.log("created pool at:", gasstablePool.address, { gasexistingPrice });
+  price = BigInt(Math.sqrt(GASPRICE_STABLE * (10 ** (18 - STABLE_DECIMALS))) * 2 ** 96); //1 G$ = 0.0001 Stable
+  amount1 = ethers.utils.parseUnits((5 / GASPRICE_STABLE).toString(), 18);
+  amount0 = ethers.utils.parseUnits("5", STABLE_DECIMALS);
+
+  if ((await gasstablePool.token0()).toLowerCase() === protocolSettings.reserve.gasToken.toLowerCase()) {
+    price = BigInt(Math.sqrt(1 / GASPRICE_STABLE / (10 ** (18 - STABLE_DECIMALS))) * 2 ** 96);
+    let temp = amount0;
+    amount0 = amount1;
+    amount1 = temp;
+  }
+
+  if (gasexistingPrice > 0) {
+    console.log("pool already initialized");
+    price = BigInt(Math.sqrt(gasexistingPrice) * 2 ** 96); //1 G$ = 0.0001 Stable
+  } else {
+    await (await gasstablePool.initialize(price)).wait();
+    console.log("initialized pool with price:", price.toString(), { amount0, amount1 });
+  }
+
+  // print allowance for nfpm
+  const gasToken = (await ethers.getContractAt("IERC20", protocolSettings.reserve.gasToken)) as IERC20;
+  stableAllowance = await stable.allowance(root.address, NFPM);
+  const gasAllowance = await gasToken.allowance(root.address, NFPM);
+  console.log("stable allowance for NFPM:", ethers.utils.formatUnits(stableAllowance, STABLE_DECIMALS));
+  console.log("weth allowance for NFPM:", ethers.utils.formatUnits(gasAllowance, 18));
+
+  await (
+    await nfpm.mint({
+      token0: await gasstablePool.token0(),
+      token1: await gasstablePool.token1(),
+      fee: POOL_FEE,
+      tickLower: -887220,
+      tickUpper: 887220,
+      amount0Desired: amount0,
+      amount1Desired: amount1,
+      amount0Min: amount0.mul(8).div(10),
+      amount1Min: amount1.mul(8).div(10),
+      recipient: root.address,
+      deadline: Math.floor(Date.now() / 1000) + 60 * 10
+    })
+  ).wait();
+};
+main();

package/scripts/multichain-deploy/helpers.ts

@@ -67,6 +67,7 @@ export const deploySuperGoodDollar = async (
     [superfluidHost]
   ).then(printDeploy)) as Contract;
 
+  console.log("supergoodollar logic deployed:", SuperGoodDollar.address);
   const uupsFactory = await ethers.getContractFactory("UUPSProxy");
   const GoodDollarProxy = (await deployDeterministic(
     {
@@ -75,9 +76,13 @@ export const deploySuperGoodDollar = async (
     },
     []
   ).then(printDeploy)) as Contract;
-
-  await GoodDollarProxy.initializeProxy(SuperGoodDollar.address).then(printDeploy);
-
+  console.log("supergoodollar proxy deployed:", GoodDollarProxy.address);
+  try {
+    await GoodDollarProxy.initializeProxy(SuperGoodDollar.address).then(printDeploy);
+  } catch (e) {
+    console.log("failed initialized supergd proxy. probably already was init");
+  }
+  console.log("supergoodollar proxy initialized:", GoodDollarProxy.address);
   let OutFlowNFT = await ethers.getContractAt("ConstantOutflowNFT", ethers.constants.AddressZero);
   let InFlowNFT = await ethers.getContractAt("ConstantOutflowNFT", ethers.constants.AddressZero);
 
@@ -103,9 +108,13 @@ export const deploySuperGoodDollar = async (
     await InFlowNFT.initializeProxy(superfluidInflowNFTLogic);
   }
   console.log("initializing supergooddollar");
-  await SuperGoodDollar.attach(GoodDollarProxy.address)[
-    "initialize(string,string,uint256,address,address,address,address)"
-  ](...tokenArgs);
+  try {
+    await SuperGoodDollar.attach(GoodDollarProxy.address)[
+      "initialize(string,string,uint256,address,address,address,address)"
+    ](...tokenArgs);
+  } catch (e) {
+    console.log("failed initializing supergd. probably already was init");
+  }
 
   const GoodDollar = await ethers.getContractAt("ISuperGoodDollar", GoodDollarProxy.address);
 
@@ -224,6 +233,67 @@ export const deployDeterministic = async (contract, args: any[], factoryOpts = {
   }
 };
 
+export const upgradeDeterministicToNewImplViaGuardian = async (contract, factoryOpts = {}) => {
+  try {
+    let proxyFactory: ProxyFactory1967;
+    proxyFactory = (await ethers.getContractAt("ProxyFactory1967", release.ProxyFactory)) as ProxyFactory1967;
+    const Contract =
+      (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))
+    );
+
+    if (contract.isUpgradeable === true) {
+      const proxyAddr = await proxyFactory["getDeploymentAddress(uint256,address)"](
+        salt,
+        await proxyFactory.signer.getAddress()
+      );
+      const code = await ethers.provider.getCode(proxyAddr);
+      if (code && code !== "0x") {
+        const implAddr = await getImplementationAddress(ethers.provider, proxyAddr).catch(e => "0x");
+        if (implAddr && implAddr !== "0x") {
+          console.log("proxy exists and impl set already:", contract.name, proxyAddr, implAddr);
+          console.log("Deploying:", contract.name, " implementation", {
+            proxyAddr
+          });
+
+          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 proposalContracts = [release.DistributionHelper];
+
+          const proposalEthValues = proposalContracts.map(_ => 0);
+
+          const proposalFunctionSignatures = [
+            "upgradeTo(address)" //add ubischeme
+          ];
+
+          const proposalFunctionInputs = [ethers.utils.defaultAbiCoder.encode(["address"], [impl.address])];
+          let [root] = await ethers.getSigners();
+          await executeViaGuardian(
+            proposalContracts,
+            proposalEthValues,
+            proposalFunctionSignatures,
+            proposalFunctionInputs,
+            root
+          );
+
+          console.log("proxy upgraded:", contract.name, { proxyAddr, implAddr: impl.address });
+          return Contract.attach(proxyAddr);
+        }
+      }
+    } else {
+      console.log("This contract is not upgradeable");
+    }
+  } catch (e) {
+    console.log("Failed deploying contract:", { contract });
+    throw e;
+  }
+};
+
 export const executeViaGuardian = async (
   contracts,
   ethValues,