@gooddollar/goodprotocol 2.0.5-beta.0 → 2.0.5-beta.10

package/scripts/multichain-deploy/1_basicdao-deploy.ts

@@ -12,19 +12,13 @@ import DAOCreatorABI from "@gooddollar/goodcontracts/build/contracts/DaoCreatorG
 // import IdentityABI from "@gooddollar/goodcontracts/build/contracts/Identity.json";
 import FeeFormulaABI from "@gooddollar/goodcontracts/build/contracts/FeeFormula.json";
 
-import {
-  deployDeterministic,
-  deploySuperGoodDollar,
-  verifyProductionSigner
-} from "./helpers";
+import { deployDeterministic, deploySuperGoodDollar, verifyProductionSigner } from "./helpers";
 import releaser from "../releaser";
 import ProtocolSettings from "../../releases/deploy-settings.json";
 import dao from "../../releases/deployment.json";
 import { TransactionResponse } from "@ethersproject/providers";
 
-const printDeploy = async (
-  c: Contract | TransactionResponse
-): Promise<Contract | TransactionResponse> => {
+const printDeploy = async (c: Contract | TransactionResponse): Promise<Contract | TransactionResponse> => {
   if (c instanceof Contract) {
     await c.deployed();
     console.log("deployed to: ", c.address);
@@ -37,11 +31,7 @@ const printDeploy = async (
 };
 
 export const createDAO = async () => {
-  let protocolSettings = defaultsDeep(
-    {},
-    ProtocolSettings[network.name],
-    ProtocolSettings["default"]
-  );
+  let protocolSettings = defaultsDeep({}, ProtocolSettings[network.name], ProtocolSettings["default"]);
 
   let release: { [key: string]: any } = dao[network.name];
   const isProduction = network.name.includes("production");
@@ -54,34 +44,17 @@ export const createDAO = async () => {
     network,
     daoOwner,
     root: root.address,
-    balance: await ethers.provider
-      .getBalance(root.address)
-      .then(_ => _.toString()),
+    balance: await ethers.provider.getBalance(root.address).then(_ => _.toString()),
     release
   });
 
-  const DAOCreatorFactory = new ethers.ContractFactory(
-    DAOCreatorABI.abi,
-    DAOCreatorABI.bytecode,
-    root
-  );
+  const DAOCreatorFactory = new ethers.ContractFactory(DAOCreatorABI.abi, DAOCreatorABI.bytecode, root);
 
-  const FeeFormulaFactory = new ethers.ContractFactory(
-    FeeFormulaABI.abi,
-    FeeFormulaABI.bytecode,
-    root
-  );
+  const FeeFormulaFactory = new ethers.ContractFactory(FeeFormulaABI.abi, FeeFormulaABI.bytecode, root);
 
-  const proxyFactory = await ethers.getContractAt(
-    "ProxyFactory1967",
-    release.ProxyFactory
-  );
-  const salt = ethers.BigNumber.from(
-    ethers.utils.keccak256(ethers.utils.toUtf8Bytes("NameService"))
-  );
-  const nameserviceFutureAddress = await proxyFactory[
-    "getDeploymentAddress(uint256,address)"
-  ](salt, root.address);
+  const proxyFactory = await ethers.getContractAt("ProxyFactory1967", release.ProxyFactory);
+  const salt = ethers.BigNumber.from(ethers.utils.keccak256(ethers.utils.toUtf8Bytes("NameService")));
+  const nameserviceFutureAddress = await proxyFactory["getDeploymentAddress(uint256,address)"](salt, root.address);
   console.log("deploying identity", { nameserviceFutureAddress });
   const Identity = (await deployDeterministic(
     {
@@ -92,12 +65,11 @@ export const createDAO = async () => {
     [root.address, ethers.constants.AddressZero]
   ).then(printDeploy)) as Contract;
 
-  const daoCreator = await DAOCreatorFactory.deploy();
+  const daoCreator = (await DAOCreatorFactory.deploy().then(printDeploy)) as Contract;
 
-  const FeeFormula = (await deployDeterministic(
-    { name: "FeeFormula", factory: FeeFormulaFactory },
-    [0]
-  ).then(printDeploy)) as Contract;
+  const FeeFormula = (await deployDeterministic({ name: "FeeFormula", factory: FeeFormulaFactory }, [0]).then(
+    printDeploy
+  )) as Contract;
 
   let GoodDollar;
   if (protocolSettings.superfluidHost) {
@@ -115,8 +87,7 @@ export const createDAO = async () => {
       {
         name: "GoodDollar",
         isUpgradeable: true,
-        initializer:
-          "initialize(string, string, uint256, address, address, address,address)"
+        initializer: "initialize(string, string, uint256, address, address, address,address)"
       },
       [
         isProduction ? "GoodDollar" : "GoodDollar Dev",
@@ -148,16 +119,11 @@ export const createDAO = async () => {
   // await Identity.setAuthenticationPeriod(365).then(printDeploy);
 
   console.log("creating dao");
-  await daoCreator
-    .forgeOrg(GoodDollar.address, GReputation.address, [], 0, [])
-    .then(printDeploy);
+  await daoCreator.forgeOrg(GoodDollar.address, GReputation.address, [], 0, []).then(printDeploy);
   console.log("forgeOrg done ");
   const Avatar = new ethers.Contract(
     await daoCreator.avatar(),
-    [
-      "function owner() view returns (address)",
-      "function nativeToken() view returns (address)"
-    ],
+    ["function owner() view returns (address)", "function nativeToken() view returns (address)"],
     root
   );
 
@@ -181,16 +147,13 @@ export const createDAO = async () => {
     )
     .then(printDeploy);
 
-  const NameService = await deployDeterministic(
-    { name: "NameService", isUpgradeable: true },
-    [
-      controller,
-      ["CONTROLLER", "AVATAR", "IDENTITY", "GOODDOLLAR", "REPUTATION"].map(_ =>
-        ethers.utils.keccak256(ethers.utils.toUtf8Bytes(_))
-      ),
-      [controller, Avatar.address, Identity.address, gd, GReputation.address]
-    ]
-  );
+  const NameService = await deployDeterministic({ name: "NameService", isUpgradeable: true }, [
+    controller,
+    ["CONTROLLER", "AVATAR", "IDENTITY", "GOODDOLLAR", "REPUTATION"].map(_ =>
+      ethers.utils.keccak256(ethers.utils.toUtf8Bytes(_))
+    ),
+    [controller, Avatar.address, Identity.address, gd, GReputation.address]
+  ]);
 
   console.log("set GRep nameservice..");
   await (await GReputation.updateDAO(NameService.address)).wait();
@@ -206,54 +169,31 @@ export const createDAO = async () => {
     await GoodDollar.renounceMinter().then(printDeploy);
   }
 
-  const daoOwnerDaoPermissions = await Controller.getSchemePermissions(
-    daoOwner,
-    Avatar.address
-  );
+  const daoOwnerDaoPermissions = await Controller.getSchemePermissions(daoOwner, Avatar.address);
 
-  const deployerIsNotGDMinter =
-    (await GoodDollar.isMinter(root.address)) === false;
+  const deployerIsNotGDMinter = (await GoodDollar.isMinter(root.address)) === false;
 
   const avatarIsGDMinter = await GoodDollar.isMinter(Avatar.address);
 
-  const deployerIsNotGDPauser =
-    (await GoodDollar.isPauser(root.address)) === false;
+  const deployerIsNotGDPauser = (await GoodDollar.isPauser(root.address)) === false;
 
-  const deployerIsNotRepMinter =
-    (await GReputation.hasRole(GReputation.MINTER_ROLE(), root.address)) ===
-    false;
-  const avatarIsRepMinter = await GReputation.hasRole(
-    GReputation.MINTER_ROLE(),
-    Avatar.address
-  );
+  const deployerIsNotRepMinter = (await GReputation.hasRole(GReputation.MINTER_ROLE(), root.address)) === false;
+  const avatarIsRepMinter = await GReputation.hasRole(GReputation.MINTER_ROLE(), Avatar.address);
 
-  const deployerIsIdentityOwner = await Identity.hasRole(
-    ethers.constants.HashZero,
-    root.address
-  );
+  const deployerIsIdentityOwner = await Identity.hasRole(ethers.constants.HashZero, root.address);
 
-  const avatarIsIdentityOwner = await Identity.hasRole(
-    ethers.constants.HashZero,
-    Avatar.address
-  );
+  const avatarIsIdentityOwner = await Identity.hasRole(ethers.constants.HashZero, Avatar.address);
 
   //try to modify DAO -> should not succeed
   await (await GReputation.updateDAO(ethers.constants.AddressZero)).wait();
 
-  const grepHasDAOSet =
-    (await GReputation.nameService()) === NameService.address;
+  const grepHasDAOSet = (await GReputation.nameService()) === NameService.address;
 
-  const factoryIsNotGoodOwner =
-    (await GReputation.hasRole(
-      ethers.constants.HashZero,
-      proxyFactory.address
-    )) === false;
+  const factoryIsNotGoodOwner = (await GReputation.hasRole(ethers.constants.HashZero, proxyFactory.address)) === false;
 
-  const factoryIsNotGDMinter =
-    (await GoodDollar.isMinter(proxyFactory.address)) === false;
+  const factoryIsNotGDMinter = (await GoodDollar.isMinter(proxyFactory.address)) === false;
 
-  const factoryIsNotGDPauser =
-    (await GoodDollar.isPauser(root.address)) === false;
+  const factoryIsNotGDPauser = (await GoodDollar.isPauser(root.address)) === false;
 
   console.log({
     daoOwnerDaoPermissions,

package/scripts/multichain-deploy/2b_otp-deploy.ts

@@ -49,8 +49,8 @@ export const deployHelpers = async () => {
   console.log("deploying onetime payments", { gasprice: protocolSettings.gasPrice });
   const OTP = (await deployDeterministic(
     {
-      name: "OneTimePayments",
-      salt: "OneTimePayments",
+      name: "OneTimePaymentsV2",
+      salt: "OneTimePaymentsV2",
       isUpgradeable: false
     },
     [release.NameService]
@@ -59,12 +59,12 @@ export const deployHelpers = async () => {
   // const OTP = await ethers.getContractAt("OneTimePayments", release.OneTimePayments);
 
   const torelease = {
-    OneTimePayments: OTP.address
+    OneTimePaymentsV2: OTP.address
   };
   await releaser(torelease, network.name, "deployment", false);
 
   const constructorArgs = ethers.utils.defaultAbiCoder.encode(["address"], [release.NameService]);
-  await verifyContract(OTP.address, "OneTimePayments", network.name, undefined, constructorArgs);
+  await verifyContract(OTP.address, "OneTimePaymentsV2", network.name, undefined, constructorArgs);
 };
 
 export const main = async () => {

package/scripts/multichain-deploy/helpers.ts

@@ -65,11 +65,11 @@ export const deploySuperGoodDollar = async (superfluidHost, tokenArgs) => {
     []
   ).then(printDeploy)) as Contract;
 
-  await GoodDollarProxy.initializeProxy(SuperGoodDollar.address);
+  await GoodDollarProxy.initializeProxy(SuperGoodDollar.address).then(printDeploy);
 
-  await SuperGoodDollar.attach(GoodDollarProxy.address)[
-    "initialize(string,string,uint256,address,address,address,address)"
-  ](...tokenArgs);
+  await SuperGoodDollar.attach(GoodDollarProxy.address)
+    ["initialize(string,string,uint256,address,address,address,address)"](...tokenArgs)
+    .then(printDeploy);
 
   const GoodDollar = await ethers.getContractAt("ISuperGoodDollar", GoodDollarProxy.address);
   return GoodDollar;
@@ -143,6 +143,7 @@ export const executeViaGuardian = async (
   let release: { [key: string]: any } = dao[network || networkName];
   const ctrl = await (await ethers.getContractAt("Controller", release.Controller)).connect(guardian);
 
+  const results = [];
   for (let i = 0; i < contracts.length; i++) {
     const contract = contracts[i];
     console.log("executing:", contracts[i], functionSigs[i], functionInputs[i]);
@@ -151,10 +152,15 @@ export const executeViaGuardian = async (
     if (contract === ctrl.address) {
       console.log("executing directly on controller:", sigHash, encoded);
 
-      await guardian.sendTransaction({ to: contract, data: encoded }).then(printDeploy);
+      const tx = await guardian
+        .sendTransaction({ to: contract, data: encoded })
+        .then(printDeploy)
+        .then(_ => _.wait());
+      results.push(tx);
     } else {
       const simulationResult = await ctrl.callStatic.genericCall(contract, encoded, release.Avatar, ethValues[i], {
-        from: await guardian.getAddress()
+        from: await guardian.getAddress(),
+        value: ethValues[i]
       });
       console.log("executing genericCall:", {
         sigHash,
@@ -162,9 +168,15 @@ export const executeViaGuardian = async (
         simulationResult
       });
       if (simulationResult[0] === false) throw new Error("simulation failed:" + contract);
-      await ctrl.genericCall(contract, encoded, release.Avatar, ethValues[i]).then(printDeploy);
+      const tx = await ctrl
+        .genericCall(contract, encoded, release.Avatar, ethValues[i])
+        .then(printDeploy)
+        .then(_ => _.wait());
+      // console.log("generic call events:", tx.events);
+      results.push(tx);
     }
   }
+  return results;
 };
 
 export const executeViaSafe = async (
@@ -200,7 +212,7 @@ export const executeViaSafe = async (
     safeSigner = safeSignerOrNetwork as any;
   }
   const chainId = await safeSigner.getChainId();
-  console.log("safeSigner:", safeSigner.address, { chainId });
+  console.log("safeSigner:", safeSigner.address, { chainId, safeAddress });
   let txServiceUrl;
   switch (chainId) {
     case 1:
@@ -240,7 +252,7 @@ export const executeViaSafe = async (
     const encoded = ethers.utils.solidityPack(["bytes4", "bytes"], [sigHash, functionInputs[i]]);
     if (contract === ctrl.address) {
       const simulationResult =
-        isSimulation === false &&
+        isSimulation === true &&
         (await ctrl.callStatic[functionSigs[i]](...functionInputs[i], {
           from: safeAddress,
           value: ethValues[i]
@@ -265,15 +277,16 @@ export const executeViaSafe = async (
       });
 
       const simulationResult =
-        isSimulation === false &&
+        isSimulation === true &&
         (await ctrl.callStatic.genericCall(contract, encoded, release.Avatar, ethValues[i], {
-          from: safeAddress
+          from: safeAddress,
+          value: ethValues[i]
         }));
       console.log("executing genericCall simulation result:", {
         sigHash,
         simulationResult
       });
-      if (isSimulation === false && simulationResult[0] === false) throw new Error("simulation failed:" + contract);
+      if (isSimulation === true && simulationResult[0] === false) throw new Error("simulation failed:" + contract);
       const genericEncode = ctrl.interface.encodeFunctionData("genericCall", [
         contract,
         encoded,

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

@@ -0,0 +1,251 @@
+/**
+ * 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;
+const isForkSimulation = networkName === "localhost";
+
+export const step1 = async () => {
+  const isProduction = networkName.includes("production");
+  let [root, ...signers] = await ethers.getSigners();
+
+  let networkEnv = networkName.split("-")[0];
+  if (isForkSimulation) networkEnv = "production";
+  const fuseNetwork = networkEnv;
+
+  if (networkEnv === "fuse") networkEnv = "development";
+  const celoNetwork = networkEnv + "-celo";
+  const mainnetNetwork = `${networkName === "localhost" ? "production" : networkName.split("-")[0]}-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();
+
+  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,
+      dao[fuseNetwork].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":
+      isForkSimulation && (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":
+      isForkSimulation && (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