@gooddollar/goodprotocol 2.0.25-beta.6 → 2.0.25-beta.7

package/contracts/invite/OneTimeReward.sol

@@ -0,0 +1,87 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import "@openzeppelin/contracts/access/Ownable.sol";
+
+import "../Interfaces.sol";
+import "../utils/NameService.sol";
+import "../utils/DAOUpgradeableContract.sol";
+
+contract OneTimeReward is Ownable, DAOContract {
+	bool public isActive;
+	uint public rewardAmount;
+	mapping(address => bool) public claimed;
+
+	event RewardClaimed(address indexed user, uint amount);
+
+	constructor(uint256 _rewardAmount, INameService _nameService) {
+		rewardAmount = _rewardAmount;
+		isActive = true;
+		setDAO(_nameService);
+	}
+
+	function getIdentity() public view returns (IIdentityV2) {
+		return IIdentityV2(nameService.getAddress("IDENTITY"));
+	}
+
+	function updateSettings(
+		bool _isActive,
+		uint _rewardAmount
+	) external onlyOwner {
+		isActive = _isActive;
+		rewardAmount = _rewardAmount;
+	}
+
+	function checkActiveAndBalance() public view returns (bool) {
+		if (!isActive) {
+			return false;
+		}
+
+		if (nativeToken().balanceOf(address(this)) < rewardAmount) {
+			return false;
+		}
+
+		return true;
+	}
+
+	function checkCanClaimReward(address _user) public view returns (bool) {
+		address whitelistedRoot = getIdentity().getWhitelistedRoot(_user);
+		return canClaimReward(whitelistedRoot);
+	}
+
+	function canClaimReward(
+		address whitelistedRoot
+	) internal view returns (bool) {
+		if (checkActiveAndBalance() == false) {
+			return false;
+		}
+
+		if (whitelistedRoot == address(0)) {
+			return false;
+		}
+
+		if (claimed[whitelistedRoot]) {
+			return false;
+		}
+
+		return true;
+	}
+
+	function claimReward(address _user) public {
+		address whitelistedRoot = getIdentity().getWhitelistedRoot(_user);
+		require(canClaimReward(whitelistedRoot), "User cannot claim reward");
+		claimed[whitelistedRoot] = true;
+
+		nativeToken().transfer(_user, rewardAmount);
+
+		emit RewardClaimed(_user, rewardAmount);
+	}
+
+	function withdrawAll(address _token) external onlyOwner {
+		uint balance = IERC20(_token).balanceOf(address(this));
+		require(balance > 0, "No tokens to withdraw");
+
+		IERC20(_token).transfer(msg.sender, balance);
+	}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gooddollar/goodprotocol",
-  "version": "2.0.25-beta.6",
+  "version": "2.0.25-beta.7",
   "description": "GoodDollar Protocol",
   "engines": {
     "node": ">=16.x"

package/scripts/deployFullDAO.ts

@@ -88,6 +88,8 @@ export const createDAO = async () => {
     .deploy()
     .then(printDeploy)) as Contract;
 
+  await BancorFormula.init()
+
   const AddFounders = (await AddFoundersFactory.deploy().then(
     printDeploy
   )) as Contract;
@@ -421,14 +423,14 @@ const deployMainnet = async (Avatar, Identity) => {
   let DAIEthOracle = daiEthOracleAddr
     ? await ethers.getContractAt("DaiEthPriceMockOracle", daiEthOracleAddr)
     : ((await (await ethers.getContractFactory("DaiEthPriceMockOracle"))
-        .deploy()
-        .then(printDeploy)) as Contract);
+      .deploy()
+      .then(printDeploy)) as Contract);
 
   let ETHUsdOracle = ethUsdOracleAddr
     ? await ethers.getContractAt("EthUSDMockOracle", ethUsdOracleAddr)
     : ((await (await ethers.getContractFactory("EthUSDMockOracle"))
-        .deploy()
-        .then(printDeploy)) as Contract);
+      .deploy()
+      .then(printDeploy)) as Contract);
 
   return {
     Contribution,

package/test/helpers.ts

@@ -134,6 +134,8 @@ export const createDAO = async (tokenType: "super" | "regular" = "super") => {
     await ethers.getContractFactory("BancorFormula")
   ).deploy();
 
+  await BancorFormula.init();
+
   console.log("deploy upgradeable identity...");
 
   const Identity = await upgrades.deployProxy(

package/test/reserve/GoodReserveCDai.test.ts

@@ -474,6 +474,7 @@ describe("GoodReserve - staking with cDAI mocks", () => {
       "BancorFormula",
       await marketMaker.getBancor()
     );
+
     const expectedReturn = await bancor.calculateSaleReturn(
       supplyBefore.toString(),
       reserveBalanceBefore.toString(),
@@ -966,7 +967,7 @@ describe("GoodReserve - staking with cDAI mocks", () => {
       parseInt(reserveBalance.toString()) *
       (1 -
         (1 - amount.toNumber() / parseInt(supply.toString())) **
-          (1000000 / reserveToken.reserveRatio));
+        (1000000 / reserveToken.reserveRatio));
 
     expected = Math.ceil((0.8 * expected) / 100) * 100; //deduct 20% contribution, allow 5 points precission mismatch (due to bancor pow estimation?), match solidity no floating point
     //expected = Math.floor(0.8 * expected);

package/types/@openzeppelin/contracts/access/Ownable.ts

@@ -0,0 +1,175 @@
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+import type {
+  BaseContract,
+  BigNumber,
+  BytesLike,
+  CallOverrides,
+  ContractTransaction,
+  Overrides,
+  PopulatedTransaction,
+  Signer,
+  utils,
+} from "ethers";
+import type {
+  FunctionFragment,
+  Result,
+  EventFragment,
+} from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type {
+  TypedEventFilter,
+  TypedEvent,
+  TypedListener,
+  OnEvent,
+} from "../../../common";
+
+export interface OwnableInterface extends utils.Interface {
+  functions: {
+    "owner()": FunctionFragment;
+    "renounceOwnership()": FunctionFragment;
+    "transferOwnership(address)": FunctionFragment;
+  };
+
+  getFunction(
+    nameOrSignatureOrTopic: "owner" | "renounceOwnership" | "transferOwnership"
+  ): FunctionFragment;
+
+  encodeFunctionData(functionFragment: "owner", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "renounceOwnership",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "transferOwnership",
+    values: [string]
+  ): string;
+
+  decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "renounceOwnership",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "transferOwnership",
+    data: BytesLike
+  ): Result;
+
+  events: {
+    "OwnershipTransferred(address,address)": EventFragment;
+  };
+
+  getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
+}
+
+export interface OwnershipTransferredEventObject {
+  previousOwner: string;
+  newOwner: string;
+}
+export type OwnershipTransferredEvent = TypedEvent<
+  [string, string],
+  OwnershipTransferredEventObject
+>;
+
+export type OwnershipTransferredEventFilter =
+  TypedEventFilter<OwnershipTransferredEvent>;
+
+export interface Ownable extends BaseContract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  interface: OwnableInterface;
+
+  queryFilter<TEvent extends TypedEvent>(
+    event: TypedEventFilter<TEvent>,
+    fromBlockOrBlockhash?: string | number | undefined,
+    toBlock?: string | number | undefined
+  ): Promise<Array<TEvent>>;
+
+  listeners<TEvent extends TypedEvent>(
+    eventFilter?: TypedEventFilter<TEvent>
+  ): Array<TypedListener<TEvent>>;
+  listeners(eventName?: string): Array<Listener>;
+  removeAllListeners<TEvent extends TypedEvent>(
+    eventFilter: TypedEventFilter<TEvent>
+  ): this;
+  removeAllListeners(eventName?: string): this;
+  off: OnEvent<this>;
+  on: OnEvent<this>;
+  once: OnEvent<this>;
+  removeListener: OnEvent<this>;
+
+  functions: {
+    owner(overrides?: CallOverrides): Promise<[string]>;
+
+    renounceOwnership(
+      overrides?: Overrides & { from?: string }
+    ): Promise<ContractTransaction>;
+
+    transferOwnership(
+      newOwner: string,
+      overrides?: Overrides & { from?: string }
+    ): Promise<ContractTransaction>;
+  };
+
+  owner(overrides?: CallOverrides): Promise<string>;
+
+  renounceOwnership(
+    overrides?: Overrides & { from?: string }
+  ): Promise<ContractTransaction>;
+
+  transferOwnership(
+    newOwner: string,
+    overrides?: Overrides & { from?: string }
+  ): Promise<ContractTransaction>;
+
+  callStatic: {
+    owner(overrides?: CallOverrides): Promise<string>;
+
+    renounceOwnership(overrides?: CallOverrides): Promise<void>;
+
+    transferOwnership(
+      newOwner: string,
+      overrides?: CallOverrides
+    ): Promise<void>;
+  };
+
+  filters: {
+    "OwnershipTransferred(address,address)"(
+      previousOwner?: string | null,
+      newOwner?: string | null
+    ): OwnershipTransferredEventFilter;
+    OwnershipTransferred(
+      previousOwner?: string | null,
+      newOwner?: string | null
+    ): OwnershipTransferredEventFilter;
+  };
+
+  estimateGas: {
+    owner(overrides?: CallOverrides): Promise<BigNumber>;
+
+    renounceOwnership(
+      overrides?: Overrides & { from?: string }
+    ): Promise<BigNumber>;
+
+    transferOwnership(
+      newOwner: string,
+      overrides?: Overrides & { from?: string }
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    renounceOwnership(
+      overrides?: Overrides & { from?: string }
+    ): Promise<PopulatedTransaction>;
+
+    transferOwnership(
+      newOwner: string,
+      overrides?: Overrides & { from?: string }
+    ): Promise<PopulatedTransaction>;
+  };
+}

package/types/@openzeppelin/contracts/access/index.ts

@@ -3,3 +3,4 @@
 /* eslint-disable */
 export type { AccessControl } from "./AccessControl";
 export type { IAccessControl } from "./IAccessControl";
+export type { Ownable } from "./Ownable";