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

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

@@ -1,8 +1,21 @@
-import fetch from "cross-fetch";
 import fs from "fs";
 import { chunk, uniqBy } from "lodash";
-import { bulkIsWhitelisted, bulkLastAuth } from "./utils";
+import delay from "delay";
 
+import { bulkIsWhitelisted, bulkIsWhitelistedFuse, bulkLastAuth } from "./utils";
+
+const fetchImages = 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());
+  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);
+};
 //create tunnel to fv server ssh -L 9090:server:8080 -N user@server -i sshkey
 const main = async () => {
   const data = JSON.parse(fs.readFileSync("fvtriplets2.txt").toString());
@@ -20,22 +33,125 @@ const main = async () => {
     return fs.existsSync(key) === false;
   });
   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());
-    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);
-  });
+  const ps = notfetched.map(fetchImages);
 
   await Promise.all(ps);
 };
 
+// check which ids have been indexed, if not then make sure they are whitelisted
+const checkIndexedOrDelete = async () => {
+  const data = JSON.parse(
+    "[" + fs.readFileSync("fvids.json").toString().replace(/\n$/, "").replaceAll(/\n/g, ",\n") + "]"
+  );
+  const triplets = uniqBy(data, _ => _["wallet"]);
+
+  const accounts = triplets.map(_ => _["wallet"]);
+  console.log("Total accounts:", accounts.length, accounts[0]);
+  let whitelisted = [];
+  for (let batch of chunk(accounts, 200)) {
+    whitelisted.push(...(await bulkIsWhitelistedFuse(batch)));
+  }
+  const failed = triplets.filter(_ => whitelisted.includes(_["wallet"]) === false);
+
+  console.log("Total whitelisted:", whitelisted.length);
+  console.log("Total not whitelisted:", failed.length);
+  let ps = [];
+
+  ps = [];
+  for (let record of triplets) {
+    const isEnrolled = fetch("http://localhost:9090/enrollment-3d/" + record["identifier"].slice(0, 42))
+      .then(_ => _.json())
+      .then(_ => _.success);
+    // const isEnrolled = "unknown";
+    const isIndexed = fetch("http://localhost:9090/3d-db/get", {
+      method: "POST",
+      body: JSON.stringify({ identifier: record["identifier"].slice(0, 42), groupName: "GoodDollar" })
+    })
+      .then(_ => _.json())
+      .then(_ => _.success);
+
+    ps.push(
+      Promise.all([isEnrolled, isIndexed]).then(_ => ({
+        ...record,
+        isEnrolled: _[0],
+        isIndexed: _[1],
+        isWhitelisted: whitelisted.includes(record.wallet)
+      }))
+    );
+    if (ps.length % 50 === 0) {
+      console.log("waiting...", ps.length);
+      await Promise.all(ps);
+    }
+  }
+  console.log("waiting...", ps.length);
+  const r = await Promise.all(ps);
+  const toDelete = r.filter(
+    _ => (_.isWhitelisted && (!_.isEnrolled || !_.isIndexed)) || (!_.isWhitelisted && _.isIndexed && !_.isEnrolled)
+  );
+  const toWhitelist = r.filter(_ => !_.isWhitelisted && _.isEnrolled && _.isIndexed);
+
+  console.log("toDelete:", toDelete.length);
+
+  console.log("toWhitelist:", toWhitelist.length);
+  fs.writeFileSync("fvIndexedOrEnrolled.json", JSON.stringify(r));
+};
+
+const fixInvalidIndexed = async () => {
+  const indexedOrEnrolled = JSON.parse(fs.readFileSync("fvIndexedOrEnrolled.json").toString());
+  const toDelete = indexedOrEnrolled.filter(
+    _ => (_.isWhitelisted && (!_.isEnrolled || !_.isIndexed)) || (!_.isWhitelisted && _.isIndexed && !_.isEnrolled)
+  );
+  const toWhitelist = indexedOrEnrolled.filter(_ => !_.isWhitelisted && _.isEnrolled && _.isIndexed);
+
+  console.log("toDelete:", toDelete.length);
+
+  console.log("toWhitelist:", toWhitelist.length);
+
+  console.log(toWhitelist);
+  return;
+  let ps = [];
+  for (let record of toWhitelist) {
+    ps.push(fetch(`https://goodserver.gooddollar.org/syncWhitelist/${record.wallet}`).then(_ => _.json()));
+    if (ps.length > 0 && ps.length % 3 === 0) {
+      console.log("waiting...", ps.length);
+      await Promise.all(ps).catch(e => console.log(e));
+      console.log("waiting 60 seconds for rate limit");
+      await delay(50000);
+    }
+  }
+  if (ps.length > 0) {
+    console.log("waiting...", ps.length);
+    await Promise.all(ps).catch(e => console.log(e));
+  }
+
+  const removeWhitelist = toDelete.filter(_ => _.isWhitelisted).map(_ => _.wallet);
+  // removeWhitelist.push(...toWhitelist.map(_ => _.wallet));
+  ps = [];
+  for (let record of toDelete) {
+    if (record.isIndexed) {
+      // console.log("removing record from index and queuing for whitelist removal", record.wallet);
+      const isIndexed = fetch("http://localhost:9090/3d-db/delete", {
+        method: "POST",
+        body: JSON.stringify({ identifier: record["identifier"].slice(0, 42), groupName: "GoodDollar" })
+      }).then(_ => _.json());
+
+      ps.push(
+        isIndexed.then(_ => {
+          if (!_.success) throw new Error(`delete index failed: ${record.wallet}`);
+        })
+      );
+    }
+    if (ps.length > 0 && ps.length % 10 === 0) {
+      console.log("waiting...", ps.length);
+      await Promise.all(ps).catch(e => console.log(e));
+    }
+  }
+  console.log("waiting...", ps.length);
+  await Promise.all(ps).catch(e => console.log(e));
+  console.log({ removeWhitelist }, removeWhitelist.length);
+  fs.writeFileSync("removeWhitelist.json", JSON.stringify(removeWhitelist));
+};
+
 const deleteIdentifiers = async password => {
   const data = JSON.parse(fs.readFileSync("fvtriplets2.txt").toString());
   const triplets = uniqBy(chunk(data, 3), _ => _.join("_"));
@@ -89,7 +205,8 @@ const deleteIdentifiers = async password => {
   const res = await Promise.all(ps);
   console.log(res);
 };
-
+// checkIndexedOrDelete();
+fixInvalidIndexed();
 // main();
-console.log(process.env.ADMIN_PASSWORD);
-deleteIdentifiers(process.env.ADMIN_PASSWORD);
+// console.log(process.env.ADMIN_PASSWORD);
+// deleteIdentifiers(process.env.ADMIN_PASSWORD);

package/scripts/utils.ts

@@ -13,6 +13,17 @@ export const bulkIsWhitelisted = async (accounts: Array<String>) => {
   const whitelisted = accounts.filter((v, i) => result[i]);
   return whitelisted;
 };
+export const bulkIsWhitelistedFuse = async (accounts: Array<String>) => {
+  setMulticallAddress(122, "0x3CE6158b7278Bf6792e014FA7B4f3c6c46fe9410");
+  setMulticallAddress(42220, "0x75F59534dd892c1f8a7B172D639FA854D529ada3");
+  const provider = new ethers.providers.JsonRpcProvider("https://rpc.fuse.io");
+  const ethcallProvider = new Provider(provider, 122);
+  const identityContract = new Contract("0x2F9C28de9e6d44b71B91b8BA337A5D82e308E7BE", Identity.abi);
+  const calls = accounts.map(d => identityContract.isWhitelisted(d));
+  const result = await ethcallProvider.all(calls);
+  const whitelisted = accounts.filter((v, i) => result[i]);
+  return whitelisted;
+};
 
 export const bulkLastAuth = async (accounts: Array<String>) => {
   setMulticallAddress(122, "0x3CE6158b7278Bf6792e014FA7B4f3c6c46fe9410");

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