@gooddollar/goodprotocol 2.0.34-beta.2 → 2.0.34-beta.4

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/fulldeploy.sh

@@ -1,26 +1,26 @@
 #run with source .env && ./scripts/multichain-deploy/fulldeploy.sh
 NETWORK=$1
 npx hardhat run ./scripts/multichain-deploy/0_proxyFactory-deploy.ts --network $NETWORK
-if [ $? != 0 ]; then
-    exit 1;
-fi
+# if [ $? != 0 ]; then
+#     exit 1;
+# fi
 npx hardhat run ./scripts/multichain-deploy/1_basicdao-deploy.ts --network $NETWORK
-if [ $? != 0 ]; then
-    exit 1;
-fi
+# if [ $? != 0 ]; then
+#     exit 1;
+# fi
 npx hardhat run ./scripts/multichain-deploy/2_helpers-deploy.ts --network $NETWORK
-if [ $? != 0 ]; then
-    exit 1;
-fi
-npx hardhat run ./scripts/multichain-deploy/3_gdSavings-deploy.ts --network $NETWORK
-if [ $? != 0 ]; then
-    exit 1;
-fi
+# # if [ $? != 0 ]; then
+# #     exit 1;
+# # fi
+# npx hardhat run ./scripts/multichain-deploy/3_gdSavings-deploy.ts --network $NETWORK
+# if [ $? != 0 ]; then
+#     exit 1;
+# fi
 npx hardhat run ./scripts/multichain-deploy/4_ubi-deploy.ts --network $NETWORK
 if [ $? != 0 ]; then
     exit 1;
 fi
-npx hardhat run ./scripts/multichain-deploy/5_gov-deploy.ts --network $NETWORK
-if [ $? != 0 ]; then
-    exit 1;
-fi
+# npx hardhat run ./scripts/multichain-deploy/5_gov-deploy.ts --network $NETWORK
+# if [ $? != 0 ]; then
+#     exit 1;
+# fi

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,

package/scripts/multichain-deploy/verify.ts

@@ -0,0 +1,41 @@
+import { network, ethers, upgrades, run } from "hardhat";
+
+import {
+  deployDeterministic,
+  deploySuperGoodDollar,
+  verifyProductionSigner,
+  verifyContract,
+  verifyOnEtherscan
+} from "./helpers";
+import releaser from "../releaser";
+import ProtocolSettings from "../../releases/deploy-settings.json";
+import dao from "../../releases/deployment.json";
+import { getImplementationAddress } from "@openzeppelin/upgrades-core";
+
+const main = async () => {
+  const release = dao[network.name] || {};
+  console.log("verifying network:", network.name, release);
+  const protocolSettings = ProtocolSettings[network.name] || ProtocolSettings["default"];
+  // await verifyContract(release.ProxyFactory, "contracts/utils/ProxyFactory1967.sol:ProxyFactory1967");
+  // await verifyContract(release.Identity, "contracts/utils/ProxyFactory1967.sol:ERC1967Proxy", false);
+  // await verifyContract(release.Identity, "contracts/identity/IdentityV3.sol:IdentityV3", network.name);
+  // await verifyContract(release.NameService, "contracts/utils/NameService.sol:NameService", network.name);
+  // if (protocolSettings.superfluidHost) {
+  //   await verifyContract(release.GoodDollar, "contracts/token/superfluid/UUPSProxy.sol:UUPSProxy", network.name, false);
+  //   await verifyContract(
+  //     release.GoodDollar,
+  //     "contracts/token/superfluid/SuperGoodDollar.sol:SuperGoodDollar",
+  //     network.name,
+  //     true,
+  //     ethers.constants.AddressZero
+  //   );
+  // } else {
+  //   await verifyContract(release.GoodDollar, "contracts/token/GoodDollar.sol:GoodDollar", network.name);
+  // }
+
+  // await verifyContract(release.AdminWallet, "contracts/utils/AdminWallet.sol:AdminWallet", network.name);
+  // await verifyContract(release.Faucet, "contracts/fuseFaucet/Faucet.sol:Faucet", network.name);
+  // await verifyContract(release.Invites, "contracts/invite/InvitesV2.sol:InvitesV2", network.name);
+  await verifyContract(release.UBIScheme, "contracts/ubi/UBISchemeV2.sol:UBISchemeV2", network.name);
+};
+main();