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

package/contracts/utils/BuyGDClone.sol

@@ -0,0 +1,171 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8;
+import "@openzeppelin/contracts-upgradeable/proxy/ClonesUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+import "../Interfaces.sol";
+
+interface ISwapRouter {
+	struct ExactInputSingleParams {
+		address tokenIn;
+		address tokenOut;
+		uint24 fee;
+		address recipient;
+		uint256 amountIn;
+		uint256 amountOutMinimum;
+		uint160 sqrtPriceLimitX96;
+	}
+
+	/// @notice Swaps `amountIn` of one token for as much as possible of another token
+	/// @dev Setting `amountIn` to 0 will cause the contract to look up its own balance,
+	/// and swap the entire amount, enabling contracts to send tokens before calling this function.
+	/// @param params The parameters necessary for the swap, encoded as `ExactInputSingleParams` in calldata
+	/// @return amountOut The amount of the received token
+	function exactInputSingle(
+		ExactInputSingleParams calldata params
+	) external payable returns (uint256 amountOut);
+
+	struct ExactInputParams {
+		bytes path;
+		address recipient;
+		uint256 amountIn;
+		uint256 amountOutMinimum;
+	}
+
+	/// @notice Swaps `amountIn` of one token for as much as possible of another along the specified path
+	/// @dev Setting `amountIn` to 0 will cause the contract to look up its own balance,
+	/// and swap the entire amount, enabling contracts to send tokens before calling this function.
+	/// @param params The parameters necessary for the multi-hop swap, encoded as `ExactInputParams` in calldata
+	/// @return amountOut The amount of the received token
+	function exactInput(
+		ExactInputParams calldata params
+	) external payable returns (uint256 amountOut);
+
+	struct ExactOutputSingleParams {
+		address tokenIn;
+		address tokenOut;
+		uint24 fee;
+		address recipient;
+		uint256 amountOut;
+		uint256 amountInMaximum;
+		uint160 sqrtPriceLimitX96;
+	}
+
+	/// @notice Swaps as little as possible of one token for `amountOut` of another token
+	/// that may remain in the router after the swap.
+	/// @param params The parameters necessary for the swap, encoded as `ExactOutputSingleParams` in calldata
+	/// @return amountIn The amount of the input token
+	function exactOutputSingle(
+		ExactOutputSingleParams calldata params
+	) external payable returns (uint256 amountIn);
+
+	struct ExactOutputParams {
+		bytes path;
+		address recipient;
+		uint256 amountOut;
+		uint256 amountInMaximum;
+	}
+
+	/// @notice Swaps as little as possible of one token for `amountOut` of another along the specified path (reversed)
+	/// that may remain in the router after the swap.
+	/// @param params The parameters necessary for the multi-hop swap, encoded as `ExactOutputParams` in calldata
+	/// @return amountIn The amount of the input token
+	function exactOutput(
+		ExactOutputParams calldata params
+	) external payable returns (uint256 amountIn);
+}
+
+contract BuyGDClone is Initializable {
+	error NOT_ALLOWED(address);
+	error REFUND_FAILED(uint256);
+
+	ISwapRouter public immutable router;
+	address public constant celo = 0x471EcE3750Da237f93B8E339c536989b8978a438;
+	address public immutable cusd;
+	address public immutable gd;
+
+	address public owner;
+	address public executer;
+
+	receive() external payable {}
+
+	constructor(ISwapRouter _router, address _cusd, address _gd) {
+		router = _router;
+		cusd = _cusd;
+		gd = _gd;
+	}
+
+	function initialize(address _owner, address _executer) external initializer {
+		owner = _owner;
+		executer = _executer;
+	}
+
+	function swap(uint256 _minAmount) external {
+		uint256 gasCosts = msg.sender == owner ? 0 : (block.basefee + 1e9) * 400000;
+		if (msg.sender != owner && msg.sender != executer)
+			revert NOT_ALLOWED(msg.sender);
+		uint256 balance = address(this).balance;
+		ERC20(celo).approve(address(router), balance);
+		ISwapRouter.ExactInputParams memory params = ISwapRouter.ExactInputParams({
+			path: abi.encodePacked(celo, uint24(3000), cusd, uint24(10000), gd),
+			recipient: owner,
+			amountIn: balance - gasCosts,
+			amountOutMinimum: _minAmount
+		});
+		router.exactInput(params);
+		if (msg.sender != owner) {
+			(bool sent, ) = msg.sender.call{ value: gasCosts }("");
+			if (!sent) revert REFUND_FAILED(gasCosts);
+		}
+	}
+
+	function swapCusd(uint256 _minAmount) external {
+		uint256 gasCosts = msg.sender == executer ? 1e17 : 0;
+		if (msg.sender != owner && msg.sender != executer)
+			revert NOT_ALLOWED(msg.sender);
+		uint balance = ERC20(cusd).balanceOf(address(this));
+		ERC20(cusd).approve(address(router), balance);
+		ISwapRouter.ExactInputParams memory params = ISwapRouter.ExactInputParams({
+			path: abi.encodePacked(cusd, uint24(10000), gd),
+			recipient: owner,
+			amountIn: balance - gasCosts,
+			amountOutMinimum: _minAmount
+		});
+		router.exactInput(params);
+		if (msg.sender == executer) {
+			ERC20(cusd).transfer(msg.sender, gasCosts);
+		}
+	}
+
+	function recover(address token) external {
+		if (token == address(0)) {
+			(bool sent, ) = payable(owner).call{ value: address(this).balance }("");
+			if (!sent) revert REFUND_FAILED(address(this).balance);
+		} else ERC20(token).transfer(owner, ERC20(token).balanceOf(address(this)));
+	}
+}
+
+contract BuyGDCloneFactory {
+	address immutable impl;
+
+	constructor(ISwapRouter _router, address _cusd, address _gd) {
+		impl = address(new BuyGDClone(_router, _cusd, _gd));
+	}
+
+	function create(address owner, address executer) external returns (address) {
+		bytes32 salt = keccak256(abi.encode(owner, executer));
+		address clone = ClonesUpgradeable.cloneDeterministic(impl, salt);
+		BuyGDClone(payable(clone)).initialize(owner, executer);
+		return clone;
+	}
+
+	function predict(
+		address owner,
+		address executer
+	) external view returns (address) {
+		bytes32 salt = keccak256(abi.encode(owner, executer));
+
+		return
+			ClonesUpgradeable.predictDeterministicAddress(impl, salt, address(this));
+	}
+}

package/contracts/utils/GDFaucet.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity >=0.8.0;
+
+import "./DAOContract.sol";
+
+contract GDFaucet is DAOContract {
+	uint256 public dripAmount;
+	mapping(address => uint256) public lastDripTime;
+
+	constructor(INameService _dao, uint256 _dripAmount) {
+		setDAO(_dao);
+		dripAmount = _dripAmount;
+	}
+
+	function drip() external {
+		require(
+			block.timestamp - lastDripTime[msg.sender] >= 24 hours,
+			"drip limit"
+		);
+		lastDripTime[msg.sender] = block.timestamp;
+		uint decimals = nativeToken().decimals();
+		require(
+			dao.mintTokens(dripAmount * (10 ** decimals), msg.sender, dao.avatar()),
+			"mint failed"
+		);
+	}
+}

package/hardhat.config.ts

@@ -59,7 +59,8 @@ const hhconfig: HardhatUserConfig = {
   etherscan: {
     apiKey: {
       mainnet: etherscan_key,
-      celo: celoscan_key
+      celo: celoscan_key,
+      alfajores: celoscan_key
     },
     customChains: [
       {
@@ -69,6 +70,14 @@ const hhconfig: HardhatUserConfig = {
           apiURL: "https://api.celoscan.io/api",
           browserURL: "https://celoscan.io/"
         }
+      },
+      {
+        network: "alfajores",
+        chainId: 44787,
+        urls: {
+          apiURL: "https://api.alfajores.celoscan.io/api",
+          browserURL: "https://alfajores.celoscan.io/"
+        }
       }
     ]
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gooddollar/goodprotocol",
-  "version": "2.0.7-beta.1",
+  "version": "2.0.7-beta.3",
   "description": "GoodDollar Protocol",
   "engines": {
     "node": "18.x"

package/releases/deployment.json

@@ -479,7 +479,8 @@
         "Invites": "0x36829D1Cda92FFF5782d5d48991620664FC857d3",
         "UBIScheme": "0x43d72Ff17701B2DA814620735C39C620Ce0ea4A1",
         "OneTimePayments": "0xB27D247f5C2a61D2Cb6b6E67FEE51d839447e97d",
-        "SwapHelper": "0xE45CaB86609a16dFaDec112FDd61E4EA80EdaA8D"
+        "SwapHelper": "0xE45CaB86609a16dFaDec112FDd61E4EA80EdaA8D",
+        "UniswapV3Router": "0x5615CDAb10dc425a742d643d949a7F474C01abc4"
     },
     "gnosis": {
         "GuardiansSafe": "0x84c10b45fe51bfb4f86c19a47fdbc187d4572fb8"
@@ -506,7 +507,8 @@
         "CompoundVotingMachine": "0xC2C303131939370ed75c95686F691f290b56Be66",
         "GuardiansSafe": "0x84C10B45fE51bfB4f86c19A47Fdbc187d4572Fb8",
         "OneTimePayments": "0xB23e54fd8c2f35F9d38884Fc1611F5e9004f10ea",
-        "OneTimePaymentsV2": "0x2cb1c7d50371e277d7a36B171c0ACe9B157518EE"
+        "OneTimePaymentsV2": "0x2cb1c7d50371e277d7a36B171c0ACe9B157518EE",
+        "UniswapV3Router": "0x5615CDAb10dc425a742d643d949a7F474C01abc4"
     },
     "staging-celo": {
         "network": "staging-celo",
@@ -530,7 +532,8 @@
         "CompoundVotingMachine": "0xCd25fB84AB22582F1034bcd80c399a3126f2E775",
         "GuardiansSafe": "0x84C10B45fE51bfB4f86c19A47Fdbc187d4572Fb8",
         "OneTimePayments": "0x514820Af2DaE5F537dE16E576471528176318113",
-        "OneTimePaymentsV2": "0x963E7B4c970626Bb103c61fA16b002AFf6E6c2C7"
+        "OneTimePaymentsV2": "0x963E7B4c970626Bb103c61fA16b002AFf6E6c2C7",
+        "UniswapV3Router": "0x5615CDAb10dc425a742d643d949a7F474C01abc4"
     },
     "development-goerli": {
         "ProxyFactory": "0x65D8eACBCd9618b8780C4b444081915a5D54D611",
@@ -555,6 +558,8 @@
         "GReputation": "0x3647469733C01713A7d9bdf6834bd4aBd59D66fa",
         "DAOCreator": "0x35ea7176cfde2D35Dff3E688F7bA45D1d5dF0A76",
         "SuperFluidResolver": "0x6e9CaBE4172344Db81a1E1D735a6AD763700064A",
-        "SuperFluidHost": "0x14764E92A63e73a2Dac1fF08F35A64647fB50C91"
+        "SuperFluidHost": "0x14764E92A63e73a2Dac1fF08F35A64647fB50C91",
+        "UniswapV3Router": "0x5615CDAb10dc425a742d643d949a7F474C01abc4",
+        "GDFaucet": "0x8986F9C6b3D0b9A8b92ef7f1eF7EB9e767D414e1"
     }
 }

package/scripts/multichain-deploy/6_testnetFaucet.ts

@@ -0,0 +1,85 @@
+/***
+ * 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 protocolSettings = defaultsDeep({}, ProtocolSettings[network.name], ProtocolSettings["default"]);
+
+  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 GDFaucet = release.GDFaucet
+    ? await ethers.getContractAt("GDFaucet", release.GDFaucet)
+    : ((await deployDeterministic(
+        {
+          name: "GDFaucet",
+          salt: "GDFaucet",
+          isUpgradeable: false
+        },
+        [release.NameService, 10000]
+      ).then(printDeploy)) as Contract);
+
+  const torelease = {
+    GDFaucet: GDFaucet.address
+  };
+  await releaser(torelease, network.name, "deployment", false);
+
+  const controller = await ethers.getContractAt("Controller", release.Controller);
+
+  const tx = await controller
+    .registerScheme(GDFaucet.address, ethers.constants.HashZero, "0x00000001", release.Avatar)
+    .then(printDeploy);
+
+  console.log("TokenFaucet deployed and registered as a scheme via the controller");
+
+  await verifyContract(
+    GDFaucet.address,
+    "GDFaucet",
+    network.name,
+    undefined,
+    ethers.utils.defaultAbiCoder.encode(["address", "uint"], [release.NameService, 10000])
+  );
+};
+
+export const main = async () => {
+  await deployHelpers();
+};
+if (process.argv[1].includes("6_testnetFaucet")) main();

package/scripts/multichain-deploy/helpers.ts

@@ -332,7 +332,7 @@ export const verifyContract = async (
   proxyName?: string,
   forcedConstructorArguments?: string
 ) => {
-  let networkProvider = network.name.includes("-") ? network.name.split("-")[1] : "fuse";
+  let networkProvider = network.name.includes("-") ? network.name.split("-")[1] : network.name;
   networkProvider = networkProvider === "mainnet" ? "ethereum" : networkProvider;
   console.log("truffle compile...");
   await exec("npx truffle compile");

package/scripts/upgrades/multichain-temp-fix.ts

@@ -0,0 +1,126 @@
+/***
+ * Disable UBI bridge via multichain
+ * Upgrade Plan:
+ * - deploy new DistHelper
+ * - disable multichain distribution
+ * - create new distribution instead to guardians
+ */
+
+import { network, ethers } from "hardhat";
+import { Contract } from "ethers";
+import { defaultsDeep } from "lodash";
+
+import { printDeploy, executeViaGuardian, executeViaSafe, verifyProductionSigner } from "../multichain-deploy/helpers";
+
+import ProtocolSettings from "../../releases/deploy-settings.json";
+
+import dao from "../../releases/deployment.json";
+import { verifyContract } from "../multichain-deploy/helpers";
+let { name: networkName } = network;
+
+export const upgrade = async () => {
+  const isProduction = networkName.includes("production");
+  let [root, ...signers] = await ethers.getSigners();
+
+  if (isProduction) verifyProductionSigner(root);
+
+  let guardian = root;
+  // simulate on fork
+  if (network.name === "hardhat") {
+    networkName = "production-mainnet";
+    root = await ethers.getImpersonatedSigner("0x5128E3C1f8846724cc1007Af9b4189713922E4BB");
+  }
+
+  let release: { [key: string]: any } = dao[networkName];
+  let protocolSettings = defaultsDeep({}, ProtocolSettings[networkName], ProtocolSettings["default"]);
+  //make sure safe has enough eth to simulate txs
+  if (network.name === "hardhat") {
+    guardian = await ethers.getImpersonatedSigner(protocolSettings.guardiansSafe);
+    await root.sendTransaction({ value: ethers.constants.WeiPerEther, to: protocolSettings.guardiansSafe });
+  }
+
+  console.log("got signers:", {
+    networkName,
+    root: root.address,
+    guardian: guardian.address,
+    balance: await ethers.provider.getBalance(root.address).then(_ => _.toString()),
+    guardianBalance: await ethers.provider.getBalance(guardian.address).then(_ => _.toString())
+  });
+
+  let networkEnv = networkName.split("-")[0];
+  const fuseNetwork = networkEnv;
+  if (networkEnv === "fuse") networkEnv = "development";
+  const celoNetwork = networkEnv + "-celo";
+
+  let f = await ethers.getContractFactory("GoodFundManager");
+  console.log("bytecode", f.bytecode.length);
+  let newDistHelper = (await ethers.deployContract("DistributionHelper").then(printDeploy)) as Contract;
+
+  if (isProduction) await verifyContract(newDistHelper, "GoodReserveCDai", networkName);
+
+  const proposalContracts = [
+    release.DistributionHelper, //controller -> upgrade disthelper
+    release.DistributionHelper, //set new distribution params
+    release.DistributionHelper //set new distribution params
+  ];
+
+  const proposalEthValues = proposalContracts.map(_ => 0);
+
+  const proposalFunctionSignatures = [
+    "upgradeTo(address)", //upgrade disthelper
+    "addOrUpdateRecipient((uint32,uint32,address,uint8))", // remove multichain
+    "addOrUpdateRecipient((uint32,uint32,address,uint8))" // guardians distribution
+  ];
+
+  const proposalFunctionInputs = [
+    ethers.utils.defaultAbiCoder.encode(["address"], [newDistHelper.address]),
+    ethers.utils.defaultAbiCoder.encode(
+      ["uint32", "uint32", "address", "uint8"],
+      [0, 42220, dao[celoNetwork].UBIScheme, 1]
+    ),
+    ethers.utils.defaultAbiCoder.encode(
+      ["uint32", "uint32", "address", "uint8"],
+      [8182, 42220, release.GuardiansSafe, 3] //ubi to guardians
+    )
+  ];
+
+  if (isProduction) {
+    await executeViaSafe(
+      proposalContracts,
+      proposalEthValues,
+      proposalFunctionSignatures,
+      proposalFunctionInputs,
+      protocolSettings.guardiansSafe,
+      "mainnet"
+    );
+  } else {
+    //simulation or dev envs
+    await executeViaGuardian(
+      proposalContracts,
+      proposalEthValues,
+      proposalFunctionSignatures,
+      proposalFunctionInputs,
+      guardian,
+      networkName
+    );
+  }
+
+  if (!isProduction) {
+    //check simulation results
+    let fm = await ethers.getContractAt("GoodFundManager", release.GoodFundManager);
+    let dh = await ethers.getContractAt("DistributionHelper", release.DistributionHelper);
+
+    console.log(await dh.distributionRecipients(0));
+    console.log(await dh.distributionRecipients(1));
+    console.log(await dh.distributionRecipients(2));
+    let tx = await (await fm.collectInterest(["0x7b7246c78e2f900d17646ff0cb2ec47d6ba10754"], true)).wait();
+    let gd = await ethers.getContractAt("IGoodDollar", "0x67C5870b4A41D4Ebef24d2456547A03F1f3e094B");
+    const safeBalance = await gd.balanceOf("0xE0c5daa7CC6F88d29505f702a53bb5E67600e7Ec");
+    console.log({ safeBalance }, tx.events);
+  }
+};
+
+export const main = async () => {
+  await upgrade().catch(console.log);
+};
+if (process.argv[1].includes("multichain-temp-fix")) main();

package/truffle-config.js

@@ -103,6 +103,14 @@ module.exports = {
       confirmations: 1, // # of confs to wait between deployments. (default: 0)
       timeoutBlocks: 20, // # of blocks before a deployment times out  (minimum/default: 50)
       skipDryRun: true // Skip dry run before migrations? (default: false for public nets )
+    },
+    alfajores: {
+      provider: () => new Web3.providers.HttpProvider(`https://alfajores-forno.celo-testnet.org`),
+      network_id: 44787, // Ropsten's id
+      gas: 150000, // Ropsten has a lower block limit than mainnet
+      confirmations: 1, // # of confs to wait between deployments. (default: 0)
+      timeoutBlocks: 20, // # of blocks before a deployment times out  (minimum/default: 50)
+      skipDryRun: true // Skip dry run before migrations? (default: false for public nets )
     }
 
     // Useful for private networks