@gooddollar/goodprotocol 2.0.5-beta.4 → 2.0.5-beta.6

package/scripts/proposals/gip-14_1.ts

@@ -0,0 +1,255 @@
+/**
+ * increase rate of UBI distribution on Celo
+ * also includes old foundation funds transfers from firstclaimpool and avatar towards initial topping of the UBI pool for the launch campaign
+ */
+
+import { ethers, network } from "hardhat";
+import { defaultsDeep } from "lodash";
+import prompt from "prompt";
+import { reset } from "@nomicfoundation/hardhat-network-helpers";
+
+import { executeViaGuardian, executeViaSafe, verifyProductionSigner } from "../multichain-deploy/helpers";
+
+import ProtocolSettings from "../../releases/deploy-settings.json";
+
+import dao from "../../releases/deployment.json";
+
+const { name: networkName } = network;
+
+export const step1 = async () => {
+  const isProduction = networkName.includes("production");
+  let [root, ...signers] = await ethers.getSigners();
+
+  if (isProduction) verifyProductionSigner(root);
+
+  let networkEnv = networkName.split("-")[0];
+  const isForkSimulation = networkName === "localhost";
+  if (isForkSimulation) networkEnv = "production";
+  const fuseNetwork = networkEnv;
+
+  if (networkEnv === "fuse") networkEnv = "development";
+  const celoNetwork = networkEnv + "-celo";
+  const mainnetNetwork = `${networkName === "localhost" ? "production" : networkName}-mainnet`; //simulate production on localhost requires running hardhat node in fork mode
+
+  let protocolSettings = defaultsDeep({}, ProtocolSettings[networkName], ProtocolSettings["default"]);
+
+  if (isForkSimulation)
+    // fund safe with eth so we can simulate TXs
+    await root.sendTransaction({ to: dao[mainnetNetwork].GuardiansSafe, value: ethers.constants.WeiPerEther });
+
+  console.log("got signers:", {
+    networkName,
+    root: root.address,
+    balance: await ethers.provider.getBalance(root.address).then(_ => _.toString()),
+    mainnetNetwork,
+    fuseNetwork,
+    celoNetwork
+  });
+
+  const proposalContracts = [
+    dao[mainnetNetwork].GoodReserveCDai, // update the nonubi bps to 55%. 10% community fund + 45% celo ubi
+    dao[mainnetNetwork].DistributionHelper, //set community fund to 0.1818 so it gets 10% from 55%
+    dao[mainnetNetwork].DistributionHelper //set celo ubi to 0.8182 so it gets 45% from 55%
+  ];
+
+  const proposalEthValues = proposalContracts.map(_ => 0);
+
+  const proposalFunctionSignatures = [
+    "setDistributionHelper(address,uint32)",
+    "addOrUpdateRecipient((uint32,uint32,address,uint8))",
+    "addOrUpdateRecipient((uint32,uint32,address,uint8))"
+  ];
+
+  const proposalFunctionInputs = [
+    ethers.utils.defaultAbiCoder.encode(["address", "uint32"], [dao[mainnetNetwork].DistributionHelper, 5500]),
+    ethers.utils.defaultAbiCoder.encode(
+      ["uint32", "uint32", "address", "uint8"],
+      [8182, 42220, dao[celoNetwork].UBIScheme, 1]
+    ),
+    ethers.utils.defaultAbiCoder.encode(
+      ["uint32", "uint32", "address", "uint8"],
+      [1818, 122, dao[fuseNetwork].CommunitySafe, 0] //community safe on fuse
+    )
+  ];
+
+  if (isProduction) {
+    await executeViaSafe(
+      proposalContracts,
+      proposalEthValues,
+      proposalFunctionSignatures,
+      proposalFunctionInputs,
+      protocolSettings.guardiansSafe,
+      "mainnet"
+    );
+  } else {
+    await executeViaGuardian(
+      proposalContracts,
+      proposalEthValues,
+      proposalFunctionSignatures,
+      proposalFunctionInputs,
+      isForkSimulation ? await ethers.getImpersonatedSigner(dao[mainnetNetwork].GuardiansSafe) : root,
+      mainnetNetwork
+    );
+  }
+
+  if (isForkSimulation) {
+    const reserve = await ethers.getContractAt("GoodReserveCDai", dao[mainnetNetwork].GoodReserveCDai);
+    //verify balance of avatar is 0
+    const events = await reserve.queryFilter(reserve.filters.DistributionHelperSet(), -10);
+    console.log({ events });
+    console.assert(events[0].args?.bps === 5500, "wrong bps");
+    const helper = await ethers.getContractAt("DistributionHelper", dao[mainnetNetwork].DistributionHelper);
+    const helperEvents = await helper.queryFilter(helper.filters.RecipientUpdated(), -10);
+    console.log(
+      "helperEvents",
+      helperEvents.map(_ => _.args)
+    );
+
+    //verify multichain bridge did burn
+    console.assert(
+      helperEvents.find(
+        _ =>
+          _.args?.recipient[0] === 1818 &&
+          _.args?.recipient[2] == dao[fuseNetwork].CommunitySafe &&
+          _.args?.recipient[1] === 122 &&
+          _.args?.recipient[3] === 0
+      ),
+      "wrong community pool bps"
+    );
+    console.assert(
+      helperEvents.find(
+        _ =>
+          _.args?.recipient[0] === 8182 &&
+          _.args?.recipient[2] == dao[celoNetwork].UBIScheme &&
+          _.args?.recipient[1] === 42220 &&
+          _.args?.recipient[3] === 1
+      ),
+      "wrong celo ubi pool bps"
+    );
+  }
+};
+
+export const step2 = async () => {
+  const isProduction = networkName.includes("production");
+  let [root, ...signers] = await ethers.getSigners();
+
+  if (isProduction) verifyProductionSigner(root);
+
+  let networkEnv = networkName.split("-")[0];
+  const isForkSimulation = networkName === "localhost";
+  if (isForkSimulation) networkEnv = "production";
+  const fuseNetwork = networkEnv;
+
+  if (networkEnv === "fuse") networkEnv = "development";
+  const celoNetwork = networkEnv + "-celo";
+  const mainnetNetwork = `${networkName === "localhost" ? "production" : networkName}-mainnet`; //simulate production on localhost requires running hardhat node in fork mode
+
+  let protocolSettings = defaultsDeep({}, ProtocolSettings[networkName], ProtocolSettings["default"]);
+
+  if (isForkSimulation)
+    // fund safe with eth so we can simulate TXs
+    await root.sendTransaction({ to: dao[fuseNetwork].GuardiansSafe, value: ethers.constants.WeiPerEther });
+
+  console.log("got signers:", {
+    networkName,
+    root: root.address,
+    balance: await ethers.provider.getBalance(root.address).then(_ => _.toString()),
+    mainnetNetwork,
+    fuseNetwork,
+    celoNetwork
+  });
+
+  const fuseProposalContracts = [
+    dao[fuseNetwork].FirstClaimPool, // end the pool to get locked funds
+    dao[fuseNetwork].GoodDollar, //approve multichain wrapper
+    dao[fuseNetwork].MultichainRouter //anyswapout
+  ];
+
+  const fuseProposalEthValues = fuseProposalContracts.map(_ => 0);
+
+  const fuseProposalFunctionSignatures = [
+    "end()",
+    // "transferAndCall(address,uint256,bytes)"//transferAndcall not working in simulation. using aprrove+anyswapout
+    "approve(address,uint256)",
+    "anySwapOut(address,address,uint256,uint256)"
+  ];
+
+  const gd = await ethers.getContractAt("GoodDollar", dao[fuseNetwork].GoodDollar);
+  const aBalance = await gd.balanceOf(dao[fuseNetwork].Avatar);
+  const bBalance = await gd.balanceOf(dao[fuseNetwork].FirstClaimPool);
+
+  console.log("balances to bridge:", aBalance.toString(), bBalance.toString());
+  const fuseProposalFunctionInputs = [
+    ethers.utils.defaultAbiCoder.encode([], []),
+    ethers.utils.defaultAbiCoder.encode(
+      ["address", "uint256"],
+      [dao[fuseNetwork].GoodDollarMintBurnWrapper, aBalance.add(bBalance)]
+    ),
+    ethers.utils.defaultAbiCoder.encode(
+      ["address", "address", "uint256", "uint256"],
+      [dao[fuseNetwork].GoodDollarMintBurnWrapper, dao[celoNetwork].UBIScheme, aBalance.add(bBalance), 42220]
+    )
+
+    //transferAndCall isnt working in simualation for some reason
+    // ethers.utils.defaultAbiCoder.encode(
+    //   ["address", "uint256", "bytes"],
+    //   [
+    //     dao[fuseNetwork].GoodDollarMintBurnWrapper,
+    //     aBalance.add(bBalance),
+    //     ethers.utils.defaultAbiCoder.encode(["address", "uint256"], [dao[celoNetwork].UBIScheme, 42220])
+    //   ] //target ubipool on celo for multichain bridge
+    // )
+  ];
+
+  const totalSupplyBefore = await gd.totalSupply();
+  if (isProduction) {
+    await executeViaSafe(
+      fuseProposalContracts,
+      fuseProposalEthValues,
+      fuseProposalFunctionSignatures,
+      fuseProposalFunctionInputs,
+      protocolSettings.guardiansSafe,
+      "fuse"
+    );
+  } else {
+    await executeViaGuardian(
+      fuseProposalContracts,
+      fuseProposalEthValues,
+      fuseProposalFunctionSignatures,
+      fuseProposalFunctionInputs,
+      isForkSimulation ? await ethers.getImpersonatedSigner(dao[fuseNetwork].GuardiansSafe) : root,
+      fuseNetwork
+    );
+  }
+
+  if (isForkSimulation) {
+    //verify balance of avatar is 0
+    console.assert((await gd.balanceOf(dao[fuseNetwork].Avatar)).eq(0), await gd.balanceOf(dao[fuseNetwork].Avatar));
+    //verify multichain bridge did burn
+    console.assert((await gd.totalSupply()).lt(totalSupplyBefore), "bridge didnt burn G$s");
+  }
+};
+
+export const main = async () => {
+  prompt.start();
+  const { stepNumber } = await prompt.get(["stepNumber"]);
+
+  console.log("running step:", { stepNumber });
+  switch (stepNumber) {
+    case "1":
+      await reset("https://cloudflare-eth.com");
+      await step1();
+      break;
+
+    //to simulate run first
+    //npx hardhat node --fork https://rpc.fuse.io
+    //then run npx hardhat run scripts/proposals/gip-14_1.ts --network localhost
+    case "2":
+      await reset("https://rpc.fuse.io");
+      await step2();
+      break;
+  }
+  // await upgrade().catch(console.log);
+};
+
+main();

package/scripts/proposals/gips-14_1.md

@@ -0,0 +1,29 @@
+## Mainnet on-chain proposal
+
+- On mainnet we send 10% to community pool and 50% of the remaining 90% (ie 45%) to the Celo UBI Pool, so in total its 55% we distribute via the distribution helper.
+- 10% of the 55% is 0.1818 or 1818 in bps
+- 45% of the 55% is 0.8182 or 8182 in bps
+
+| contract                                                       | method                                                          | arguments                                                                                                        |
+| -------------------------------------------------------------- | --------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------- |
+| Reserve: 0xa150a825d425B36329D8294eeF8bD0fE68f8F6E0            | setDistributionHelper(DistributionHelper \_helper, uin32 \_bps) | (DistributionHelper:"0xAcadA0C9795fdBb6921AE96c4D7Db2F8B8c52Fd0",5500)                                           |
+| DistributionHelper: 0xAcadA0C9795fdBb6921AE96c4D7Db2F8B8c52Fd0 | addOrUpdateRecipient(DistributionRecipient memory \_recipient)  | {bps: 8182, chainId: 42220, addr: CeloUBIScheme:'0x43d72Ff17701B2DA814620735C39C620Ce0ea4A1', transferType: 1}   |
+| DistributionHelper: 0xAcadA0C9795fdBb6921AE96c4D7Db2F8B8c52Fd0 | addOrUpdateRecipient(DistributionRecipient memory \_recipient)  | {bps: 1818, chainId: 122, addr: FuseCommunitySafe:'0x5Eb5f5fE13d1D5e6440DbD5913412299Bc5B5564', transferType: 0} |
+
+## Fuse on-chain proposal
+
+- On fuse we collect funds from FirstClaimPool and then transfer these funds + older funds in Avatar (also from older FirstClaimPool/Invite contracts funded by GoodLabs) to the UBI Pool on Celo via the multichain bridge
+
+| contract                                                     | method                                                                         | arguments                                                                                                                                                       |
+| ------------------------------------------------------------ | ------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| FirstClaimPool: 0x18BcdF79A724648bF34eb06701be81bD072A2384   | end()                                                                          |                                                                                                                                                                 |
+| GoodDollar: 0x495d133B938596C9984d462F007B676bDc57eCEC       | approve(address spender,uint256 amount)                                        | (GoodDollarMintBurnWrapper:"0x031b2B7C7854dd8EE9C4A644D7e54aD17F56e3cB",128069283 + 463420500)                                                                  |
+| MultichainRouter: 0xAcadA0C9795fdBb6921AE96c4D7Db2F8B8c52Fd0 | function anySwapOut(address token,address to,uint256 amount,uint256 toChainID) | (GoodDollarMintBurnWrapper:"0x031b2B7C7854dd8EE9C4A644D7e54aD17F56e3cB",CeloUBIScheme:"0x43d72Ff17701B2DA814620735C39C620Ce0ea4A1",128069283 + 463420500,42220) |
+
+## To Test/Simulate on a forked chain
+
+- `npx hardhat node --fork https://rpc.fuse.io &`
+- `npx hardhat run scripts/proposals/gip-14_1.ts --network localhost`
+- Choose step:
+  1: run mainnet proposal
+  2: run fuse proposal

package/types/IFirstClaimPool.ts

@@ -28,6 +28,7 @@ export interface IFirstClaimPoolInterface extends ethers.utils.Interface {
   functions: {
     "awardUser(address)": FunctionFragment;
     "claimAmount()": FunctionFragment;
+    "end()": FunctionFragment;
   };
 
   encodeFunctionData(functionFragment: "awardUser", values: [string]): string;
@@ -35,12 +36,14 @@ export interface IFirstClaimPoolInterface extends ethers.utils.Interface {
     functionFragment: "claimAmount",
     values?: undefined
   ): string;
+  encodeFunctionData(functionFragment: "end", values?: undefined): string;
 
   decodeFunctionResult(functionFragment: "awardUser", data: BytesLike): Result;
   decodeFunctionResult(
     functionFragment: "claimAmount",
     data: BytesLike
   ): Result;
+  decodeFunctionResult(functionFragment: "end", data: BytesLike): Result;
 
   events: {};
 }
@@ -78,6 +81,10 @@ export interface IFirstClaimPool extends BaseContract {
     ): Promise<ContractTransaction>;
 
     claimAmount(overrides?: CallOverrides): Promise<[BigNumber]>;
+
+    end(
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
   };
 
   awardUser(
@@ -87,10 +94,16 @@ export interface IFirstClaimPool extends BaseContract {
 
   claimAmount(overrides?: CallOverrides): Promise<BigNumber>;
 
+  end(
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
   callStatic: {
     awardUser(user: string, overrides?: CallOverrides): Promise<BigNumber>;
 
     claimAmount(overrides?: CallOverrides): Promise<BigNumber>;
+
+    end(overrides?: CallOverrides): Promise<void>;
   };
 
   filters: {};
@@ -102,6 +115,10 @@ export interface IFirstClaimPool extends BaseContract {
     ): Promise<BigNumber>;
 
     claimAmount(overrides?: CallOverrides): Promise<BigNumber>;
+
+    end(
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
   };
 
   populateTransaction: {
@@ -111,5 +128,9 @@ export interface IFirstClaimPool extends BaseContract {
     ): Promise<PopulatedTransaction>;
 
     claimAmount(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    end(
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
   };
 }

package/types/InvitesFuseV2.ts

@@ -44,6 +44,7 @@ export interface InvitesFuseV2Interface extends ethers.utils.Interface {
     "levels(uint256)": FunctionFragment;
     "owner()": FunctionFragment;
     "setActive(bool)": FunctionFragment;
+    "setIdentity(address)": FunctionFragment;
     "setLevel(uint256,uint256,uint256,uint256)": FunctionFragment;
     "setLevelExpirationEnabled(bool)": FunctionFragment;
     "stats()": FunctionFragment;
@@ -99,6 +100,7 @@ export interface InvitesFuseV2Interface extends ethers.utils.Interface {
   ): string;
   encodeFunctionData(functionFragment: "owner", values?: undefined): string;
   encodeFunctionData(functionFragment: "setActive", values: [boolean]): string;
+  encodeFunctionData(functionFragment: "setIdentity", values: [string]): string;
   encodeFunctionData(
     functionFragment: "setLevel",
     values: [BigNumberish, BigNumberish, BigNumberish, BigNumberish]
@@ -147,6 +149,10 @@ export interface InvitesFuseV2Interface extends ethers.utils.Interface {
   decodeFunctionResult(functionFragment: "levels", data: BytesLike): Result;
   decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
   decodeFunctionResult(functionFragment: "setActive", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "setIdentity",
+    data: BytesLike
+  ): Result;
   decodeFunctionResult(functionFragment: "setLevel", data: BytesLike): Result;
   decodeFunctionResult(
     functionFragment: "setLevelExpirationEnabled",
@@ -295,6 +301,11 @@ export interface InvitesFuseV2 extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<ContractTransaction>;
 
+    setIdentity(
+      _identity: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<ContractTransaction>;
+
     setLevel(
       _lvl: BigNumberish,
       _toNext: BigNumberish,
@@ -420,6 +431,11 @@ export interface InvitesFuseV2 extends BaseContract {
     overrides?: Overrides & { from?: string | Promise<string> }
   ): Promise<ContractTransaction>;
 
+  setIdentity(
+    _identity: string,
+    overrides?: Overrides & { from?: string | Promise<string> }
+  ): Promise<ContractTransaction>;
+
   setLevel(
     _lvl: BigNumberish,
     _toNext: BigNumberish,
@@ -535,6 +551,8 @@ export interface InvitesFuseV2 extends BaseContract {
 
     setActive(_active: boolean, overrides?: CallOverrides): Promise<void>;
 
+    setIdentity(_identity: string, overrides?: CallOverrides): Promise<void>;
+
     setLevel(
       _lvl: BigNumberish,
       _toNext: BigNumberish,
@@ -684,6 +702,11 @@ export interface InvitesFuseV2 extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<BigNumber>;
 
+    setIdentity(
+      _identity: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<BigNumber>;
+
     setLevel(
       _lvl: BigNumberish,
       _toNext: BigNumberish,
@@ -781,6 +804,11 @@ export interface InvitesFuseV2 extends BaseContract {
       overrides?: Overrides & { from?: string | Promise<string> }
     ): Promise<PopulatedTransaction>;
 
+    setIdentity(
+      _identity: string,
+      overrides?: Overrides & { from?: string | Promise<string> }
+    ): Promise<PopulatedTransaction>;
+
     setLevel(
       _lvl: BigNumberish,
       _toNext: BigNumberish,