@gooddollar/goodprotocol 2.0.25-beta.0 → 2.0.25-beta.2

package/scripts/analytics/checkBridgeBalances.ts

@@ -0,0 +1,442 @@
+import { groupBy, range, sortBy } from "lodash";
+import PromisePool from "async-promise-pool";
+import fs from "fs";
+import { Provider, setMulticallAddress } from "ethers-multicall";
+
+import { ethers } from "hardhat";
+import { Retrier } from "@jsier/retrier";
+import { BigNumber } from "ethers";
+import EthDater from "ethereum-block-by-date";
+
+setMulticallAddress(122, "0x3CE6158b7278Bf6792e014FA7B4f3c6c46fe9410");
+// "https://celo-mainnet-archive.allthatnode.com" : "https://explorer-node.fuse.io"
+
+const celoProvider = new ethers.providers.JsonRpcProvider("https://celo-mainnet-archive.allthatnode.com");
+const fuseProvider = new ethers.providers.JsonRpcProvider("https://explorer-node.fuse.io");
+const ethProvider = new ethers.providers.JsonRpcProvider("https://ethereum-mainnet-archive.allthatnode.com");
+
+const GD_CELO = "0x62B8B11039FcfE5aB0C56E502b1C372A3d2a9c7A";
+const GD_FUSE = "0x495d133B938596C9984d462F007B676bDc57eCEC";
+const GD_ETH = "0x67C5870b4A41D4Ebef24d2456547A03F1f3e094B";
+const ETH_BRIDGES = [
+  "0xd17652350cfd2a37ba2f947c910987a3b1a1c60d",
+  "0xa3247276DbCC76Dd7705273f766eB3E8a5ecF4a5",
+  "0xD5D11eE582c8931F336fbcd135e98CEE4DB8CCB0",
+  "0x17B09b22823F00BB9b8ee2d4632E332cadC29458"
+];
+
+const CELO_MULTIBRIDGE = "0xf27Ee99622C3C9b264583dACB2cCE056e194494f";
+const CELO_MPBBRIDGE = "0xa3247276DbCC76Dd7705273f766eB3E8a5ecF4a5";
+let gd = new ethers.Contract(
+  GD_CELO,
+  [
+    "event Transfer(address indexed from, address indexed to, uint amount)",
+    "function balanceOf(address) view returns(uint256)",
+    "function totalSupply() view returns(uint256)"
+  ],
+  celoProvider
+);
+
+const multiBridge = new ethers.Contract(
+  CELO_MULTIBRIDGE,
+  [
+    "event LogAnySwapOut(address indexed token,address indexed from,address indexed to,uint256 amount,uint256 fromChainID,uint256 toChainID)",
+    "event LogAnySwapIn(bytes32 indexed txhash,address indexed token,address indexed to,uint256 amount,uint256 fromChainID, uint256 toChainID)"
+  ],
+  celoProvider
+);
+
+const mpbBridge = new ethers.Contract(
+  CELO_MPBBRIDGE,
+  [
+    "event BridgeRequest(address indexed from,address indexed to,uint256 targetChainId,uint256 normalizedAmount,uint256 timestamp,uint8 bridge,uint256 indexed id)",
+    "event ExecutedTransfer(address indexed from,address indexed to,uint256 normalizedAmount,uint256 fee,uint256 sourceChainId,uint8 bridge,uint256 indexed id)"
+  ],
+  celoProvider
+);
+const main = async () => {
+  console.log("starting...");
+
+  //   let mintFuse = await getTransferEvents(
+  //     gd.connect(new ethers.providers.JsonRpcProvider("https://rpc.fuse.io")).attach(GD_FUSE),
+  //     ethers.constants.AddressZero,
+  //     6000000,
+  //     undefined
+  //   );
+  //   fs.writeFileSync("mintFuse.json", JSON.stringify(mintFuse, null, 2));
+  //   mintFuse.forEach(log => (log.amount = log.args.amount.toString()));
+
+  //   const mintFuse = JSON.parse(fs.readFileSync("mintFuse.json").toString());
+
+  //   let mintCelo = await getTransferEvents(gd, ethers.constants.AddressZero, 17000000, undefined);
+  //   fs.writeFileSync("mintCelo.json", JSON.stringify(mintCelo, null, 2));
+
+  if (false) {
+    let multiOut = await fetch(
+      "https://explorer.celo.org/mainnet/api?module=logs&action=getLogs&fromBlock=0&toBlock=latest&address=0xf27Ee99622C3C9b264583dACB2cCE056e194494f&topic0=0x97116cf6cd4f6412bb47914d6db18da9e16ab2142f543b86e207c24fbd16b23a&topic1=0x0000000000000000000000005566b6e4962ba83e05a426ad89031ec18e9cadd3&topic0_1_opr=and"
+    )
+      .then(_ => _.json())
+      .then(_ => _.result);
+
+    console.log("multiOut");
+    let multiIn = await fetch(
+      "https://explorer.celo.org/mainnet/api?module=logs&action=getLogs&fromBlock=0&toBlock=latest&address=0xf27Ee99622C3C9b264583dACB2cCE056e194494f&topic0=0xaac9ce45fe3adf5143598c4f18a369591a20a3384aedaf1b525d29127e1fcd55&topic2=0x0000000000000000000000005566b6e4962ba83e05a426ad89031ec18e9cadd3&topic0_2_opr=and"
+    )
+      .then(_ => _.json())
+      .then(_ => _.result);
+
+    console.log("multiIn");
+    let multiInFuse = await fetch(
+      "https://explorer.fuse.io/api?module=logs&action=getLogs&fromBlock=0&toBlock=latest&address=0x735aBE48e8782948a37C7765ECb76b98CdE97B0F&topic0=0xaac9ce45fe3adf5143598c4f18a369591a20a3384aedaf1b525d29127e1fcd55&topic2=0x000000000000000000000000031b2b7c7854dd8ee9c4a644d7e54ad17f56e3cb&topic0_2_opr=and"
+    )
+      .then(_ => _.json())
+      .then(_ => _.result);
+
+    console.log("multiInFuse");
+    let multiOutFuse = await fetch(
+      "https://explorer.fuse.io/api?module=logs&action=getLogs&fromBlock=0&toBlock=latest&address=0x735aBE48e8782948a37C7765ECb76b98CdE97B0F&topic0=0x97116cf6cd4f6412bb47914d6db18da9e16ab2142f543b86e207c24fbd16b23a&topic1=0x000000000000000000000000031b2b7c7854dd8ee9c4a644d7e54ad17f56e3cb&topic0_1_opr=and"
+    )
+      .then(_ => _.json())
+      .then(_ => _.result);
+
+    console.log("multiOutFuse");
+    let mpbOut = await fetch(
+      "https://explorer.celo.org/mainnet/api?module=logs&action=getLogs&fromBlock=0&toBlock=latest&address=0xa3247276DbCC76Dd7705273f766eB3E8a5ecF4a5&topic0=0xabeeb7182c7294cd8efcd40e9ff952c1b759c2165b3634aac589429de5d55ad0"
+    )
+      .then(_ => _.json())
+      .then(_ => _.result);
+
+    console.log("mpbOut");
+    let mpbIn = await fetch(
+      "https://explorer.celo.org/mainnet/api?module=logs&action=getLogs&fromBlock=0&toBlock=latest&address=0xa3247276DbCC76Dd7705273f766eB3E8a5ecF4a5&topic0=0x6cf712ce908185c8c38a073b7315f79687e7440fb057d9d1ca76a2509a1282ee"
+    )
+      .then(_ => _.json())
+      .then(_ => _.result);
+
+    console.log("mpbIn");
+    let mpbOutFuse = await fetch(
+      "https://explorer.fuse.io/api?module=logs&action=getLogs&fromBlock=0&toBlock=latest&address=0xa3247276DbCC76Dd7705273f766eB3E8a5ecF4a5&topic0=0xabeeb7182c7294cd8efcd40e9ff952c1b759c2165b3634aac589429de5d55ad0"
+    )
+      .then(_ => _.json())
+      .then(_ => _.result);
+
+    console.log("mpbOutFuse");
+    let mpbInFuse = await fetch(
+      "https://explorer.fuse.io/api?module=logs&action=getLogs&fromBlock=0&toBlock=latest&address=0xa3247276DbCC76Dd7705273f766eB3E8a5ecF4a5&topic0=0x6cf712ce908185c8c38a073b7315f79687e7440fb057d9d1ca76a2509a1282ee"
+    )
+      .then(_ => _.json())
+      .then(_ => _.result);
+
+    console.log("mpbInFuse");
+    let outFuse = await fetch(
+      "https://explorer.fuse.io/api?module=logs&action=getLogs&fromBlock=0&toBlock=latest&address=0x495d133B938596C9984d462F007B676bDc57eCEC&topic0=0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef&topic1=0x000000000000000000000000d39021db018e2caeadb4b2e6717d31550e7918d0&topic2=0x0000000000000000000000000000000000000000000000000000000000000000&topic1_2_opr=and&topic0_1_opr=and&topic0_2_opr=and"
+    )
+      .then(_ => _.json())
+      .then(_ => _.result);
+
+    console.log("outFuse");
+    let inFuse = await fetch(
+      "https://explorer.fuse.io/api?module=logs&action=getLogs&fromBlock=0&toBlock=latest&address=0xD39021DB018E2CAEadb4B2e6717D31550e7918D0&topic0=0x2f9a6098d4503a127779ba975f5f6b04f842362b1809f346989e9abc0b4dedb6"
+    )
+      .then(_ => _.json())
+      .then(_ => _.result);
+
+    console.log("inFuse");
+
+    let outFuse2 = await fetch(
+      "https://explorer.fuse.io/api?module=logs&action=getLogs&fromBlock=0&toBlock=latest&address=0x495d133B938596C9984d462F007B676bDc57eCEC&topic0=0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef&topic1=0x000000000000000000000000e24957CB0f0001A03314C72E6EBC331436e2f7F60&topic2=0x0000000000000000000000000000000000000000000000000000000000000000&topic1_2_opr=and&topic0_1_opr=and&topic0_2_opr=and"
+    )
+      .then(_ => _.json())
+      .then(_ => _.result);
+
+    console.log("outFuse");
+    let inFuse2 = await fetch(
+      "https://explorer.fuse.io/api?module=logs&action=getLogs&fromBlock=0&toBlock=latest&address=0xe24957CB0f0001A03314C72E6EBC331436e2f7F6&topic0=0x6fc115a803b8703117d9a3956c5a15401cb42401f91630f015eb6b043fa76253"
+    )
+      .then(_ => _.json())
+      .then(_ => _.result);
+
+    mpbIn.forEach(log => {
+      log.params = ethers.utils.defaultAbiCoder.decode(["uint256", "uint256", "uint256", "uint8"], log.data);
+      log.amount = log.params[0];
+    });
+    mpbOut.forEach(log => {
+      log.params = ethers.utils.defaultAbiCoder.decode(["uint256", "uint256", "uint256", "uint8"], log.data);
+      log.amountOut = log.params[1];
+    });
+    mpbInFuse.forEach(log => {
+      log.params = ethers.utils.defaultAbiCoder.decode(["uint256", "uint256", "uint256", "uint8"], log.data);
+      log.amount = log.params[0];
+    });
+    mpbOutFuse.forEach(log => {
+      log.params = ethers.utils.defaultAbiCoder.decode(["uint256", "uint256", "uint256", "uint8"], log.data);
+      log.amountOut = log.params[1];
+    });
+
+    multiIn.forEach(log => {
+      log.params = ethers.utils.defaultAbiCoder.decode(["uint256", "uint256", "uint256"], log.data);
+      log.amount = log.params[0];
+    });
+    multiOut.forEach(log => {
+      log.params = ethers.utils.defaultAbiCoder.decode(["uint256", "uint256", "uint256"], log.data);
+      log.amountOut = log.params[0];
+    });
+
+    multiInFuse.forEach(log => {
+      log.params = ethers.utils.defaultAbiCoder.decode(["uint256", "uint256", "uint256"], log.data);
+      log.amount = log.params[0];
+    });
+    multiOutFuse.forEach(log => {
+      log.params = ethers.utils.defaultAbiCoder.decode(["uint256", "uint256", "uint256"], log.data);
+      log.amountOut = log.params[0];
+    });
+
+    inFuse.forEach(log => {
+      log.params = ethers.utils.defaultAbiCoder.decode(["uint256"], log.data);
+      log.amount = log.params[0];
+    });
+    outFuse.forEach(log => {
+      log.params = ethers.utils.defaultAbiCoder.decode(["uint256"], log.data);
+      log.amountOut = log.params[0];
+    });
+
+    outFuse2.forEach(log => {
+      log.params = ethers.utils.defaultAbiCoder.decode(["uint256"], log.data);
+      log.amountOut = log.params[0];
+    });
+    inFuse2.forEach(log => {
+      log.params = ethers.utils.defaultAbiCoder.decode(["address", "uint256", "bytes32"], log.data);
+      log.amount = log.params[1];
+    });
+
+    //   console.log({
+    //     mpbOut: mpbOut.length,
+    //     mpbIn: mpbIn.length,
+    //     multiOut: multiOut.length,
+    //     multiIn: multiIn.length,
+    //     multiInFuse: multiInFuse.length,
+    //     multiOutFuse: multiOutFuse.length,
+    //     mpbInFuse: mpbInFuse.length,
+    //     mpbOutFuse: mpbOutFuse.length,
+    //     inFuse: inFuse.length,
+    //     outFuse: outFuse.length,
+    //     inFuse2: inFuse2.length,
+    //     outFuse2: outFuse2.length
+    //     // mintFuse: mintFuse.length
+    //   });
+
+    //   //   const found = []
+    //   //     .concat(mpbIn, multiIn, multiInFuse, mpbInFuse, inFuse)
+    //   //     .filter(_ => _.params[0].gt(ethers.constants.WeiPerEther.mul(180000000)));
+
+    //   const found = [].concat(mpbIn, multiIn, multiInFuse, mpbInFuse, inFuse, inFuse2);
+
+    //   const bytx = Object.entries(groupBy(found, _ => _.transactionHash)).filter((k, v) => (v as any).length > 1);
+
+    //   console.log({ bytx });
+
+    //   //   const bridgeMintsTxs = found.map(_ => _.transactionHash);
+    //   //   const nonBridgeMints = mintCelo.filter(l => !bridgeMintsTxs.includes(l.transactionHash));
+    //   //   console.log(
+    //   //     "nonbridgemints celo:",
+    //   //     nonBridgeMints.map(_ => _.transactionHash)
+    //   //   );
+    //   //   return;
+
+    //   let totalMpbOut = mpbOut
+    //     .filter(_ => _.params[0].eq(1))
+    //     .reduce((prev, cur) => prev.add(ethers.BigNumber.from(cur.params[1])), ethers.constants.Zero);
+
+    //   let totalMpbIn = mpbIn
+    //     .filter(_ => _.params[2].eq(1))
+    //     .reduce((prev, cur) => prev.add(ethers.BigNumber.from(cur.params[0])), ethers.constants.Zero);
+
+    //   totalMpbOut = mpbOutFuse
+    //     .filter(_ => _.params[0].eq(1))
+    //     .reduce((prev, cur) => prev.add(ethers.BigNumber.from(cur.params[1])), totalMpbOut);
+
+    //   totalMpbIn = mpbInFuse
+    //     .filter(_ => _.params[2].eq(1))
+    //     .reduce((prev, cur) => prev.add(ethers.BigNumber.from(cur.params[0])), totalMpbIn);
+
+    //   let totalMultiOut = multiOut
+    //     .filter(l => l.params[2].eq(1))
+    //     .reduce((prev, cur) => prev.add(ethers.BigNumber.from(cur.params[0])), ethers.constants.Zero);
+
+    //   let totalMultiIn = multiIn
+    //     .filter(l => l.params[1].eq(1))
+    //     .reduce((prev, cur) => prev.add(ethers.BigNumber.from(cur.params[0])), ethers.constants.Zero);
+
+    //   totalMultiOut = multiOutFuse
+    //     .filter(l => l.params[2].eq(1))
+    //     .reduce((prev, cur) => prev.add(ethers.BigNumber.from(cur.params[0])), totalMultiOut);
+    //   totalMultiIn = multiInFuse
+    //     .filter(l => l.params[1].eq(1))
+    //     .reduce((prev, cur) => prev.add(ethers.BigNumber.from(cur.params[0])), totalMultiIn);
+
+    //   let totalInFuse = inFuse.reduce((prev, cur) => prev.add(ethers.BigNumber.from(cur.params[0])), ethers.constants.Zero);
+
+    //   let totalOutFuse = outFuse.reduce(
+    //     (prev, cur) => prev.add(ethers.BigNumber.from(cur.params[0])),
+    //     ethers.constants.Zero
+    //   );
+
+    //   let totalInFuse2 = inFuse2.reduce(
+    //     (prev, cur) => prev.add(ethers.BigNumber.from(cur.params[0])),
+    //     ethers.constants.Zero
+    //   );
+
+    //   let totalOutFuse2 = outFuse2.reduce(
+    //     (prev, cur) => prev.add(ethers.BigNumber.from(cur.params[1])),
+    //     ethers.constants.Zero
+    //   );
+
+    //   console.log({
+    //     totalMpbOut,
+    //     totalMpbIn,
+    //     totalMultiOut,
+    //     totalMultiIn,
+    //     totalInFuse,
+    //     totalOutFuse,
+    //     totalInFuse2,
+    //     totalOutFuse2
+    //   });
+
+    //   const all = [].concat(
+    //     mpbIn.filter(_ => _.params[2].eq(1)),
+    //     mpbOut.filter(_ => _.params[0].eq(1)),
+    //     multiIn.filter(l => l.params[1].eq(1)),
+    //     multiOut.filter(l => l.params[2].eq(1)),
+    //     multiInFuse.filter(l => l.params[1].eq(1)),
+    //     multiOutFuse.filter(l => l.params[2].eq(1)),
+    //     mpbInFuse.filter(_ => _.params[2].eq(1)),
+    //     mpbOutFuse.filter(_ => _.params[0].eq(1)),
+    //     inFuse,
+    //     outFuse,
+    //     outFuse2,
+    //     inFuse2
+    //   );
+
+    //   fs.writeFileSync("allBridgeEvents.json", JSON.stringify(all));
+  }
+  const all = JSON.parse(fs.readFileSync("allBridgeEvents.json").toString());
+
+  let counter = 0;
+  let total = ethers.constants.Zero;
+  const gdEth = gd.connect(ethProvider).attach(GD_ETH);
+  const sorted = sortBy(all, _ => Number(_.timeStamp));
+  console.log(sorted.slice(0, 10));
+
+  const ethDater = new EthDater(ethProvider);
+  const fuseDater = new EthDater(fuseProvider);
+  const celoDater = new EthDater(celoProvider);
+
+  for (let log of sorted) {
+    if (log.amountOut) {
+      log.amountOut = ethers.BigNumber.from(log.amountOut.hex);
+      total = total.sub(
+        log.amountOut.gte(ethers.constants.WeiPerEther)
+          ? log.amountOut.div(ethers.constants.WeiPerEther)
+          : log.amountOut.div(100)
+      );
+    }
+    if (log.amount) {
+      log.amount = ethers.BigNumber.from(log.amount.hex);
+      total = total.add(
+        log.amount.gte(ethers.constants.WeiPerEther)
+          ? log.amount.div(ethers.constants.WeiPerEther)
+          : log.amount.div(100)
+      );
+    }
+    counter++;
+    if (
+      counter >= 1040 ||
+      (counter >= 950 && counter % 10 === 0) ||
+      counter % 100 === 0 ||
+      counter >= sorted.length - 1
+    ) {
+      //   const [tx, tx2] = await Promise.all([
+      //     fuseProvider.getTransaction(log.transactionHash),
+      //     celoProvider.getTransaction(log.transactionHash)
+      //   ]);
+      const timestamp = Number(log.timeStamp);
+      const [ethBlock, fuseBlock, celoBlock] = await Promise.all([
+        ethDater.getDate(timestamp * 1000, false, false),
+        fuseDater.getDate(timestamp * 1000, true, false),
+        celoDater.getDate(timestamp * 1000, true, false)
+      ]);
+      console.log("counter:", counter, timestamp, { ethBlock, fuseBlock, celoBlock });
+
+      const res = await Promise.all(
+        ETH_BRIDGES.map(b => gdEth.balanceOf(b, { blockTag: ethBlock.block }).catch(_ => ethers.constants.Zero))
+      );
+      const [onFuse, onCelo] = await Promise.all([
+        gd
+          .connect(fuseProvider)
+          .attach(GD_FUSE)
+          .totalSupply({ blockTag: fuseBlock.block })
+          .catch(_ => ethers.constants.Zero),
+        gd.totalSupply({ blockTag: celoBlock.block }).catch(_ => ethers.constants.Zero)
+      ]);
+      const onBridges = res.reduce((prev, cur) => prev.add(cur), ethers.constants.Zero).div(100);
+      console.log(
+        "bridged:" + total.toString(),
+        "on bridges:" + onBridges.toString(),
+        "on chains:",
+        onCelo.div(ethers.constants.WeiPerEther).add(onFuse.div(100)).toString(),
+        "time:",
+        timestamp,
+        {
+          onFuse,
+          onCelo
+        },
+        res.map(_ => _.toString())
+      );
+    }
+  }
+  //
+
+  //   console.log(txs.length);
+  //   fs.writeFileSync("stuckgd.json", JSON.stringify(txs));
+};
+
+const getTransferEvents = async (gd, from, fromBlock, toBlock) => {
+  const curBlock = toBlock || (await gd.provider.getBlockNumber());
+  let txs = [];
+  const f = gd.filters.Transfer(from, null);
+  const STEP_SIZE = 10000;
+  const fromBlocks = range(fromBlock, curBlock, STEP_SIZE);
+  const pool = new PromisePool({ concurrency: 2 });
+  console.log({ curBlock });
+  fromBlocks.forEach(start => {
+    pool.add(async () => {
+      const options = { limit: 3, delay: 2000 };
+      const retrier = new Retrier(options);
+
+      const results = await retrier
+        .resolve(() => gd.queryFilter(f, start, start + STEP_SIZE))
+        .catch(e => console.warn("queryfilter failed:", { start }));
+      if (!results) return;
+
+      txs = txs.concat(results);
+      console.log({ start }, results.length);
+    });
+  });
+
+  await pool.all();
+  return txs;
+};
+
+// const analyze = () => {
+//   const txs = JSON.parse(fs.readFileSync("stuckgd.json").toString());
+//   let value = 0;
+//   console.log(txs[0]);
+//   txs.forEach(tx => {
+//     value += Number(tx.args[2].hex);
+//     console.log(`erc20,${GD_CELO},${tx.args[0]},${Number(tx.args[2].hex) / 1e18},`);
+//   });
+//   console.log(txs.length, { value });
+// };
+// analyze();
+
+main().catch(e => console.error("Error:", e.message));

package/scripts/multichain-deploy/helpers.ts

@@ -306,9 +306,9 @@ export const executeViaSafe = async (
       const [, target] = contract.split("_");
       const simulationResult = await ethers.provider.call({
         to: target,
-        value: ethValues[i],
         data: encoded,
-        from: safeAddress
+        from: safeAddress,
+        value: ethValues[i]
       });
 
       console.log("executing from guardians safe:", {
@@ -348,8 +348,7 @@ export const executeViaSafe = async (
       });
 
       const simulationResult = await ctrl.callStatic.genericCall(contract, encoded, release.Avatar, ethValues[i], {
-        from: safeAddress,
-        value: ethValues[i]
+        from: safeAddress
       });
       console.log("executing genericCall simulation result:", {
         sigHash,
@@ -364,7 +363,7 @@ export const executeViaSafe = async (
       ]);
       safeTransactionData.push({
         to: ctrl.address,
-        value: ethValues[i],
+        value: "0",
         data: genericEncode
       });
     }

package/test/staking/FuseStaking.test.ts

@@ -12,12 +12,7 @@ describe("FuseStakingV3", () => {
   let founder, staker1, staker2;
   let signers;
 
-  let uniswap: waffle.MockContract,
-    uniswapFactory,
-    uniswapPair,
-    gdusdcPair,
-    fusefusdPair,
-    ubiMock;
+  let uniswap: waffle.MockContract, uniswapFactory, uniswapPair, gdusdcPair, fusefusdPair, ubiMock;
 
   const deployMocks = async () => {
     let u = await hre.artifacts.readArtifact("Uniswap");
@@ -35,24 +30,14 @@ describe("FuseStakingV3", () => {
     await uniswap.mock.WETH.returns(signers[3].address);
     await uniswapFactory.mock.getPair.returns(uniswapPair.address);
     await uniswapFactory.mock.getPair
-      .withArgs(
-        ethers.constants.AddressZero,
-        "0x620fd5fa44BE6af63715Ef4E65DDFA0387aD13F5"
-      )
+      .withArgs(ethers.constants.AddressZero, "0x620fd5fa44BE6af63715Ef4E65DDFA0387aD13F5")
       .returns(gdusdcPair.address);
 
     await uniswapFactory.mock.getPair
-      .withArgs(
-        signers[3].address,
-        "0x249BE57637D8B013Ad64785404b24aeBaE9B098B"
-      )
+      .withArgs(signers[3].address, "0x249BE57637D8B013Ad64785404b24aeBaE9B098B")
       .returns(fusefusdPair.address);
 
-    await uniswapPair.mock.getReserves.returns(
-      ethers.utils.parseEther("1000"),
-      "100000",
-      "0"
-    );
+    await uniswapPair.mock.getReserves.returns(ethers.utils.parseEther("1000"), "100000", "0");
     await gdusdcPair.mock.getReserves.returns("4984886100", "10789000000", "0");
     await fusefusdPair.mock.getReserves.returns(
       ethers.utils.parseEther("10000"),
@@ -67,9 +52,7 @@ describe("FuseStakingV3", () => {
     await deployMocks();
 
     let network = networkConfig.name;
-    staking = (await (
-      await ethers.getContractFactory("FuseStakingV3")
-    ).deploy()) as FuseStakingV3;
+    staking = (await (await ethers.getContractFactory("FuseStakingV3")).deploy()) as FuseStakingV3;
 
     await staking.initialize(uniswap.address, NULL_ADDRESS);
     await staking.setUBIScheme(ubiMock.address);
@@ -80,54 +63,42 @@ describe("FuseStakingV3", () => {
   });
 
   it("should calc quantity with slippage", async () => {
-    const res = await staking[
-      "calcMaxTokenWithPriceImpact(uint256,uint256,uint256)"
-    ]("6917100025787759640000", "265724494", ethers.utils.parseEther("500"));
+    const res = await staking["calcMaxTokenWithPriceImpact(uint256,uint256,uint256)"](
+      "6917100025787759640000",
+      "265724494",
+      ethers.utils.parseEther("500")
+    );
 
     // const fuseQuantity = ethers.utils.formatEther(res);
     expect(res.maxToken).to.gt(0);
-    expect(res.maxToken).to.equal(
-      BigNumber.from("6917100025787759640000").mul(3).div(100)
-    );
-    expect(res.tokenOut).to.equal(7717004);
+    expect(res.maxToken).to.equal(BigNumber.from("6917100025787759640000").mul(6).div(1000));
+    expect(res.tokenOut).to.equal(1580111);
   });
 
   it("should calc quantity with uniswap mock", async () => {
-    const res = await staking["calcMaxFuseWithPriceImpact(uint256)"](
-      ethers.utils.parseEther("500")
-    );
+    const res = await staking["calcMaxFuseWithPriceImpact(uint256)"](ethers.utils.parseEther("500"));
 
     // const fuseQuantity = ethers.utils.formatEther(res);
     expect(res.fuseAmount).to.gt(0);
-    expect(res.fuseAmount).to.equal(ethers.utils.parseEther("30"));
+    expect(res.fuseAmount).to.equal(ethers.utils.parseEther("6"));
 
-    await uniswapPair.mock.getReserves.returns(
-      ethers.utils.parseEther("100"),
-      "500000",
-      "0"
-    );
-    const res2 = await staking["calcMaxFuseWithPriceImpact(uint256)"](
-      ethers.utils.parseEther("500")
-    );
+    await uniswapPair.mock.getReserves.returns(ethers.utils.parseEther("100"), "500000", "0");
+    const res2 = await staking["calcMaxFuseWithPriceImpact(uint256)"](ethers.utils.parseEther("500"));
 
-    expect(res2.fuseAmount).to.equal(ethers.utils.parseEther("3"));
+    expect(res2.fuseAmount).to.equal(ethers.utils.parseEther("0.6"));
   });
 
   it("should calculate gd/usdc quantity with 0 price impact ", async () => {
-    const res = await staking["calcMaxFuseUSDCWithPriceImpact(uint256)"](
-      ethers.utils.parseEther("10")
-    );
+    const res = await staking["calcMaxFuseUSDCWithPriceImpact(uint256)"](ethers.utils.parseEther("10"));
     //exchanging 10 fuse which are equal 2$ USDC should have no significant price impact on usdc/gd swap so we should be able to swap the whole 10
     expect(res.maxFuse).to.gt(0);
     expect(res.maxFuse).to.equal(ethers.utils.parseEther("10"));
   });
 
   it("should detect gd/usdc price impact", async () => {
-    const res = await staking["calcMaxFuseUSDCWithPriceImpact(uint256)"](
-      ethers.utils.parseEther("10000")
-    );
+    const res = await staking["calcMaxFuseUSDCWithPriceImpact(uint256)"](ethers.utils.parseEther("10000"));
     expect(res.maxFuse).to.lt(ethers.utils.parseEther("10000"));
-    expect(res.maxFuse).to.equal(ethers.utils.parseEther("1618.35")); //on fuse swap it was around 335$ on above gd/usdc reserves that reaches 3% impact, that means 335*5=1675fuse
+    expect(res.maxFuse).to.equal(ethers.utils.parseEther("323.67")); //on fuse swap it was around 335$ on above gd/usdc reserves that reaches 3% impact, that means 335*5=1675fuse
   });
 
   it("should match fuseswap and allow to exchange +-4600 fuse to G$", async () => {
@@ -141,10 +112,8 @@ describe("FuseStakingV3", () => {
       "0"
     );
 
-    const res = await staking["calcMaxFuseUSDCWithPriceImpact(uint256)"](
-      ethers.utils.parseEther("10000")
-    );
-    expect(res.maxFuse).to.lt(ethers.utils.parseEther("5000"));
-    expect(res.maxFuse).to.gt(ethers.utils.parseEther("4500"));
+    const res = await staking["calcMaxFuseUSDCWithPriceImpact(uint256)"](ethers.utils.parseEther("10000"));
+    expect(res.maxFuse).to.lt(ethers.utils.parseEther("1000"));
+    expect(res.maxFuse).to.gt(ethers.utils.parseEther("450"));
   });
 });

package/types/contracts/staking/FuseStakingV3.sol/FuseStakingV3.ts

@@ -70,7 +70,7 @@ export interface FuseStakingV3Interface extends utils.Interface {
     "uniswap()": FunctionFragment;
     "uniswapFactory()": FunctionFragment;
     "uniswapPair()": FunctionFragment;
-    "updateSettings(uint256,uint256)": FunctionFragment;
+    "updateSettings(uint256,uint256,uint256)": FunctionFragment;
     "upgrade()": FunctionFragment;
     "validators(uint256)": FunctionFragment;
     "withdraw(uint256)": FunctionFragment;
@@ -245,7 +245,7 @@ export interface FuseStakingV3Interface extends utils.Interface {
   ): string;
   encodeFunctionData(
     functionFragment: "updateSettings",
-    values: [BigNumberish, BigNumberish]
+    values: [BigNumberish, BigNumberish, BigNumberish]
   ): string;
   encodeFunctionData(functionFragment: "upgrade", values?: undefined): string;
   encodeFunctionData(
@@ -608,6 +608,7 @@ export interface FuseStakingV3 extends BaseContract {
     updateSettings(
       _stakeBackRatio: BigNumberish,
       _communityPoolRatio: BigNumberish,
+      _maxSlippageRatio: BigNumberish,
       overrides?: Overrides & { from?: string }
     ): Promise<ContractTransaction>;
 
@@ -767,6 +768,7 @@ export interface FuseStakingV3 extends BaseContract {
   updateSettings(
     _stakeBackRatio: BigNumberish,
     _communityPoolRatio: BigNumberish,
+    _maxSlippageRatio: BigNumberish,
     overrides?: Overrides & { from?: string }
   ): Promise<ContractTransaction>;
 
@@ -905,6 +907,7 @@ export interface FuseStakingV3 extends BaseContract {
     updateSettings(
       _stakeBackRatio: BigNumberish,
       _communityPoolRatio: BigNumberish,
+      _maxSlippageRatio: BigNumberish,
       overrides?: CallOverrides
     ): Promise<void>;
 
@@ -1087,6 +1090,7 @@ export interface FuseStakingV3 extends BaseContract {
     updateSettings(
       _stakeBackRatio: BigNumberish,
       _communityPoolRatio: BigNumberish,
+      _maxSlippageRatio: BigNumberish,
       overrides?: Overrides & { from?: string }
     ): Promise<BigNumber>;
 
@@ -1251,6 +1255,7 @@ export interface FuseStakingV3 extends BaseContract {
     updateSettings(
       _stakeBackRatio: BigNumberish,
       _communityPoolRatio: BigNumberish,
+      _maxSlippageRatio: BigNumberish,
       overrides?: Overrides & { from?: string }
     ): Promise<PopulatedTransaction>;