@gooddollar/goodprotocol 1.0.18 → 1.0.19-beta.2

package/releases/deployment.json

@@ -529,5 +529,16 @@
         "ProxyAdmin": "0x57179b2A8eB019157b0C3E761cdB26c82C982a3B",
         "FuseFaucet": "0x01ab5966C1d742Ae0CFF7f14cC0F4D85156e83d9",
         "FuseStaking": "0xA199F0C353E25AdF022378B0c208D600f39a6505"
+    },
+    "production-celo": {
+        "ProxyFactory": "0x99C22e78A579e2176311c736C4c9F0b0D5A47806",
+        "GoodDollar": "0xf2283840cE37DAe0a06B40a9A80603977f36fA3F",
+        "Avatar": "0xCD5e8a81B1e02c1837A674f87dF327C14f4e5748",
+        "Controller": "0x3D0bacBdC06A28971855275D511e6249bE67112d",
+        "Identity": "0x96B81f82A29e78C5ba9E2034Ce8490fd641a24eb",
+        "NameService": "0x563a80a452264a9e1aa37c6FA0B46D04C3c71b24",
+        "GReputation": "0xAC132ECe25217867E318eA8ff63420C90d5a74A6",
+        "network": "production-celo",
+        "networkId": 42220
     }
 }

package/scripts/multichain-deploy/basicdao-deploy.ts

@@ -0,0 +1,256 @@
+import { network, ethers, upgrades, run } from "hardhat";
+import { networkNames } from "@openzeppelin/upgrades-core";
+import { isFunction, get, omitBy } from "lodash";
+import { getImplementationAddress } from "@openzeppelin/upgrades-core";
+import pressAnyKey from "press-any-key";
+import { Contract } from "ethers";
+import { range } from "lodash";
+// import DAOCreatorABI from "@gooddollar/goodcontracts/build/contracts/DaoCreatorGoodDollar.json";
+import DAOCreatorABI from "../../../GoodBootstrap/packages/contracts/build/contracts/DaoCreatorGoodDollarWithRep.json";
+// import IdentityABI from "@gooddollar/goodcontracts/build/contracts/Identity.json";
+import IdentityABI from "../../../GoodBootstrap/packages/contracts/build/contracts/IdentityWithOwner.json";
+import FeeFormulaABI from "@gooddollar/goodcontracts/build/contracts/FeeFormula.json";
+// import AddFoundersABI from "@gooddollar/goodcontracts/build/contracts/AddFoundersGoodDollar.json";
+import AddFoundersABI from "../../../GoodBootstrap/packages/contracts/build/contracts/AddFoundersGoodDollarWithRep.json";
+import ContributionCalculation from "@gooddollar/goodcontracts/stakingModel/build/contracts/ContributionCalculation.json";
+import FirstClaimPool from "@gooddollar/goodcontracts/stakingModel/build/contracts/FirstClaimPool.json";
+import BridgeMock from "@gooddollar/goodcontracts/stakingModel/build/contracts/BridgeMock.json";
+import AdminWalletABI from "@gooddollar/goodcontracts/build/contracts/AdminWallet.json";
+import OTPABI from "@gooddollar/goodcontracts/build/contracts/OneTimePayments.json";
+import HomeBridgeABI from "@gooddollar/goodcontracts/build/contracts/DeployHomeBridge.json";
+import ForeignBridgeABI from "@gooddollar/goodcontracts/build/contracts/DeployForeignBridge.json";
+
+import { deployDeterministic } from "./helpers";
+import releaser from "../../scripts/releaser";
+import ProtocolSettings from "../../releases/deploy-settings.json";
+import dao from "../../releases/deployment.json";
+import { TransactionResponse } from "@ethersproject/providers";
+
+const { name } = network;
+
+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]];
+  const protocolSettings = ProtocolSettings["production"];
+  let release: { [key: string]: any } = {};
+
+  let [root, ...signers] = await ethers.getSigners();
+  //generic call permissions
+  let schemeMock = root;
+  const isMainnet = network.name.includes("main");
+
+  console.log("got signers:", {
+    network,
+    root: root.address,
+    schemeMock: schemeMock.address,
+    balance: await ethers.provider
+      .getBalance(root.address)
+      .then(_ => _.toString())
+  });
+
+  const DAOCreatorFactory = new ethers.ContractFactory(
+    DAOCreatorABI.abi,
+    DAOCreatorABI.bytecode,
+    root
+  );
+
+  const IdentityFactory = new ethers.ContractFactory(
+    IdentityABI.abi,
+    IdentityABI.bytecode,
+    root
+  );
+  const FeeFormulaFactory = new ethers.ContractFactory(
+    FeeFormulaABI.abi,
+    FeeFormulaABI.bytecode,
+    root
+  );
+  const AddFoundersFactory = new ethers.ContractFactory(
+    AddFoundersABI.abi,
+    AddFoundersABI.bytecode,
+    root
+  );
+
+  const AddFounders = (await AddFoundersFactory.deploy().then(
+    printDeploy
+  )) as Contract;
+  // const AddFounders = await ethers.getContractAt(
+  //   AddFoundersABI.abi,
+  //   "0x6F1BAbfF5E119d61F0c6d8653d84E8B284B87091"
+  // );
+
+  const Identity = (await deployDeterministic(
+    {
+      name: "Identity",
+      factory: IdentityFactory
+    },
+    [root.address]
+  ).then(printDeploy)) as Contract;
+
+  // const Identity = await ethers.getContractAt(
+  //   IdentityABI.abi,
+  //   release.Identity
+  // );
+
+  const daoCreator = await DAOCreatorFactory.deploy(AddFounders.address);
+
+  const FeeFormula = (await deployDeterministic(
+    { name: "FeeFormula", factory: FeeFormulaFactory },
+    [0]
+  ).then(printDeploy)) as Contract;
+
+  const GReputation = (await deployDeterministic(
+    {
+      name: "GReputation",
+      isUpgradable: true,
+      initializer: "initialize(address, string, bytes32, uint256)"
+    },
+    [
+      ethers.constants.AddressZero,
+      "fuse",
+      protocolSettings.governance.gdaoAirdrop, //should fail on real deploy if not set
+      protocolSettings.governance.gdaoTotalSupply //should fail on real deploy if not set
+    ]
+  ).then(printDeploy)) as Contract;
+
+  console.log("setting identity auth period");
+  await Identity.setAuthenticationPeriod(365).then(printDeploy);
+
+  console.log("creating dao");
+  await daoCreator
+    .forgeOrg(
+      "GoodDollar",
+      "G$",
+      0,
+      FeeFormula.address,
+      Identity.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)"
+    ],
+    root
+  );
+
+  // 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");
+
+  let schemes = [process.env.DAO_OWNER, Identity.address];
+
+  const gd = await Avatar.nativeToken();
+
+  const controller = await Avatar.owner();
+
+  console.log("setting schemes", schemes);
+
+  await daoCreator
+    .setSchemes(
+      Avatar.address,
+      schemes,
+      schemes.map(_ => ethers.constants.HashZero),
+      ["0x0000001f", "0x00000001"],
+      ""
+    )
+    .then(printDeploy);
+
+  const NameService = await deployDeterministic(
+    { name: "NameService", isUpgradable: true },
+    [
+      controller,
+      ["CONTROLLER", "AVATAR", "IDENTITY", "GOODDOLLAR"].map(_ =>
+        ethers.utils.keccak256(ethers.utils.toUtf8Bytes(_))
+      ),
+      [controller, Avatar.address, Identity.address, gd]
+    ]
+  );
+
+  await (await GReputation.updateDAO(NameService.address)).wait();
+  console.log("GRep nameservice:");
+  //verifications
+  const Controller = await ethers.getContractAt("Controller", controller);
+  const GoodDollar = await ethers.getContractAt("IGoodDollar", gd);
+
+  await GoodDollar.renounceMinter().then(printDeploy);
+  await Identity.transferOwnership(process.env.DAO_OWNER).then(printDeploy);
+
+  const daoOwnerDaoPermissions = await Controller.getSchemePermissions(
+    process.env.DAO_OWNER,
+    Avatar.address
+  );
+
+  const deployerIsNotGDMinter =
+    (await GoodDollar.isMinter(root.address)) === false;
+  const avatarIsGDMinter = await GoodDollar.isMinter(Avatar.address);
+
+  const deployerIsNotRepMinter =
+    (await GReputation.hasRole(GReputation.MINTER_ROLE(), root.address)) ===
+    false;
+  const avatarIsRepMinter = await GReputation.hasRole(
+    GReputation.MINTER_ROLE(),
+    Avatar.address
+  );
+  const daoOwnerIsIdentityOwner =
+    process.env.DAO_OWNER === (await Identity.owner());
+
+  //try to modify DAO -> should not succeed
+  await (await GReputation.updateDAO(ethers.constants.AddressZero)).wait();
+
+  const grepHasDAOSet =
+    (await GReputation.nameService()) === NameService.address;
+
+  console.log({
+    daoOwnerDaoPermissions,
+    deployerIsNotGDMinter,
+    deployerIsNotRepMinter,
+    avatarIsRepMinter,
+    daoOwnerIsIdentityOwner,
+    avatarIsGDMinter,
+    grepHasDAOSet
+  });
+
+  release = {
+    ProxyFactory: "0x99C22e78A579e2176311c736C4c9F0b0D5A47806",
+    GoodDollar: gd,
+    Avatar: Avatar.address,
+    Controller: controller,
+    Identity: Identity.address,
+    NameService: NameService.address,
+    GReputation: GReputation.address
+  };
+  await releaser(release, network.name, "deployment", false);
+};
+
+export const main = async (networkName = name) => {
+  await createDAO().catch(console.log);
+};
+main();

package/scripts/multichain-deploy/helpers.ts

@@ -0,0 +1,96 @@
+import { ContractFactory } from "ethers";
+import { network, ethers, upgrades, run } from "hardhat";
+
+let totalGas = 0;
+const gasUsage = {};
+const GAS_SETTINGS = {};
+export const countTotalGas = async (tx, name) => {
+  let res = tx;
+  if (tx.deployTransaction) tx = tx.deployTransaction;
+  if (tx.wait) res = await tx.wait();
+  if (res.gasUsed) {
+    totalGas += parseInt(res.gasUsed);
+    gasUsage[name] = gasUsage[name] || 0;
+    gasUsage[name] += parseInt(res.gasUsed);
+  } else console.log("no gas data", { res, tx });
+};
+
+export const deployDeterministic = async (
+  contract,
+  args: any[],
+  factoryOpts = {}
+) => {
+  try {
+    let proxyFactory;
+    if (!network.name.startsWith("production")) {
+      proxyFactory = await (
+        await ethers.getContractFactory("ProxyFactory1967")
+      ).deploy();
+    } else
+      proxyFactory = await ethers.getContractAt(
+        "ProxyFactory1967",
+        "0x99C22e78A579e2176311c736C4c9F0b0D5A47806"
+      );
+    const Contract =
+      (contract.factory as ContractFactory) ||
+      (await ethers.getContractFactory(contract.name, factoryOpts));
+
+    const salt = ethers.BigNumber.from(
+      ethers.utils.keccak256(ethers.utils.toUtf8Bytes(contract.name))
+    );
+
+    if (contract.isUpgradable === true) {
+      console.log("Deploying:", contract.name, "using proxyfactory");
+      const encoded = Contract.interface.encodeFunctionData(
+        contract.initializer || "initialize",
+        args
+      );
+      const tx = await Contract.deploy(GAS_SETTINGS);
+      const impl = await tx.deployed();
+      console.log("implementation deployed:", contract.name, impl.address);
+      await countTotalGas(tx, contract.name);
+
+      const tx2 = await proxyFactory.deployProxy(
+        salt,
+        impl.address,
+        encoded,
+        GAS_SETTINGS
+      );
+      await countTotalGas(tx2, contract.name);
+      const deployTx = await tx2
+        .wait()
+        .catch(e =>
+          console.error("failed to deploy proxy, assuming it exists...", e)
+        );
+      const proxyAddr = await proxyFactory[
+        "getDeploymentAddress(uint256,address)"
+      ](salt, await proxyFactory.signer.getAddress());
+      console.log("proxy deployed:", contract.name, proxyAddr);
+      return Contract.attach(proxyAddr);
+    } else {
+      console.log("Deploying:", contract.name, "using proxyfactory code");
+      const constructor = Contract.interface.encodeDeploy(args);
+      const bytecode = ethers.utils.solidityPack(
+        ["bytes", "bytes"],
+        [Contract.bytecode, constructor]
+      );
+      const deployTx = await (
+        await proxyFactory.deployCode(salt, bytecode, GAS_SETTINGS)
+      ).wait();
+
+      const proxyAddr = await proxyFactory[
+        "getDeploymentAddress(uint256,address,bytes32)"
+      ](
+        salt,
+        await proxyFactory.signer.getAddress(),
+        ethers.utils.keccak256(bytecode)
+      );
+      console.log("proxy deployed:", contract.name, proxyAddr);
+
+      return Contract.attach(proxyAddr);
+    }
+  } catch (e) {
+    console.log("Failed deploying contract:", { contract });
+    throw e;
+  }
+};

package/test/governance/ClaimersDistribution.test.ts

@@ -84,9 +84,9 @@ describe("ClaimersDistribution", () => {
   });
 
   it("should update claim if claimed today", async () => {
-    const ts = Date.now();
+    const ts = await ethers.provider.getBlock("latest").then(_ => _.timestamp);
     await ubiScheme.connect(claimer1).claim();
-    expect(await cd.lastUpdated(claimer1.address)).gt((ts / 1000).toFixed(0));
+    expect(await cd.lastUpdated(claimer1.address)).gt(ts.toFixed(0));
     expect(await cd.getMonthClaims(claimer1.address)).to.equal(1);
     const monthData = await cd.months(await cd.currentMonth());
     expect(monthData.totalClaims).to.equal(1);
@@ -102,9 +102,9 @@ describe("ClaimersDistribution", () => {
   });
 
   it("should update stats after second claimer", async () => {
-    const ts = Date.now();
+    const ts = await ethers.provider.getBlock("latest").then(_ => _.timestamp);
     await ubiScheme.connect(claimer2).claim();
-    expect(await cd.lastUpdated(claimer2.address)).gt((ts / 1000).toFixed(0));
+    expect(await cd.lastUpdated(claimer2.address)).gt(ts.toFixed(0));
     expect(await cd.getMonthClaims(claimer2.address)).to.equal(1);
     const monthData = await cd.months(await cd.currentMonth());
     expect(monthData.totalClaims).to.equal(2);
@@ -115,9 +115,9 @@ describe("ClaimersDistribution", () => {
 
   it("should distribute reputation after a month and update to current monthly distribution", async () => {
     await increaseTime(60 * 60 * 24 * 30);
-    const ts = Date.now();
+    const ts = await ethers.provider.getBlock("latest").then(_ => _.timestamp);
     await ubiScheme.connect(claimer2).claim();
-    expect(await cd.lastUpdated(claimer2.address)).gt((ts / 1000).toFixed(0));
+    expect(await cd.lastUpdated(claimer2.address)).gt(ts.toFixed(0));
     expect(await cd.getMonthClaims(claimer2.address)).to.equal(1);
     const monthData = await cd.months(await cd.currentMonth());
     expect(monthData.totalClaims).to.equal(1);

package/test/governance/CompoundVotingMachine.daoscheme.ts

@@ -54,7 +54,7 @@ describe("CompoundVotingMachine#DAOScheme", () => {
 
   let genericCall, queuePeriod;
 
-  let avatar, mock, Controller;
+  let avatar, mock, Controller, setAddress;
 
   before(async () => {
     [root, acct, ...signers] = await ethers.getSigners();
@@ -79,6 +79,7 @@ describe("CompoundVotingMachine#DAOScheme", () => {
     )) as GReputation;
 
     gov = votingMachine;
+    setAddress = setDAOAddress;
 
     //this will give root minter permissions
     setDAOAddress("GDAO_CLAIMERS", root.address);
@@ -313,4 +314,16 @@ describe("CompoundVotingMachine#DAOScheme", () => {
     expect(states[await gov.state(proposalId)]).to.equal("Executed");
     expect(await c.isSchemeRegistered(gov.address, avatar)).to.eq(false);
   });
+
+  it("should be able to update reputation", async () => {
+    const originalRep = await gov.rep();
+    const repToSet = root.address;
+    await setAddress("REPUTATION", root.address);
+    await gov.updateRep();
+    const updatedRep = await gov.rep();
+    expect(updatedRep).to.not.eq(originalRep);
+    expect(updatedRep).to.eq(repToSet);
+    await setAddress("REPUTATION", originalRep);
+    await gov.updateRep();
+  });
 });

package/test/governance/CompoundVotingMachine.guardian.test.ts

@@ -129,8 +129,18 @@ describe("CompoundVotingMachine#Guardian", () => {
     await gov.connect(acct).setGuardian(root.address); //restore
   });
 
+  it("Should allow set guardian to fix bad guardian deployment", async () => {
+    const badAddress = "0x4659176E962763e7C8A4eF965ecfD0fdf9f52057";
+    await gov.setGuardian(badAddress);
+    expect(await gov.guardian()).to.equal(badAddress);
+
+    await gov.connect(acct).fixGuardian(root.address);
+    expect(await gov.guardian()).to.equal(root.address);
+  });
+
   it("Should be able to set guardian by avatar if foundation expired", async () => {
-    await increaseTime(60 * 60 * 24 * 365 * 2);
+    await ethers.provider.send("evm_setNextBlockTimestamp", [1672531201]); //1672531200
+    await ethers.provider.send("evm_mine", []);
 
     const encoded = gov.interface.encodeFunctionData("setGuardian", [
       acct.address

package/test/governance/GReputation.test.ts

@@ -119,7 +119,6 @@ describe("GReputation", () => {
   });
 
   it("should have avatar as role manager", async () => {
-    // const invites = await Invites.deployed();
     expect(await grep.hasRole(await grep.DEFAULT_ADMIN_ROLE(), avatar)).to.be
       .true;
   });
@@ -742,6 +741,25 @@ describe("GReputation", () => {
       );
     });
 
+    it("it should be able to get totalSupplyLocal for particular block", async () => {
+      let currentBlock = await ethers.provider.getBlockNumber();
+      const totalSupplyLocalBefore = await grep["totalSupplyLocal(uint256)"](currentBlock);
+      await grepWithOwner["mint(address,uint256)"](
+        founder,
+        ethers.utils.parseEther("1")
+      );
+      currentBlock = await ethers.provider.getBlockNumber();
+      const totalSupplyLocalAfter = await grep["totalSupplyLocal(uint256)"](currentBlock);
+      expect(totalSupplyLocalAfter).to.equal(
+        totalSupplyLocalBefore.add(ethers.utils.parseEther("1"))
+      );
+      
+      await grepWithOwner["burn(address,uint256)"](
+        founder,
+        ethers.utils.parseEther("1")
+      );
+    });
+
     it("it should return 0 when particular blockchain state is empty", async () => {
       let state = await grep["getVotesAtBlockchain(bytes32,address,uint256)"](
         ethers.utils.keccak256(ethers.utils.toUtf8Bytes("notExist")),
@@ -844,5 +862,18 @@ describe("GReputation", () => {
       expect(await grep.balanceOfLocal(repTarget)).to.equal(111);
       expect(await grep.balanceOfLocal(rep3)).to.equal(startBalance.add(111));
     });
+
+    it("should get accurate prior votes", async () => {
+      await grep.connect(signers[3]).undelegate();
+      const selectedBlock = await ethers.provider.getBlockNumber();
+      const selectedBlockVotes = await grep.getCurrentVotes(rep2);
+      await advanceBlocks(1);
+      await (await grepWithOwner["mint(address,uint256)"](rep2, 1)).wait();
+      await advanceBlocks(1);
+      const priorSelectedBlockVotes = await grep.getPriorVotes(rep2, selectedBlock);
+      const votesAfterAdvancing = await grep.getCurrentVotes(rep2);
+      expect(priorSelectedBlockVotes).to.eq(selectedBlockVotes);
+      expect(priorSelectedBlockVotes).to.be.not.eq(votesAfterAdvancing);
+    });
   });
 });

package/test/governance/StakersDistribution.test.ts

@@ -859,4 +859,65 @@ describe("StakersDistribution - staking with GD  and get Rewards in GDAO", () =>
     expect(usdcStakingPendingGdaos).to.be.gt(0);
     expect(usdcStakingPendingGdaos.toString().length).to.be.gt(18);
   });
-});
+
+  it("should get user minted and pending rewards", async () => {
+    const goodFundManagerFactory = await ethers.getContractFactory(
+      "GoodFundManager"
+    );
+
+    const simpleStaking1 = await deployDaiStaking();
+    const ictrl = await ethers.getContractAt(
+      "Controller",
+      controller,
+      schemeMock
+    );
+    const currentBlockNumber = await ethers.provider.getBlockNumber();
+    let encodedData = goodFundManagerFactory.interface.encodeFunctionData(
+      "setStakingReward",
+      [
+        "100000",
+        simpleStaking1.address,
+        currentBlockNumber - 5,
+        currentBlockNumber + 20,
+        false
+      ] // set 10 gd per block
+    );
+    await ictrl.genericCall(goodFundManager.address, encodedData, avatar, 0);
+
+    let [userMintedRewardBeforeStake, userPendingRewardBeforeStake] =
+      await getUserMintedAndPendingRewards(staker.address, simpleStaking1.address);
+    expect(userMintedRewardBeforeStake).to.eq('0');
+    expect(userPendingRewardBeforeStake).to.eq('0');
+
+    const stakingAmount = ethers.utils.parseEther("1000");
+    await dai["mint(address,uint256)"](staker.address, stakingAmount);
+    await dai.connect(staker).approve(simpleStaking1.address, stakingAmount);
+    await simpleStaking1.connect(staker).stake(stakingAmount, 0, false);
+    await advanceBlocks(5); //should accumulate some gdao rewards
+
+    let [userMintedRewardAfterStake, userPendingRewardAfterStake] =
+      await getUserMintedAndPendingRewards(staker.address, simpleStaking1.address);
+    expect(userMintedRewardAfterStake.eq(0));
+    expect(userPendingRewardAfterStake.gt(0));
+
+    await stakersDistribution.claimReputation(staker.address, [
+      simpleStaking1.address
+    ]);
+
+    let [userMintedRewardAfterClaim, userPendingRewardAfterClaim] =
+      await getUserMintedAndPendingRewards(staker.address, simpleStaking1.address);
+    expect(userMintedRewardAfterClaim.gt(0));
+    expect(userPendingRewardAfterClaim.eq(0));
+  });
+
+  async function getUserMintedAndPendingRewards(stakerAddress, stakingContractAddress) {
+    const userMintedAndPending = await stakersDistribution.getUserMintedAndPending(
+      [stakingContractAddress],
+      stakerAddress
+    );
+    const userMintedReward = userMintedAndPending[0];
+    const userPendingReward = userMintedAndPending[1];
+
+    return [userMintedReward, userPendingReward];
+  }
+});

package/test/helpers.ts

@@ -222,6 +222,20 @@ export const createDAO = async () => {
     await ictrl.genericCall(nameService.address, encoded, Avatar.address, 0);
   };
 
+  const runAsAvatarOnly = async (contract, functionAbi, ...parameters) => {
+    const funcNameEnd = functionAbi.indexOf('(');;
+    expect(funcNameEnd).to.be.gt(-1);
+    const functionName = functionAbi.substring(0, funcNameEnd);
+
+    const tx = await contract[functionAbi](...parameters).catch(e=>e);
+    expect(tx.message.toUpperCase()).to.contain("AVATAR");
+    const encoded = contract.interface.encodeFunctionData(functionName, [
+      ...parameters
+    ]);
+
+    await ictrl.genericCall(contract.address, encoded, Avatar.address, 0);
+  };
+
   const setReserveToken = async (token, gdReserve, tokenReserve, RR) => {
     const encoded = marketMaker.interface.encodeFunctionData(
       "initializeToken",
@@ -296,6 +310,7 @@ export const createDAO = async () => {
     identityDeployed: Identity,
     nameService,
     setDAOAddress,
+    runAsAvatarOnly,
     setSchemes,
     setReserveToken,
     genericCall,

package/test/reserve/GoodMarketMaker.test.ts

@@ -597,4 +597,15 @@ describe("GoodMarketMaker - calculate gd value at reserve", () => {
     expect(gdPriceAfter.gt(gdPriceBefore));
     expect(reserveRatioAfter).to.be.equal(reserveRatioBefore);
   });
+
+  it("should not set reserve ratio daily expansion with illigal values", async () => {
+    const invalidZeroDenominator = 0;
+    await expect(marketMaker.setReserveRatioDailyExpansion(1, invalidZeroDenominator)).to.be.
+      revertedWith("denominator must be above 0");
+
+    const denominator = 1;
+    const nominatorHigherThanDenom = 2;
+    await expect(marketMaker.setReserveRatioDailyExpansion(nominatorHigherThanDenom, denominator)).to.be.
+      revertedWith("Invalid nom or denom value");
+  });
 });