@gooddollar/goodprotocol 2.0.25-beta.5 → 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.5",
+  "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/scripts/fv.ts

@@ -3,13 +3,15 @@ import fs from "fs";
 import { chunk, uniqBy } from "lodash";
 import { bulkIsWhitelisted, bulkLastAuth } from "./utils";
 
+//create tunnel to fv server ssh -L 9090:server:8080 -N user@server -i sshkey
 const main = async () => {
-  const data = JSON.parse(fs.readFileSync("fvtriplets.txt").toString());
+  const data = JSON.parse(fs.readFileSync("fvtriplets2.txt").toString());
   const triplets = uniqBy(chunk(data, 3), _ => _.join("_"));
 
   const accounts = triplets.map(_ => _[0]);
   const whitelisted = await bulkIsWhitelisted(accounts);
   const failed = triplets.filter(_ => whitelisted.includes(_[0]) === false);
+
   console.log("Total accounts:", accounts.length);
   console.log("Total whitelisted:", whitelisted.length);
   console.log("Total failed re-auth:", failed.length);
@@ -19,48 +21,39 @@ const main = async () => {
   });
   console.log({ notfetched });
   const ps = notfetched.map(async a => {
-    const i1 = await fetch("http://localhost:9090/enrollment-3d/" + a[1]).then(
-      _ => _.json()
-    );
-    const i2 = await fetch("http://localhost:9090/enrollment-3d/" + a[2]).then(
-      _ => _.json()
-    );
+    const i1 = await fetch("http://localhost:9090/enrollment-3d/" + a[1]).then(_ => _.json());
+    const i2 = await fetch("http://localhost:9090/enrollment-3d/" + a[2]).then(_ => _.json());
     if (i1.auditTrailBase64 && i2.auditTrailBase64) {
-      fs.writeFileSync(
-        "fvimages/" + a.join("_") + "-a.jpg",
-        i1.auditTrailBase64,
-        {
-          encoding: "base64"
-        }
-      );
-      fs.writeFileSync(
-        "fvimages/" + a.join("_") + "-b.jpg",
-        i2.auditTrailBase64,
-        {
-          encoding: "base64"
-        }
-      );
-    } else
-      console.log("not found", a, !!i1.auditTrailBase64, !!i2.auditTrailBase64);
+      fs.writeFileSync("fvimages/" + a.join("_") + "-a.jpg", i1.auditTrailBase64, {
+        encoding: "base64"
+      });
+      fs.writeFileSync("fvimages/" + a.join("_") + "-b.jpg", i2.auditTrailBase64, {
+        encoding: "base64"
+      });
+    } else console.log("not found", a, !!i1.auditTrailBase64, !!i2.auditTrailBase64);
   });
 
   await Promise.all(ps);
 };
 
-const deleteIdentifiers = async () => {
-  const data = JSON.parse(fs.readFileSync("todeletefvtriplets.txt").toString());
+const deleteIdentifiers = async password => {
+  const data = JSON.parse(fs.readFileSync("fvtriplets2.txt").toString());
   const triplets = uniqBy(chunk(data, 3), _ => _.join("_"));
   const accounts = triplets.map(_ => _[0]);
   const whitelisted = await bulkIsWhitelisted(accounts);
   const lastAuth = await bulkLastAuth(accounts);
+  console.log(
+    "no last auth",
+    Object.entries(lastAuth).filter(_ => _[1] === 0)
+  );
+  const dateYearsAgo = new Date();
+  dateYearsAgo.setFullYear(dateYearsAgo.getFullYear() - 3);
   const failed = triplets.filter(
-    _ =>
-      whitelisted.includes(_[0]) === false && lastAuth.includes(_[0]) === true
+    _ => whitelisted.includes(_[0]) === false && lastAuth[_[0]] > 0 && lastAuth[_[0]] < dateYearsAgo.getTime() / 1000
   );
 
   let ps = [];
-  console.log({ failed });
-
+  console.log("old lastauth:", failed.length, "out of:", triplets.length);
   for (let record of failed) {
     ps.push(
       fetch("https://goodserver.gooddollar.org/admin/verify/face/delete", {
@@ -97,5 +90,6 @@ const deleteIdentifiers = async () => {
   console.log(res);
 };
 
-deleteIdentifiers();
 // main();
+console.log(process.env.ADMIN_PASSWORD);
+deleteIdentifiers(process.env.ADMIN_PASSWORD);

package/scripts/utils.ts

@@ -5,14 +5,9 @@ import { ethers } from "hardhat";
 export const bulkIsWhitelisted = async (accounts: Array<String>) => {
   setMulticallAddress(122, "0x3CE6158b7278Bf6792e014FA7B4f3c6c46fe9410");
   setMulticallAddress(42220, "0x75F59534dd892c1f8a7B172D639FA854D529ada3");
-  const celoProvider = new ethers.providers.JsonRpcProvider(
-    "https://forno.celo.org"
-  );
+  const celoProvider = new ethers.providers.JsonRpcProvider("https://forno.celo.org");
   const ethcallProvider = new Provider(celoProvider, 42220);
-  const identityContract = new Contract(
-    "0xC361A6E67822a0EDc17D899227dd9FC50BD62F42",
-    Identity.abi
-  );
+  const identityContract = new Contract("0xC361A6E67822a0EDc17D899227dd9FC50BD62F42", Identity.abi);
   const calls = accounts.map(d => identityContract.isWhitelisted(d));
   const result = await ethcallProvider.all(calls);
   const whitelisted = accounts.filter((v, i) => result[i]);
@@ -22,17 +17,10 @@ export const bulkIsWhitelisted = async (accounts: Array<String>) => {
 export const bulkLastAuth = async (accounts: Array<String>) => {
   setMulticallAddress(122, "0x3CE6158b7278Bf6792e014FA7B4f3c6c46fe9410");
   setMulticallAddress(42220, "0x75F59534dd892c1f8a7B172D639FA854D529ada3");
-  const celoProvider = new ethers.providers.JsonRpcProvider(
-    "https://forno.celo.org"
-  );
-  const ethcallProvider = new Provider(celoProvider, 42220);
-  const identityContract = new Contract(
-    "0xC361A6E67822a0EDc17D899227dd9FC50BD62F42",
-    Identity.abi
-  );
+  const fuseProvider = new ethers.providers.JsonRpcProvider("https://rpc.fuse.io");
+  const ethcallProvider = new Provider(fuseProvider, 122);
+  const identityContract = new Contract("0x2F9C28de9e6d44b71B91b8BA337A5D82e308E7BE", Identity.abi);
   const calls = accounts.map(d => identityContract.lastAuthenticated(d));
   const result = await ethcallProvider.all(calls);
-  console.log({ result });
-  const whitelisted = accounts.filter((v, i) => parseInt(result[i]));
-  return whitelisted;
+  return Object.fromEntries(accounts.map((v, i) => [v, parseInt(result[i])]));
 };

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/tsconfig.json

@@ -1,6 +1,6 @@
 {
   "compilerOptions": {
-    "target": "es2018",
+    "target": "ESNext",
     "module": "commonjs",
     "strict": false,
     "moduleResolution": "node",

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";