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

package/contracts/utils/BuyGDClone.sol

@@ -5,6 +5,38 @@ import "@openzeppelin/contracts-upgradeable/proxy/ClonesUpgradeable.sol";
 import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
 import "../Interfaces.sol";
 
+//@mean-finance/uniswap-v3-oracle
+interface IStaticOracle {
+	/// @notice Will increase observations for all existing pools for the given pair, so they start accruing information for twap calculations
+	/// @dev Will revert if there are no pools available for the pair and period combination
+	/// @param tokenA One of the pair's tokens
+	/// @param tokenB The other of the pair's tokens
+	/// @param cardinality The cardinality that will be guaranteed when quoting
+	/// @return preparedPools The pools that were prepared
+	function prepareAllAvailablePoolsWithCardinality(
+		address tokenA,
+		address tokenB,
+		uint16 cardinality
+	) external returns (address[] memory preparedPools);
+
+	/// @notice Returns a quote, based on the given tokens and amount, by querying all of the pair's pools
+	/// @dev If some pools are not configured correctly for the given period, then they will be ignored
+	/// @dev Will revert if there are no pools available/configured for the pair and period combination
+	/// @param baseAmount Amount of token to be converted
+	/// @param baseToken Address of an ERC20 token contract used as the baseAmount denomination
+	/// @param quoteToken Address of an ERC20 token contract used as the quoteAmount denomination
+	/// @param period Number of seconds from which to calculate the TWAP
+	/// @return quoteAmount Amount of quoteToken received for baseAmount of baseToken
+	/// @return queriedPools The pools that were queried to calculate the quote
+	function quoteAllAvailablePoolsWithTimePeriod(
+		uint128 baseAmount,
+		address baseToken,
+		address quoteToken,
+		uint32 period
+	) external view returns (uint256 quoteAmount, address[] memory queriedPools);
+}
+
+// @uniswap/v3-core
 interface ISwapRouter {
 	struct ExactInputSingleParams {
 		address tokenIn;
@@ -75,36 +107,75 @@ interface ISwapRouter {
 	) external payable returns (uint256 amountIn);
 }
 
+/*
+ * @title BuyGDClone
+ * @notice This contract allows users to swap Celo or cUSD for GoodDollar (GD) tokens.
+ * @dev This contract is a clone of the BuyGD contract, which is used to buy GD tokens on the GoodDollar platform.
+ * @dev This contract uses the SwapRouter contract to perform the swaps.
+ */
 contract BuyGDClone is Initializable {
-	error NOT_ALLOWED(address);
 	error REFUND_FAILED(uint256);
+	error NO_BALANCE();
 
 	ISwapRouter public immutable router;
 	address public constant celo = 0x471EcE3750Da237f93B8E339c536989b8978a438;
+	uint32 public immutable twapPeriod;
 	address public immutable cusd;
 	address public immutable gd;
+	IStaticOracle public immutable oracle;
 
 	address public owner;
-	address public executer;
 
 	receive() external payable {}
 
-	constructor(ISwapRouter _router, address _cusd, address _gd) {
+	constructor(
+		ISwapRouter _router,
+		address _cusd,
+		address _gd,
+		IStaticOracle _oracle
+	) {
 		router = _router;
 		cusd = _cusd;
 		gd = _gd;
+		oracle = _oracle;
+		twapPeriod = 300; //5 minutes
 	}
 
-	function initialize(address _owner, address _executer) external initializer {
+	/**
+	 * @notice Initializes the contract with the owner's address.
+	 * @param _owner The address of the owner of the contract.
+	 */
+	function initialize(address _owner) external initializer {
 		owner = _owner;
-		executer = _executer;
 	}
 
-	function swap(uint256 _minAmount) external {
+	/**
+	 * @notice Swaps either Celo or cUSD for GD tokens.
+	 * @dev If the contract has a balance of Celo, it will swap Celo for GD tokens.
+	 * @dev If the contract has a balance of cUSD, it will swap cUSD for GD tokens.
+	 * @param _minAmount The minimum amount of GD tokens to receive from the swap.
+	 */
+	function swap(uint256 _minAmount) external payable {
+		uint256 balance = address(this).balance;
+		if (balance > 0) return swapCelo(_minAmount);
+
+		balance = ERC20(cusd).balanceOf(address(this));
+		if (balance > 0) return swapCusd(_minAmount);
+
+		revert NO_BALANCE();
+	}
+
+	/**
+	 * @notice Swaps Celo for GD tokens.
+	 * @param _minAmount The minimum amount of GD tokens to receive from the swap.
+	 */
+	function swapCelo(uint256 _minAmount) public payable {
 		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;
+
+		uint256 minByTwap = minAmountByTWAP(balance, celo);
+		_minAmount = _minAmount > minByTwap ? _minAmount : minByTwap;
+
 		ERC20(celo).approve(address(router), balance);
 		ISwapRouter.ExactInputParams memory params = ISwapRouter.ExactInputParams({
 			path: abi.encodePacked(celo, uint24(3000), cusd, uint24(10000), gd),
@@ -119,11 +190,17 @@ contract BuyGDClone is Initializable {
 		}
 	}
 
-	function swapCusd(uint256 _minAmount) external {
-		uint256 gasCosts = msg.sender == executer ? 1e17 : 0;
-		if (msg.sender != owner && msg.sender != executer)
-			revert NOT_ALLOWED(msg.sender);
+	/**
+	 * @notice Swaps cUSD for GD tokens.
+	 * @param _minAmount The minimum amount of GD tokens to receive from the swap.
+	 */
+	function swapCusd(uint256 _minAmount) public {
+		uint256 gasCosts = msg.sender != owner ? 1e17 : 0; //fixed 0.1$
 		uint balance = ERC20(cusd).balanceOf(address(this));
+
+		uint256 minByTwap = minAmountByTWAP(balance, cusd);
+		_minAmount = _minAmount > minByTwap ? _minAmount : minByTwap;
+
 		ERC20(cusd).approve(address(router), balance);
 		ISwapRouter.ExactInputParams memory params = ISwapRouter.ExactInputParams({
 			path: abi.encodePacked(cusd, uint24(10000), gd),
@@ -132,38 +209,99 @@ contract BuyGDClone is Initializable {
 			amountOutMinimum: _minAmount
 		});
 		router.exactInput(params);
-		if (msg.sender == executer) {
+		if (msg.sender != owner) {
 			ERC20(cusd).transfer(msg.sender, gasCosts);
 		}
 	}
 
+	/**
+	 * @notice Calculates the minimum amount of tokens that can be received for a given amount of base tokens,
+	 * based on the time-weighted average price (TWAP) of the token pair over a specified period of time.
+	 * @param baseAmount The amount of base tokens to swap.
+	 * @param baseToken The address of the base token.
+	 * @return minTwap The minimum amount of G$ expected to receive by twap
+	 */
+	function minAmountByTWAP(
+		uint256 baseAmount,
+		address baseToken
+	) public view returns (uint256 minTwap) {
+		uint128 toConvert = uint128(baseAmount);
+		uint256 quote;
+		if (baseToken == celo) {
+			(quote, ) = oracle.quoteAllAvailablePoolsWithTimePeriod(
+				toConvert,
+				baseToken,
+				cusd,
+				twapPeriod
+			);
+			toConvert = uint128(quote);
+		}
+		(quote, ) = oracle.quoteAllAvailablePoolsWithTimePeriod(
+			toConvert,
+			cusd,
+			gd,
+			twapPeriod
+		);
+		//minAmount should not be 5% under twap (ie we dont expect price movement > 5% in timePeriod)
+		return (quote * 95) / 100;
+	}
+
+	/**
+	 * @notice Recovers tokens accidentally sent to the contract.
+	 * @param token The address of the token to recover. Use address(0) to recover ETH.
+	 */
 	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)));
+		} else {
+			ERC20(token).transfer(owner, ERC20(token).balanceOf(address(this)));
+		}
 	}
 }
 
+/**
+ * @title BuyGDCloneFactory
+ * @notice Factory contract for creating clones of BuyGDClone contract
+ */
 contract BuyGDCloneFactory {
 	address immutable impl;
 
-	constructor(ISwapRouter _router, address _cusd, address _gd) {
-		impl = address(new BuyGDClone(_router, _cusd, _gd));
+	/**
+	 * @notice Initializes the BuyGDCloneFactory contract with the provided parameters.
+	 * @param _router The address of the SwapRouter contract.
+	 * @param _cusd The address of the cUSD token contract.
+	 * @param _gd The address of the GD token contract.
+	 * @param _oracle The address of the StaticOracle contract.
+	 */
+	constructor(
+		ISwapRouter _router,
+		address _cusd,
+		address _gd,
+		IStaticOracle _oracle
+	) {
+		impl = address(new BuyGDClone(_router, _cusd, _gd, _oracle));
 	}
 
-	function create(address owner, address executer) external returns (address) {
-		bytes32 salt = keccak256(abi.encode(owner, executer));
+	/**
+	 * @notice Creates a new clone of the BuyGDClone contract with the provided owner address.
+	 * @param owner The address of the owner of the new BuyGDClone contract.
+	 * @return The address of the new BuyGDClone contract.
+	 */
+	function create(address owner) external returns (address) {
+		bytes32 salt = keccak256(abi.encode(owner));
 		address clone = ClonesUpgradeable.cloneDeterministic(impl, salt);
-		BuyGDClone(payable(clone)).initialize(owner, executer);
+		BuyGDClone(payable(clone)).initialize(owner);
 		return clone;
 	}
 
-	function predict(
-		address owner,
-		address executer
-	) external view returns (address) {
-		bytes32 salt = keccak256(abi.encode(owner, executer));
+	/**
+	 * @notice Predicts the address of a new clone of the BuyGDClone contract with the provided owner address.
+	 * @param owner The address of the owner of the new BuyGDClone contract.
+	 * @return The predicted address of the new BuyGDClone contract.
+	 */
+	function predict(address owner) external view returns (address) {
+		bytes32 salt = keccak256(abi.encode(owner));
 
 		return
 			ClonesUpgradeable.predictDeterministicAddress(impl, salt, address(this));

package/package.json

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

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

@@ -9,7 +9,6 @@
 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";
@@ -54,8 +53,12 @@ export const upgrade = async () => {
 
   let f = await ethers.getContractFactory("GoodFundManager");
   console.log("bytecode", f.bytecode.length);
-  let newDistHelper = (await ethers.deployContract("DistributionHelper").then(printDeploy)) as Contract;
-
+  // let newDistHelper = (await ethers
+  //   .deployContract("DistributionHelper", { maxFeePerGas: 22e9, nonce: 118 })
+  //   .then(printDeploy)) as Contract;
+  let newDistHelper = (await (await ethers.getContractFactory("DistributionHelper"))
+    .deploy({ maxFeePerGas: 15e9, maxPriorityFeePerGas: 1e9 })
+    .then(printDeploy)) as Contract;
   if (isProduction) await verifyContract(newDistHelper, "GoodReserveCDai", networkName);
 
   const proposalContracts = [

package/truffle-config.js

@@ -58,6 +58,10 @@ module.exports = {
     // },
     // Useful for deploying to a public network.
     // NB: It's important to wrap the provider as a function.
+    "production-mainnet": {
+      provider: () => new Web3.providers.HttpProvider(`https://cloudflare-eth.com`),
+      network_id: 1
+    },
     kovan: {
       provider: () => new Web3.providers.HttpProvider(`https://ropsten.infura.io/v3/YOUR-PROJECT-ID`),
       network_id: 42, // Ropsten's id

package/types/BuyGDClone.ts

@@ -12,6 +12,7 @@ import {
   BaseContract,
   ContractTransaction,
   Overrides,
+  PayableOverrides,
   CallOverrides,
 } from "ethers";
 import { BytesLike } from "@ethersproject/bytes";
@@ -28,43 +29,61 @@ export interface BuyGDCloneInterface extends ethers.utils.Interface {
   functions: {
     "celo()": FunctionFragment;
     "cusd()": FunctionFragment;
-    "executer()": FunctionFragment;
     "gd()": FunctionFragment;
-    "initialize(address,address)": FunctionFragment;
+    "initialize(address)": FunctionFragment;
+    "minAmountByTWAP(uint256,address)": FunctionFragment;
+    "oracle()": FunctionFragment;
     "owner()": FunctionFragment;
     "recover(address)": FunctionFragment;
     "router()": FunctionFragment;
     "swap(uint256)": FunctionFragment;
+    "swapCelo(uint256)": FunctionFragment;
     "swapCusd(uint256)": FunctionFragment;
+    "twapPeriod()": FunctionFragment;
   };
 
   encodeFunctionData(functionFragment: "celo", values?: undefined): string;
   encodeFunctionData(functionFragment: "cusd", values?: undefined): string;
-  encodeFunctionData(functionFragment: "executer", values?: undefined): string;
   encodeFunctionData(functionFragment: "gd", values?: undefined): string;
+  encodeFunctionData(functionFragment: "initialize", values: [string]): string;
   encodeFunctionData(
-    functionFragment: "initialize",
-    values: [string, string]
+    functionFragment: "minAmountByTWAP",
+    values: [BigNumberish, string]
   ): string;
+  encodeFunctionData(functionFragment: "oracle", values?: undefined): string;
   encodeFunctionData(functionFragment: "owner", values?: undefined): string;
   encodeFunctionData(functionFragment: "recover", values: [string]): string;
   encodeFunctionData(functionFragment: "router", values?: undefined): string;
   encodeFunctionData(functionFragment: "swap", values: [BigNumberish]): string;
+  encodeFunctionData(
+    functionFragment: "swapCelo",
+    values: [BigNumberish]
+  ): string;
   encodeFunctionData(
     functionFragment: "swapCusd",
     values: [BigNumberish]
   ): string;
+  encodeFunctionData(
+    functionFragment: "twapPeriod",
+    values?: undefined
+  ): string;
 
   decodeFunctionResult(functionFragment: "celo", data: BytesLike): Result;
   decodeFunctionResult(functionFragment: "cusd", data: BytesLike): Result;
-  decodeFunctionResult(functionFragment: "executer", data: BytesLike): Result;
   decodeFunctionResult(functionFragment: "gd", data: BytesLike): Result;
   decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "minAmountByTWAP",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "oracle", data: BytesLike): Result;
   decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
   decodeFunctionResult(functionFragment: "recover", data: BytesLike): Result;
   decodeFunctionResult(functionFragment: "router", data: BytesLike): Result;
   decodeFunctionResult(functionFragment: "swap", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "swapCelo", data: BytesLike): Result;
   decodeFunctionResult(functionFragment: "swapCusd", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "twapPeriod", data: BytesLike): Result;
 
   events: {
     "Initialized(uint8)": EventFragment;
@@ -108,16 +127,21 @@ export interface BuyGDClone extends BaseContract {
 
     cusd(overrides?: CallOverrides): Promise<[string]>;
 
-    executer(overrides?: CallOverrides): Promise<[string]>;
-
     gd(overrides?: CallOverrides): Promise<[string]>;
 
     initialize(
       _owner: string,
-      _executer: string,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
+    minAmountByTWAP(
+      baseAmount: BigNumberish,
+      baseToken: string,
+      overrides?: CallOverrides
+    ): Promise<[BigNumber] & { minTwap: BigNumber }>;
+
+    oracle(overrides?: CallOverrides): Promise<[string]>;
+
     owner(overrides?: CallOverrides): Promise<[string]>;
 
     recover(
@@ -129,29 +153,41 @@ export interface BuyGDClone extends BaseContract {
 
     swap(
       _minAmount: BigNumberish,
-      overrides?: Overrides & { from?: string | Promise<string> }
+      overrides?: PayableOverrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
+    swapCelo(
+      _minAmount: BigNumberish,
+      overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
     swapCusd(
       _minAmount: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
+
+    twapPeriod(overrides?: CallOverrides): Promise<[number]>;
   };
 
   celo(overrides?: CallOverrides): Promise<string>;
 
   cusd(overrides?: CallOverrides): Promise<string>;
 
-  executer(overrides?: CallOverrides): Promise<string>;
-
   gd(overrides?: CallOverrides): Promise<string>;
 
   initialize(
     _owner: string,
-    _executer: string,
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
+  minAmountByTWAP(
+    baseAmount: BigNumberish,
+    baseToken: string,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  oracle(overrides?: CallOverrides): Promise<string>;
+
   owner(overrides?: CallOverrides): Promise<string>;
 
   recover(
@@ -163,7 +199,12 @@ export interface BuyGDClone extends BaseContract {
 
   swap(
     _minAmount: BigNumberish,
-    overrides?: Overrides & { from?: string | Promise<string> }
+    overrides?: PayableOverrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
+  swapCelo(
+    _minAmount: BigNumberish,
+    overrides?: PayableOverrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
   swapCusd(
@@ -171,20 +212,24 @@ export interface BuyGDClone extends BaseContract {
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
+  twapPeriod(overrides?: CallOverrides): Promise<number>;
+
   callStatic: {
     celo(overrides?: CallOverrides): Promise<string>;
 
     cusd(overrides?: CallOverrides): Promise<string>;
 
-    executer(overrides?: CallOverrides): Promise<string>;
-
     gd(overrides?: CallOverrides): Promise<string>;
 
-    initialize(
-      _owner: string,
-      _executer: string,
+    initialize(_owner: string, overrides?: CallOverrides): Promise<void>;
+
+    minAmountByTWAP(
+      baseAmount: BigNumberish,
+      baseToken: string,
       overrides?: CallOverrides
-    ): Promise<void>;
+    ): Promise<BigNumber>;
+
+    oracle(overrides?: CallOverrides): Promise<string>;
 
     owner(overrides?: CallOverrides): Promise<string>;
 
@@ -194,10 +239,17 @@ export interface BuyGDClone extends BaseContract {
 
     swap(_minAmount: BigNumberish, overrides?: CallOverrides): Promise<void>;
 
+    swapCelo(
+      _minAmount: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<void>;
+
     swapCusd(
       _minAmount: BigNumberish,
       overrides?: CallOverrides
     ): Promise<void>;
+
+    twapPeriod(overrides?: CallOverrides): Promise<number>;
   };
 
   filters: {
@@ -210,16 +262,21 @@ export interface BuyGDClone extends BaseContract {
 
     cusd(overrides?: CallOverrides): Promise<BigNumber>;
 
-    executer(overrides?: CallOverrides): Promise<BigNumber>;
-
     gd(overrides?: CallOverrides): Promise<BigNumber>;
 
     initialize(
       _owner: string,
-      _executer: string,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
+    minAmountByTWAP(
+      baseAmount: BigNumberish,
+      baseToken: string,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    oracle(overrides?: CallOverrides): Promise<BigNumber>;
+
     owner(overrides?: CallOverrides): Promise<BigNumber>;
 
     recover(
@@ -231,13 +288,20 @@ export interface BuyGDClone extends BaseContract {
 
     swap(
       _minAmount: BigNumberish,
-      overrides?: Overrides & { from?: string | Promise<string> }
+      overrides?: PayableOverrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
+    swapCelo(
+      _minAmount: BigNumberish,
+      overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
     swapCusd(
       _minAmount: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
+
+    twapPeriod(overrides?: CallOverrides): Promise<BigNumber>;
   };
 
   populateTransaction: {
@@ -245,16 +309,21 @@ export interface BuyGDClone extends BaseContract {
 
     cusd(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
-    executer(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-
     gd(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
     initialize(
       _owner: string,
-      _executer: string,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
+    minAmountByTWAP(
+      baseAmount: BigNumberish,
+      baseToken: string,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    oracle(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
     owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
     recover(
@@ -266,12 +335,19 @@ export interface BuyGDClone extends BaseContract {
 
     swap(
       _minAmount: BigNumberish,
-      overrides?: Overrides & { from?: string | Promise<string> }
+      overrides?: PayableOverrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
+    swapCelo(
+      _minAmount: BigNumberish,
+      overrides?: PayableOverrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
     swapCusd(
       _minAmount: BigNumberish,
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
+
+    twapPeriod(overrides?: CallOverrides): Promise<PopulatedTransaction>;
   };
 }