@gooddollar/goodprotocol 2.0.32-beta.0 → 2.0.32

package/contracts/utils/ReserveRestore.sol

@@ -7,151 +7,175 @@ import "../reserve/GoodReserveCDai.sol";
 import "hardhat/console.sol";
 
 contract ReserveRestore {
-	NameService ns;
-	uint256 public constant LOCKED_HACKED_FUNDS = 971921364208;
-	bool public executed;
-	address owner;
-
-	constructor(NameService _ns) {
-		ns = _ns;
-		owner = msg.sender;
-	}
-
-	function end() external {
-		require(msg.sender == owner, "not owner");
-		Controller ctrl = Controller(ns.getAddress("CONTROLLER"));
-		address avatar = ns.dao().avatar();
-
-		// prevent executing again}
-		require(ctrl.unregisterSelf(avatar), "unregistering failed");
-	}
-
-	function donate(address daiFrom, uint256 amount) external {
-		require(msg.sender == owner, "not owner");
-		address avatar = ns.dao().avatar();
-
-		GoodReserveCDai reserve = GoodReserveCDai(ns.getAddress("RESERVE"));
-		ERC20(ns.getAddress("DAI")).transferFrom(daiFrom, address(this), amount);
-		uint256 daiBalance = ERC20(ns.getAddress("DAI")).balanceOf(address(this));
-		cERC20 cdai = cERC20(ns.getAddress("CDAI"));
-		ERC20 dai = ERC20(ns.getAddress("DAI"));
-
-		dai.approve(address(cdai), daiBalance);
-		//Mint cDAIs
-		uint256 cDaiResult = cdai.mint(daiBalance);
-		require(cDaiResult == 0, "Minting cDai failed");
-		uint256 cdaiBalance = cdai.balanceOf(address(this));
-		cdai.transfer(address(reserve), cdaiBalance);
-		cdaiBalance = cdai.balanceOf(address(reserve));
-
-		uint256 gdSupply = ERC20(ns.getAddress("GOODDOLLAR")).totalSupply() -
-			LOCKED_HACKED_FUNDS;
-		console.log("supply: %s", gdSupply);
-		// get 0.0001 dai price in cdai
-		uint256 currentPrice = reserve.currentPrice();
-		console.log("currentPrice: %s", currentPrice);
-
-		console.log("cdaiBalance: %s", cdaiBalance);
-
-		// given price calculate the reserve ratio
-		uint32 reserveRatio = uint32(
-			(cdaiBalance * 1e2 * 1e6) / (currentPrice * gdSupply)
-		); // mul by 1e2 to cover gd precision, cdaibalance precision=initialprice, mul by 1e6 to receive result in the precision of reserveRatio(1e6)
-		console.log("reserveRatio: %s", reserveRatio);
-		Controller ctrl = Controller(ns.getAddress("CONTROLLER"));
-		//     function initializeToken(
-		// 	ERC20 _token,
-		// 	uint256 _gdSupply,
-		// 	uint256 _tokenSupply,
-		// 	uint32 _reserveRatio,
-		// 	uint256 _lastExpansion
-		// )
-		(bool ok, ) = ctrl.genericCall(
-			address(reserve.getMarketMaker()),
-			abi.encodeCall(
-				GoodMarketMaker.initializeToken,
-				(cdai, gdSupply, cdaiBalance, reserveRatio, block.timestamp)
-			),
-			address(avatar),
-			0
-		);
-		require(ok, "initializeToken failed");
-	}
-
-	function upgrade(address daiFrom, uint256 amount) external {
-		require(msg.sender == owner, "not owner");
-		require(executed == false, "already upgraded");
-		executed = true;
-		address avatar = ns.dao().avatar();
-
-		GoodReserveCDai reserve = GoodReserveCDai(ns.getAddress("RESERVE"));
-		ERC20(ns.getAddress("DAI")).transferFrom(daiFrom, address(this), amount);
-		uint256 daiBalance = ERC20(ns.getAddress("DAI")).balanceOf(address(this));
-		require(daiBalance >= 50000e18, "not enough reserve");
-		cERC20 cdai = cERC20(ns.getAddress("CDAI"));
-		ERC20 dai = ERC20(ns.getAddress("DAI"));
-
-		dai.approve(address(cdai), daiBalance);
-		//Mint cDAIs
-		uint256 cDaiResult = cdai.mint(daiBalance);
-		require(cDaiResult == 0, "Minting cDai failed");
-		uint256 cdaiBalance = cdai.balanceOf(address(this));
-		cdai.transfer(address(reserve), cdaiBalance);
-		cdaiBalance = cdai.balanceOf(address(reserve));
-
-		uint256 gdSupply = ERC20(ns.getAddress("GOODDOLLAR")).totalSupply() -
-			LOCKED_HACKED_FUNDS;
-		console.log("supply: %s", gdSupply);
-		// get 0.0001 dai price in cdai
-		uint256 initialPriceCdai = (0.0001 * 1e8 * 1e28) /
-			cdai.exchangeRateStored(); //excghange rate is at 1e28 precision rate/1e28=1 cdai price in dai mul by 1e8 to get in cdai precision
-		console.log("initialPriceCdai: %s", initialPriceCdai);
-
-		console.log("cdaiBalance: %s", cdaiBalance);
-
-		// given price calculate the reserve ratio
-		uint32 reserveRatio = uint32(
-			(cdaiBalance * 1e2 * 1e6) / (initialPriceCdai * gdSupply)
-		); // mul by 1e2 to cover gd precision, cdaibalance precision=initialprice, mul by 1e6 to receive result in the precision of reserveRatio(1e6)
-		console.log("reserveRatio: %s", reserveRatio);
-		Controller ctrl = Controller(ns.getAddress("CONTROLLER"));
-		//     function initializeToken(
-		// 	ERC20 _token,
-		// 	uint256 _gdSupply,
-		// 	uint256 _tokenSupply,
-		// 	uint32 _reserveRatio,
-		// 	uint256 _lastExpansion
-		// )
-		(bool ok, ) = ctrl.genericCall(
-			address(reserve.getMarketMaker()),
-			abi.encodeCall(
-				GoodMarketMaker.initializeToken,
-				(cdai, gdSupply, cdaiBalance, reserveRatio, block.timestamp)
-			),
-			address(avatar),
-			0
-		);
-		require(ok, "initializeToken failed");
-		// ContributionCalc(
-		// 		ns.getAddress("CONTRIBUTION_CALCULATION")
-		// 	).setContributionRatio(0.1*1e18,1e18);
-
-		// exit contribution to 10%
-		(ok, ) = ctrl.genericCall(
-			address(ns.getAddress("CONTRIBUTION_CALCULATION")),
-			abi.encodeCall(ContributionCalc.setContributionRatio, (0.1 * 1e18, 1e18)),
-			address(avatar),
-			0
-		);
-		require(ok, "setContributionRatio failed");
-
-		(ok, ) = ctrl.genericCall(
-			address(reserve),
-			abi.encodeCall(GoodReserveCDai.setGDXDisabled, (true, true)),
-			address(avatar),
-			0
-		);
-
-		require(ok, "setContributionRatio failed");
-	}
+    NameService ns;
+    uint256 public constant LOCKED_HACKED_FUNDS = 971921364208;
+    bool public executed;
+    address owner;
+
+    constructor(NameService _ns) {
+        ns = _ns;
+        owner = msg.sender;
+    }
+
+    function end() external {
+        require(msg.sender == owner, "not owner");
+        Controller ctrl = Controller(ns.getAddress("CONTROLLER"));
+        address avatar = ns.dao().avatar();
+
+        // prevent executing again}
+        require(ctrl.unregisterSelf(avatar), "unregistering failed");
+    }
+
+    function donate(address daiFrom, uint256 amount) external {
+        require(msg.sender == owner, "not owner");
+        address avatar = ns.dao().avatar();
+
+        GoodReserveCDai reserve = GoodReserveCDai(ns.getAddress("RESERVE"));
+        ERC20(ns.getAddress("DAI")).transferFrom(
+            daiFrom,
+            address(this),
+            amount
+        );
+        uint256 daiBalance = ERC20(ns.getAddress("DAI")).balanceOf(
+            address(this)
+        );
+        cERC20 cdai = cERC20(ns.getAddress("CDAI"));
+        ERC20 dai = ERC20(ns.getAddress("DAI"));
+
+        dai.approve(address(cdai), daiBalance);
+        //Mint cDAIs
+        uint256 cDaiResult = cdai.mint(daiBalance);
+        require(cDaiResult == 0, "Minting cDai failed");
+        uint256 cdaiBalance = cdai.balanceOf(address(this));
+        cdai.transfer(address(reserve), cdaiBalance);
+        cdaiBalance = cdai.balanceOf(address(reserve));
+
+        uint256 gdSupply = ERC20(ns.getAddress("GOODDOLLAR")).totalSupply() -
+            LOCKED_HACKED_FUNDS;
+        console.log("supply: %s", gdSupply);
+        // get 0.0001 dai price in cdai
+        uint256 currentPrice = reserve.currentPrice();
+        console.log("currentPrice: %s", currentPrice);
+
+        console.log("cdaiBalance: %s", cdaiBalance);
+
+        // given price calculate the reserve ratio
+        uint32 reserveRatio = uint32(
+            (cdaiBalance * 1e2 * 1e6) / (currentPrice * gdSupply)
+        ); // mul by 1e2 to cover gd precision, cdaibalance precision=initialprice, mul by 1e6 to receive result in the precision of reserveRatio(1e6)
+        console.log("reserveRatio: %s", reserveRatio);
+        Controller ctrl = Controller(ns.getAddress("CONTROLLER"));
+        //     function initializeToken(
+        // 	ERC20 _token,
+        // 	uint256 _gdSupply,
+        // 	uint256 _tokenSupply,
+        // 	uint32 _reserveRatio,
+        // 	uint256 _lastExpansion
+        // )
+        (bool ok, ) = ctrl.genericCall(
+            address(reserve.getMarketMaker()),
+            abi.encodeCall(
+                GoodMarketMaker.initializeToken,
+                (cdai, gdSupply, cdaiBalance, reserveRatio, block.timestamp)
+            ),
+            address(avatar),
+            0
+        );
+        require(ok, "initializeToken failed");
+    }
+
+    function upgrade(address daiFrom, uint256 amount) external {
+        require(msg.sender == owner, "not owner");
+        require(executed == false, "already upgraded");
+        executed = true;
+        address avatar = ns.dao().avatar();
+
+        GoodReserveCDai reserve = GoodReserveCDai(ns.getAddress("RESERVE"));
+        ERC20(ns.getAddress("DAI")).transferFrom(
+            daiFrom,
+            address(this),
+            amount
+        );
+        uint256 daiBalance = ERC20(ns.getAddress("DAI")).balanceOf(
+            address(this)
+        );
+        require(daiBalance >= 50000e18, "not enough reserve");
+        cERC20 cdai = cERC20(ns.getAddress("CDAI"));
+        ERC20 dai = ERC20(ns.getAddress("DAI"));
+
+        dai.approve(address(cdai), daiBalance);
+        //Mint cDAIs
+        uint256 cDaiResult = cdai.mint(daiBalance);
+        require(cDaiResult == 0, "Minting cDai failed");
+        uint256 cdaiBalance = cdai.balanceOf(address(this));
+        cdai.transfer(address(reserve), cdaiBalance);
+        cdaiBalance = cdai.balanceOf(address(reserve));
+
+        uint256 gdSupply = ERC20(ns.getAddress("GOODDOLLAR")).totalSupply() -
+            LOCKED_HACKED_FUNDS;
+        console.log("supply: %s", gdSupply);
+        // get 0.0001 dai price in cdai
+        uint256 initialPriceCdai = (0.0001 * 1e8 * 1e28) /
+            cdai.exchangeRateStored(); //excghange rate is at 1e28 precision rate/1e28=1 cdai price in dai mul by 1e8 to get in cdai precision
+        console.log("initialPriceCdai: %s", initialPriceCdai);
+
+        console.log("cdaiBalance: %s", cdaiBalance);
+
+        // given price calculate the reserve ratio
+        uint32 reserveRatio = uint32(
+            (cdaiBalance * 1e2 * 1e6) / (initialPriceCdai * gdSupply)
+        ); // mul by 1e2 to cover gd precision, cdaibalance precision=initialprice, mul by 1e6 to receive result in the precision of reserveRatio(1e6)
+        console.log("reserveRatio: %s", reserveRatio);
+        Controller ctrl = Controller(ns.getAddress("CONTROLLER"));
+        //     function initializeToken(
+        // 	ERC20 _token,
+        // 	uint256 _gdSupply,
+        // 	uint256 _tokenSupply,
+        // 	uint32 _reserveRatio,
+        // 	uint256 _lastExpansion
+        // )
+        (bool ok, ) = ctrl.genericCall(
+            address(reserve.getMarketMaker()),
+            abi.encodeCall(
+                GoodMarketMaker.initializeToken,
+                (cdai, gdSupply, cdaiBalance, reserveRatio, block.timestamp)
+            ),
+            address(avatar),
+            0
+        );
+        require(ok, "initializeToken failed");
+        // ContributionCalc(
+        // 		ns.getAddress("CONTRIBUTION_CALCULATION")
+        // 	).setContributionRatio(0.1*1e18,1e18);
+
+        // exit contribution to 10%
+        (ok, ) = ctrl.genericCall(
+            address(ns.getAddress("CONTRIBUTION_CALCULATION")),
+            abi.encodeCall(
+                ContributionCalc.setContributionRatio,
+                (0.1 * 1e18, 1e18)
+            ),
+            address(avatar),
+            0
+        );
+        require(ok, "setContributionRatio failed");
+
+        (ok, ) = ctrl.genericCall(
+            address(reserve),
+            abi.encodeCall(GoodReserveCDai.setGDXDisabled, (true, true)),
+            address(avatar),
+            0
+        );
+
+        require(ok, "gdx disable failed");
+
+        // unpause reserve
+        (ok, ) = ctrl.genericCall(
+            address(reserve),
+            abi.encodeCall(ERC20PresetMinterPauserUpgradeable.unpause, ()),
+            address(avatar),
+            0
+        );
+        require(ok, "unpause failed");
+    }
 }

package/hardhat.config.ts

@@ -211,14 +211,14 @@ const hhconfig: HardhatUserConfig = {
       accounts: [deployerPrivateKey],
       url: "https://forno.celo.org",
       gas: 8000000,
-      gasPrice: 5000000000,
+      gasPrice: 25e9,
       chainId: 42220
     },
     celo: {
       accounts: { mnemonic },
       url: "https://forno.celo.org",
       gas: 3000000,
-      gasPrice: 5000000000,
+      gasPrice: 25e9,
       chainId: 42220
     },
     alfajores: {
@@ -237,14 +237,14 @@ const hhconfig: HardhatUserConfig = {
       accounts: { mnemonic },
       url: "https://forno.celo.org",
       gas: 3000000,
-      gasPrice: 5000000000,
+      gasPrice: 25e9,
       chainId: 42220
     },
     "development-celo": {
       accounts: { mnemonic },
       url: "https://forno.celo.org",
       gas: 3000000,
-      gasPrice: 5000000000,
+      gasPrice: 25e9,
       chainId: 42220
     },
     "development-base": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gooddollar/goodprotocol",
-  "version": "2.0.32-beta.0",
+  "version": "2.0.32",
   "description": "GoodDollar Protocol",
   "engines": {
     "node": ">=16.x"
@@ -76,12 +76,15 @@
     "@mean-finance/uniswap-v3-oracle": "^1.0.3",
     "@nomicfoundation/hardhat-chai-matchers": "1",
     "@nomicfoundation/hardhat-network-helpers": "^1.0.8",
-    "@nomicfoundation/hardhat-verify": "^2.0.1",
+    "@nomicfoundation/hardhat-verify": "2",
     "@nomiclabs/hardhat-ethers": "^2.2.1",
     "@nomiclabs/hardhat-waffle": "^2.0.6",
     "@openzeppelin/contracts": "^4.8.0",
     "@openzeppelin/contracts-upgradeable": "^4.8.0",
     "@openzeppelin/hardhat-upgrades": "^1.22.1",
+    "@safe-global/api-kit": "^3.0.1",
+    "@safe-global/protocol-kit": "^6.0.2",
+    "@safe-global/types-kit": "^2.0.1",
     "@superfluid-finance/ethereum-contracts": "1.8.1",
     "@superfluid-finance/sdk-core": "^0.5.8",
     "@swc/core": "1.3.96",

package/releases/deployment.json

@@ -436,11 +436,13 @@
     "BuyGDFactoryV2": "0x1F60C4C7037C6766924A43666B781ED1479587a2",
     "CUSD": "0x765DE816845861e75A25fCA122bb6898B8B1282a",
     "BulkWhitelist": "0x30Afd0534dAA29135308d048103b40dc1BA4518d",
-    "MentoProxyAdmin": "0x9A0234633124B338BA83815633fD7b61d10A5036",
-    "MentoExchangeProvider": "0xAcA417869dCa426fc40Ec8a2B7022E217eA233eF",
-    "MentoExpansionController": "0x0249EC175b481028cDd857bf36F2bf08E6cC4754",
-    "MentoReserve": "0x861cF82ebeBED3a99017CD5A271FBe71A4123302",
-    "MentoBroker": "0x9F94b2cF2a2CC0c85A021F2c6a80095D14E6a0f2"
+    "MentoProxyAdmin": "0x8471406C3Bff67Cc6538481C8550364bda6Ca691",
+    "MentoExchangeProvider": "0x2fFBB49055d487DdBBb0C052Cd7c2a02A7971e41",
+    "MentoExpansionController": "0x5557E9dEF86ad6564462741a7A3f3679C1223f5d",
+    "MentoReserve": "0x94A3240f484A04F5e3d524f528d02694c109463b",
+    "MentoBroker": "0x88de45906D4F5a57315c133620cfa484cB297541",
+    "MentoUpgradeHelper": "0xc413cC6C58f0c290e89ddAeC83c2590017985eb7",
+    "CeloDistributionHelper": "0x6B845eFfAf36c374e8E7cf543Efa680f2F71F098"
   },
   "gnosis": { "GuardiansSafe": "0x84c10b45fe51bfb4f86c19a47fdbc187d4572fb8" },
   "development-celo": {

package/scripts/multichain-deploy/helpers.ts

@@ -2,10 +2,14 @@ import { Contract, ContractFactory, Signer } from "ethers";
 import { network, ethers, upgrades, run } from "hardhat";
 import * as safeethers from "ethers";
 import { TransactionResponse, TransactionReceipt } from "@ethersproject/providers";
-import Safe from "@gnosis.pm/safe-core-sdk";
+// import Safe from "@gnosis.pm/safe-core-sdk";
 import EthersAdapter from "@gnosis.pm/safe-ethers-lib";
-import { MetaTransactionData } from "@gnosis.pm/safe-core-sdk-types";
-import SafeClient from "@gnosis.pm/safe-service-client";
+// import { MetaTransactionData } from "@gnosis.pm/safe-core-sdk-types";
+// import SafeClient from "@gnosis.pm/safe-service-client";
+
+import SafeApiKit from "@safe-global/api-kit";
+import Safe, { Eip1193Provider } from "@safe-global/protocol-kit";
+import { MetaTransactionData, OperationType } from "@safe-global/types-kit";
 
 import util from "util";
 import dao from "../../releases/deployment.json";
@@ -248,27 +252,36 @@ export const executeViaSafe = async (
     throw new Error("safe signer is missing");
   }
 
-  let safeSigner = new ethers.Wallet(process.env.SAFEOWNER_PRIVATE_KEY, new ethers.providers.CloudflareProvider());
+  // let safeSigner = new ethers.Wallet(
+  //   process.env.SAFEOWNER_PRIVATE_KEY,
+  //   new ethers.providers.JsonRpcProvider("https://rpc.flashbots.net")
+  // );
+  let chainId = 1;
+  let provider = "https://mainnet.infura.io";
   if (typeof safeSignerOrNetwork === "string") {
     switch (safeSignerOrNetwork) {
       case "mainnet":
         break;
       case "celo":
-        safeSigner = new ethers.Wallet(process.env.SAFEOWNER_PRIVATE_KEY).connect(
-          new ethers.providers.JsonRpcProvider("https://forno.celo.org")
-        );
+        chainId = 42220;
+        provider = "https://forno.celo.org";
+        // safeSigner = new ethers.Wallet(process.env.SAFEOWNER_PRIVATE_KEY).connect(
+        //   new ethers.providers.JsonRpcProvider("https://forno.celo.org")
+        // );
         break;
       case "fuse":
-        safeSigner = new ethers.Wallet(process.env.SAFEOWNER_PRIVATE_KEY).connect(
-          new ethers.providers.JsonRpcProvider("https://rpc.fuse.io")
-        );
+        chainId = 122;
+        provider = "https://rpc.fuse.io";
+        // safeSigner = new ethers.Wallet(process.env.SAFEOWNER_PRIVATE_KEY).connect(
+        //   new ethers.providers.JsonRpcProvider("https://rpc.fuse.io")
+        // );
         break;
     }
   } else if (safeSignerOrNetwork) {
-    safeSigner = safeSignerOrNetwork as any;
+    // safeSigner = safeSignerOrNetwork as any;
   }
-  const chainId = await safeSigner.getChainId();
-  console.log("safeSigner:", safeSigner.address, { chainId, safeAddress });
+
+  console.log("safeSigner:", { chainId, safeAddress });
   let txServiceUrl;
   switch (chainId) {
     case 1:
@@ -282,18 +295,26 @@ export const executeViaSafe = async (
       break;
   }
   console.log("creating safe adapter", { txServiceUrl });
-  const ethAdapter = new EthersAdapter({
-    ethers: safeethers,
-    signerOrProvider: safeSigner
+  const safeService = new SafeApiKit({
+    chainId: BigInt(chainId)
   });
-  console.log("creating safe client", { txServiceUrl });
 
-  const safeService = new SafeClient({
-    txServiceUrl,
-    ethAdapter
+  const safeSdk = await Safe.init({
+    provider,
+    signer: process.env.SAFEOWNER_PRIVATE_KEY,
+    safeAddress
   });
 
-  const safeSdk = await Safe.create({ ethAdapter, safeAddress });
+  const senderAddress = await safeSdk.getSafeProvider().getSignerAddress();
+
+  // console.log("creating safe client", { txServiceUrl });
+
+  // const safeService = new SafeClient({
+  //   txServiceUrl,
+  //   ethAdapter
+  // });
+
+  // const safeSdk = await Safe.create({ ethAdapter, safeAddress });
 
   let release: { [key: string]: any } = dao[networkName];
   const ctrl = await ethers.getContractAt("Controller", release.Controller, null);
@@ -374,13 +395,13 @@ export const executeViaSafe = async (
   }
 
   const safeTransaction = await safeSdk.createTransaction({
-    safeTransactionData
+    transactions: safeTransactionData
   });
 
   const safeTxHash = await safeSdk.getTransactionHash(safeTransaction);
-  const signedHash = await safeSdk.signTransactionHash(safeTxHash);
+  const signedHash = await safeSdk.signHash(safeTxHash);
 
-  const senderAddress = await safeSigner.getAddress();
+  // const senderAddress = await safeSigner.getAddress();
   console.log("propose safe transaction", {
     safeAddress,
     safeTransactionData: safeTransaction.data,