@gooddollar/goodprotocol 2.0.32 → 2.0.34-beta.0

package/scripts/multichain-deploy/fulldeploy.sh

@@ -1,26 +1,26 @@
 #run with source .env && ./scripts/multichain-deploy/fulldeploy.sh
 NETWORK=$1
 npx hardhat run ./scripts/multichain-deploy/0_proxyFactory-deploy.ts --network $NETWORK
-if [ $? != 0 ]; then
-    exit 1;
-fi
+# if [ $? != 0 ]; then
+#     exit 1;
+# fi
 npx hardhat run ./scripts/multichain-deploy/1_basicdao-deploy.ts --network $NETWORK
-if [ $? != 0 ]; then
-    exit 1;
-fi
+# if [ $? != 0 ]; then
+#     exit 1;
+# fi
 npx hardhat run ./scripts/multichain-deploy/2_helpers-deploy.ts --network $NETWORK
-if [ $? != 0 ]; then
-    exit 1;
-fi
-npx hardhat run ./scripts/multichain-deploy/3_gdSavings-deploy.ts --network $NETWORK
-if [ $? != 0 ]; then
-    exit 1;
-fi
+# # if [ $? != 0 ]; then
+# #     exit 1;
+# # fi
+# npx hardhat run ./scripts/multichain-deploy/3_gdSavings-deploy.ts --network $NETWORK
+# if [ $? != 0 ]; then
+#     exit 1;
+# fi
 npx hardhat run ./scripts/multichain-deploy/4_ubi-deploy.ts --network $NETWORK
 if [ $? != 0 ]; then
     exit 1;
 fi
-npx hardhat run ./scripts/multichain-deploy/5_gov-deploy.ts --network $NETWORK
-if [ $? != 0 ]; then
-    exit 1;
-fi
+# npx hardhat run ./scripts/multichain-deploy/5_gov-deploy.ts --network $NETWORK
+# if [ $? != 0 ]; then
+#     exit 1;
+# fi

package/scripts/multichain-deploy/helpers.ts

@@ -1,22 +1,20 @@
+import { readFileSync } from "fs";
 import { Contract, ContractFactory, Signer } from "ethers";
-import { network, ethers, upgrades, run } from "hardhat";
-import * as safeethers from "ethers";
+import { network, ethers } from "hardhat";
 import { TransactionResponse, TransactionReceipt } from "@ethersproject/providers";
-// import Safe from "@gnosis.pm/safe-core-sdk";
-import EthersAdapter from "@gnosis.pm/safe-ethers-lib";
-// import { MetaTransactionData } from "@gnosis.pm/safe-core-sdk-types";
-// import SafeClient from "@gnosis.pm/safe-service-client";
+import { getImplementationAddress } from "@openzeppelin/upgrades-core";
 
 import SafeApiKit from "@safe-global/api-kit";
-import Safe, { Eip1193Provider } from "@safe-global/protocol-kit";
-import { MetaTransactionData, OperationType } from "@safe-global/types-kit";
+import Safe from "@safe-global/protocol-kit";
+import { MetaTransactionData } from "@safe-global/types-kit";
 
 import util from "util";
 import dao from "../../releases/deployment.json";
+import { ProxyFactory1967 } from "../../types";
 
 const exec = util.promisify(require("child_process").exec);
 
-const networkName = network.name === "localhost" ? "production-mainnet" : network.name;
+const networkName = network.name;
 let totalGas = 0;
 const gasUsage = {};
 const GAS_SETTINGS = { gasLimit: 10000000 };
@@ -60,6 +58,7 @@ export const deploySuperGoodDollar = async (
   { superfluidHost, superfluidInflowNFTLogic, superfluidOutflowNFTLogic },
   tokenArgs
 ) => {
+  const withNFTs = !!(superfluidInflowNFTLogic && superfluidOutflowNFTLogic);
   const SuperGoodDollar = (await deployDeterministic(
     {
       name: "SuperGoodDollar",
@@ -79,59 +78,67 @@ export const deploySuperGoodDollar = async (
 
   await GoodDollarProxy.initializeProxy(SuperGoodDollar.address).then(printDeploy);
 
-  const OutFlowNFT = (await deployDeterministic(
-    {
-      name: "SuperGoodDollar OutflowNFT",
-      factory: uupsFactory
-    },
-    []
-  ).then(printDeploy)) as Contract;
-
-  const InFlowNFT = (await deployDeterministic(
-    {
-      name: "SuperGoodDollar InflowNFT",
-      factory: uupsFactory
-    },
-    []
-  ).then(printDeploy)) as Contract;
-
-  await OutFlowNFT.initializeProxy(superfluidOutflowNFTLogic);
-  await InFlowNFT.initializeProxy(superfluidInflowNFTLogic);
-
+  let OutFlowNFT = await ethers.getContractAt("ConstantOutflowNFT", ethers.constants.AddressZero);
+  let InFlowNFT = await ethers.getContractAt("ConstantOutflowNFT", ethers.constants.AddressZero);
+
+  if (withNFTs) {
+    OutFlowNFT = (await deployDeterministic(
+      {
+        name: "SuperGoodDollar OutflowNFT",
+        factory: uupsFactory
+      },
+      []
+    ).then(printDeploy)) as Contract;
+
+    InFlowNFT = (await deployDeterministic(
+      {
+        name: "SuperGoodDollar InflowNFT",
+        factory: uupsFactory
+      },
+      []
+    ).then(printDeploy)) as Contract;
+
+    console.log("initializing superfluid nfts proxies");
+    await OutFlowNFT.initializeProxy(superfluidOutflowNFTLogic);
+    await InFlowNFT.initializeProxy(superfluidInflowNFTLogic);
+  }
+  console.log("initializing supergooddollar");
   await SuperGoodDollar.attach(GoodDollarProxy.address)[
-    "initialize(string,string,uint256,address,address,address,address,address,address)"
-  ](...tokenArgs, OutFlowNFT.address, InFlowNFT.address);
+    "initialize(string,string,uint256,address,address,address,address)"
+  ](...tokenArgs);
 
   const GoodDollar = await ethers.getContractAt("ISuperGoodDollar", GoodDollarProxy.address);
 
-  const constantInflowNFT = await ethers.getContractAt("ConstantInflowNFT", InFlowNFT.address);
+  if (withNFTs) {
+    const constantInflowNFT = await ethers.getContractAt("ConstantInflowNFT", InFlowNFT.address);
 
-  const constantOutflowNFT = await ethers.getContractAt("ConstantOutflowNFT", OutFlowNFT.address);
-
-  await constantOutflowNFT
-    .attach(OutFlowNFT.address)
-    .initialize(
-      GoodDollarProxy.address,
-      (await GoodDollar.symbol()) + " Outflow NFT",
-      (await GoodDollar.symbol()) + " COF"
-    );
-  await constantInflowNFT
-    .attach(InFlowNFT.address)
-    .initialize(
-      GoodDollarProxy.address,
-      (await GoodDollar.symbol()) + " Inflow NFT",
-      (await GoodDollar.symbol()) + " CIF"
-    );
+    const constantOutflowNFT = await ethers.getContractAt("ConstantOutflowNFT", OutFlowNFT.address);
 
+    console.log("initializing inflow and outflow nfts");
+    await constantOutflowNFT
+      .attach(OutFlowNFT.address)
+      .initialize(
+        GoodDollarProxy.address,
+        (await GoodDollar.symbol()) + " Outflow NFT",
+        (await GoodDollar.symbol()) + " COF"
+      );
+    await constantInflowNFT
+      .attach(InFlowNFT.address)
+      .initialize(
+        GoodDollarProxy.address,
+        (await GoodDollar.symbol()) + " Inflow NFT",
+        (await GoodDollar.symbol()) + " CIF"
+      );
+  }
   return GoodDollar;
 };
 
 export const deployDeterministic = async (contract, args: any[], factoryOpts = {}, redeployProxyFactory = false) => {
   try {
-    let proxyFactory;
+    let proxyFactory: ProxyFactory1967;
     if (networkName.startsWith("develop") && redeployProxyFactory) {
-      proxyFactory = await (await ethers.getContractFactory("ProxyFactory1967")).deploy();
-    } else proxyFactory = await ethers.getContractAt("ProxyFactory1967", release.ProxyFactory);
+      proxyFactory = (await (await ethers.getContractFactory("ProxyFactory1967")).deploy()) as ProxyFactory1967;
+    } else proxyFactory = (await ethers.getContractAt("ProxyFactory1967", release.ProxyFactory)) as ProxyFactory1967;
     const Contract =
       (contract.factory as ContractFactory) || (await ethers.getContractFactory(contract.name, factoryOpts));
 
@@ -140,39 +147,73 @@ export const deployDeterministic = async (contract, args: any[], factoryOpts = {
     );
 
     if (contract.isUpgradeable === true) {
+      const proxyAddr = await proxyFactory["getDeploymentAddress(uint256,address)"](
+        salt,
+        await proxyFactory.signer.getAddress()
+      );
+      const code = await ethers.provider.getCode(proxyAddr);
+      if (code && code !== "0x") {
+        const implAddr = await getImplementationAddress(ethers.provider, proxyAddr).catch(e => "0x");
+        if (implAddr && implAddr !== "0x") {
+          console.log("proxy exists and impl set already:", contract.name, proxyAddr, implAddr);
+          return Contract.attach(proxyAddr);
+        }
+      }
+
       console.log("Deploying:", contract.name, "using proxyfactory", {
         args,
+        proxyAddr,
         proxyFactory: proxyFactory.address
       });
+
       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);
+      let tx2;
+      try {
+        if (contract.withProxyFactory === false) {
+          console.log("deploying proxy without proxy factory", { salt, impl: impl.address, encoded });
+          const proxy = await ethers.getContractFactory("contracts/utils/ProxyFactory1967.sol:ERC1967Proxy");
+          tx2 = await proxyFactory.deployCode(salt, proxy.bytecode, GAS_SETTINGS);
+          await tx2.wait();
+          console.log("proxy deployed initializing...", contract.name, proxyAddr, tx2.hash);
+          tx2 = await proxy.attach(proxyAddr).initialize(impl.address, encoded);
+          console.log("proxy initialized:", contract.name, proxyAddr, tx2.hash);
+        } else {
+          console.log("deploying proxy with proxyfactory", { salt, impl: impl.address, encoded });
+          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 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", {
-        proxyFactory: proxyFactory.address,
-        args
-      });
       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)
       );
+      const code = await ethers.provider.getCode(proxyAddr);
+      if (code && code !== "0x") {
+        console.log("contract already exists:", contract.name, proxyAddr);
+        return Contract.attach(proxyAddr);
+      }
+
+      console.log("Deploying:", contract.name, "using proxyfactory code", {
+        proxyFactory: proxyFactory.address,
+        args
+      });
+
+      const deployTx = await (await proxyFactory.deployCode(salt, bytecode, GAS_SETTINGS)).wait();
+
       console.log("proxy deployed:", contract.name, proxyAddr);
 
       return Contract.attach(proxyAddr);
@@ -422,16 +463,108 @@ export const verifyContract = async (
   address,
   contractPath,
   networkName = network.name,
-  proxyName?: string,
+  maybeProxy: boolean = true,
   forcedConstructorArguments?: string
 ) => {
-  const cmd = `yarn hardhat verify --contract ${contractPath} ${address} ${
+  const impl = await getImplementationAddress(ethers.provider, address).catch(e => "");
+  const contractAddress = maybeProxy ? impl || address : address;
+  console.log("verifying contract:", { contractPath, address, impl, networkName, forcedConstructorArguments });
+  const cmd = `yarn hardhat verify --contract ${contractPath} ${contractAddress} ${
     forcedConstructorArguments ?? ""
   } --network ${networkName}`;
   console.log("running...:", cmd);
-  await exec(cmd).then(({ stdout, stderr }) => {
-    console.log("Result for:", cmd);
-    console.log(stdout);
-    console.log(stderr);
-  });
+  await exec(cmd)
+    .then(({ stdout, stderr }) => {
+      console.log("Result for:", cmd);
+      console.log(stdout);
+      console.log(stderr);
+    })
+    .catch(e => {
+      console.error("Error verifying contract:", e);
+    });
+  if (maybeProxy && impl) {
+    const chainid = network.config.chainId.toString();
+    console.log("linking proxy to impl", { impl, address });
+    const body = new URLSearchParams({
+      chaini: network.config.chainId.toString(),
+      apikey: process.env.ETHERSCAN_KEY,
+      module: "contract",
+      action: "verifyproxycontract",
+      address
+    });
+
+    const response = await fetch(`https://api.etherscan.io/v2/api?chainid=${chainid}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body
+    });
+
+    const data = await response.json();
+    if (data.status !== "1") {
+      return console.log(`Proxy Verification submission failed: ${data.result}`);
+    }
+
+    const guid = data.result;
+    console.log(`Proxy Verification submitted. GUID: ${guid}`);
+  }
 };
+
+/**
+ * Verify a flattened contract on Etherscan
+ * @param {string} contractPath - Path to the contract (e.g., contracts/MyContract.sol)
+ * @param {string} contractName - Contract name (e.g., MyContract)
+ * @param {string} contractAddress - Deployed contract address
+ * @param {string} compilerVersion - Compiler version (e.g., v0.8.24+commit.e11b9ed9)
+ * @param {Array} constructorArgs - Object with {types:[], values:[]} for encoding
+ */
+export async function verifyOnEtherscan(
+  chainid,
+  contractPath,
+  contractName,
+  contractAddress,
+  compilerVersion,
+  constructorArgs = { types: [], values: [] }
+) {
+  const apiKey = process.env.ETHERSCAN_KEY;
+  if (!apiKey) {
+    throw new Error("ETHERSCAN_API_KEY not set in .env");
+  }
+
+  const sourceCode = readFileSync(contractPath, "utf8");
+
+  let constructorEncoded = "";
+  if (constructorArgs.types && constructorArgs.values) {
+    constructorEncoded = ethers.utils.defaultAbiCoder.encode(constructorArgs.types, constructorArgs.values).slice(2); // Remove '0x'
+  }
+
+  console.log("Submitting verification request to Etherscan...", { chainid, contractAddress, contractName });
+
+  const body = new URLSearchParams({
+    chainid,
+    apikey: apiKey,
+    module: "contract",
+    action: "verifysourcecode",
+    contractaddress: contractAddress,
+    sourceCode: sourceCode,
+    codeformat: "solidity-single-file",
+    contractname: contractName,
+    compilerversion: compilerVersion,
+    optimizationUsed: "1",
+    runs: "200",
+    constructorArguements: constructorEncoded
+  });
+
+  const response = await fetch(`https://api.etherscan.io/v2/api?chainid=${chainid}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body
+  });
+
+  const data = await response.json();
+  if (data.status !== "1") {
+    return console.log(`Verification submission failed: ${data.result}`);
+  }
+
+  const guid = data.result;
+  console.log(`Verification submitted. GUID: ${guid}`);
+}

package/scripts/multichain-deploy/verify.ts

@@ -0,0 +1,41 @@
+import { network, ethers, upgrades, run } from "hardhat";
+
+import {
+  deployDeterministic,
+  deploySuperGoodDollar,
+  verifyProductionSigner,
+  verifyContract,
+  verifyOnEtherscan
+} from "./helpers";
+import releaser from "../releaser";
+import ProtocolSettings from "../../releases/deploy-settings.json";
+import dao from "../../releases/deployment.json";
+import { getImplementationAddress } from "@openzeppelin/upgrades-core";
+
+const main = async () => {
+  const release = dao[network.name] || {};
+  console.log("verifying network:", network.name, release);
+  const protocolSettings = ProtocolSettings[network.name] || ProtocolSettings["default"];
+  // await verifyContract(release.ProxyFactory, "contracts/utils/ProxyFactory1967.sol:ProxyFactory1967");
+  // await verifyContract(release.Identity, "contracts/utils/ProxyFactory1967.sol:ERC1967Proxy", false);
+  // await verifyContract(release.Identity, "contracts/identity/IdentityV3.sol:IdentityV3", network.name);
+  // await verifyContract(release.NameService, "contracts/utils/NameService.sol:NameService", network.name);
+  // if (protocolSettings.superfluidHost) {
+  //   await verifyContract(release.GoodDollar, "contracts/token/superfluid/UUPSProxy.sol:UUPSProxy", network.name, false);
+  //   await verifyContract(
+  //     release.GoodDollar,
+  //     "contracts/token/superfluid/SuperGoodDollar.sol:SuperGoodDollar",
+  //     network.name,
+  //     true,
+  //     ethers.constants.AddressZero
+  //   );
+  // } else {
+  //   await verifyContract(release.GoodDollar, "contracts/token/GoodDollar.sol:GoodDollar", network.name);
+  // }
+
+  // await verifyContract(release.AdminWallet, "contracts/utils/AdminWallet.sol:AdminWallet", network.name);
+  // await verifyContract(release.Faucet, "contracts/fuseFaucet/Faucet.sol:Faucet", network.name);
+  // await verifyContract(release.Invites, "contracts/invite/InvitesV2.sol:InvitesV2", network.name);
+  await verifyContract(release.UBIScheme, "contracts/ubi/UBISchemeV2.sol:UBISchemeV2", network.name);
+};
+main();

package/test/governance/ClaimersDistribution.test.ts

@@ -240,7 +240,7 @@ describe("ClaimersDistribution", () => {
       // console.log({ totalGas }, tx.gasUsed.toNumber(), tx2.gasUsed.toNumber());
     }
     console.log(Object.keys(gasCosts));
-    expect(totalGas / 30).gt(480000);
+    expect(totalGas / 30).gt(470000);
   });
 
   it("should not cost alot of gas to claim with reputation distribution with regular token [@skip-on-coverage]", async () => {

package/test/helpers.ts

@@ -58,53 +58,67 @@ export const deploySuperGoodDollar = async (sfContracts, tokenArgs) => {
     "contracts/token/superfluid/UUPSProxy.sol:UUPSProxy"
   );
   const GoodDollarProxy = await GoodDollarProxyFactory.deploy();
+  console.log("deployed supergooddollar proxy, initializing proxy...");
+  await GoodDollarProxy.initializeProxy(SuperGoodDollar.address);
 
-  console.log("deploying flow nfts...");
-
-  const outNftProxy = await GoodDollarProxyFactory.deploy();
-  const inNftProxy = await GoodDollarProxyFactory.deploy();
-
-  const constantInflowNFT = await ethers.deployContract("ConstantInflowNFT", [
-    sfContracts.host,
-    outNftProxy.address
-  ]);
+  if (sfContracts.host !== ethers.constants.AddressZero) {
+    console.log("deploying flow nfts...");
 
-  const constantOutflowNFT = await ethers.deployContract("ConstantOutflowNFT", [
-    sfContracts.host,
-    inNftProxy.address
-  ]);
-  await outNftProxy.initializeProxy(constantOutflowNFT.address);
-  await inNftProxy.initializeProxy(constantInflowNFT.address);
+    const outNftProxy = await GoodDollarProxyFactory.deploy();
+    const inNftProxy = await GoodDollarProxyFactory.deploy();
 
-  console.log("deployed supergooddollar proxy, initializing proxy...");
-  await GoodDollarProxy.initializeProxy(SuperGoodDollar.address);
+    const constantInflowNFT = await ethers.deployContract("ConstantInflowNFT", [
+      sfContracts.host,
+      outNftProxy.address
+    ]);
 
-  console.log("initializing supergooddollar....");
-  await SuperGoodDollar.attach(GoodDollarProxy.address)[
-    "initialize(string,string,uint256,address,address,address,address,address,address)"
-  ](...tokenArgs, outNftProxy.address, inNftProxy.address);
-  const GoodDollar = await ethers.getContractAt(
-    "SuperGoodDollar",
-    GoodDollarProxy.address
-  );
-  console.log("supergooddollar created successfully");
-
-  await constantOutflowNFT
-    .attach(outNftProxy.address)
-    .initialize(
-      (await GoodDollar.symbol()) + " Outflow NFT",
-      (await GoodDollar.symbol()) + " COF"
+    const constantOutflowNFT = await ethers.deployContract(
+      "ConstantOutflowNFT",
+      [sfContracts.host, inNftProxy.address]
     );
-  await constantInflowNFT
-    .attach(inNftProxy.address)
-    .initialize(
-      (await GoodDollar.symbol()) + " Inflow NFT",
-      (await GoodDollar.symbol()) + " CIF"
+    await outNftProxy.initializeProxy(constantOutflowNFT.address);
+    await inNftProxy.initializeProxy(constantInflowNFT.address);
+
+    console.log("initializing supergooddollar....");
+    await SuperGoodDollar.attach(GoodDollarProxy.address)[
+      "initialize(string,string,uint256,address,address,address,address)"
+    ](...tokenArgs);
+    const GoodDollar = await ethers.getContractAt(
+      "SuperGoodDollar",
+      GoodDollarProxy.address
     );
+    console.log("supergooddollar created successfully");
 
-  return GoodDollar;
+    await constantOutflowNFT
+      .attach(outNftProxy.address)
+      .initialize(
+        (await GoodDollar.symbol()) + " Outflow NFT",
+        (await GoodDollar.symbol()) + " COF"
+      );
+    await constantInflowNFT
+      .attach(inNftProxy.address)
+      .initialize(
+        (await GoodDollar.symbol()) + " Inflow NFT",
+        (await GoodDollar.symbol()) + " CIF"
+      );
+    return GoodDollar;
+  } else {
+    console.log("initializing supergooddollar....");
+    await SuperGoodDollar.attach(GoodDollarProxy.address)[
+      "initialize(string,string,uint256,address,address,address,address)"
+    ](...tokenArgs);
+    const GoodDollar = await ethers.getContractAt(
+      "SuperGoodDollar",
+      GoodDollarProxy.address
+    );
+    console.log("supergooddollar created successfully");
+    return GoodDollar;
+  }
 };
-export const createDAO = async (tokenType: "super" | "regular" = "super") => {
+export const createDAO = async (
+  tokenType: "super" | "regular" = "super",
+  identity: "v2" | "v3" = "v3"
+) => {
   let [root, ...signers] = await ethers.getSigners();
 
   const sfContracts = await deploySuperFluid();
@@ -122,7 +136,9 @@ export const createDAO = async (tokenType: "super" | "regular" = "super") => {
     root
   );
 
-  const IdentityFactory = await ethers.getContractFactory("IdentityV2");
+  const IdentityFactory = await ethers.getContractFactory(
+    identity === "v2" ? "IdentityV2" : "IdentityV3"
+  );
 
   const FeeFormulaFactory = new ethers.ContractFactory(
     FeeFormulaABI.abi,
@@ -441,10 +457,7 @@ export const createDAO = async (tokenType: "super" | "regular" = "super") => {
   await setDAOAddress("REPUTATION", reputation.address);
 
   console.log("setting reserve token...");
-  await cDAI["mint(address,uint256)"](
-    goodReserve.address,
-    10000
-  );
+  await cDAI["mint(address,uint256)"](goodReserve.address, 10000);
   await setReserveToken(
     cDAI.address,
     "100", //1gd
@@ -511,8 +524,8 @@ export const deployUBI = async (deployedDAO, withFirstClaim = true) => {
   });
 
   let ubiScheme = await upgrades.deployProxy(
-    await ethers.getContractFactory("UBIScheme"),
-    [nameService.address, firstClaim.address, 14],
+    await ethers.getContractFactory("UBISchemeV2"),
+    [nameService.address],
     { kind: "uups" }
   );
 

package/test/identity/IdentityV2.test.ts

@@ -16,6 +16,9 @@ describe("Identity", () => {
 
   let avatar, gd: IGoodDollar, Controller, id: IIdentity;
 
+  const createDAOv2 = async () => {
+    return createDAO("super", "v2");
+  };
   before(async () => {
     [founder, ...signers] = await ethers.getSigners();
     let {
@@ -24,7 +27,7 @@ describe("Identity", () => {
       gd: gooddollar,
       identity: idv2,
       genericCall: gc
-    } = await loadFixture(createDAO);
+    } = await loadFixture(createDAOv2);
 
     genericCall = gc;
     identity = (await ethers.getContractAt("IdentityV2", idv2)) as IdentityV2;