@gooddollar/goodprotocol 1.0.3-beta.2 → 1.0.4-beta.0

package/scripts/deployFullDAO.ts

@@ -21,15 +21,28 @@ import releaser from "../scripts/releaser";
 import ProtocolSettings from "../releases/deploy-settings.json";
 import dao from "../releases/deployment.json";
 import { main as deployV2 } from "./upgradeToV2/upgradeToV2";
+import { TransactionResponse } from "@ethersproject/providers";
+import pressAnyKey from "press-any-key";
+
 const { name } = network;
 
-const printDeploy = (c: Contract): Contract => {
-  console.log("deployed to: ", c.address);
+const printDeploy = async (
+  c: Contract | TransactionResponse
+): Promise<Contract | TransactionResponse> => {
+  if (c instanceof Contract) {
+    await c.deployed();
+    console.log("deployed to: ", c.address);
+  }
+  if (c.wait) {
+    await c.wait();
+    console.log("tx done:", c.hash);
+  }
   return c;
 };
 
 export const createDAO = async () => {
   const fusedao = dao[network.name.split("-")[0]];
+  let release: { [key: string]: any } = {}; //dao[network.name];
   let [root, ...signers] = await ethers.getSigners();
   //generic call permissions
   let schemeMock = root;
@@ -44,7 +57,6 @@ export const createDAO = async () => {
       .then(_ => _.toString())
   });
 
-  console.log("deployed erc20 tokens");
   const DAOCreatorFactory = new ethers.ContractFactory(
     DAOCreatorABI.abi,
     DAOCreatorABI.bytecode,
@@ -67,48 +79,51 @@ export const createDAO = async () => {
     root
   );
 
-  const BancorFormula = await (
+  const BancorFormula = (await (
     await ethers.getContractFactory("BancorFormula")
-  ).deploy();
+  )
+    .deploy()
+    .then(printDeploy)) as Contract;
 
-  const AddFounders = await AddFoundersFactory.deploy().then(printDeploy);
+  const AddFounders = (await AddFoundersFactory.deploy().then(
+    printDeploy
+  )) as Contract;
   // const AddFounders = await ethers.getContractAt(
   //   AddFoundersABI.abi,
   //   "0x6F1BAbfF5E119d61F0c6d8653d84E8B284B87091"
   // );
 
-  const Identity = await IdentityFactory.deploy().then(printDeploy);
+  const Identity = (await IdentityFactory.deploy().then(
+    printDeploy
+  )) as Contract;
   // const Identity = await ethers.getContractAt(
   //   IdentityABI.abi,
-  //   "0x77Bd4D825F4df162BDdda73a7E295c27e09E289f"
+  //   release.Identity
   // );
 
-  const daoCreator = await DAOCreatorFactory.deploy(AddFounders.address).then(
+  const daoCreator = (await DAOCreatorFactory.deploy(AddFounders.address).then(
     printDeploy
-  );
-  // const daoCreator = await ethers.getContractAt(
-  //   DAOCreatorABI.abi,
-  //   "0xfD1eFFDed0EE8739dF61B580F24bCd6585d0c6B4"
-  // );
-
-  const FeeFormula = await FeeFormulaFactory.deploy(0).then(printDeploy);
-  // const FeeFormula = await ethers.getContractAt(
-  //   FeeFormulaABI.abi,
-  //   "0x85b146AAa910aF4ab1D64cD81ab6f804aDf3053c"
-  // );
-
-  await Identity.setAuthenticationPeriod(365);
-  await daoCreator.forgeOrg(
-    "GoodDollar",
-    "G$",
-    0,
-    FeeFormula.address,
-    Identity.address,
-    [root.address, signers[0].address, signers[1].address],
-    1000,
-    [100000, 100000, 100000]
-  );
+  )) as Contract;
 
+  const FeeFormula = (await FeeFormulaFactory.deploy(0).then(
+    printDeploy
+  )) as Contract;
+
+  await Identity.setAuthenticationPeriod(365).then(printDeploy);
+  console.log("setAuthPeriod");
+  await daoCreator
+    .forgeOrg(
+      "GoodDollar",
+      "G$",
+      0,
+      FeeFormula.address,
+      Identity.address,
+      [root.address, signers[0].address, signers[1].address],
+      1000,
+      [100000, 100000, 100000]
+    )
+    .then(printDeploy);
+  console.log("forgeOrg done ");
   const Avatar = new ethers.Contract(
     await daoCreator.avatar(),
     [
@@ -118,7 +133,16 @@ export const createDAO = async () => {
     root
   );
 
-  await Identity.setAvatar(Avatar.address);
+  // const Avatar = new ethers.Contract(
+  //   release.Avatar,
+  //   [
+  //     "function owner() view returns (address)",
+  //     "function nativeToken() view returns (address)"
+  //   ],
+  //   root
+  // );
+
+  await Identity.setAvatar(Avatar.address).then(printDeploy);
 
   console.log("Done deploying DAO, setting schemes permissions");
 
@@ -130,13 +154,15 @@ export const createDAO = async () => {
 
   console.log("setting schemes", schemes);
 
-  await daoCreator.setSchemes(
-    Avatar.address,
-    schemes,
-    schemes.map(_ => ethers.constants.HashZero),
-    ["0x0000001F", "0x00000001"],
-    ""
-  );
+  await daoCreator
+    .setSchemes(
+      Avatar.address,
+      schemes,
+      schemes.map(_ => ethers.constants.HashZero),
+      ["0x0000001F", "0x00000001"],
+      ""
+    )
+    .then(printDeploy);
 
   let { setSchemes, genericCall, addWhitelisted } = await getHelperFunctions(
     Identity,
@@ -145,13 +171,22 @@ export const createDAO = async () => {
   );
 
   let mainnet: { [key: string]: Contract } = {};
+  release = {
+    ...release,
+    Avatar: Avatar.address,
+    Controller: controller,
+    GoodDollar: gd,
+    Identity: Identity.address,
+    FeeFormula: FeeFormula.address
+  };
 
   if (isMainnet) {
     mainnet = await deployMainnet(Avatar, Identity);
+    Object.entries(mainnet).forEach(([k, v]) => (release[k] = v.address));
   }
 
   let sidechain: { [key: string]: any } = {};
-  let release: { [key: string]: any } = {};
+
   if (false === isMainnet) {
     sidechain = await deploySidechain(
       setSchemes,
@@ -162,23 +197,24 @@ export const createDAO = async () => {
     );
     schemes.push(sidechain.OneTimePayments.address);
     const adminWallet = await deployAdminWallet(Identity.address);
-    await root.sendTransaction({
-      to: adminWallet.address,
-      value: ethers.utils.parseUnits("0.1", "ether")
-    });
     Object.entries(sidechain).forEach(([k, v]) => (release[k] = v.address));
     release["AdminWallet"] = adminWallet.address;
   }
 
+  await releaser(release, network.name);
+
+  await pressAnyKey();
   const bridgeRelease = await deployBridge(Avatar, gd, setSchemes, isMainnet);
   release = { ...release, ...bridgeRelease };
+  await releaser(release, network.name);
 
-  //deploy v2 mainnet/sidechain contracts, returns their addresses
+  await pressAnyKey();
+  // deploy v2 mainnet/sidechain contracts, returns their addresses
   const v2 = await deployV2(network.name, false, {
-    FirstClaimPool: sidechain?.FirstClaimPool?.address,
-    BancorFormula: BancorFormula.address,
-    Avatar: Avatar.address,
-    Controller: controller,
+    FirstClaimPool: release.FirstClaimPool,
+    BancorFormula: release.BancorFormula,
+    Avatar: release.Avatar,
+    Controller: release.Controller,
     DAIUsdOracle: ethers.constants.AddressZero,
     COMPUsdOracle: ethers.constants.AddressZero,
     USDCUsdOracle: ethers.constants.AddressZero,
@@ -186,20 +222,22 @@ export const createDAO = async () => {
     AaveLendingPool: ethers.constants.AddressZero,
     AaveIncentiveController: ethers.constants.AddressZero,
     GasPriceOracle: ethers.constants.AddressZero,
-    cDAI: mainnet?.cDAI?.address || ethers.constants.AddressZero,
-    DAI: mainnet?.dai?.address || ethers.constants.AddressZero,
-    COMP: mainnet?.COMP?.address || ethers.constants.AddressZero,
+    cDAI: release.cDAI || ethers.constants.AddressZero,
+    DAI: release.DAI || ethers.constants.AddressZero,
+    COMP: release.COMP || ethers.constants.AddressZero,
     USDC: ethers.constants.AddressZero,
-    Identity: Identity.address,
-    GoodDollar: gd,
-    Contribution: mainnet?.contribution?.address,
+    Identity: release.Identity,
+    GoodDollar: release.GoodDollar,
+    Contribution: release.Contribution,
     UniswapRouter: "0x0000000000000000000000000000000000000001",
-    ...bridgeRelease,
+    HomeBridge: release.HomeBridge,
+    ForeignBridge: release.ForeignBridge,
     SchemeRegistrar: ethers.constants.AddressZero,
     UpgradeScheme: ethers.constants.AddressZero
   });
-  release = { ...release, ...v2 };
-
+  release = { ...v2, ...release };
+  await releaser(release, network.name);
+  await pressAnyKey();
   if (isMainnet) {
     await setSchemes([release.ProtocolUpgrade]);
     await performUpgrade(release, fusedao.UBIScheme);
@@ -218,28 +256,16 @@ export const createDAO = async () => {
 
   if (false === isMainnet) {
     let encoded = (
-      await ethers.getContractAt("IGoodDollar", gd)
+      await ethers.getContractAt("IGoodDollar", release.GoodDollar)
     ).interface.encodeFunctionData("mint", [release.UBIScheme, 1000000]);
 
-    await genericCall(gd, encoded);
+    await genericCall(release.GoodDollar, encoded);
 
     await setSchemes([release.ProtocolUpgradeFuse]);
     await performUpgradeFuse(release);
   }
 
   await releaser(release, network.name);
-
-  return {
-    ...mainnet,
-    ...sidechain,
-    daoCreator,
-    controller,
-    avatar: await daoCreator.avatar(),
-    gd: await Avatar.nativeToken(),
-    identity: Identity.address,
-    bancorFormula: BancorFormula.address
-    // bridge: Bridge.address,
-  };
 };
 
 const deployBridge = async (Avatar, gd, setSchemes, isMainnet) => {
@@ -261,18 +287,19 @@ const deployBridge = async (Avatar, gd, setSchemes, isMainnet) => {
     isMainnet,
     isAlreadyMinter
   });
-  const scheme = await bridgeFactory.deploy(
-    Avatar.address,
-    BridgeFactoryContract
-  );
+  const scheme = (await bridgeFactory
+    .deploy(Avatar.address, BridgeFactoryContract)
+    .then(printDeploy)) as Contract;
   await setSchemes([scheme.address]);
 
   if (network.name.includes("develop")) {
-    const mockBridge = await new ethers.ContractFactory(
+    const mockBridge = (await new ethers.ContractFactory(
       BridgeMock.abi,
       BridgeMock.bytecode,
       root
-    ).deploy();
+    )
+      .deploy()
+      .then(printDeploy)) as Contract;
     console.log("deployed mock bridge for develop mode:", mockBridge.address);
     return isMainnet
       ? { ForeignBridge: mockBridge.address }
@@ -284,11 +311,12 @@ const deployBridge = async (Avatar, gd, setSchemes, isMainnet) => {
       ? scheme.setBridge()
       : scheme.setBridge(isAlreadyMinter === false))
   ).wait();
-  console.log("deployed bridge:", tx.events[0].args);
+  const bridgeEvent = tx.events.find(_ => _.event?.includes("Bridge"));
+  console.log("deployed bridge:", bridgeEvent);
   console.log(tx.events, tx);
   return isMainnet
-    ? { ForeignBridge: tx.events[0].args._foreignBridge }
-    : { HomeBridge: tx.events[0].args._homeBridge };
+    ? { ForeignBridge: bridgeEvent.args._foreignBridge }
+    : { HomeBridge: bridgeEvent.args._homeBridge };
 };
 
 const deployMainnet = async (Avatar, Identity) => {
@@ -301,17 +329,17 @@ const deployMainnet = async (Avatar, Identity) => {
   const cdaiAddr = ProtocolSettings[network.name]?.compound?.cdai;
   const COMPAddr = ProtocolSettings[network.name]?.compound?.comp;
 
-  let dai = daiAddr
+  let DAI = daiAddr
     ? await ethers.getContractAt("DAIMock", daiAddr)
-    : await daiFactory.deploy();
+    : ((await daiFactory.deploy().then(printDeploy)) as Contract);
 
   let COMP = COMPAddr
     ? await ethers.getContractAt("DAIMock", COMPAddr)
-    : await daiFactory.deploy();
+    : ((await daiFactory.deploy().then(printDeploy)) as Contract);
 
   let cDAI = cdaiAddr
     ? await ethers.getContractAt("DAIMock", cdaiAddr)
-    : await cdaiFactory.deploy(dai.address);
+    : ((await cdaiFactory.deploy(DAI.address).then(printDeploy)) as Contract);
 
   const ccFactory = new ethers.ContractFactory(
     ContributionCalculation.abi,
@@ -319,17 +347,17 @@ const deployMainnet = async (Avatar, Identity) => {
     root
   );
 
-  const contribution = await ccFactory
+  const Contribution = (await ccFactory
     .deploy(Avatar.address, 0, 1e15)
-    .then(printDeploy);
+    .then(printDeploy)) as Contract;
   // const contribution = await ethers.getContractAt(
   //   ContributionCalculation.abi,
   //   "0xc3171409dB6827A68294B3A0D40a31310E83eD6B"
   // );
 
   return {
-    contribution,
-    dai,
+    Contribution,
+    DAI,
     COMP,
     cDAI
   };
@@ -374,7 +402,9 @@ export const deploySidechain = async (
     identity
   });
 
-  const firstClaim = await fcFactory.deploy(avatar, identity, 1000);
+  const firstClaim = (await fcFactory
+    .deploy(avatar, identity, 1000)
+    .then(printDeploy)) as Contract;
 
   let encoded = (
     await ethers.getContractAt("IGoodDollar", gd)
@@ -384,21 +414,29 @@ export const deploySidechain = async (
 
   console.log("deploying OneTimePayments");
 
-  const otp = await otpf.deploy(avatar, identity).then(printDeploy);
+  const otp = (await otpf
+    .deploy(avatar, identity)
+    .then(printDeploy)) as Contract;
 
   console.log("deploying OneTimePayments invites");
-  const invites = await upgrades.deployProxy(invitesf, [
-    avatar,
-    identity,
-    gd,
-    10000
-  ]);
-
-  const faucet = await upgrades.deployProxy(faucetf, [identity]);
+  const invites = (await upgrades
+    .deployProxy(invitesf, [avatar, identity, gd, 10000])
+    .then(printDeploy)) as Contract;
+
+  const faucet = (await upgrades
+    .deployProxy(faucetf, [identity])
+    .then(printDeploy)) as Contract;
+
+  await root
+    .sendTransaction({
+      to: faucet.address,
+      value: ethers.utils.parseEther("5")
+    })
+    .then(printDeploy);
 
   console.log("setting firstclaim and otp schemes...");
   await setSchemes([firstClaim.address, otp.address]);
-  const tx = await firstClaim.start();
+  await firstClaim.start().then(printDeploy);
 
   return {
     FirstClaimPool: firstClaim,
@@ -415,24 +453,28 @@ const deployAdminWallet = async identity => {
     hdNode.derivePath(`m/44'/60'/0'/0/${i + 1}`)
   );
 
-  const adminWallet = await new ethers.ContractFactory(
+  const adminWallet = (await new ethers.ContractFactory(
     AdminWalletABI.abi,
     AdminWalletABI.bytecode,
     root
-  ).deploy(
-    admins.slice(0, 20).map(_ => _.address),
-    ethers.utils.parseUnits("1000000", "gwei"),
-    4,
-    identity
-  );
+  )
+    .deploy(
+      admins.slice(0, 20).map(_ => _.address),
+      ethers.utils.parseUnits("1000000", "gwei"),
+      4,
+      identity
+    )
+    .then(printDeploy)) as Contract;
 
   const id = await ethers.getContractAt("IIdentity", identity);
-  await id.addIdentityAdmin(adminWallet.address);
-  await root.sendTransaction({
-    to: adminWallet.address,
-    value: ethers.utils.parseEther("10")
-  });
-  await adminWallet["topAdmins(uint256)"](0);
+  await id.addIdentityAdmin(adminWallet.address).then(printDeploy);
+  await root
+    .sendTransaction({
+      to: adminWallet.address,
+      value: ethers.utils.parseEther("1")
+    })
+    .then(printDeploy);
+  await adminWallet["topAdmins(uint256)"](0).then(printDeploy);
   console.log(
     "deployAdminWallet admins:",
     admins.map(_ => _.address),
@@ -457,17 +499,19 @@ const getHelperFunctions = async (Identity, Avatar, schemeMock) => {
         params[i] || ethers.constants.HashZero,
         "0x0000001F",
         Avatar.address
-      );
+      ).then(printDeploy);
     }
   };
 
   const genericCall = (target, encodedFunc) => {
-    return Controller.genericCall(target, encodedFunc, Avatar.address, 0);
+    return Controller.genericCall(target, encodedFunc, Avatar.address, 0).then(
+      printDeploy
+    );
   };
 
   const addWhitelisted = (addr, did, isContract = false) => {
     if (isContract) return Identity.addContract(addr);
-    return Identity.addWhitelistedWithDID(addr, did);
+    return Identity.addWhitelistedWithDID(addr, did).then(printDeploy);
   };
 
   return { setSchemes, addWhitelisted, genericCall };
@@ -480,39 +524,43 @@ const performUpgradeFuse = async release => {
   );
 
   console.log("performing protocol v2 upgrade on Fuse...", { release });
-  await upgrade.upgrade(
-    release.NameService,
-    //old contracts
-    [
-      ethers.constants.AddressZero,
-      ethers.constants.AddressZero,
-      ethers.constants.AddressZero,
-      release.FirstClaimPool
-    ],
-    release.UBIScheme,
-    [
-      ethers.utils.keccak256(ethers.utils.toUtf8Bytes("REPUTATION")),
-      ethers.utils.keccak256(ethers.utils.toUtf8Bytes("BRIDGE_CONTRACT")),
-      ethers.utils.keccak256(ethers.utils.toUtf8Bytes("UBISCHEME")),
-      ethers.utils.keccak256(ethers.utils.toUtf8Bytes("GDAO_STAKING")),
-      ethers.utils.keccak256(ethers.utils.toUtf8Bytes("GDAO_CLAIMERS"))
-    ],
-    [
-      release.GReputation,
-      release.HomeBridge || ethers.constants.AddressZero,
+  await upgrade
+    .upgrade(
+      release.NameService,
+      //old contracts
+      [
+        ethers.constants.AddressZero,
+        ethers.constants.AddressZero,
+        ethers.constants.AddressZero,
+        release.FirstClaimPool
+      ],
       release.UBIScheme,
-      release.GovernanceStaking,
-      release.ClaimersDistribution
-    ]
-  );
+      [
+        ethers.utils.keccak256(ethers.utils.toUtf8Bytes("REPUTATION")),
+        ethers.utils.keccak256(ethers.utils.toUtf8Bytes("BRIDGE_CONTRACT")),
+        ethers.utils.keccak256(ethers.utils.toUtf8Bytes("UBISCHEME")),
+        ethers.utils.keccak256(ethers.utils.toUtf8Bytes("GDAO_STAKING")),
+        ethers.utils.keccak256(ethers.utils.toUtf8Bytes("GDAO_CLAIMERS"))
+      ],
+      [
+        release.GReputation,
+        release.HomeBridge || ethers.constants.AddressZero,
+        release.UBIScheme,
+        release.GovernanceStaking,
+        release.ClaimersDistribution
+      ]
+    )
+    .then(printDeploy);
 
   console.log("upgrading governance...");
 
-  await upgrade.upgradeGovernance(
-    ethers.constants.AddressZero,
-    ethers.constants.AddressZero,
-    release.CompoundVotingMachine
-  );
+  await upgrade
+    .upgradeGovernance(
+      ethers.constants.AddressZero,
+      ethers.constants.AddressZero,
+      release.CompoundVotingMachine
+    )
+    .then(printDeploy);
 };
 
 const performUpgrade = async (release, ubiScheme) => {
@@ -524,10 +572,35 @@ const performUpgrade = async (release, ubiScheme) => {
   console.log("performing protocol v2 upgrade on Mainnet...", {
     release
   });
-  console.log("upgrading nameservice + staking rewards...");
+  console.log(
+    "upgrading nameservice + staking rewards...",
+    release.NameService,
+    [
+      ethers.utils.keccak256(ethers.utils.toUtf8Bytes("RESERVE")),
+      ethers.utils.keccak256(ethers.utils.toUtf8Bytes("MARKET_MAKER")),
+      ethers.utils.keccak256(ethers.utils.toUtf8Bytes("FUND_MANAGER")),
+      ethers.utils.keccak256(ethers.utils.toUtf8Bytes("REPUTATION")),
+      ethers.utils.keccak256(ethers.utils.toUtf8Bytes("GDAO_STAKERS")),
+      ethers.utils.keccak256(ethers.utils.toUtf8Bytes("BRIDGE_CONTRACT")),
+      ethers.utils.keccak256(ethers.utils.toUtf8Bytes("UBI_RECIPIENT")),
+      ethers.utils.keccak256(ethers.utils.toUtf8Bytes("EXCHANGE_HELPER"))
+    ],
+    [
+      release.GoodReserveCDai,
+      release.GoodMarketMaker,
+      release.GoodFundManager,
+      release.GReputation,
+      release.StakersDistribution,
+      release.ForeignBridge || ethers.constants.AddressZero,
+      ubiScheme,
+      release.ExchangeHelper
+    ],
+    release.StakingContracts.map((_: any) => _[0]),
+    release.StakingContracts.map((_: any) => _[1])
+  );
   let tx;
-  tx = await (
-    await upgrade.upgradeBasic(
+  tx = await upgrade
+    .upgradeBasic(
       release.NameService,
       [
         ethers.utils.keccak256(ethers.utils.toUtf8Bytes("RESERVE")),
@@ -552,7 +625,7 @@ const performUpgrade = async (release, ubiScheme) => {
       release.StakingContracts.map((_: any) => _[0]),
       release.StakingContracts.map((_: any) => _[1])
     )
-  ).wait();
+    .then(printDeploy);
 
   console.log("upgrading reserve...", {
     params: [
@@ -563,21 +636,25 @@ const performUpgrade = async (release, ubiScheme) => {
       release.COMP
     ]
   });
-  tx = await upgrade.upgradeReserve(
-    release.NameService,
-    ethers.constants.AddressZero,
-    ethers.constants.AddressZero,
-    ethers.constants.AddressZero,
-    release.COMP
-  );
+  tx = await upgrade
+    .upgradeReserve(
+      release.NameService,
+      ethers.constants.AddressZero,
+      ethers.constants.AddressZero,
+      ethers.constants.AddressZero,
+      release.COMP
+    )
+    .then(printDeploy);
 
   console.log("upgrading governance...");
 
-  tx = await upgrade.upgradeGovernance(
-    ethers.constants.AddressZero,
-    ethers.constants.AddressZero,
-    release.CompoundVotingMachine
-  );
+  tx = await upgrade
+    .upgradeGovernance(
+      ethers.constants.AddressZero,
+      ethers.constants.AddressZero,
+      release.CompoundVotingMachine
+    )
+    .then(printDeploy);
 };
 
 const main = async () => {

package/scripts/keeper/fishInactive.ts

@@ -0,0 +1,57 @@
+import { range, chunk } from "lodash";
+import { ethers as Ethers } from "hardhat";
+import fetch from "node-fetch";
+
+const ONE_DAY = 24 * 60 * 60;
+
+const main = async () => {
+  const signer = (await Ethers.getSigners())[0];
+  console.log("signer:", signer.address);
+  const ubiScheme = new Ethers.Contract(
+    "0xD7aC544F8A570C4d8764c3AAbCF6870CBD960D0D",
+    ["function fishMulti(address[] tofish)"]
+  ).connect(signer);
+  const twoWeeksAgo =
+    parseInt((Date.now() / 1000).toFixed(0)) - 24 * 60 * 60 * 14;
+
+  const daysAgo: number[] = range(0, 180, 1);
+  let curDay = twoWeeksAgo;
+  for (let day of daysAgo) {
+    const query = `
+      { 
+        walletStats(first:1000, where: { lastClaimed_lt: ${curDay},lastClaimed_gt: ${
+      curDay - 24 * 60 * 60
+    } isActiveUser: true }) {
+        id        
+      }
+    }
+  `;
+
+    console.log(
+      "fetching inactive users since:",
+      { curDay, day },
+      JSON.stringify({ query })
+    );
+    const { walletStats } = await fetch(
+      "https://api.thegraph.com/subgraphs/name/gooddollar/gooddollarfuse",
+      {
+        method: "post",
+        body: JSON.stringify({ query }),
+        headers: { "Content-Type": "application/json" }
+      }
+    ).then(_ => _.json());
+
+    console.log("got inactive wallets:", walletStats.length);
+    const accounts = walletStats.map(_ => _.id);
+    for (let tofish of chunk(accounts, 50)) {
+      const tx = await ubiScheme.fishMulti(tofish, { gasLimit: 2000000 });
+      console.log("fishing tx:", tx, tofish);
+      const res = await tx.wait();
+      console.log("fishing tx result:", res);
+    }
+
+    curDay = curDay - ONE_DAY;
+  }
+};
+
+main();