@gooddollar/goodprotocol 2.0.3-beta.0 → 2.0.4

package/scripts/upgradeToV3/v3-fuse-multichain.ts

@@ -0,0 +1,117 @@
+/***
+ * This script will deploy a reserve upgrade and the DistributionHelper so that some of the expansion can be allocated
+ * for non-ubi purposes
+ * Upgrade process:
+ * mainnet:
+ * - deploy reserve
+ * - deploy distributionHelper
+ * - create proposal that:
+ *  - upgrades the reserve
+ *  - sets the distributionHelper at reserve with the agreed bps
+ *  - add to the distributionHelper the contracts addresses to receive part of the UBI
+ */
+
+import { network, ethers } from "hardhat";
+import { defaultsDeep } from "lodash";
+import {
+  deployDeterministic,
+  printDeploy,
+  executeViaGuardian,
+  executeViaSafe,
+  verifyProductionSigner
+} from "../multichain-deploy/helpers";
+import { deployWrapper } from "../multichain-deploy/multichainWrapper-deploy";
+
+import releaser from "../releaser";
+import ProtocolSettings from "../../releases/deploy-settings.json";
+import dao from "../../releases/deployment.json";
+import { BigNumber } from "ethers";
+const { name: networkName } = network;
+
+export const deployFuse = async () => {
+  const isProduction = networkName.includes("production");
+  let [root, ...signers] = await ethers.getSigners();
+
+  if (isProduction) verifyProductionSigner(root);
+
+  let executionMethod = "safe";
+
+  const networkKey = networkName === "localhost" ? "production-mainnet" : networkName;
+  let release: { [key: string]: any } = dao[networkKey];
+  let settings = defaultsDeep({}, ProtocolSettings[networkName], ProtocolSettings["default"]);
+
+  console.log("got signers:", {
+    networkName,
+    networkKey,
+    root: root.address,
+    balance: await ethers.provider.getBalance(root.address).then(_ => _.toString())
+  });
+
+  const Wrapper = await deployWrapper();
+  // const Wrapper = await ethers.getContractAt("GoodDollarMintBurnWrapper", release.GoodDollarMintBurnWrapper);
+
+  const proposalContracts = [
+    release.NameService, //nameservice add Wrapper,MultiChainRouter
+    release.GoodDollar, // give mint rights to Wrapper
+    Wrapper.address //add multichainrouter as minter
+  ];
+
+  const proposalEthValues = proposalContracts.map(_ => 0);
+
+  const proposalFunctionSignatures = [
+    "setAddresses(bytes32[],address[])",
+    "addMinter(address)",
+    "addMinter(address,uint256,uint256,uint32,uint256,uint256,uint32,bool)"
+  ];
+
+  const proposalFunctionInputs = [
+    ethers.utils.defaultAbiCoder.encode(
+      ["bytes32[]", "address[]"],
+      [
+        [
+          ethers.utils.keccak256(ethers.utils.toUtf8Bytes("MINTBURN_WRAPPER")),
+          ethers.utils.keccak256(ethers.utils.toUtf8Bytes("MULTICHAIN_ROUTER"))
+        ],
+        [Wrapper.address, release.MultichainRouter]
+      ]
+    ), //setAddresses(bytes32[],address[])"
+    ethers.utils.defaultAbiCoder.encode(["address"], [Wrapper.address]), //addMinter(address)
+    ethers.utils.defaultAbiCoder.encode(
+      ["address", "uint256", "uint256", "uint32", "uint256", "uint256", "uint32", "bool"],
+      [
+        release.MultichainRouter,
+        0,
+        0,
+        0,
+        0,
+        300 * 1e6 * 100, //300M G$ 2 decimals
+        1000, //10%
+        false
+      ]
+    ) //addMinter(address,uint256,uint256,uint32,uint256,uint256,uint32,bool)
+  ];
+
+  if (executionMethod === "safe") {
+    return executeViaSafe(
+      proposalContracts,
+      proposalEthValues,
+      proposalFunctionSignatures,
+      proposalFunctionInputs,
+      networkName === "localhost" ? "0xE0c5daa7CC6F88d29505f702a53bb5E67600e7Ec" : release.GuardiansSafe,
+      "fuse"
+    );
+  } else {
+    return executeViaGuardian(
+      proposalContracts,
+      proposalEthValues,
+      proposalFunctionSignatures,
+      proposalFunctionInputs,
+      root
+    );
+  }
+};
+
+export const main = async () => {
+  await deployFuse().catch(console.log);
+};
+if (process.argv[1].includes("v3-fuse-multichain")) main();

package/scripts/upgrades/celo-defi-ubi-deploy.ts

@@ -7,7 +7,7 @@
  * - add 1000 celo to adminwallet and faucet
  * - monitor adminwallet + faucet on defender
  *
- * Step 3:
+ * Step 3: (once guardians sign Identity upgrade)
  * - upgrade AdminWallet+Invites+Faucet on Fuse to support whitelisting chainid
  * - upgrade backend server to support whitelisting with chainid
  *
@@ -57,14 +57,20 @@ const step3 = async () => {
 
   const adminimpl = await (await ethers.getContractFactory("AdminWalletFuse")).deploy();
   const curadmin = adminimpl.attach(release.AdminWallet);
-  const upgradetx = await (await curadmin.upgradeTo(adminimpl.address)).wait();
+  console.log("deployed admin impl", adminimpl.address);
+  const encodedAdmin = adminimpl.interface.encodeFunctionData("upgrade", [release.NameService]);
+  const upgradetx = await (await curadmin.upgradeToAndCall(adminimpl.address, encodedAdmin)).wait();
   const impl = adminimpl.address;
   console.log("AdminWallet upgraded", { impl, txhash: upgradetx.transactionHash });
   await verifyContract(impl, "AdminWalletFuse", networkName);
 
   const faucetimpl = await (await ethers.getContractFactory("FuseFaucetV2")).deploy();
   const proxyAdmin = await ethers.getContractAt("ProxyAdmin", release.ProxyAdmin);
-  const encoded = faucetimpl.interface.encodeFunctionData("upgrade", [release.AdminWallet, root.address]);
+  const encoded = faucetimpl.interface.encodeFunctionData("upgrade", [
+    release.AdminWallet,
+    root.address,
+    release.NameService
+  ]);
   const faucettx = await (await proxyAdmin.upgradeAndCall(release.FuseFaucet, faucetimpl.address, encoded)).wait();
   console.log("Faucet upgraded", faucettx.transactionHash);
   await verifyContract(faucetimpl.address, "FuseFaucetV2", networkName);

package/scripts/upgrades/identity-upgrade.ts

@@ -43,63 +43,71 @@ export const upgrade = async () => {
   console.log("got signers:", {
     networkName,
     root: root.address,
-    balance: await ethers.provider.getBalance(root.address).then(_ => _.toString())
+    balance: await ethers.provider.getBalance(root.address).then(_ => _.toString()),
+    Identity: release.Identity
   });
 
-  let OldIdentity = await ethers.getContractAt(OldIdentityABI.abi, release.OldIdentity || release.Identity);
+  let OldIdentity = await ethers.getContractAt(OldIdentityABI.abi, release.IdentityOld || release.Identity);
   // let Identity = await ethers.getContractAt("IdentityV2", release.Identity);
   // Identity = await ethers.getContractAt("IdentityV2", "0xb0cD4828Cc90C5BC28f4920Adf2Fd8F025003D7E");
-  console.log("deploying new identity...");
+  console.log("deploying new identity...", { old: OldIdentity.address });
   let Identity = (await deployDeterministic(
     {
       name: "IdentityV2",
       salt: "IdentityV2",
       isUpgradeable: true
     },
-    [root.address, release.Identity]
+    [root.address, OldIdentity.address]
   ).then(printDeploy)) as Contract;
 
   let torelease = {
     Identity: Identity.address,
-    IdentityOld: release.Identity
+    IdentityOld: OldIdentity.address
   };
 
   await releaser(torelease, networkName, "deployment", false);
 
   console.log("calling initDAO...");
-  const tx = await (await Identity.initDAO(release.NameService)).wait();
+  const tx = await Identity.initDAO(release.NameService).then(printDeploy);
   await Identity.grantRole(
     ethers.utils.keccak256(ethers.utils.toUtf8Bytes("identity_admin")),
     release.AdminWallet
   ).then(printDeploy);
-  await OldIdentity.addIdentityAdmin(Identity.address).then(printDeploy);
+
+  //done via Avatar in proposal
+  // await OldIdentity.addIdentityAdmin(Identity.address).then(printDeploy);
 
   const impl = await getImplementationAddress(ethers.provider, Identity.address);
   await verifyContract(impl, "IdentityV2", networkName);
 
   const proposalContracts = [
     release.GoodDollar, //controller -> set new identity in G$
-    release.NameService //nameservice modify to new Identity
+    release.NameService, //nameservice modify to new Identity
+    OldIdentity.address // add new Identity as admin in old identity
   ];
 
   const proposalEthValues = proposalContracts.map(_ => 0);
 
   const proposalFunctionSignatures = [
     "setIdentity(address)", //set Identity on GoodDollar token
-    "setAddress(string,address)" //set new identity address in nameservice
+    "setAddress(string,address)", //set new identity address in nameservice
+    "addIdentityAdmin(address)"
   ];
 
   const proposalFunctionInputs = [
     ethers.utils.defaultAbiCoder.encode(["address"], [Identity.address]),
-    ethers.utils.defaultAbiCoder.encode(["string", "address"], ["IDENTITY", Identity.address])
+    ethers.utils.defaultAbiCoder.encode(["string", "address"], ["IDENTITY", Identity.address]),
+    ethers.utils.defaultAbiCoder.encode(["address"], [Identity.address])
   ];
+
   if (isProduction) {
     await executeViaSafe(
       proposalContracts,
       proposalEthValues,
       proposalFunctionSignatures,
-      proposalFunctionSignatures,
-      protocolSettings.guardiansSafe
+      proposalFunctionInputs,
+      protocolSettings.guardiansSafe,
+      "fuse"
     );
   } else {
     await executeViaGuardian(

package/test/faucet/Faucet.test.ts

@@ -67,7 +67,7 @@ describe("Faucet", () => {
     expect(await faucet.canTop(user1.address)).to.true;
     const tx = await (await faucet.connect(signers[0]).topWallet(user1.address)).wait();
     const balance = await ethers.provider.getBalance(user1.address);
-    expect(balance).to.equal(await faucet.toppingAmount());
+    expect(balance).to.equal(await faucet.getToppingAmount());
   });
 
   it("should not let new user top more than once", async () => {
@@ -98,7 +98,7 @@ describe("Faucet", () => {
     const tx = await (await faucet.topWallet(user1.address)).wait();
     console.log(tx.gasUsed.toString());
     const balance = await ethers.provider.getBalance(user1.address);
-    expect(balance).to.equal(await faucet.toppingAmount());
+    expect(balance).to.equal(await faucet.getToppingAmount());
   });
 
   it("should not let identified user top over daily limit", async () => {
@@ -123,12 +123,13 @@ describe("Faucet", () => {
   // });
 
   it("should not let user top over weekly limit", async () => {
+    const toppingAmount = await faucet.getToppingAmount();
     for (let i = 0; i < 5; i++) {
       await ethers.provider.send("evm_increaseTime", [60 * 60 * 24]);
       await (await faucet.topWallet(user1.address)).wait();
       await user1.sendTransaction({
         to: ethers.constants.AddressZero,
-        value: ethers.utils.parseUnits("5000000", "gwei")
+        value: toppingAmount.mul(80).div(100)
       });
     }
     await ethers.provider.send("evm_increaseTime", [60 * 60 * 24]);

package/test/faucet/FuseFaucet.test.ts

@@ -58,7 +58,7 @@ describe("FuseFaucet", () => {
       call: { fn: "upgrade", args: [signers[1].address, founder.address, ns] }
     });
     expect(res).not.empty;
-    await expect(res.upgrade(signers[0].address, signers[0].address, ns)).revertedWith("already upgraded");
+    await expect(res.upgrade(signers[0].address, signers[0].address, ns)).revertedWith("wrong upgrade version");
     expect(await res.owner()).equal(founder.address);
     expect(await res.relayer()).equal(signers[1].address);
   });

package/test/ubi/UBISchemeCycle.test.ts

@@ -13,19 +13,10 @@ const ONE_DAY = 86400;
 describe("UBIScheme cycle", () => {
   let goodDollar, firstClaimPool;
   let reputation;
-  let root,
-    acct,
-    claimer1,
-    claimer2,
-    claimer3,
-    signers,
-    nameService,
-    genericCall,
-    ubiScheme: UBIScheme;
+  let root, acct, claimer1, claimer2, claimer3, signers, nameService, genericCall, ubiScheme: UBIScheme;
 
   before(async () => {
-    [root, acct, claimer1, claimer2, claimer3, ...signers] =
-      await ethers.getSigners();
+    [root, acct, claimer1, claimer2, claimer3, ...signers] = await ethers.getSigners();
 
     const deployedDAO = await loadFixture(createDAO);
     let {
@@ -53,8 +44,8 @@ describe("UBIScheme cycle", () => {
     // await increaseTime(60 * 60 * 24);
   });
 
-  it("should deploy the ubi with default cycle of 90 days", async () => {
-    expect(await ubiScheme.cycleLength()).to.equal(90);
+  it("should deploy the ubi with default cycle of 30 days", async () => {
+    expect(await ubiScheme.cycleLength()).to.equal(30);
   });
 
   it("should not be able to change cycleLength if not avatar", async () => {
@@ -64,9 +55,7 @@ describe("UBIScheme cycle", () => {
 
   it("should be able to change cycleLength if avatar", async () => {
     // initializing the ubi
-    let encodedCall = ubiScheme.interface.encodeFunctionData("setCycleLength", [
-      8
-    ]);
+    let encodedCall = ubiScheme.interface.encodeFunctionData("setCycleLength", [8]);
     await genericCall(ubiScheme.address, encodedCall);
     expect(await ubiScheme.cycleLength()).to.be.equal(8);
   });
@@ -81,10 +70,7 @@ describe("UBIScheme cycle", () => {
 
   it("should set ubischeme", async () => {
     // initializing the ubi
-    let encodedCall = firstClaimPool.interface.encodeFunctionData(
-      "setUBIScheme",
-      [ubiScheme.address]
-    );
+    let encodedCall = firstClaimPool.interface.encodeFunctionData("setUBIScheme", [ubiScheme.address]);
 
     await genericCall(firstClaimPool.address, encodedCall);
     // await firstClaimPool.start();
@@ -98,9 +84,7 @@ describe("UBIScheme cycle", () => {
     let currentCycle = await ubiScheme.currentCycleLength();
     let balance = await goodDollar.balanceOf(ubiScheme.address);
     expect(currentCycle.toNumber()).to.be.gt(0);
-    const cycleEvent = transaction.events.find(
-      e => e.event === "UBICycleCalculated"
-    );
+    const cycleEvent = transaction.events.find(e => e.event === "UBICycleCalculated");
     expect(cycleEvent.args.day.toNumber()).to.be.a("number");
     expect(cycleEvent.args.pool).to.be.equal(balance);
     expect(cycleEvent.args.cycleLength).to.be.equal(cycleLength);
@@ -110,48 +94,33 @@ describe("UBIScheme cycle", () => {
   it("should  have calculated dailyCyclePool and dailyUbi correctly", async () => {
     increaseTime(ONE_DAY);
     let transaction = await ubiScheme.connect(claimer2).claim();
-    expect(
-      await goodDollar.balanceOf(claimer2.address).then(_ => _.toNumber())
-    ).to.be.equal(1000 + (await ubiScheme.dailyUbi().then(_ => _.toNumber()))); //first day 10G$ (1000 wei), second claim 125000 wei daily pool divided by 2 active users = 625000
-    expect(
-      await ubiScheme.dailyCyclePool().then(_ => _.toNumber())
-    ).to.be.equal(125000);
-    expect(
-      await ubiScheme.currentDayInCycle().then(_ => _.toNumber())
-    ).to.be.equal(1); //1 day passed
+    expect(await goodDollar.balanceOf(claimer2.address).then(_ => _.toNumber())).to.be.equal(
+      1000 + (await ubiScheme.dailyUbi().then(_ => _.toNumber()))
+    ); //first day 10G$ (1000 wei), second claim 125000 wei daily pool divided by 2 active users = 625000
+    expect(await ubiScheme.dailyCyclePool().then(_ => _.toNumber())).to.be.equal(125000);
+    expect(await ubiScheme.currentDayInCycle().then(_ => _.toNumber())).to.be.equal(1); //1 day passed
   });
 
   it("should calculate next cycle even if day passed without claims(setDay)", async () => {
     increaseTime(ONE_DAY * 9);
-    expect(
-      await ubiScheme.currentDayInCycle().then(_ => _.toNumber())
-    ).to.be.equal(10); //10 days passed total
+    expect(await ubiScheme.currentDayInCycle().then(_ => _.toNumber())).to.be.equal(10); //10 days passed total
 
     let transaction = await (await ubiScheme.connect(claimer1).claim()).wait(); //claims in new ubi cycle
     let dailyClaimAmount = (await ubiScheme.dailyCyclePool()).div(1000); //initialy we have by default min 1000 active users
 
-    expect(await goodDollar.balanceOf(claimer1.address)).to.be.equal(
-      dailyClaimAmount.add(1000)
-    ); //intial 10 from first claim pool + daily
-    const cycleEvent = transaction.events.find(
-      e => e.event === "UBICycleCalculated"
-    );
+    expect(await goodDollar.balanceOf(claimer1.address)).to.be.equal(dailyClaimAmount.add(1000)); //intial 10 from first claim pool + daily
+    const cycleEvent = transaction.events.find(e => e.event === "UBICycleCalculated");
 
     expect(cycleEvent).to.be.not.empty;
 
-    expect(
-      await ubiScheme.currentDayInCycle().then(_ => _.toNumber())
-    ).to.be.equal(0); //new cycle started
+    expect(await ubiScheme.currentDayInCycle().then(_ => _.toNumber())).to.be.equal(0); //new cycle started
     //intial balance on cycle start 1000000 - 125(one user that claimed) = 999875, divide by cycle length (8) = 124984
     expect(cycleEvent.args.dailyUBIPool).to.be.equal(124984);
   });
 
   it("should calculate cycle early if we can increase current daily pool", async () => {
     //increase ubi pool balance
-    let encoded = goodDollar.interface.encodeFunctionData("mint", [
-      ubiScheme.address,
-      400000
-    ]);
+    let encoded = goodDollar.interface.encodeFunctionData("mint", [ubiScheme.address, 400000]);
     await genericCall(goodDollar.address, encoded);
     let balance = await goodDollar.balanceOf(ubiScheme.address);
 
@@ -164,9 +133,7 @@ describe("UBIScheme cycle", () => {
     const estimated = await ubiScheme.estimateNextDailyUBI();
     await increaseTime(ONE_DAY); //make sure
     let transaction = await (await ubiScheme.connect(claimer1).claim()).wait();
-    const cycleEvent = transaction.events.find(
-      e => e.event === "UBICycleCalculated"
-    );
+    const cycleEvent = transaction.events.find(e => e.event === "UBICycleCalculated");
     const dailyUBI = await ubiScheme.dailyUbi();
     expect(dailyUBI).to.eq(estimated); //the estimated before actual calculation should be correct, ie equal to actual dailyUBI calculated after first claim.
     expect(cycleEvent).to.be.not.empty;
@@ -178,10 +145,7 @@ describe("UBIScheme cycle", () => {
 
   it("should not calculate cycle early if not possible to increase daily ubi pool", async () => {
     //increase ubi pool balance
-    let encoded = goodDollar.interface.encodeFunctionData("mint", [
-      ubiScheme.address,
-      100
-    ]);
+    let encoded = goodDollar.interface.encodeFunctionData("mint", [ubiScheme.address, 100]);
     await genericCall(goodDollar.address, encoded);
     let balance = await goodDollar.balanceOf(ubiScheme.address);
     const curCycleLen = await ubiScheme.cycleLength();
@@ -191,9 +155,7 @@ describe("UBIScheme cycle", () => {
 
     await increaseTime(ONE_DAY); //make sure
     let transaction = await (await ubiScheme.connect(claimer1).claim()).wait();
-    const cycleEvent = transaction.events.find(
-      e => e.event === "UBICycleCalculated"
-    );
+    const cycleEvent = transaction.events.find(e => e.event === "UBICycleCalculated");
     expect(cycleEvent).to.be.undefined;
   });
 });