From c0155b6edf30392d697931d2339f27f53d8a1826 Mon Sep 17 00:00:00 2001
From: aalavandhann <6264334+aalavandhan@users.noreply.github.com>
Date: Thu, 21 Mar 2024 22:38:14 -0400
Subject: [PATCH] updated hardhat version and test-suite to support new
 interface/balancer

---
 .github/workflows/nightly.yml                 |    2 +-
 .github/workflows/test.yml                    |    2 +-
 .nvmrc                                        |    2 +-
 .../contracts/_interfaces/IBalancer.sol       |    2 +-
 spot-contracts/contracts/_test/DMock.sol      |   52 +
 .../contracts/_test/HelpersTester.sol         |   16 +-
 .../contracts/_test/mocks/MockVault.sol       |   32 +-
 spot-contracts/hardhat.config.ts              |   10 +-
 spot-contracts/package.json                   |   26 +-
 spot-contracts/test/BondIssuer.ts             |  130 +-
 spot-contracts/test/FeePolicy.ts              |  542 --
 spot-contracts/test/RouterV2.ts               |  149 -
 spot-contracts/test/RouterV3.ts               |  256 +
 spot-contracts/test/_utils/HelpersTester.ts   |  230 +-
 spot-contracts/test/_utils/Sigmoid.ts         |   68 +-
 spot-contracts/test/balancer/Balancer.ts      |  730 ++
 .../test/balancer/Balancer_mint_redeem.ts     | 1294 +++
 spot-contracts/test/helpers.ts                |  245 +-
 spot-contracts/test/perp/PerpetualTranche.ts  |  480 +-
 .../test/perp/PerpetualTranche_deposit.ts     |  281 +-
 .../test/perp/PerpetualTranche_redeem.ts      |  285 +-
 .../test/perp/PerpetualTranche_rollover.ts    |  403 +-
 .../test/rollover-vault/RolloverVault.ts      |  138 +-
 .../rollover-vault/RolloverVault_deploy.ts    |  169 +-
 .../RolloverVault_deposit_redeem.ts           |  589 +-
 .../rollover-vault/RolloverVault_recover.ts   |  274 +-
 .../test/rollover-vault/RolloverVault_swap.ts |  988 +--
 yarn.lock                                     | 6991 +++--------------
 28 files changed, 5021 insertions(+), 9365 deletions(-)
 create mode 100644 spot-contracts/contracts/_test/DMock.sol
 delete mode 100644 spot-contracts/test/FeePolicy.ts
 delete mode 100644 spot-contracts/test/RouterV2.ts
 create mode 100644 spot-contracts/test/RouterV3.ts
 create mode 100644 spot-contracts/test/balancer/Balancer.ts
 create mode 100644 spot-contracts/test/balancer/Balancer_mint_redeem.ts

diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml
index d6658bc6..4aecfd8a 100644
--- a/.github/workflows/nightly.yml
+++ b/.github/workflows/nightly.yml
@@ -11,7 +11,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        node-version: [16.x]
+        node-version: [20.x]
         os: [ubuntu-latest]
 
     steps:
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index b4842eae..5d6e8eda 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -12,7 +12,7 @@ jobs:
 
     strategy:
       matrix:
-        node-version: [16.x]
+        node-version: [20.x]
         os: [ubuntu-latest]
 
     steps:
diff --git a/.nvmrc b/.nvmrc
index b6a7d89c..209e3ef4 100644
--- a/.nvmrc
+++ b/.nvmrc
@@ -1 +1 @@
-16
+20
diff --git a/spot-contracts/contracts/_interfaces/IBalancer.sol b/spot-contracts/contracts/_interfaces/IBalancer.sol
index 4ad9b3e9..1ce9136d 100644
--- a/spot-contracts/contracts/_interfaces/IBalancer.sol
+++ b/spot-contracts/contracts/_interfaces/IBalancer.sol
@@ -14,7 +14,7 @@ interface IBalancer {
     /// @notice Emits the component and the token denomination and amount of fees collected.
     /// @param collector Address of fee recipient.
     /// @param token Address of fee token.
-    /// @param balance The amount tokens paid as fees.
+    /// @param amount The amount tokens paid as fees.
     event Fee(address collector, IERC20Upgradeable token, uint256 amount);
 
     //--------------------------------------------------------------------------
diff --git a/spot-contracts/contracts/_test/DMock.sol b/spot-contracts/contracts/_test/DMock.sol
new file mode 100644
index 00000000..ff0cac3b
--- /dev/null
+++ b/spot-contracts/contracts/_test/DMock.sol
@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+contract DMock {
+    struct MockCall {
+        bytes data;
+        bytes returnValue;
+    }
+
+    // Maps a method signature to its mock call definition
+    mapping(bytes32 => MockCall) public mockCalls;
+
+    // Fallback function to handle all calls
+    // solhint-disable-next-line
+    fallback(bytes calldata) external returns (bytes memory) {
+        // Check if mock has been defined based on {sig,param} pair
+        MockCall storage mockCall_ = mockCalls[keccak256(msg.data)];
+
+        // else check if generic mock has been defined based on sig
+        if (mockCall_.data.length <= 0) {
+            mockCall_ = mockCalls[keccak256(abi.encodePacked(bytes4(msg.data)))];
+        }
+
+        // solhint-disable-next-line custom-errors
+        require(mockCall_.data.length > 0, "DMock: method not mocked");
+
+        // Return the mocked return value
+        return mockCall_.returnValue;
+    }
+
+    // Function to set up a mock call, given method sig and parameters
+    function mockCall(bytes memory data, bytes memory returnValue) public {
+        mockCalls[keccak256(data)] = MockCall(data, returnValue);
+    }
+
+    // Function to set up a mock call, given just method sig
+    function mockMethod(bytes4 sig, bytes memory returnValue) public {
+        bytes memory data = abi.encodePacked(sig);
+        mockCalls[keccak256(data)] = MockCall(data, returnValue);
+    }
+
+    // Function to clear mocked call
+    function clearMockCall(bytes memory data) public {
+        delete mockCalls[keccak256(data)];
+    }
+
+    // Function to clear mocked method call
+    function clearMockMethodSig(bytes4 sig) public {
+        bytes memory data = abi.encodePacked(sig);
+        delete mockCalls[keccak256(data)];
+    }
+}
diff --git a/spot-contracts/contracts/_test/HelpersTester.sol b/spot-contracts/contracts/_test/HelpersTester.sol
index b082b957..971aeb69 100644
--- a/spot-contracts/contracts/_test/HelpersTester.sol
+++ b/spot-contracts/contracts/_test/HelpersTester.sol
@@ -29,12 +29,12 @@ contract HelpersTester {
         return b.trancheAt(index);
     }
 
-    function getSeniorTranche(IBondController b) public view returns (ITranche) {
-        return b.getSeniorTranche();
+    function seniorTranche(IBondController b) public view returns (ITranche) {
+        return b.seniorTranche();
     }
 
-    function getSeniorTrancheRatio(IBondController b) public view returns (uint256) {
-        return b.getSeniorTrancheRatio();
+    function seniorTrancheRatio(IBondController b) public view returns (uint256) {
+        return b.seniorTrancheRatio();
     }
 
     function previewDeposit(IBondController b, uint256 collateralAmount) public view returns (TokenAmount[] memory) {
@@ -66,8 +66,8 @@ contract HelpersTester {
         IPerpetualTranche perp,
         uint256 perpTVL,
         uint256 perpAmtToMint
-    ) public returns (uint256, uint256) {
-        IBondController depositBond = perp.getDepositBond();
+    ) public view returns (uint256, uint256) {
+        IBondController depositBond = perp.depositBond();
         return
             PerpHelpers.estimateUnderlyingAmtToTranche(
                 PerpHelpers.MintEstimationParams({
@@ -77,8 +77,8 @@ contract HelpersTester {
                         address(depositBond)
                     ),
                     depositBondTotalDebt: depositBond.totalDebt(),
-                    depositTrancheSupply: (depositBond.getSeniorTranche()).totalSupply(),
-                    depositTrancheTR: depositBond.getSeniorTrancheRatio()
+                    depositTrancheSupply: (depositBond.seniorTranche()).totalSupply(),
+                    depositTrancheTR: depositBond.seniorTrancheRatio()
                 }),
                 perpAmtToMint
             );
diff --git a/spot-contracts/contracts/_test/mocks/MockVault.sol b/spot-contracts/contracts/_test/mocks/MockVault.sol
index 1c9c8415..33bf0dc5 100644
--- a/spot-contracts/contracts/_test/mocks/MockVault.sol
+++ b/spot-contracts/contracts/_test/mocks/MockVault.sol
@@ -2,43 +2,13 @@
 pragma solidity ^0.8.20;
 
 import { IPerpetualTranche, IERC20Upgradeable, ITranche } from "../../_interfaces/IPerpetualTranche.sol";
-import { TokenAmount, RolloverData } from "../../_interfaces/CommonTypes.sol";
+import { RolloverData } from "../../_interfaces/CommonTypes.sol";
 
 contract MockVault {
     function getTVL() public pure returns (uint256) {
         return 0;
     }
 
-    function mintPerps(IPerpetualTranche perp, ITranche trancheIn, uint256 trancheInAmt) public {
-        trancheIn.transferFrom(msg.sender, address(this), trancheInAmt);
-
-        trancheIn.approve(address(perp), trancheInAmt);
-        perp.deposit(trancheIn, trancheInAmt);
-
-        perp.transfer(msg.sender, perp.balanceOf(address(this)));
-    }
-
-    function computePerpMintAmt(
-        IPerpetualTranche perp,
-        ITranche trancheIn,
-        uint256 trancheInAmt
-    ) public returns (uint256) {
-        return perp.computeMintAmt(trancheIn, trancheInAmt);
-    }
-
-    function redeemPerps(IPerpetualTranche perp, uint256 perpAmt) public {
-        perp.transferFrom(msg.sender, address(this), perpAmt);
-        TokenAmount[] memory tokensOut = perp.redeem(perpAmt);
-        for (uint256 i = 0; i < tokensOut.length; ++i) {
-            IERC20Upgradeable tokenOut = tokensOut[i].token;
-            tokenOut.transfer(msg.sender, tokenOut.balanceOf(address(this)));
-        }
-    }
-
-    function computePerpRedemptionAmts(IPerpetualTranche perp, uint256 perpAmt) public returns (TokenAmount[] memory) {
-        return perp.computeRedemptionAmts(perpAmt);
-    }
-
     function rollover(
         IPerpetualTranche perp,
         ITranche trancheIn,
diff --git a/spot-contracts/hardhat.config.ts b/spot-contracts/hardhat.config.ts
index 5d66ddf7..6f9d1bed 100644
--- a/spot-contracts/hardhat.config.ts
+++ b/spot-contracts/hardhat.config.ts
@@ -1,7 +1,7 @@
 import { HardhatUserConfig } from "hardhat/config";
 import { Wallet } from "ethers";
 
-import "@nomiclabs/hardhat-ethers";
+import "@nomicfoundation/hardhat-ethers";
 import "@nomicfoundation/hardhat-chai-matchers";
 import "@nomicfoundation/hardhat-verify";
 import "@openzeppelin/hardhat-upgrades";
@@ -9,10 +9,10 @@ import "solidity-coverage";
 import "hardhat-gas-reporter";
 
 // Loads custom tasks
-import "./tasks/tools";
-import "./tasks/deploy";
-import "./tasks/upgrade";
-import "./tasks/ops";
+// import "./tasks/tools";
+// import "./tasks/deploy";
+// import "./tasks/upgrade";
+// import "./tasks/ops";
 
 // Loads env variables from .env file
 import * as dotenv from "dotenv";
diff --git a/spot-contracts/package.json b/spot-contracts/package.json
index 28a57f1d..79dff853 100644
--- a/spot-contracts/package.json
+++ b/spot-contracts/package.json
@@ -16,22 +16,21 @@
     "test": "yarn hardhat test test/*.ts test/**/*.ts"
   },
   "dependencies": {
-    "@openzeppelin/contracts-upgradeable": "^4.7.3"
+    "@openzeppelin/contracts-upgradeable": "4.7.3"
   },
   "devDependencies": {
-    "@defi-wonderland/smock": "^2.3.4",
     "@ethersproject/abi": "^5.6.4",
     "@ethersproject/abstract-provider": "^5.7.0",
     "@ethersproject/abstract-signer": "^5.7.0",
     "@ethersproject/bytes": "^5.6.1",
     "@ethersproject/providers": "^5.6.8",
-    "@nomicfoundation/hardhat-chai-matchers": "^1.0.6",
-    "@nomicfoundation/hardhat-verify": "^1.1.0",
-    "@nomiclabs/hardhat-ethers": "^2.2.1",
-    "@nomiclabs/hardhat-waffle": "^2.0.3",
-    "@openzeppelin/hardhat-upgrades": "^1.19.0",
+    "@nomicfoundation/hardhat-chai-matchers": "latest",
+    "@nomicfoundation/hardhat-ethers": "^3.0.0",
+    "@nomicfoundation/hardhat-verify": "latest",
+    "@nomiclabs/hardhat-waffle": "^2.0.6",
+    "@openzeppelin/hardhat-upgrades": "^3.0.4",
     "@openzeppelin/upgrades-core": "latest",
-    "@typechain/ethers-v5": "^10.1.0",
+    "@typechain/ethers-v6": "^0.5.1",
     "@typechain/hardhat": "^6.1.2",
     "@types/chai": "^4.3.1",
     "@types/mocha": "^9.1.1",
@@ -51,11 +50,12 @@
     "eslint-plugin-prettier": "^4.2.1",
     "eslint-plugin-promise": "^6.0.0",
     "eslint-plugin-unused-imports": "^3.0.0",
-    "ethereum-waffle": "^3.4.4",
-    "ethers": "^5.6.9",
-    "ganache-cli": "^6.12.2",
-    "hardhat": "^2.19.4",
-    "hardhat-gas-reporter": "^1.0.9",
+    "ethereum-waffle": "latest",
+    "ethers": "^6.6.0",
+    "ethers-v5": "npm:ethers@^5.7.0",
+    "ganache-cli": "latest",
+    "hardhat": "^2.22.1",
+    "hardhat-gas-reporter": "latest",
     "lodash": "^4.17.21",
     "prettier": "^2.7.1",
     "prettier-plugin-solidity": "^1.0.0-dev.23",
diff --git a/spot-contracts/test/BondIssuer.ts b/spot-contracts/test/BondIssuer.ts
index f27497b1..54b9100f 100644
--- a/spot-contracts/test/BondIssuer.ts
+++ b/spot-contracts/test/BondIssuer.ts
@@ -13,14 +13,16 @@ describe("BondIssuer", function () {
     const accounts = await ethers.getSigners();
     deployer = accounts[0];
     otherUser = accounts[1];
+
     bondFactory = await setupBondFactory();
+
     const Token = await ethers.getContractFactory("MockERC20");
     token = await Token.deploy();
     await token.init("Test token", "TEST");
     const BondIssuer = await ethers.getContractFactory("BondIssuer");
     issuer = await upgrades.deployProxy(
       BondIssuer.connect(deployer),
-      [bondFactory.address, token.address, 86400, [200, 300, 500], 3600, 900],
+      [bondFactory.target, token.target, 86400, [200, 300, 500], 3600, 900],
       {
         initializer: "init(address,address,uint256,uint256[],uint256,uint256)",
       },
@@ -29,17 +31,17 @@ describe("BondIssuer", function () {
   });
 
   afterEach(async function () {
-    await network.provider.send("hardhat_reset");
+    await network.provider.request({ method: "hardhat_reset" });
   });
 
   describe("#setup", function () {
     it("should set storage parameters", async function () {
       expect(await issuer.owner()).to.eq(await deployer.getAddress());
-      expect(await issuer.bondFactory()).to.eq(bondFactory.address);
+      expect(await issuer.bondFactory()).to.eq(bondFactory.target);
       expect(await issuer.minIssueTimeIntervalSec()).to.eq(3600);
       expect(await issuer.issueWindowOffsetSec()).to.eq(900);
       expect(await issuer.maxMaturityDuration()).to.eq(86400);
-      expect(await issuer.collateral()).to.eq(token.address);
+      expect(await issuer.collateral()).to.eq(token.target);
       expect(await issuer.trancheRatios(0)).to.eq(200);
       expect(await issuer.trancheRatios(1)).to.eq(300);
       expect(await issuer.trancheRatios(2)).to.eq(500);
@@ -117,12 +119,12 @@ describe("BondIssuer", function () {
         await TimeHelpers.setNextBlockTimestamp(mockTime(901));
         const tx = await issuer.issue();
         const txR = await tx.wait();
-        const bondIssuedEvent = txR.events[txR.events.length - 1];
-        const bond = bondIssuedEvent.args.bond;
+        const bondIssuedLog = txR.logs[txR.logs.length - 1];
+        const bond = bondIssuedLog.args.bond;
 
         expect(tx).to.emit(issuer, "BondIssued");
         expect(await issuer.isInstance(bond)).to.eq(true);
-        expect(await issuer.callStatic.getLatestBond()).to.eq(bond);
+        expect(await issuer.getLatestBond.staticCall()).to.eq(bond);
         expect(await issuer.lastIssueWindowTimestamp()).to.eq(mockTime(900));
 
         expect(await issuer.issuedCount()).to.eq(1);
@@ -204,7 +206,7 @@ describe("BondIssuer", function () {
   describe("#getLatestBond", function () {
     describe("when a new bond is up to be issued", function () {
       it("should issue a new bond and return the new bond", async function () {
-        const bond = await issuer.callStatic.getLatestBond();
+        const bond = await issuer.getLatestBond.staticCall();
         await expect(issuer.getLatestBond()).to.emit(issuer, "BondIssued").withArgs(bond);
       });
     });
@@ -213,9 +215,9 @@ describe("BondIssuer", function () {
       it("should return the last bond", async function () {
         const tx = await issuer.issue();
         const txR = await tx.wait();
-        const bondIssuedEvent = txR.events[txR.events.length - 1];
-        const bond = bondIssuedEvent.args.bond;
-        expect(await issuer.callStatic.getLatestBond()).to.eq(bond);
+        const bondIssuedLog = txR.logs[txR.logs.length - 1];
+        const bond = bondIssuedLog.args.bond;
+        expect(await issuer.getLatestBond.staticCall()).to.eq(bond);
         await expect(issuer.getLatestBond()).to.not.emit(issuer, "BondIssued");
       });
     });
@@ -239,23 +241,23 @@ describe("BondIssuer", function () {
       beforeEach(async function () {
         await TimeHelpers.setNextBlockTimestamp(mockTime(900));
         await issuer.issue();
-        lastBond = await bondAt(await issuer.callStatic.getLatestBond());
+        lastBond = await bondAt(await issuer.getLatestBond.staticCall());
         expect(await issuer.issuedCount()).to.eq(1);
-        expect(await issuer.issuedBondAt(0)).to.eq(lastBond.address);
+        expect(await issuer.issuedBondAt(0)).to.eq(lastBond.target);
         expect(await issuer.activeCount()).to.eq(1);
-        expect(await issuer.activeBondAt(0)).to.eq(lastBond.address);
+        expect(await issuer.activeBondAt(0)).to.eq(lastBond.target);
 
         await TimeHelpers.setNextBlockTimestamp(mockTime(87301));
         tx = issuer.matureActive();
         await tx;
       });
       it("should emit mature", async function () {
-        await expect(tx).to.emit(issuer, "BondMature").withArgs(lastBond.address);
+        await expect(tx).to.emit(issuer, "BondMature").withArgs(lastBond.target);
         await expect(tx).to.emit(lastBond, "Mature");
       });
       it("should keep track of active and mature bonds", async function () {
         expect(await issuer.issuedCount()).to.eq(1);
-        expect(await issuer.issuedBondAt(0)).to.eq(lastBond.address);
+        expect(await issuer.issuedBondAt(0)).to.eq(lastBond.target);
         expect(await issuer.activeCount()).to.eq(0);
         await expect(issuer.activeBondAt(0)).to.be.reverted;
       });
@@ -266,9 +268,9 @@ describe("BondIssuer", function () {
       beforeEach(async function () {
         await TimeHelpers.setNextBlockTimestamp(mockTime(900));
         await issuer.issue();
-        lastBond = await bondAt(await issuer.callStatic.getLatestBond());
+        lastBond = await bondAt(await issuer.getLatestBond.staticCall());
         expect(await issuer.issuedCount()).to.eq(1);
-        expect(await issuer.issuedBondAt(0)).to.eq(lastBond.address);
+        expect(await issuer.issuedBondAt(0)).to.eq(lastBond.target);
 
         await TimeHelpers.setNextBlockTimestamp(mockTime(87301));
         await lastBond.mature();
@@ -281,7 +283,7 @@ describe("BondIssuer", function () {
       });
       it("should keep track of active and mature bonds", async function () {
         expect(await issuer.issuedCount()).to.eq(1);
-        expect(await issuer.issuedBondAt(0)).to.eq(lastBond.address);
+        expect(await issuer.issuedBondAt(0)).to.eq(lastBond.target);
         expect(await issuer.activeCount()).to.eq(0);
         await expect(issuer.activeBondAt(0)).to.be.reverted;
       });
@@ -292,41 +294,41 @@ describe("BondIssuer", function () {
       beforeEach(async function () {
         await TimeHelpers.setNextBlockTimestamp(mockTime(900));
         await issuer.issue();
-        b1 = await bondAt(await issuer.callStatic.getLatestBond());
+        b1 = await bondAt(await issuer.getLatestBond.staticCall());
 
         await TimeHelpers.setNextBlockTimestamp(mockTime(83700));
         await issuer.issue();
-        b2 = await bondAt(await issuer.callStatic.getLatestBond());
+        b2 = await bondAt(await issuer.getLatestBond.staticCall());
 
         await TimeHelpers.setNextBlockTimestamp(mockTime(87300));
         await issuer.issue();
-        b3 = await bondAt(await issuer.callStatic.getLatestBond());
+        b3 = await bondAt(await issuer.getLatestBond.staticCall());
 
         expect(await issuer.issuedCount()).to.eq(3);
-        expect(await issuer.issuedBondAt(0)).to.eq(b1.address);
-        expect(await issuer.issuedBondAt(1)).to.eq(b2.address);
-        expect(await issuer.issuedBondAt(2)).to.eq(b3.address);
+        expect(await issuer.issuedBondAt(0)).to.eq(b1.target);
+        expect(await issuer.issuedBondAt(1)).to.eq(b2.target);
+        expect(await issuer.issuedBondAt(2)).to.eq(b3.target);
 
         expect(await issuer.activeCount()).to.eq(3);
-        expect(await issuer.activeBondAt(0)).to.eq(b1.address);
-        expect(await issuer.activeBondAt(1)).to.eq(b2.address);
-        expect(await issuer.activeBondAt(2)).to.eq(b3.address);
+        expect(await issuer.activeBondAt(0)).to.eq(b1.target);
+        expect(await issuer.activeBondAt(1)).to.eq(b2.target);
+        expect(await issuer.activeBondAt(2)).to.eq(b3.target);
 
         tx = issuer.matureActive();
         await tx;
       });
       it("should emit mature on the oldest bond", async function () {
         await expect(tx).to.emit(b1, "Mature");
-        await expect(tx).to.emit(issuer, "BondMature").withArgs(b1.address);
+        await expect(tx).to.emit(issuer, "BondMature").withArgs(b1.target);
       });
       it("should keep track of active and mature bonds", async function () {
         expect(await issuer.issuedCount()).to.eq(3);
-        expect(await issuer.issuedBondAt(0)).to.eq(b1.address);
-        expect(await issuer.issuedBondAt(1)).to.eq(b2.address);
-        expect(await issuer.issuedBondAt(2)).to.eq(b3.address);
+        expect(await issuer.issuedBondAt(0)).to.eq(b1.target);
+        expect(await issuer.issuedBondAt(1)).to.eq(b2.target);
+        expect(await issuer.issuedBondAt(2)).to.eq(b3.target);
         expect(await issuer.activeCount()).to.eq(2);
-        expect(await issuer.activeBondAt(0)).to.eq(b3.address);
-        expect(await issuer.activeBondAt(1)).to.eq(b2.address);
+        expect(await issuer.activeBondAt(0)).to.eq(b3.target);
+        expect(await issuer.activeBondAt(1)).to.eq(b2.target);
         await expect(issuer.activeBondAt(2)).to.be.reverted;
       });
     });
@@ -336,44 +338,44 @@ describe("BondIssuer", function () {
       beforeEach(async function () {
         await TimeHelpers.setNextBlockTimestamp(mockTime(900));
         await issuer.issue();
-        b1 = await bondAt(await issuer.callStatic.getLatestBond());
+        b1 = await bondAt(await issuer.getLatestBond.staticCall());
 
         await TimeHelpers.setNextBlockTimestamp(mockTime(83700));
         await issuer.issue();
-        b2 = await bondAt(await issuer.callStatic.getLatestBond());
+        b2 = await bondAt(await issuer.getLatestBond.staticCall());
 
         await TimeHelpers.setNextBlockTimestamp(mockTime(87300));
         await issuer.issue();
-        b3 = await bondAt(await issuer.callStatic.getLatestBond());
+        b3 = await bondAt(await issuer.getLatestBond.staticCall());
 
         await TimeHelpers.setNextBlockTimestamp(mockTime(170100));
 
         expect(await issuer.issuedCount()).to.eq(3);
-        expect(await issuer.issuedBondAt(0)).to.eq(b1.address);
-        expect(await issuer.issuedBondAt(1)).to.eq(b2.address);
-        expect(await issuer.issuedBondAt(2)).to.eq(b3.address);
+        expect(await issuer.issuedBondAt(0)).to.eq(b1.target);
+        expect(await issuer.issuedBondAt(1)).to.eq(b2.target);
+        expect(await issuer.issuedBondAt(2)).to.eq(b3.target);
 
         expect(await issuer.activeCount()).to.eq(3);
-        expect(await issuer.activeBondAt(0)).to.eq(b1.address);
-        expect(await issuer.activeBondAt(1)).to.eq(b2.address);
-        expect(await issuer.activeBondAt(2)).to.eq(b3.address);
+        expect(await issuer.activeBondAt(0)).to.eq(b1.target);
+        expect(await issuer.activeBondAt(1)).to.eq(b2.target);
+        expect(await issuer.activeBondAt(2)).to.eq(b3.target);
 
         tx = issuer.matureActive();
         await tx;
       });
       it("should emit mature", async function () {
         await expect(tx).to.emit(b1, "Mature");
-        await expect(tx).to.emit(issuer, "BondMature").withArgs(b1.address);
+        await expect(tx).to.emit(issuer, "BondMature").withArgs(b1.target);
         await expect(tx).to.emit(b2, "Mature");
-        await expect(tx).to.emit(issuer, "BondMature").withArgs(b2.address);
+        await expect(tx).to.emit(issuer, "BondMature").withArgs(b2.target);
       });
       it("should keep track of active and mature bonds", async function () {
         expect(await issuer.issuedCount()).to.eq(3);
-        expect(await issuer.issuedBondAt(0)).to.eq(b1.address);
-        expect(await issuer.issuedBondAt(1)).to.eq(b2.address);
-        expect(await issuer.issuedBondAt(2)).to.eq(b3.address);
+        expect(await issuer.issuedBondAt(0)).to.eq(b1.target);
+        expect(await issuer.issuedBondAt(1)).to.eq(b2.target);
+        expect(await issuer.issuedBondAt(2)).to.eq(b3.target);
         expect(await issuer.activeCount()).to.eq(1);
-        expect(await issuer.activeBondAt(0)).to.eq(b3.address);
+        expect(await issuer.activeBondAt(0)).to.eq(b3.target);
         await expect(issuer.activeBondAt(1)).to.be.reverted;
       });
     });
@@ -383,44 +385,44 @@ describe("BondIssuer", function () {
       beforeEach(async function () {
         await TimeHelpers.setNextBlockTimestamp(mockTime(900));
         await issuer.issue();
-        b1 = await bondAt(await issuer.callStatic.getLatestBond());
+        b1 = await bondAt(await issuer.getLatestBond.staticCall());
 
         await TimeHelpers.setNextBlockTimestamp(mockTime(83700));
         await issuer.issue();
-        b2 = await bondAt(await issuer.callStatic.getLatestBond());
+        b2 = await bondAt(await issuer.getLatestBond.staticCall());
 
         await TimeHelpers.setNextBlockTimestamp(mockTime(87300));
         await issuer.issue();
-        b3 = await bondAt(await issuer.callStatic.getLatestBond());
+        b3 = await bondAt(await issuer.getLatestBond.staticCall());
 
         await TimeHelpers.setNextBlockTimestamp(mockTime(260100));
 
         expect(await issuer.issuedCount()).to.eq(3);
-        expect(await issuer.issuedBondAt(0)).to.eq(b1.address);
-        expect(await issuer.issuedBondAt(1)).to.eq(b2.address);
-        expect(await issuer.issuedBondAt(2)).to.eq(b3.address);
+        expect(await issuer.issuedBondAt(0)).to.eq(b1.target);
+        expect(await issuer.issuedBondAt(1)).to.eq(b2.target);
+        expect(await issuer.issuedBondAt(2)).to.eq(b3.target);
 
         expect(await issuer.activeCount()).to.eq(3);
-        expect(await issuer.activeBondAt(0)).to.eq(b1.address);
-        expect(await issuer.activeBondAt(1)).to.eq(b2.address);
-        expect(await issuer.activeBondAt(2)).to.eq(b3.address);
+        expect(await issuer.activeBondAt(0)).to.eq(b1.target);
+        expect(await issuer.activeBondAt(1)).to.eq(b2.target);
+        expect(await issuer.activeBondAt(2)).to.eq(b3.target);
 
         tx = issuer.matureActive();
         await tx;
       });
       it("should emit mature", async function () {
         await expect(tx).to.emit(b1, "Mature");
-        await expect(tx).to.emit(issuer, "BondMature").withArgs(b1.address);
+        await expect(tx).to.emit(issuer, "BondMature").withArgs(b1.target);
         await expect(tx).to.emit(b2, "Mature");
-        await expect(tx).to.emit(issuer, "BondMature").withArgs(b2.address);
+        await expect(tx).to.emit(issuer, "BondMature").withArgs(b2.target);
         await expect(tx).to.emit(b3, "Mature");
-        await expect(tx).to.emit(issuer, "BondMature").withArgs(b3.address);
+        await expect(tx).to.emit(issuer, "BondMature").withArgs(b3.target);
       });
       it("should keep track of active and mature bonds", async function () {
         expect(await issuer.issuedCount()).to.eq(3);
-        expect(await issuer.issuedBondAt(0)).to.eq(b1.address);
-        expect(await issuer.issuedBondAt(1)).to.eq(b2.address);
-        expect(await issuer.issuedBondAt(2)).to.eq(b3.address);
+        expect(await issuer.issuedBondAt(0)).to.eq(b1.target);
+        expect(await issuer.issuedBondAt(1)).to.eq(b2.target);
+        expect(await issuer.issuedBondAt(2)).to.eq(b3.target);
         expect(await issuer.activeCount()).to.eq(0);
         await expect(issuer.activeBondAt(0)).to.be.reverted;
       });
diff --git a/spot-contracts/test/FeePolicy.ts b/spot-contracts/test/FeePolicy.ts
deleted file mode 100644
index a4660029..00000000
--- a/spot-contracts/test/FeePolicy.ts
+++ /dev/null
@@ -1,542 +0,0 @@
-import { expect, use } from "chai";
-import { ethers, upgrades } from "hardhat";
-import { Contract, Signer } from "ethers";
-import { smock } from "@defi-wonderland/smock";
-
-import { toPercFixedPtAmt, toFixedPtAmt } from "./helpers";
-use(smock.matchers);
-
-let feePolicy: Contract, deployer: Signer, otherUser: Signer;
-const toPerc = toPercFixedPtAmt;
-const toAmt = toFixedPtAmt;
-
-describe("FeePolicy", function () {
-  beforeEach(async function () {
-    const accounts = await ethers.getSigners();
-    deployer = accounts[0];
-    otherUser = accounts[1];
-
-    const FeePolicy = await ethers.getContractFactory("FeePolicy");
-    feePolicy = await upgrades.deployProxy(FeePolicy.connect(deployer), [], {
-      initializer: "init()",
-    });
-  });
-
-  describe("#init", function () {
-    it("should return the initial parameters", async function () {
-      expect(await feePolicy.targetSubscriptionRatio()).to.eq(toPerc("1.33"));
-      expect(await feePolicy.deviationRatioBoundLower()).to.eq(toPerc("0.75"));
-      expect(await feePolicy.deviationRatioBoundUpper()).to.eq(toPerc("2"));
-    });
-    it("should return owner", async function () {
-      expect(await feePolicy.owner()).to.eq(await deployer.getAddress());
-    });
-    it("should return decimals", async function () {
-      expect(await feePolicy.decimals()).to.eq(8);
-    });
-  });
-
-  describe("#updateTargetSubscriptionRatio", function () {
-    describe("when triggered by non-owner", function () {
-      it("should revert", async function () {
-        await expect(feePolicy.connect(otherUser).updateTargetSubscriptionRatio(toPerc("1.25"))).to.be.revertedWith(
-          "Ownable: caller is not the owner",
-        );
-      });
-    });
-
-    describe("when parameters are invalid", function () {
-      it("should revert", async function () {
-        await expect(
-          feePolicy.connect(deployer).updateTargetSubscriptionRatio(toPerc("0.5")),
-        ).to.be.revertedWithCustomError(feePolicy, "InvalidTargetSRBounds");
-      });
-    });
-
-    describe("when parameters are invalid", function () {
-      it("should revert", async function () {
-        await expect(
-          feePolicy.connect(deployer).updateTargetSubscriptionRatio(toPerc("2.1")),
-        ).to.be.revertedWithCustomError(feePolicy, "InvalidTargetSRBounds");
-      });
-    });
-
-    describe("when triggered by owner", function () {
-      it("should update the target sr", async function () {
-        expect(await feePolicy.targetSubscriptionRatio()).to.eq(toPerc("1.33"));
-        await feePolicy.connect(deployer).updateTargetSubscriptionRatio(toPerc("1.25"));
-        expect(await feePolicy.targetSubscriptionRatio()).to.eq(toPerc("1.25"));
-      });
-    });
-  });
-
-  describe("#updateDeviationRatioBounds", function () {
-    describe("when triggered by non-owner", function () {
-      it("should revert", async function () {
-        await expect(
-          feePolicy.connect(otherUser).updateDeviationRatioBounds(toPerc("1"), toPerc("1")),
-        ).to.be.revertedWith("Ownable: caller is not the owner");
-      });
-    });
-
-    describe("when parameters are invalid", function () {
-      it("should revert", async function () {
-        await expect(
-          feePolicy.connect(deployer).updateDeviationRatioBounds(toPerc("1.01"), toPerc("2")),
-        ).to.be.revertedWithCustomError(feePolicy, "InvalidDRBounds");
-      });
-    });
-
-    describe("when parameters are invalid", function () {
-      it("should revert", async function () {
-        await expect(
-          feePolicy.connect(deployer).updateDeviationRatioBounds(toPerc("0.5"), toPerc("0.99")),
-        ).to.be.revertedWithCustomError(feePolicy, "InvalidDRBounds");
-      });
-    });
-
-    describe("when triggered by owner", function () {
-      it("should update the target sr", async function () {
-        expect(await feePolicy.deviationRatioBoundLower()).to.eq(toPerc("0.75"));
-        expect(await feePolicy.deviationRatioBoundUpper()).to.eq(toPerc("2"));
-        await feePolicy.connect(deployer).updateDeviationRatioBounds(toPerc("0.5"), toPerc("1.5"));
-        expect(await feePolicy.deviationRatioBoundLower()).to.eq(toPerc("0.5"));
-        expect(await feePolicy.deviationRatioBoundUpper()).to.eq(toPerc("1.5"));
-      });
-    });
-  });
-
-  describe("#updatePerpMintFees", function () {
-    describe("when triggered by non-owner", function () {
-      it("should revert", async function () {
-        await expect(feePolicy.connect(otherUser).updatePerpMintFees(toPerc("0.01"))).to.be.revertedWith(
-          "Ownable: caller is not the owner",
-        );
-      });
-    });
-
-    describe("when parameters are invalid", function () {
-      it("should revert", async function () {
-        await expect(feePolicy.connect(deployer).updatePerpMintFees(toPerc("1.01"))).to.be.revertedWithCustomError(
-          feePolicy,
-          "InvalidPerc",
-        );
-      });
-    });
-
-    describe("when triggered by owner", function () {
-      it("should update the mint fees", async function () {
-        expect(await feePolicy.computePerpMintFeePerc()).to.eq("0");
-        await feePolicy.connect(deployer).updatePerpMintFees(toPerc("0.01"));
-        expect(await feePolicy.computePerpMintFeePerc()).to.eq(toPerc("0.01"));
-      });
-    });
-  });
-
-  describe("#updatePerpBurnFees", function () {
-    describe("when triggered by non-owner", function () {
-      it("should revert", async function () {
-        await expect(feePolicy.connect(otherUser).updatePerpBurnFees(toPerc("0.01"))).to.be.revertedWith(
-          "Ownable: caller is not the owner",
-        );
-      });
-    });
-
-    describe("when parameters are invalid", function () {
-      it("should revert", async function () {
-        await expect(feePolicy.connect(deployer).updatePerpBurnFees(toPerc("1.01"))).to.be.revertedWithCustomError(
-          feePolicy,
-          "InvalidPerc",
-        );
-      });
-    });
-
-    describe("when triggered by owner", function () {
-      it("should update the burn fees", async function () {
-        expect(await feePolicy.computePerpBurnFeePerc()).to.eq("0");
-        await feePolicy.connect(deployer).updatePerpBurnFees(toPerc("0.01"));
-        expect(await feePolicy.computePerpBurnFeePerc()).to.eq(toPerc("0.01"));
-      });
-    });
-  });
-
-  describe("#updatePerpRolloverFees", function () {
-    describe("when triggered by non-owner", function () {
-      it("should revert", async function () {
-        await expect(
-          feePolicy.connect(otherUser).updatePerpRolloverFees({
-            lower: toPerc("-0.01"),
-            upper: toPerc("0.01"),
-            growth: toPerc("3"),
-          }),
-        ).to.be.revertedWith("Ownable: caller is not the owner");
-      });
-    });
-
-    describe("when parameters are invalid", function () {
-      it("should revert", async function () {
-        await expect(
-          feePolicy.connect(deployer).updatePerpRolloverFees({
-            lower: toPerc("-0.011"),
-            upper: toPerc("0.01"),
-            growth: toPerc("3"),
-          }),
-        ).to.be.revertedWithCustomError(feePolicy, "InvalidSigmoidAsymptotes");
-      });
-      it("should revert", async function () {
-        await expect(
-          feePolicy.connect(deployer).updatePerpRolloverFees({
-            lower: toPerc("-0.01"),
-            upper: toPerc("0.011"),
-            growth: toPerc("3"),
-          }),
-        ).to.be.revertedWithCustomError(feePolicy, "InvalidSigmoidAsymptotes");
-      });
-
-      it("should revert", async function () {
-        await expect(
-          feePolicy.connect(deployer).updatePerpRolloverFees({
-            lower: toPerc("0.02"),
-            upper: toPerc("0.01"),
-            growth: toPerc("3"),
-          }),
-        ).to.be.revertedWithCustomError(feePolicy, "InvalidSigmoidAsymptotes");
-      });
-    });
-
-    describe("when triggered by owner", function () {
-      it("should update parameters", async function () {
-        expect(await feePolicy.computePerpRolloverFeePerc(toPerc("1"))).to.eq(0);
-        expect(await feePolicy.computePerpRolloverFeePerc(toPerc("10"))).to.eq(toPerc("0.00769230"));
-        expect(await feePolicy.computePerpRolloverFeePerc("0")).to.eq(toPerc("-0.00245837"));
-
-        await feePolicy.connect(deployer).updatePerpRolloverFees({
-          lower: toPerc("-0.009"),
-          upper: toPerc("0.009"),
-          growth: toPerc("3"),
-        });
-
-        expect(await feePolicy.computePerpRolloverFeePerc(toPerc("1"))).to.eq(0);
-        expect(await feePolicy.computePerpRolloverFeePerc(toPerc("10"))).to.eq(toPerc("0.009"));
-        expect(await feePolicy.computePerpRolloverFeePerc("0")).to.eq(toPerc("-0.007"));
-      });
-    });
-  });
-
-  describe("#updateVaultMintFees", function () {
-    describe("when triggered by non-owner", function () {
-      it("should revert", async function () {
-        await expect(feePolicy.connect(otherUser).updateVaultMintFees(toPerc("0.01"))).to.be.revertedWith(
-          "Ownable: caller is not the owner",
-        );
-      });
-    });
-
-    describe("when parameters are invalid", function () {
-      it("should revert", async function () {
-        await expect(feePolicy.connect(deployer).updateVaultMintFees(toPerc("1.01"))).to.be.revertedWithCustomError(
-          feePolicy,
-          "InvalidPerc",
-        );
-      });
-    });
-
-    describe("when triggered by owner", function () {
-      beforeEach(async function () {});
-      it("should update the vault mint fees", async function () {
-        expect(await feePolicy.computeVaultMintFeePerc()).to.eq("0");
-        await feePolicy.connect(deployer).updateVaultMintFees(toPerc("0.025"));
-        expect(await feePolicy.computeVaultMintFeePerc()).to.eq(toPerc("0.025"));
-      });
-    });
-  });
-
-  describe("#updateVaultBurnFees", function () {
-    describe("when triggered by non-owner", function () {
-      it("should revert", async function () {
-        await expect(feePolicy.connect(otherUser).updateVaultBurnFees(toPerc("0.01"))).to.be.revertedWith(
-          "Ownable: caller is not the owner",
-        );
-      });
-    });
-
-    describe("when parameters are invalid", function () {
-      it("should revert", async function () {
-        await expect(feePolicy.connect(deployer).updateVaultBurnFees(toPerc("1.01"))).to.be.revertedWithCustomError(
-          feePolicy,
-          "InvalidPerc",
-        );
-      });
-    });
-
-    describe("when triggered by owner", function () {
-      it("should update the vault burn fees", async function () {
-        expect(await feePolicy.computeVaultBurnFeePerc()).to.eq("0");
-        await feePolicy.connect(deployer).updateVaultBurnFees(toPerc("0.025"));
-        expect(await feePolicy.computeVaultBurnFeePerc()).to.eq(toPerc("0.025"));
-      });
-    });
-  });
-
-  describe("#updateVaultUnderlyingToPerpSwapFeePerc", function () {
-    describe("when triggered by non-owner", function () {
-      it("should revert", async function () {
-        await expect(
-          feePolicy.connect(otherUser).updateVaultUnderlyingToPerpSwapFeePerc(toPerc("0.1")),
-        ).to.be.revertedWith("Ownable: caller is not the owner");
-      });
-    });
-
-    describe("when parameters are invalid", function () {
-      it("should revert", async function () {
-        await expect(
-          feePolicy.connect(deployer).updateVaultUnderlyingToPerpSwapFeePerc(toPerc("1.01")),
-        ).to.be.revertedWithCustomError(feePolicy, "InvalidPerc");
-      });
-    });
-
-    describe("when triggered by owner", function () {
-      it("should update the vault burn fees", async function () {
-        expect(await feePolicy.computeUnderlyingToPerpVaultSwapFeePerc(toPerc("1.01"), toPerc("1.01"))).to.eq(
-          toPerc("1"),
-        );
-        await feePolicy.connect(deployer).updateVaultUnderlyingToPerpSwapFeePerc(toPerc("0.1"));
-        expect(await feePolicy.computeUnderlyingToPerpVaultSwapFeePerc(toPerc("1.01"), toPerc("1.01"))).to.eq(
-          toPerc("0.1"),
-        );
-      });
-    });
-  });
-
-  describe("#updateVaultPerpToUnderlyingSwapFeePerc", function () {
-    describe("when triggered by non-owner", function () {
-      it("should revert", async function () {
-        await expect(
-          feePolicy.connect(otherUser).updateVaultPerpToUnderlyingSwapFeePerc(toPerc("0.1")),
-        ).to.be.revertedWith("Ownable: caller is not the owner");
-      });
-    });
-
-    describe("when parameters are invalid", function () {
-      it("should revert", async function () {
-        await expect(
-          feePolicy.connect(deployer).updateVaultPerpToUnderlyingSwapFeePerc(toPerc("1.01")),
-        ).to.be.revertedWithCustomError(feePolicy, "InvalidPerc");
-      });
-    });
-
-    describe("when triggered by owner", function () {
-      it("should update the vault burn fees", async function () {
-        expect(await feePolicy.computePerpToUnderlyingVaultSwapFeePerc(toPerc("1"), toPerc("1"))).to.eq(toPerc("1"));
-        await feePolicy.connect(deployer).updateVaultPerpToUnderlyingSwapFeePerc(toPerc("0.2"));
-        expect(await feePolicy.computePerpToUnderlyingVaultSwapFeePerc(toPerc("1"), toPerc("1"))).to.eq(toPerc("0.2"));
-      });
-    });
-  });
-
-  describe("fee logic", function () {
-    beforeEach(async function () {
-      await feePolicy.updatePerpMintFees(toPerc("0.025"));
-      await feePolicy.updatePerpBurnFees(toPerc("0.035"));
-      await feePolicy.updatePerpRolloverFees({
-        lower: toPerc("-0.00253"),
-        upper: toPerc("0.00769"),
-        growth: toPerc("5"),
-      });
-      await feePolicy.updateVaultUnderlyingToPerpSwapFeePerc(toPerc("0.1"));
-      await feePolicy.updateVaultPerpToUnderlyingSwapFeePerc(toPerc("0.15"));
-      await feePolicy.updateVaultMintFees(toPerc("0.05"));
-      await feePolicy.updateVaultBurnFees(toPerc("0.075"));
-      await feePolicy.updateDeviationRatioBounds(toPerc("0.85"), toPerc("1.15"));
-    });
-
-    describe("when dr is decreasing", function () {
-      async function cmpFees(dr1, dr2, fees) {
-        // perp mint, vault burn and swap u2p
-        expect(await feePolicy.computePerpMintFeePerc()).to.eq(toPerc(fees[0]));
-        expect(await feePolicy.computeVaultBurnFeePerc()).to.eq(toPerc(fees[1]));
-        expect(await feePolicy.computeUnderlyingToPerpVaultSwapFeePerc(toPerc(dr1), toPerc(dr2))).to.eq(
-          toPerc(fees[2]),
-        );
-      }
-
-      describe("when ONE < dr2, dr1", function () {
-        it("should compute fees as expected", async function () {
-          await cmpFees("1.1", "1.01", ["0.025", "0.075", "0.1"]);
-        });
-      });
-
-      describe("when ONE <= dr2, dr1", function () {
-        it("should compute fees as expected", async function () {
-          await cmpFees("1.01", "1", ["0.025", "0.075", "0.1"]);
-        });
-      });
-
-      describe("when dr2 < ONE < dr1", function () {
-        it("should compute fees as expected", async function () {
-          await cmpFees("1.05", "0.95", ["0.025", "0.075", "0.1"]);
-        });
-      });
-
-      describe("when dr2 < ONE < dr1", function () {
-        it("should compute fees as expected", async function () {
-          await cmpFees("1.01", "0.96", ["0.025", "0.075", "0.1"]);
-        });
-      });
-
-      describe("when dr2 < ONE < dr1", function () {
-        it("should compute fees as expected", async function () {
-          await cmpFees("1.1", "0.99", ["0.025", "0.075", "0.1"]);
-        });
-      });
-
-      describe("when dr2,dr1 < ONE", function () {
-        it("should compute fees as expected", async function () {
-          await cmpFees("0.99", "0.95", ["0.025", "0.075", "0.1"]);
-        });
-      });
-
-      describe("when dr2 < lower < dr1 < ONE", function () {
-        it("should compute fees as expected", async function () {
-          await cmpFees("0.9", "0.8", ["0.025", "0.075", "1"]);
-        });
-      });
-
-      describe("when dr2 < lower < ONE < dr1", function () {
-        it("should compute fees as expected", async function () {
-          await cmpFees("1.2", "0.8", ["0.025", "0.075", "1"]);
-        });
-      });
-
-      describe("when dr2,dr1 < lower", function () {
-        it("should compute fees as expected", async function () {
-          await cmpFees("0.8", "0.75", ["0.025", "0.075", "1"]);
-        });
-      });
-    });
-
-    describe("when dr is increasing", function () {
-      async function cmpFees(dr1, dr2, fees) {
-        // perp burn, vault mint and swap p2u
-        expect(await feePolicy.computePerpBurnFeePerc()).to.eq(toPerc(fees[0]));
-        expect(await feePolicy.computeVaultMintFeePerc()).to.eq(toPerc(fees[1]));
-        expect(await feePolicy.computePerpToUnderlyingVaultSwapFeePerc(toPerc(dr1), toPerc(dr2))).to.eq(
-          toPerc(fees[2]),
-        );
-      }
-
-      describe("when dr1, dr2 < ONE", function () {
-        it("should compute fees as expected", async function () {
-          await cmpFees("0.9", "0.99", ["0.035", "0.05", "0.15"]);
-        });
-      });
-
-      describe("when dr1, dr2 <= ONE", function () {
-        it("should compute fees as expected", async function () {
-          await cmpFees("0.9", "1", ["0.035", "0.05", "0.15"]);
-        });
-      });
-
-      describe("when dr1 < ONE < dr2", function () {
-        it("should compute fees as expected", async function () {
-          await cmpFees("0.95", "1.05", ["0.035", "0.05", "0.15"]);
-        });
-      });
-
-      describe("when dr1 < ONE < dr2", function () {
-        it("should compute fees as expected", async function () {
-          await cmpFees("0.99", "1.04", ["0.035", "0.05", "0.15"]);
-        });
-      });
-
-      describe("when dr1 < ONE < dr2", function () {
-        it("should compute fees as expected", async function () {
-          await cmpFees("0.99", "1.1", ["0.035", "0.05", "0.15"]);
-        });
-      });
-
-      describe("when ONE < dr1, dr2 < upper", function () {
-        it("should compute fees as expected", async function () {
-          await cmpFees("1.01", "1.05", ["0.035", "0.05", "0.15"]);
-        });
-      });
-
-      describe("when ONE < dr1 < upper < dr2", function () {
-        it("should compute fees as expected", async function () {
-          await cmpFees("1.01", "1.25", ["0.035", "0.05", "1"]);
-        });
-      });
-
-      describe("when dr1 < ONE < upper < dr2", function () {
-        it("should compute fees as expected", async function () {
-          await cmpFees("1.01", "1.25", ["0.035", "0.05", "1"]);
-        });
-      });
-
-      describe("when upper < dr1, dr2", function () {
-        it("should compute fees as expected", async function () {
-          await cmpFees("1.25", "1.35", ["0.035", "0.05", "1"]);
-        });
-      });
-    });
-
-    describe("rollover fee", function () {
-      it("should compute fees as expected", async function () {
-        expect(await feePolicy.computePerpRolloverFeePerc(toPerc("0.01"))).to.eq(toPerc("-0.00242144"));
-        expect(await feePolicy.computePerpRolloverFeePerc(toPerc("0.25"))).to.eq(toPerc("-0.00228606"));
-        expect(await feePolicy.computePerpRolloverFeePerc(toPerc("0.5"))).to.eq(toPerc("-0.00196829"));
-        expect(await feePolicy.computePerpRolloverFeePerc(toPerc("0.75"))).to.eq(toPerc("-0.00128809"));
-        expect(await feePolicy.computePerpRolloverFeePerc(toPerc("0.9"))).to.eq(toPerc("-0.00060117"));
-        expect(await feePolicy.computePerpRolloverFeePerc(toPerc("0.99"))).to.eq(toPerc("-0.00004101"));
-        expect(await feePolicy.computePerpRolloverFeePerc(toPerc("1"))).to.eq("0");
-        expect(await feePolicy.computePerpRolloverFeePerc(toPerc("1.01"))).to.eq(toPerc("0.00004146"));
-        expect(await feePolicy.computePerpRolloverFeePerc(toPerc("1.05"))).to.eq(toPerc("0.00034407"));
-        expect(await feePolicy.computePerpRolloverFeePerc(toPerc("1.1"))).to.eq(toPerc("0.00071519"));
-        expect(await feePolicy.computePerpRolloverFeePerc(toPerc("1.25"))).to.eq(toPerc("0.00195646"));
-        expect(await feePolicy.computePerpRolloverFeePerc(toPerc("1.5"))).to.eq(toPerc("0.00411794"));
-        expect(await feePolicy.computePerpRolloverFeePerc(toPerc("1.75"))).to.eq(toPerc("0.00580663"));
-        expect(await feePolicy.computePerpRolloverFeePerc(toPerc("2"))).to.eq(toPerc("0.00680345"));
-        expect(await feePolicy.computePerpRolloverFeePerc(toPerc("5"))).to.eq(toPerc("0.00768997"));
-      });
-    });
-  });
-
-  describe("#computeDeviationRatio", async function () {
-    beforeEach(async function () {
-      await feePolicy.updateTargetSubscriptionRatio(toPerc("1.25"));
-    });
-
-    describe("when deviation = 1.0", function () {
-      it("should return 1", async function () {
-        const r = await feePolicy["computeDeviationRatio((uint256,uint256,uint256))"]({
-          perpTVL: toAmt("100"),
-          vaultTVL: toAmt("500"),
-          seniorTR: 200,
-        });
-        expect(r).to.eq(toPerc("1"));
-      });
-    });
-
-    describe("when deviation > 1.0", function () {
-      it("should compute dr", async function () {
-        const r = await feePolicy["computeDeviationRatio((uint256,uint256,uint256))"]({
-          perpTVL: toAmt("100"),
-          vaultTVL: toAmt("1000"),
-          seniorTR: 200,
-        });
-        expect(r).to.eq(toPerc("2"));
-      });
-    });
-
-    describe("when deviation < 1.0", function () {
-      it("should compute dr", async function () {
-        const r = await feePolicy["computeDeviationRatio((uint256,uint256,uint256))"]({
-          perpTVL: toAmt("100"),
-          vaultTVL: toAmt("250"),
-          seniorTR: 200,
-        });
-        expect(r).to.eq(toPerc("0.5"));
-      });
-    });
-  });
-});
diff --git a/spot-contracts/test/RouterV2.ts b/spot-contracts/test/RouterV2.ts
deleted file mode 100644
index 040f3433..00000000
--- a/spot-contracts/test/RouterV2.ts
+++ /dev/null
@@ -1,149 +0,0 @@
-import { expect, use } from "chai";
-import { network, ethers, upgrades } from "hardhat";
-import { constants, Contract, Signer } from "ethers";
-import { smock } from "@defi-wonderland/smock";
-import {
-  setupCollateralToken,
-  setupBondFactory,
-  bondAt,
-  getTranches,
-  toFixedPtAmt,
-  advancePerpQueue,
-  advanceTime,
-  mintCollteralToken,
-} from "./helpers";
-use(smock.matchers);
-
-let perp: Contract,
-  bondFactory: Contract,
-  collateralToken: Contract,
-  issuer: Contract,
-  feePolicy: Contract,
-  vault: Contract,
-  deployer: Signer,
-  deployerAddress: string,
-  router: Contract,
-  depositBond: Contract,
-  depositTranches: Contract[];
-
-describe("RouterV2", function () {
-  beforeEach(async function () {
-    await network.provider.send("hardhat_reset");
-
-    const accounts = await ethers.getSigners();
-    deployer = accounts[0];
-    deployerAddress = await deployer.getAddress();
-
-    bondFactory = await setupBondFactory();
-    ({ collateralToken } = await setupCollateralToken("Bitcoin", "BTC"));
-
-    const BondIssuer = await ethers.getContractFactory("BondIssuer");
-    issuer = await upgrades.deployProxy(
-      BondIssuer.connect(deployer),
-      [bondFactory.address, collateralToken.address, 3600, [200, 800], 1200, 0],
-      {
-        initializer: "init(address,address,uint256,uint256[],uint256,uint256)",
-      },
-    );
-
-    const FeePolicy = await ethers.getContractFactory("FeePolicy");
-    feePolicy = await smock.fake(FeePolicy);
-    await feePolicy.computePerpRolloverFeePerc.returns("0");
-    await feePolicy.decimals.returns(8);
-
-    const PerpetualTranche = await ethers.getContractFactory("PerpetualTranche");
-    perp = await upgrades.deployProxy(
-      PerpetualTranche.connect(deployer),
-      ["PerpetualTranche", "PERP", collateralToken.address, issuer.address, feePolicy.address],
-      {
-        initializer: "init(string,string,address,address,address)",
-      },
-    );
-    await perp.updateTolerableTrancheMaturity(600, 3600);
-    await advancePerpQueue(perp, 3600);
-
-    const RolloverVault = await ethers.getContractFactory("RolloverVault");
-    vault = await smock.fake(RolloverVault);
-    await vault.getTVL.returns("0");
-    await perp.updateVault(vault.address);
-
-    depositBond = await bondAt(await perp.callStatic.getDepositBond());
-    depositTranches = await getTranches(depositBond);
-
-    const Router = await ethers.getContractFactory("RouterV2");
-    router = await Router.deploy();
-  });
-
-  afterEach(async function () {
-    await network.provider.send("hardhat_reset");
-  });
-
-  describe("#previewTranche", function () {
-    it("should compute the tranche amounts", async function () {
-      const r = await router.callStatic.previewTranche(perp.address, toFixedPtAmt("1000"));
-      expect(r[0]).to.eq(await perp.callStatic.getDepositBond());
-      expect(r[1][0].token).to.eq(depositTranches[0].address);
-      expect(r[1][0].amount).to.eq(toFixedPtAmt("200"));
-      expect(r[1][1].token).to.eq(depositTranches[1].address);
-      expect(r[1][1].amount).to.eq(toFixedPtAmt("800"));
-    });
-  });
-
-  describe("#trancheAndDeposit", function () {
-    beforeEach(async function () {
-      await mintCollteralToken(collateralToken, toFixedPtAmt("1100"), deployer);
-      await collateralToken.transfer(router.address, toFixedPtAmt("100"));
-    });
-
-    describe("when deposit bond is incorrect", function () {
-      beforeEach(async function () {
-        await collateralToken.approve(router.address, constants.MaxUint256);
-        await advancePerpQueue(perp, 7200);
-      });
-      it("should revert", async function () {
-        await expect(
-          router.trancheAndDeposit(perp.address, depositBond.address, toFixedPtAmt("1000")),
-        ).to.revertedWithCustomError(perp, "UnexpectedAsset");
-      });
-    });
-
-    describe("when deposit bond is not issued", function () {
-      beforeEach(async function () {
-        await collateralToken.approve(router.address, constants.MaxUint256);
-        await advanceTime(7200);
-      });
-      it("should not revert", async function () {
-        const depositBond = await bondAt(await perp.callStatic.getDepositBond());
-        await expect(router.trancheAndDeposit(perp.address, depositBond.address, toFixedPtAmt("1000"))).not.to.be
-          .reverted;
-      });
-    });
-
-    describe("when deposit bond is correct", function () {
-      beforeEach(async function () {
-        await collateralToken.approve(router.address, constants.MaxUint256);
-        await router.trancheAndDeposit(perp.address, depositBond.address, toFixedPtAmt("1000"));
-      });
-
-      it("should mint tranches", async function () {
-        expect(await perp.balanceOf(deployerAddress)).to.eq(toFixedPtAmt("200"));
-      });
-
-      it("should dust collateral tokens back", async function () {
-        expect(await collateralToken.balanceOf(deployerAddress)).to.eq(toFixedPtAmt("100"));
-      });
-
-      it("should transfer unused tranches back", async function () {
-        expect(await depositTranches[0].balanceOf(deployerAddress)).to.eq("0");
-        expect(await depositTranches[1].balanceOf(deployerAddress)).to.eq(toFixedPtAmt("800"));
-      });
-
-      it("should leave no dust", async function () {
-        expect(await depositTranches[0].balanceOf(router.address)).to.eq("0");
-        expect(await depositTranches[1].balanceOf(router.address)).to.eq("0");
-        expect(await perp.balanceOf(router.address)).to.eq("0");
-        expect(await collateralToken.balanceOf(router.address)).to.eq("0");
-      });
-    });
-  });
-});
diff --git a/spot-contracts/test/RouterV3.ts b/spot-contracts/test/RouterV3.ts
new file mode 100644
index 00000000..f109ec3e
--- /dev/null
+++ b/spot-contracts/test/RouterV3.ts
@@ -0,0 +1,256 @@
+import { expect } from "chai";
+import { network, ethers, upgrades } from "hardhat";
+import { Contract, Signer } from "ethers";
+import {
+  setupCollateralToken,
+  setupBondFactory,
+  bondAt,
+  getTranches,
+  toFixedPtAmt,
+  advancePerpQueue,
+  advanceTime,
+  mintCollteralToken,
+  advancePerpQueueToBondMaturity,
+  getDepositBond,
+  depositIntoBond,
+  mintPerps,
+  checkPerpComposition,
+  checkVaultComposition,
+  mintVaultNotes,
+  toPercFixedPtAmt,
+} from "./helpers";
+
+let perp: Contract,
+  bondFactory: Contract,
+  collateralToken: Contract,
+  issuer: Contract,
+  balancer: Contract,
+  vault: Contract,
+  deployer: Signer,
+  deployerAddress: string,
+  router: Contract,
+  depositBond: Contract,
+  depositTranches: Contract[],
+  perpTranches: Contract[],
+  remTranches: Contract[];
+
+describe("RouterV3", function () {
+  beforeEach(async function () {
+    await network.provider.request({ method: "hardhat_reset" });
+
+    const accounts = await ethers.getSigners();
+    deployer = accounts[0];
+    deployerAddress = await deployer.getAddress();
+
+    bondFactory = await setupBondFactory();
+    ({ collateralToken } = await setupCollateralToken("Bitcoin", "BTC"));
+
+    const BondIssuer = await ethers.getContractFactory("BondIssuer");
+    issuer = await upgrades.deployProxy(
+      BondIssuer.connect(deployer),
+      [bondFactory.target, collateralToken.target, 4800, [200, 800], 1200, 0],
+      {
+        initializer: "init(address,address,uint256,uint256[],uint256,uint256)",
+      },
+    );
+
+    const PerpetualTranche = await ethers.getContractFactory("PerpetualTranche");
+    perp = await upgrades.deployProxy(
+      PerpetualTranche.connect(deployer),
+      ["PerpetualTranche", "PERP", collateralToken.target, issuer.target],
+      {
+        initializer: "init(string,string,address,address)",
+      },
+    );
+    await perp.updateTolerableTrancheMaturity(1200, 4800);
+    await advancePerpQueueToBondMaturity(perp, await getDepositBond(perp));
+
+    const RolloverVault = await ethers.getContractFactory("RolloverVault");
+    vault = await upgrades.deployProxy(RolloverVault.connect(deployer));
+    await vault.init("RolloverVault", "VSHARE", perp.target);
+    await perp.updateVault(vault.target);
+
+    const Balancer = await ethers.getContractFactory("Balancer");
+    balancer = await upgrades.deployProxy(Balancer.connect(deployer), [perp.target], {
+      initializer: "init(address)",
+    });
+    balancer.updateFees({
+      perpMintFeePerc: 0n,
+      perpBurnFeePerc: 0n,
+      vaultMintFeePerc: 0n,
+      vaultBurnFeePerc: 0n,
+      rolloverFee: {
+        lower: toPercFixedPtAmt("-0.009"),
+        upper: toPercFixedPtAmt("0.009"),
+        growth: 0n,
+      },
+      underlyingToPerpSwapFeePercs: {
+        lower: 0n,
+        upper: 0n,
+      },
+      perpToUnderlyingSwapFeePercs: {
+        lower: 0n,
+        upper: 0n,
+      },
+      protocolSwapSharePerc: 0n,
+    });
+    await perp.updateBalancer(balancer.target);
+    await vault.updateBalancer(balancer.target);
+
+    await mintCollteralToken(collateralToken, toFixedPtAmt("100000"), deployer);
+    await balancer.updateSwapDRLimits({ lower: 0n, upper: toPercFixedPtAmt("1") });
+
+    perpTranches = [];
+    remTranches = [];
+    for (let i = 0; i < 4; i++) {
+      const bond = await getDepositBond(perp);
+      const tranches = await getTranches(bond);
+      await depositIntoBond(bond, toFixedPtAmt("500"), deployer);
+      await mintPerps(perp, tranches[0], toFixedPtAmt("100"), deployer);
+      await mintVaultNotes(vault, toFixedPtAmt("500"), deployer);
+      await collateralToken.approve(balancer.target, toFixedPtAmt("100"));
+      await balancer.swapUnderlyingForPerps(toFixedPtAmt("100"));
+      perpTranches.push(tranches[0]);
+      remTranches.push(tranches[1]);
+      await advancePerpQueue(perp, 1200);
+    }
+    await checkPerpComposition(
+      perp,
+      [collateralToken, ...perpTranches.slice(-3)],
+      [toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("200")],
+    );
+    await checkVaultComposition(
+      vault,
+      [collateralToken, ...remTranches],
+      [toFixedPtAmt("400"), toFixedPtAmt("400"), toFixedPtAmt("400"), toFixedPtAmt("400"), toFixedPtAmt("400")],
+    );
+
+    depositBond = await bondAt(await perp.depositBond());
+    depositTranches = await getTranches(depositBond);
+
+    const Router = await ethers.getContractFactory("RouterV3");
+    router = await Router.deploy();
+  });
+
+  afterEach(async function () {
+    await network.provider.request({ method: "hardhat_reset" });
+  });
+
+  describe("#previewTranche", function () {
+    it("should compute the tranche amounts", async function () {
+      const r = await router.previewTranche.staticCall(perp.target, toFixedPtAmt("1000"));
+      expect(r[0]).to.eq(await perp.depositBond());
+      expect(r[1][0].token).to.eq(depositTranches[0].target);
+      expect(r[1][0].amount).to.eq(toFixedPtAmt("200"));
+      expect(r[1][1].token).to.eq(depositTranches[1].target);
+      expect(r[1][1].amount).to.eq(toFixedPtAmt("800"));
+    });
+  });
+
+  describe("#mintPerps", function () {
+    beforeEach(async function () {
+      await mintCollteralToken(collateralToken, toFixedPtAmt("1100"), deployer);
+    });
+
+    describe("when deposit bond is incorrect", function () {
+      beforeEach(async function () {
+        await collateralToken.approve(router.target, ethers.MaxUint256);
+        await advancePerpQueue(perp, 7200);
+      });
+      it("should revert", async function () {
+        await expect(
+          router.mintPerps(balancer.target, depositBond.target, toFixedPtAmt("1000")),
+        ).to.revertedWithCustomError(perp, "UnacceptableDeposit");
+      });
+    });
+
+    describe("when deposit bond is not issued", function () {
+      beforeEach(async function () {
+        await collateralToken.approve(router.target, ethers.MaxUint256);
+        await advanceTime(7200);
+      });
+      it("should not revert", async function () {
+        const depositBond = await bondAt(await perp.updateDepositBond.staticCall());
+        await expect(router.mintPerps(balancer.target, depositBond.target, toFixedPtAmt("1000"))).not.to.be.reverted;
+      });
+    });
+
+    describe("when deposit bond is correct", function () {
+      let r: any;
+      beforeEach(async function () {
+        await collateralToken.approve(router.target, ethers.MaxUint256);
+        r = await router.mintPerps.staticCall(balancer.target, depositBond.target, toFixedPtAmt("1000"));
+        await router.mintPerps(balancer.target, depositBond.target, toFixedPtAmt("1000"));
+      });
+
+      it("should return minted token amounts", async function () {
+        expect(r[0]).to.eq(toFixedPtAmt("200"));
+        expect(r[1].token).to.eq(depositTranches[1].target);
+        expect(r[1].amount).to.eq(toFixedPtAmt("800"));
+      });
+
+      it("should mint tranches", async function () {
+        expect(await perp.balanceOf(deployerAddress)).to.eq(toFixedPtAmt("1000"));
+      });
+
+      it("should transfer unused tranches back", async function () {
+        expect(await depositTranches[0].balanceOf(deployerAddress)).to.eq("0");
+        expect(await depositTranches[1].balanceOf(deployerAddress)).to.eq(toFixedPtAmt("800"));
+      });
+
+      it("should leave no dust", async function () {
+        expect(await depositTranches[0].balanceOf(router.target)).to.eq("0");
+        expect(await depositTranches[1].balanceOf(router.target)).to.eq("0");
+        expect(await perp.balanceOf(router.target)).to.eq("0");
+        expect(await collateralToken.balanceOf(router.target)).to.eq("0");
+      });
+    });
+  });
+
+  describe("#redeem2", function () {
+    let r: any;
+    beforeEach(async function () {
+      expect(await collateralToken.balanceOf(deployerAddress)).to.eq(toFixedPtAmt("97600"));
+
+      await perp.approve(router.target, toFixedPtAmt("100"));
+      await vault.approve(router.target, toFixedPtAmt("100000000"));
+      r = await router.redeem2.staticCall(balancer.target, {
+        perpAmt: toFixedPtAmt("100"),
+        noteAmt: toFixedPtAmt("100000000"),
+      });
+      await router.redeem2(balancer.target, {
+        perpAmt: toFixedPtAmt("100"),
+        noteAmt: toFixedPtAmt("100000000"),
+      });
+    });
+
+    it("should return redeemed tokens", async function () {
+      expect(r[0].token).to.eq(collateralToken.target);
+      expect(r[0].amount).to.eq(toFixedPtAmt("140"));
+      expect(r[2].token).to.eq(perpTranches[1].target);
+      expect(r[2].amount).to.eq(toFixedPtAmt("20"));
+      expect(r[3].token).to.eq(perpTranches[2].target);
+      expect(r[3].amount).to.eq(toFixedPtAmt("20"));
+      expect(r[1].token).to.eq(perpTranches[3].target);
+      expect(r[1].amount).to.eq(toFixedPtAmt("20"));
+    });
+
+    it("should transfer underlying", async function () {
+      expect(await collateralToken.balanceOf(deployerAddress)).to.eq(toFixedPtAmt("97740"));
+    });
+
+    it("should leave no dust", async function () {
+      expect(await perpTranches[0].balanceOf(router.target)).to.eq(0n);
+      expect(await perpTranches[1].balanceOf(router.target)).to.eq(0n);
+      expect(await perpTranches[2].balanceOf(router.target)).to.eq(0n);
+      expect(await perpTranches[3].balanceOf(router.target)).to.eq(0n);
+      expect(await remTranches[0].balanceOf(router.target)).to.eq(0n);
+      expect(await remTranches[1].balanceOf(router.target)).to.eq(0n);
+      expect(await remTranches[2].balanceOf(router.target)).to.eq(0n);
+      expect(await remTranches[3].balanceOf(router.target)).to.eq(0n);
+      expect(await perp.balanceOf(router.target)).to.eq(0n);
+      expect(await vault.balanceOf(router.target)).to.eq(0n);
+      expect(await collateralToken.balanceOf(router.target)).to.eq(0n);
+    });
+  });
+});
diff --git a/spot-contracts/test/_utils/HelpersTester.ts b/spot-contracts/test/_utils/HelpersTester.ts
index d667589f..d5fcf3b8 100644
--- a/spot-contracts/test/_utils/HelpersTester.ts
+++ b/spot-contracts/test/_utils/HelpersTester.ts
@@ -1,8 +1,6 @@
-import { expect, use } from "chai";
+import { expect } from "chai";
 import { network, ethers } from "hardhat";
 import { Contract, Signer } from "ethers";
-import { smock } from "@defi-wonderland/smock";
-
 import {
   TimeHelpers,
   setupCollateralToken,
@@ -15,8 +13,8 @@ import {
   getTranches,
   getContractFactoryFromExternalArtifacts,
   mintCollteralToken,
+  DMock,
 } from "../helpers";
-use(smock.matchers);
 
 let bondFactory: Contract,
   collateralToken: Contract,
@@ -37,13 +35,10 @@ async function setupContracts() {
   deployerAddress = await deployer.getAddress();
   user = accounts[1];
   userAddress = await user.getAddress();
-
   bondFactory = await setupBondFactory();
   ({ collateralToken, rebaseOracle } = await setupCollateralToken("Bitcoin", "BTC"));
-
   const HelpersTester = await ethers.getContractFactory("HelpersTester");
   helper = await HelpersTester.deploy();
-  await helper.deployed();
 }
 
 describe("HelpersTester", function () {
@@ -52,28 +47,28 @@ describe("HelpersTester", function () {
   });
 
   after(async function () {
-    await network.provider.send("hardhat_reset");
+    await network.provider.request({ method: "hardhat_reset" });
   });
 
   describe("#timeToMatirity", function () {
-    let maturityDate: number, bondLength: number, bond: Contract;
+    let maturityDate: BigInt, bondLength: BigInt, bond: Contract;
     beforeEach(async function () {
       bondLength = 86400;
       bond = await createBondWithFactory(bondFactory, collateralToken, [1000], bondLength);
-      maturityDate = (await bond.maturityDate()).toNumber();
+      maturityDate = await bond.maturityDate();
     });
 
     describe("when bond is NOT mature", function () {
       it("should return the time to maturity", async function () {
-        await TimeHelpers.setNextBlockTimestamp(maturityDate - bondLength / 2);
-        expect(await helper.secondsToMaturity(bond.address)).to.eq(bondLength / 2);
+        await TimeHelpers.setNextBlockTimestamp(Number(maturityDate) - bondLength / 2);
+        expect(await helper.secondsToMaturity(bond.target)).to.eq(bondLength / 2);
       });
     });
 
     describe("when bond is mature", function () {
       it("should return the time to maturity", async function () {
-        await TimeHelpers.setNextBlockTimestamp(maturityDate + 1);
-        expect(await helper.secondsToMaturity(bond.address)).to.eq(0);
+        await TimeHelpers.setNextBlockTimestamp(Number(maturityDate) + 1);
+        expect(await helper.secondsToMaturity(bond.target)).to.eq(0);
       });
     });
   });
@@ -85,7 +80,7 @@ describe("HelpersTester", function () {
     });
 
     it("should return the tranche data", async function () {
-      const td = await helper.getTranches(bond.address);
+      const td = await helper.getTranches(bond.target);
       expect(td.tranches.length).to.eq(2);
       expect(td.trancheRatios.length).to.eq(2);
       expect(td.trancheRatios[0]).to.eq(498);
@@ -99,24 +94,24 @@ describe("HelpersTester", function () {
     it("should return the tranche when given index", async function () {
       const bond = await createBondWithFactory(bondFactory, collateralToken, [100, 100, 100, 100, 100, 500], 86400);
       for (let i = 0; i < 6; i++) {
-        expect(await helper.trancheAt(bond.address, i)).to.eq((await bond.tranches(i))[0]);
+        expect(await helper.trancheAt(bond.target, i)).to.eq((await bond.tranches(i))[0]);
       }
-      await expect(helper.trancheAt(bond.address, 7)).to.be.reverted;
+      await expect(helper.trancheAt(bond.target, 7)).to.be.reverted;
     });
   });
 
-  describe("#getSeniorTranche", function () {
+  describe("#seniorTranche", function () {
     it("should return the tranche when given index", async function () {
       const bond = await createBondWithFactory(bondFactory, collateralToken, [300, 700], 86400);
-      const td = await helper.getTranches(bond.address);
-      expect(await helper.getSeniorTranche(bond.address)).to.eq(td.tranches[0]);
+      const td = await helper.getTranches(bond.target);
+      expect(await helper.seniorTranche(bond.target)).to.eq(td.tranches[0]);
     });
   });
 
-  describe("#getSeniorTrancheRatio", function () {
+  describe("#seniorTrancheRatio", function () {
     it("should return the tranche when given index", async function () {
       const bond = await createBondWithFactory(bondFactory, collateralToken, [50, 950], 86400);
-      const ratio = await helper.getSeniorTrancheRatio(bond.address);
+      const ratio = await helper.seniorTrancheRatio(bond.target);
       expect(ratio).to.eq(50);
     });
   });
@@ -129,7 +124,7 @@ describe("HelpersTester", function () {
 
     describe("first deposit", function () {
       it("should calculate the tranche balances after deposit", async function () {
-        const d = await helper.previewDeposit(bond.address, toFixedPtAmt("1000"));
+        const d = await helper.previewDeposit(bond.target, toFixedPtAmt("1000"));
         expect(d[0].amount).to.eq(toFixedPtAmt("500"));
         expect(d[1].amount).to.eq(toFixedPtAmt("500"));
       });
@@ -152,7 +147,7 @@ describe("HelpersTester", function () {
           await rebase(collateralToken, rebaseOracle, 0);
         });
         it("should calculate the tranche balances after deposit", async function () {
-          const d = await helper.previewDeposit(bond.address, toFixedPtAmt("1000"));
+          const d = await helper.previewDeposit(bond.target, toFixedPtAmt("1000"));
           expect(d[0].amount).to.eq(toFixedPtAmt("500"));
           expect(d[1].amount).to.eq(toFixedPtAmt("500"));
         });
@@ -170,7 +165,7 @@ describe("HelpersTester", function () {
           await rebase(collateralToken, rebaseOracle, +0.25);
         });
         it("should calculate the tranche balances after deposit", async function () {
-          const d = await helper.previewDeposit(bond.address, toFixedPtAmt("1000"));
+          const d = await helper.previewDeposit(bond.target, toFixedPtAmt("1000"));
           expect(d[0].amount).to.eq(toFixedPtAmt("400"));
           expect(d[1].amount).to.eq(toFixedPtAmt("400"));
         });
@@ -188,7 +183,7 @@ describe("HelpersTester", function () {
           await rebase(collateralToken, rebaseOracle, -0.5);
         });
         it("should calculate the tranche balances after deposit", async function () {
-          const d = await helper.previewDeposit(bond.address, toFixedPtAmt("1000"));
+          const d = await helper.previewDeposit(bond.target, toFixedPtAmt("1000"));
           expect(d[0].amount).to.eq(toFixedPtAmt("1000"));
           expect(d[1].amount).to.eq(toFixedPtAmt("1000"));
         });
@@ -209,7 +204,7 @@ describe("BondTranchesHelpers", function () {
   });
 
   after(async function () {
-    await network.provider.send("hardhat_reset");
+    await network.provider.request({ method: "hardhat_reset" });
   });
 
   describe("#computeRedeemableTrancheAmounts", function () {
@@ -226,12 +221,12 @@ describe("BondTranchesHelpers", function () {
         for (const a in amounts) {
           await tranches[a].transfer(userAddress, toFixedPtAmt(amounts[a]));
         }
-        const b = await helper["computeRedeemableTrancheAmounts(address,address)"](bond.address, userAddress);
+        const b = await helper["computeRedeemableTrancheAmounts(address,address)"](bond.target, userAddress);
         for (const a in redemptionAmts) {
           expect(b[1][a]).to.eq(toFixedPtAmt(redemptionAmts[a]));
         }
-        if (b[1][0].gt("0")) {
-          await bond.connect(user).redeem(b[1]);
+        if (b[1][0] > 0n) {
+          await bond.connect(user).redeem([b[1][0], b[1][1]]);
         }
       }
 
@@ -254,26 +249,26 @@ describe("BondTranchesHelpers", function () {
 
     describe("when the user does not have tranches right proportions", function () {
       async function checkRedeemableAmts(
-        trancheRatios: number[] = [],
+        trancheRatios: BigInt[] = [],
         amounts: string[] = [],
         redemptionAmts: string[] = [],
       ) {
         const bond = await createBondWithFactory(bondFactory, collateralToken, trancheRatios, 86400);
         const amt = amounts
-          .map((a, i) => toFixedPtAmt(a).mul("1000").div(trancheRatios[i]))
-          .reduce((m, a) => (m.gt(a) ? m : a), toFixedPtAmt("0"));
-        await depositIntoBond(bond, amt.add(toFixedPtAmt("1")), deployer);
+          .map((a, i) => (toFixedPtAmt(a) * BigInt("1000")) / BigInt(trancheRatios[i]))
+          .reduce((m, a) => (m > a ? m : a), 0n);
+        await depositIntoBond(bond, amt + toFixedPtAmt("1"), deployer);
 
         const tranches = await getTranches(bond);
         for (const a in amounts) {
           await tranches[a].transfer(userAddress, toFixedPtAmt(amounts[a]));
         }
-        const b = await helper["computeRedeemableTrancheAmounts(address,address)"](bond.address, userAddress);
+        const b = await helper["computeRedeemableTrancheAmounts(address,address)"](bond.target, userAddress);
         for (const a in redemptionAmts) {
           expect(b[1][a]).to.eq(toFixedPtAmt(redemptionAmts[a]));
         }
-        if (b[1][0].gt("0")) {
-          await bond.connect(user).redeem(b[1]);
+        if (b[1][0] > 0n) {
+          await bond.connect(user).redeem([b[1][0], b[1][1]]);
         }
       }
 
@@ -391,7 +386,7 @@ describe("BondTranchesHelpers", function () {
       ) {
         bond = await createBondWithFactory(bondFactory, collateralToken, trancheRatios, 86400);
         const b = await helper["computeRedeemableTrancheAmounts(address,uint256[])"](
-          bond.address,
+          bond.target,
           amounts.map(toFixedPtAmt),
         );
         for (const a in redemptionAmts) {
@@ -436,12 +431,12 @@ describe("BondTranchesHelpers", function () {
       ) {
         const bond = await createBondWithFactory(bondFactory, collateralToken, trancheRatios, 86400);
         const amt = amounts
-          .map((a, i) => toFixedPtAmt(a).mul("1000").div(trancheRatios[i]))
-          .reduce((m, a) => (m.gt(a) ? m : a), toFixedPtAmt("0"));
-        await depositIntoBond(bond, amt.add(toFixedPtAmt("1")), deployer);
+          .map((a, i) => (toFixedPtAmt(a) * BigInt("1000")) / BigInt(trancheRatios[i]))
+          .reduce((m, a) => (m > a ? m : a), 0n);
+        await depositIntoBond(bond, amt + toFixedPtAmt("1"), deployer);
 
         const b = await helper["computeRedeemableTrancheAmounts(address,uint256[])"](
-          bond.address,
+          bond.target,
           amounts.map(toFixedPtAmt),
         );
         for (const a in redemptionAmts) {
@@ -560,11 +555,11 @@ describe("TrancheHelpers", function () {
   });
 
   after(async function () {
-    await network.provider.send("hardhat_reset");
+    await network.provider.request({ method: "hardhat_reset" });
   });
 
   describe("#getTrancheCollateralizations", function () {
-    let bond: Contract, bondLength: number, tranches: Contract[];
+    let bond: Contract, bondLength: BigInt, tranches: Contract[];
     beforeEach(async function () {
       bondLength = 86400;
       bond = await createBondWithFactory(bondFactory, collateralToken, [250, 750], bondLength);
@@ -576,7 +571,7 @@ describe("TrancheHelpers", function () {
       it("should return 0", async function () {
         const bond = await createBondWithFactory(bondFactory, collateralToken, [1000], bondLength);
         const tranches = await getTranches(bond);
-        await expect(helper.getTrancheCollateralizations(tranches[0].address)).to.be.revertedWithCustomError(
+        await expect(helper.getTrancheCollateralizations(tranches[0].target)).to.be.revertedWithCustomError(
           helper,
           "UnacceptableTrancheLength",
         );
@@ -587,7 +582,7 @@ describe("TrancheHelpers", function () {
       it("should return 0", async function () {
         const bond = await createBondWithFactory(bondFactory, collateralToken, [100, 200, 700], bondLength);
         const tranches = await getTranches(bond);
-        await expect(helper.getTrancheCollateralizations(tranches[0].address)).to.be.revertedWithCustomError(
+        await expect(helper.getTrancheCollateralizations(tranches[0].target)).to.be.revertedWithCustomError(
           helper,
           "UnacceptableTrancheLength",
         );
@@ -599,11 +594,11 @@ describe("TrancheHelpers", function () {
         const bond = await createBondWithFactory(bondFactory, collateralToken, [333, 667], bondLength);
         const tranches = await getTranches(bond);
 
-        const t0 = await helper.getTrancheCollateralizations(tranches[0].address);
+        const t0 = await helper.getTrancheCollateralizations(tranches[0].target);
         expect(t0[0]).to.eq("0");
         expect(t0[1]).to.eq("0");
 
-        const t1 = await helper.getTrancheCollateralizations(tranches[1].address);
+        const t1 = await helper.getTrancheCollateralizations(tranches[1].target);
         expect(t1[0]).to.eq("0");
         expect(t1[1]).to.eq("0");
       });
@@ -612,11 +607,11 @@ describe("TrancheHelpers", function () {
     describe("when bond not mature", function () {
       describe("when no change in supply", function () {
         it("should calculate the balances", async function () {
-          const t0 = await helper.getTrancheCollateralizations(tranches[0].address);
+          const t0 = await helper.getTrancheCollateralizations(tranches[0].target);
           expect(t0[0]).to.eq(toFixedPtAmt("250"));
           expect(t0[1]).to.eq(toFixedPtAmt("250"));
 
-          const t1 = await helper.getTrancheCollateralizations(tranches[1].address);
+          const t1 = await helper.getTrancheCollateralizations(tranches[1].target);
           expect(t1[0]).to.eq(toFixedPtAmt("750"));
           expect(t1[1]).to.eq(toFixedPtAmt("750"));
         });
@@ -625,10 +620,10 @@ describe("TrancheHelpers", function () {
       describe("when supply increases above bond threshold", function () {
         it("should calculate the balances", async function () {
           await rebase(collateralToken, rebaseOracle, 0.1);
-          const t0 = await helper.getTrancheCollateralizations(tranches[0].address);
+          const t0 = await helper.getTrancheCollateralizations(tranches[0].target);
           expect(t0[0]).to.eq(toFixedPtAmt("250"));
           expect(t0[1]).to.eq(toFixedPtAmt("250"));
-          const t1 = await helper.getTrancheCollateralizations(tranches[1].address);
+          const t1 = await helper.getTrancheCollateralizations(tranches[1].target);
           expect(t1[0]).to.eq(toFixedPtAmt("850"));
           expect(t1[1]).to.eq(toFixedPtAmt("750"));
         });
@@ -637,10 +632,10 @@ describe("TrancheHelpers", function () {
       describe("when supply decreases below bond threshold", function () {
         it("should calculate the balances", async function () {
           await rebase(collateralToken, rebaseOracle, -0.1);
-          const t0 = await helper.getTrancheCollateralizations(tranches[0].address);
+          const t0 = await helper.getTrancheCollateralizations(tranches[0].target);
           expect(t0[0]).to.eq(toFixedPtAmt("250"));
           expect(t0[1]).to.eq(toFixedPtAmt("250"));
-          const t1 = await helper.getTrancheCollateralizations(tranches[1].address);
+          const t1 = await helper.getTrancheCollateralizations(tranches[1].target);
           expect(t1[0]).to.eq(toFixedPtAmt("650"));
           expect(t1[1]).to.eq(toFixedPtAmt("750"));
         });
@@ -649,10 +644,10 @@ describe("TrancheHelpers", function () {
       describe("when supply decreases below junior threshold", function () {
         it("should calculate the balances", async function () {
           await rebase(collateralToken, rebaseOracle, -0.8);
-          const t0 = await helper.getTrancheCollateralizations(tranches[0].address);
+          const t0 = await helper.getTrancheCollateralizations(tranches[0].target);
           expect(t0[0]).to.eq(toFixedPtAmt("200"));
           expect(t0[1]).to.eq(toFixedPtAmt("250"));
-          const t1 = await helper.getTrancheCollateralizations(tranches[1].address);
+          const t1 = await helper.getTrancheCollateralizations(tranches[1].target);
           expect(t1[0]).to.eq("0");
           expect(t1[1]).to.eq(toFixedPtAmt("750"));
         });
@@ -661,16 +656,16 @@ describe("TrancheHelpers", function () {
 
     describe("when bond is mature", function () {
       beforeEach(async function () {
-        await TimeHelpers.increaseTime(bondLength);
+        await TimeHelpers.increaseTime(Number(bondLength));
         await bond.mature(); // NOTE: Any rebase after maturity goes directly to the tranches
       });
 
       describe("when no change in supply", function () {
         it("should calculate the balances", async function () {
-          const t0 = await helper.getTrancheCollateralizations(tranches[0].address);
+          const t0 = await helper.getTrancheCollateralizations(tranches[0].target);
           expect(t0[0]).to.eq(toFixedPtAmt("250"));
           expect(t0[1]).to.eq(toFixedPtAmt("250"));
-          const t1 = await helper.getTrancheCollateralizations(tranches[1].address);
+          const t1 = await helper.getTrancheCollateralizations(tranches[1].target);
           expect(t1[0]).to.eq(toFixedPtAmt("750"));
           expect(t1[1]).to.eq(toFixedPtAmt("750"));
         });
@@ -679,10 +674,10 @@ describe("TrancheHelpers", function () {
       describe("when supply increases", function () {
         it("should calculate the balances", async function () {
           await rebase(collateralToken, rebaseOracle, 0.1);
-          const t0 = await helper.getTrancheCollateralizations(tranches[0].address);
+          const t0 = await helper.getTrancheCollateralizations(tranches[0].target);
           expect(t0[0]).to.eq(toFixedPtAmt("275"));
           expect(t0[1]).to.eq(toFixedPtAmt("250"));
-          const t1 = await helper.getTrancheCollateralizations(tranches[1].address);
+          const t1 = await helper.getTrancheCollateralizations(tranches[1].target);
           expect(t1[0]).to.eq(toFixedPtAmt("825"));
           expect(t1[1]).to.eq(toFixedPtAmt("750"));
         });
@@ -691,10 +686,10 @@ describe("TrancheHelpers", function () {
       describe("when supply decreases", function () {
         it("should calculate the balances", async function () {
           await rebase(collateralToken, rebaseOracle, -0.1);
-          const t0 = await helper.getTrancheCollateralizations(tranches[0].address);
+          const t0 = await helper.getTrancheCollateralizations(tranches[0].target);
           expect(t0[0]).to.eq(toFixedPtAmt("225"));
           expect(t0[1]).to.eq(toFixedPtAmt("250"));
-          const t1 = await helper.getTrancheCollateralizations(tranches[1].address);
+          const t1 = await helper.getTrancheCollateralizations(tranches[1].target);
           expect(t1[0]).to.eq(toFixedPtAmt("675"));
           expect(t1[1]).to.eq(toFixedPtAmt("750"));
         });
@@ -707,35 +702,32 @@ describe("PerpHelpers", function () {
   beforeEach(async () => {
     await setupContracts();
 
-    const PerpetualTranche = await ethers.getContractFactory("PerpetualTranche");
-    perp = await smock.fake(PerpetualTranche);
-
-    const BondController = await getContractFactoryFromExternalArtifacts("BondController");
-    depositBond = await smock.fake(BondController);
-
-    const Tranche = await getContractFactoryFromExternalArtifacts("Tranche");
-    depositTranche = await smock.fake(Tranche);
-
-    await perp.getDepositBond.returns(depositBond.address);
-    await perp.totalSupply.returns(toFixedPtAmt("100"));
+    perp = new DMock(await ethers.getContractFactory("PerpetualTranche"));
+    await perp.deploy();
+    depositBond = new DMock(await getContractFactoryFromExternalArtifacts("BondController"));
+    await depositBond.deploy();
+    depositTranche = new DMock(await getContractFactoryFromExternalArtifacts("Tranche"));
+    await depositTranche.deploy();
 
+    await perp.mockMethod("depositBond()", [depositBond.target]);
+    await perp.mockMethod("totalSupply()", [toFixedPtAmt("100")]);
     await mintCollteralToken(collateralToken, toFixedPtAmt("500"), deployer);
-    await collateralToken.transfer(depositBond.address, toFixedPtAmt("500"));
-    await depositBond.collateralToken.returns(collateralToken.address);
-    await depositBond.tranches.whenCalledWith(0).returns([depositTranche.address, 200]);
-    await depositBond.totalDebt.returns(toFixedPtAmt("500"));
-    await depositTranche.totalSupply.returns(toFixedPtAmt("100"));
+    await collateralToken.transfer(depositBond.target, toFixedPtAmt("500"));
+    await depositBond.mockMethod("collateralToken()", [collateralToken.target]);
+    await depositBond.mockMethod("tranches(uint256)", [depositTranche.target, 200]);
+    await depositBond.mockMethod("totalDebt()", [toFixedPtAmt("500")]);
+    await depositTranche.mockMethod("totalSupply()", [toFixedPtAmt("100")]);
   });
 
   after(async function () {
-    await network.provider.send("hardhat_reset");
+    await network.provider.request({ method: "hardhat_reset" });
   });
 
   describe("when perp price = 1", async function () {
     describe("when bond cdr = 1", async function () {
       it("should compute the underlying amount", async function () {
-        const r = await helper.callStatic.estimateUnderlyingAmtToTranche(
-          perp.address,
+        const r = await helper.estimateUnderlyingAmtToTranche.staticCall(
+          perp.target,
           toFixedPtAmt("100"),
           toFixedPtAmt("10"),
         );
@@ -749,8 +741,8 @@ describe("PerpHelpers", function () {
         await rebase(collateralToken, rebaseOracle, 0.1);
       });
       it("should compute the underlying amount", async function () {
-        const r = await helper.callStatic.estimateUnderlyingAmtToTranche(
-          perp.address,
+        const r = await helper.estimateUnderlyingAmtToTranche.staticCall(
+          perp.target,
           toFixedPtAmt("100"),
           toFixedPtAmt("10"),
         );
@@ -764,8 +756,8 @@ describe("PerpHelpers", function () {
         await rebase(collateralToken, rebaseOracle, -0.1);
       });
       it("should compute the underlying amount", async function () {
-        const r = await helper.callStatic.estimateUnderlyingAmtToTranche(
-          perp.address,
+        const r = await helper.estimateUnderlyingAmtToTranche.staticCall(
+          perp.target,
           toFixedPtAmt("100"),
           toFixedPtAmt("10"),
         );
@@ -779,8 +771,8 @@ describe("PerpHelpers", function () {
         await rebase(collateralToken, rebaseOracle, -0.9);
       });
       it("should compute the underlying amount", async function () {
-        const r = await helper.callStatic.estimateUnderlyingAmtToTranche(
-          perp.address,
+        const r = await helper.estimateUnderlyingAmtToTranche.staticCall(
+          perp.target,
           toFixedPtAmt("100"),
           toFixedPtAmt("10"),
         );
@@ -793,8 +785,8 @@ describe("PerpHelpers", function () {
   describe("when perp price > 1", async function () {
     describe("when bond cdr = 1", async function () {
       it("should compute the underlying amount", async function () {
-        const r = await helper.callStatic.estimateUnderlyingAmtToTranche(
-          perp.address,
+        const r = await helper.estimateUnderlyingAmtToTranche.staticCall(
+          perp.target,
           toFixedPtAmt("200"),
           toFixedPtAmt("10"),
         );
@@ -808,8 +800,8 @@ describe("PerpHelpers", function () {
         await rebase(collateralToken, rebaseOracle, 0.1);
       });
       it("should compute the underlying amount", async function () {
-        const r = await helper.callStatic.estimateUnderlyingAmtToTranche(
-          perp.address,
+        const r = await helper.estimateUnderlyingAmtToTranche.staticCall(
+          perp.target,
           toFixedPtAmt("200"),
           toFixedPtAmt("10"),
         );
@@ -823,8 +815,8 @@ describe("PerpHelpers", function () {
         await rebase(collateralToken, rebaseOracle, -0.1);
       });
       it("should compute the underlying amount", async function () {
-        const r = await helper.callStatic.estimateUnderlyingAmtToTranche(
-          perp.address,
+        const r = await helper.estimateUnderlyingAmtToTranche.staticCall(
+          perp.target,
           toFixedPtAmt("200"),
           toFixedPtAmt("10"),
         );
@@ -838,8 +830,8 @@ describe("PerpHelpers", function () {
         await rebase(collateralToken, rebaseOracle, -0.9);
       });
       it("should compute the underlying amount", async function () {
-        const r = await helper.callStatic.estimateUnderlyingAmtToTranche(
-          perp.address,
+        const r = await helper.estimateUnderlyingAmtToTranche.staticCall(
+          perp.target,
           toFixedPtAmt("200"),
           toFixedPtAmt("10"),
         );
@@ -852,8 +844,8 @@ describe("PerpHelpers", function () {
   describe("when perp price < 1", async function () {
     describe("when bond cdr = 1", async function () {
       it("should compute the underlying amount", async function () {
-        const r = await helper.callStatic.estimateUnderlyingAmtToTranche(
-          perp.address,
+        const r = await helper.estimateUnderlyingAmtToTranche.staticCall(
+          perp.target,
           toFixedPtAmt("50"),
           toFixedPtAmt("10"),
         );
@@ -867,8 +859,8 @@ describe("PerpHelpers", function () {
         await rebase(collateralToken, rebaseOracle, 0.1);
       });
       it("should compute the underlying amount", async function () {
-        const r = await helper.callStatic.estimateUnderlyingAmtToTranche(
-          perp.address,
+        const r = await helper.estimateUnderlyingAmtToTranche.staticCall(
+          perp.target,
           toFixedPtAmt("50"),
           toFixedPtAmt("10"),
         );
@@ -882,8 +874,8 @@ describe("PerpHelpers", function () {
         await rebase(collateralToken, rebaseOracle, -0.1);
       });
       it("should compute the underlying amount", async function () {
-        const r = await helper.callStatic.estimateUnderlyingAmtToTranche(
-          perp.address,
+        const r = await helper.estimateUnderlyingAmtToTranche.staticCall(
+          perp.target,
           toFixedPtAmt("50"),
           toFixedPtAmt("10"),
         );
@@ -897,8 +889,8 @@ describe("PerpHelpers", function () {
         await rebase(collateralToken, rebaseOracle, -0.9);
       });
       it("should compute the underlying amount", async function () {
-        const r = await helper.callStatic.estimateUnderlyingAmtToTranche(
-          perp.address,
+        const r = await helper.estimateUnderlyingAmtToTranche.staticCall(
+          perp.target,
           toFixedPtAmt("50"),
           toFixedPtAmt("10"),
         );
@@ -910,8 +902,8 @@ describe("PerpHelpers", function () {
 
   describe("imperfect rounding", async function () {
     it("should compute the underlying amount", async function () {
-      const r = await helper.callStatic.estimateUnderlyingAmtToTranche(
-        perp.address,
+      const r = await helper.estimateUnderlyingAmtToTranche.staticCall(
+        perp.target,
         toFixedPtAmt("100"),
         toFixedPtAmt("0.999999999999999999"),
       );
@@ -922,13 +914,13 @@ describe("PerpHelpers", function () {
 
   describe("when perp supply is zero", function () {
     beforeEach(async function () {
-      await perp.totalSupply.returns("0");
+      await perp.mockMethod("totalSupply()", [0n]);
     });
 
     describe("when bond cdr = 1", async function () {
       it("should compute the underlying amount", async function () {
-        const r = await helper.callStatic.estimateUnderlyingAmtToTranche(
-          perp.address,
+        const r = await helper.estimateUnderlyingAmtToTranche.staticCall(
+          perp.target,
           toFixedPtAmt("100"),
           toFixedPtAmt("10"),
         );
@@ -942,8 +934,8 @@ describe("PerpHelpers", function () {
         await rebase(collateralToken, rebaseOracle, 0.1);
       });
       it("should compute the underlying amount", async function () {
-        const r = await helper.callStatic.estimateUnderlyingAmtToTranche(
-          perp.address,
+        const r = await helper.estimateUnderlyingAmtToTranche.staticCall(
+          perp.target,
           toFixedPtAmt("100"),
           toFixedPtAmt("10"),
         );
@@ -957,8 +949,8 @@ describe("PerpHelpers", function () {
         await rebase(collateralToken, rebaseOracle, -0.1);
       });
       it("should compute the underlying amount", async function () {
-        const r = await helper.callStatic.estimateUnderlyingAmtToTranche(
-          perp.address,
+        const r = await helper.estimateUnderlyingAmtToTranche.staticCall(
+          perp.target,
           toFixedPtAmt("100"),
           toFixedPtAmt("10"),
         );
@@ -972,8 +964,8 @@ describe("PerpHelpers", function () {
         await rebase(collateralToken, rebaseOracle, -0.9);
       });
       it("should compute the underlying amount", async function () {
-        const r = await helper.callStatic.estimateUnderlyingAmtToTranche(
-          perp.address,
+        const r = await helper.estimateUnderlyingAmtToTranche.staticCall(
+          perp.target,
           toFixedPtAmt("100"),
           toFixedPtAmt("10"),
         );
@@ -985,13 +977,13 @@ describe("PerpHelpers", function () {
 
   describe("when deposit bond has no deposits yet", function () {
     beforeEach(async function () {
-      await depositBond.totalDebt.returns("0");
-      await depositTranche.totalSupply.returns("0");
+      await depositBond.mockMethod("totalDebt()", [0n]);
+      await depositTranche.mockMethod("totalSupply()", [0n]);
     });
 
     it("should compute the underlying amount", async function () {
-      const r = await helper.callStatic.estimateUnderlyingAmtToTranche(
-        perp.address,
+      const r = await helper.estimateUnderlyingAmtToTranche.staticCall(
+        perp.target,
         toFixedPtAmt("100"),
         toFixedPtAmt("10"),
       );
diff --git a/spot-contracts/test/_utils/Sigmoid.ts b/spot-contracts/test/_utils/Sigmoid.ts
index b023008a..4cfa7b65 100644
--- a/spot-contracts/test/_utils/Sigmoid.ts
+++ b/spot-contracts/test/_utils/Sigmoid.ts
@@ -1,6 +1,6 @@
 import { expect } from "chai";
 import { ethers } from "hardhat";
-import { Contract, BigNumber } from "ethers";
+import { Contract } from "ethers";
 
 import { toPercFixedPtAmt } from "../helpers";
 
@@ -22,7 +22,6 @@ describe("Sigmoid", function () {
     before(async function () {
       const MathTester = await ethers.getContractFactory("MathTester");
       math = await MathTester.deploy();
-      await math.deployed();
     });
     it("should return sigmoid(x)", async function () {
       await cmp(0, 0, -0.01, 0.05, 0);
@@ -56,72 +55,71 @@ describe("Sigmoid", function () {
     before(async function () {
       const MathTester = await ethers.getContractFactory("MathTester");
       math = await MathTester.deploy();
-      await math.deployed();
     });
 
-    const decimals18 = BigNumber.from("1000000000000000000");
-    const decimals10 = BigNumber.from("10000000000");
+    const decimals18 = BigInt("1000000000000000000");
+    const decimals10 = BigInt("10000000000");
     it("2^0", async function () {
-      const e = BigNumber.from(0);
-      const one = BigNumber.from(1).mul(decimals18);
+      const e = 0n;
+      const one = 1n * decimals18;
       expect(await math.twoPower(e, one)).to.eq(one);
     });
     it("2^1", async function () {
-      const e = BigNumber.from(1).mul(decimals18);
-      const one = BigNumber.from(1).mul(decimals18);
-      const result = BigNumber.from(2).mul(decimals18);
+      const e = 1n * decimals18;
+      const one = 1n * decimals18;
+      const result = 2n * decimals18;
       expect(await math.twoPower(e, one)).to.eq(result);
     });
     it("2^30", async function () {
-      const e = BigNumber.from(30).mul(decimals18);
-      const one = BigNumber.from(1).mul(decimals18);
-      const result = BigNumber.from(2 ** 30).mul(decimals18);
+      const e = 30n * decimals18;
+      const one = 1n * decimals18;
+      const result = 2n ** 30n * decimals18;
       expect(await math.twoPower(e, one)).to.eq(result);
     });
     it("2^2.5", async function () {
-      const e = BigNumber.from("25000000000");
-      const one = BigNumber.from(1).mul(decimals10);
-      const result = BigNumber.from("56568542494");
+      const e = BigInt("25000000000");
+      const one = 1n * decimals10;
+      const result = BigInt("56568542494");
       expect(await math.twoPower(e, one)).to.eq(result);
     });
     it("2^2.25", async function () {
-      const e = BigNumber.from("22500000000");
-      const one = BigNumber.from(1).mul(decimals10);
-      const result = BigNumber.from("47568284600");
+      const e = BigInt("22500000000");
+      const one = 1n * decimals10;
+      const result = BigInt("47568284600");
       expect(await math.twoPower(e, one)).to.eq(result);
     });
     it("2^-2.25", async function () {
-      const e = BigNumber.from("-22500000000");
-      const one = BigNumber.from(1).mul(decimals10);
-      const result = BigNumber.from("2102241038");
+      const e = BigInt("-22500000000");
+      const one = 1n * decimals10;
+      const result = BigInt("2102241038");
       expect(await math.twoPower(e, one)).to.eq(result);
     });
     it("2^-0.6", async function () {
-      const e = BigNumber.from("-6000000000");
-      const one = BigNumber.from(1).mul(decimals10);
-      const result = BigNumber.from("6626183216");
+      const e = BigInt("-6000000000");
+      const one = 1n * decimals10;
+      const result = BigInt("6626183216");
       expect(await math.twoPower(e, one)).to.eq(result);
     });
     it("2^2.96875", async function () {
-      const e = BigNumber.from("29687500000");
-      const one = BigNumber.from(1).mul(decimals10);
-      const result = BigNumber.from("78285764964");
+      const e = BigInt("29687500000");
+      const one = 1n * decimals10;
+      const result = BigInt("78285764964");
       expect(await math.twoPower(e, one)).to.eq(result);
     });
     it("2^2.99", async function () {
-      const e = BigNumber.from("29900000000");
-      const one = BigNumber.from(1).mul(decimals10);
-      const result = BigNumber.from("78285764964");
+      const e = BigInt("29900000000");
+      const one = 1n * decimals10;
+      const result = BigInt("78285764964");
       expect(await math.twoPower(e, one)).to.eq(result);
     });
     it("should fail on too small exponents", async function () {
-      const e = BigNumber.from("-1011000000000");
-      const one = BigNumber.from(1).mul(decimals10);
+      const e = BigInt("-1011000000000");
+      const one = 1n * decimals10;
       await expect(math.twoPower(e, one)).to.be.revertedWithCustomError(math, "ExpTooLarge");
     });
     it("should fail on too large exponents", async function () {
-      const e = BigNumber.from("1011000000000");
-      const one = BigNumber.from(1).mul(decimals10);
+      const e = BigInt("1011000000000");
+      const one = 1n * decimals10;
       await expect(math.twoPower(e, one)).to.be.revertedWithCustomError(math, "ExpTooLarge");
     });
   });
diff --git a/spot-contracts/test/balancer/Balancer.ts b/spot-contracts/test/balancer/Balancer.ts
new file mode 100644
index 00000000..c421e0ff
--- /dev/null
+++ b/spot-contracts/test/balancer/Balancer.ts
@@ -0,0 +1,730 @@
+import { expect } from "chai";
+import { ethers, upgrades } from "hardhat";
+import { Contract, Signer } from "ethers";
+import { toPercFixedPtAmt, toFixedPtAmt, setupCollateralToken, DMock } from "../helpers";
+
+let collateralToken: Contract, balancer: Contract, deployer: Signer, otherUser: Signer;
+const toPerc = toPercFixedPtAmt;
+const toAmt = toFixedPtAmt;
+
+describe("Balancer", function () {
+  beforeEach(async function () {
+    const accounts = await ethers.getSigners();
+    deployer = accounts[0];
+    otherUser = accounts[1];
+
+    ({ collateralToken } = await setupCollateralToken("Bitcoin", "BTC"));
+
+    const perp = new DMock(await ethers.getContractFactory("PerpetualTranche"));
+    await perp.deploy();
+
+    const vault = new DMock(await ethers.getContractFactory("RolloverVault"));
+    await vault.deploy();
+
+    await perp.mockMethod("underlying()", [collateralToken.target]);
+    await perp.mockMethod("vault()", [vault.target]);
+    await perp.mockMethod("depositTrancheRatio()", [250]);
+
+    balancer = new DMock(await ethers.getContractFactory("Balancer"));
+    await balancer.deploy();
+    await balancer.mockMethod("decimals()", [8]);
+
+    const Balancer = await ethers.getContractFactory("Balancer");
+    balancer = await upgrades.deployProxy(Balancer.connect(deployer), [perp.target], {
+      initializer: "init(address)",
+    });
+  });
+
+  describe("#init", function () {
+    it("should return the initial parameters", async function () {
+      expect(await balancer.targetSubscriptionRatio()).to.eq(toPerc("1.33333333"));
+      const swapBound = await balancer.swapDRBound();
+      expect(swapBound.lower).to.eq(toPerc("0.75"));
+      expect(swapBound.upper).to.eq(toPerc("1.5"));
+      const rebalanceBound = await balancer.rebalanceDRBound();
+      expect(rebalanceBound.lower).to.eq(toPerc("1.5"));
+      expect(rebalanceBound.upper).to.eq(toPerc("1"));
+    });
+    it("should set initial fees", async function () {
+      const fees = await balancer.fees();
+      expect(fees.perpMintFeePerc).to.eq(0n);
+      expect(fees.perpBurnFeePerc).to.eq(0n);
+      expect(fees.vaultMintFeePerc).to.eq(0n);
+      expect(fees.vaultBurnFeePerc).to.eq(0n);
+      expect(fees.rolloverFee.lower).to.eq(toPerc("-0.0025641"));
+      expect(fees.rolloverFee.upper).to.eq(toPerc("0.0076923"));
+      expect(fees.rolloverFee.growth).to.eq(toPerc("5"));
+      expect(fees.underlyingToPerpSwapFeePercs.lower).to.eq(toPerc("1"));
+      expect(fees.underlyingToPerpSwapFeePercs.upper).to.eq(toPerc("1"));
+      expect(fees.perpToUnderlyingSwapFeePercs.lower).to.eq(toPerc("1"));
+      expect(fees.perpToUnderlyingSwapFeePercs.upper).to.eq(toPerc("1"));
+      expect(fees.protocolSwapSharePerc).to.eq(0n);
+    });
+    it("should return owner", async function () {
+      expect(await balancer.owner()).to.eq(await deployer.getAddress());
+    });
+    it("should return decimals", async function () {
+      expect(await balancer.decimals()).to.eq(8);
+    });
+  });
+
+  describe("#updateTargetSubscriptionRatio", function () {
+    describe("when triggered by non-owner", function () {
+      it("should revert", async function () {
+        await expect(balancer.connect(otherUser).updateTargetSubscriptionRatio(toPerc("1.25"))).to.be.revertedWith(
+          "Ownable: caller is not the owner",
+        );
+      });
+    });
+
+    describe("when parameters are invalid", function () {
+      it("should revert", async function () {
+        await expect(
+          balancer.connect(deployer).updateTargetSubscriptionRatio(toPerc("0.5")),
+        ).to.be.revertedWithCustomError(balancer, "InvalidTargetSRBounds");
+      });
+    });
+
+    describe("when parameters are invalid", function () {
+      it("should revert", async function () {
+        await expect(
+          balancer.connect(deployer).updateTargetSubscriptionRatio(toPerc("2.1")),
+        ).to.be.revertedWithCustomError(balancer, "InvalidTargetSRBounds");
+      });
+    });
+
+    describe("when triggered by owner", function () {
+      it("should update the target sr", async function () {
+        expect(await balancer.targetSubscriptionRatio()).to.eq(toPerc("1.33333333"));
+        await balancer.connect(deployer).updateTargetSubscriptionRatio(toPerc("1.25"));
+        expect(await balancer.targetSubscriptionRatio()).to.eq(toPerc("1.25"));
+      });
+    });
+  });
+
+  describe("#updateSwapDRLimits", function () {
+    describe("when triggered by non-owner", function () {
+      it("should revert", async function () {
+        await expect(balancer.connect(otherUser).updateSwapDRLimits([toPerc("1"), toPerc("1")])).to.be.revertedWith(
+          "Ownable: caller is not the owner",
+        );
+      });
+    });
+
+    describe("when triggered by owner", function () {
+      it("should update swap dr limits", async function () {
+        const _swapBound = await balancer.swapDRBound();
+        expect(_swapBound.lower).to.eq(toPerc("0.75"));
+        expect(_swapBound.upper).to.eq(toPerc("1.5"));
+        await balancer.connect(deployer).updateSwapDRLimits([toPerc("0.5"), toPerc("1.33")]);
+        const swapBound = await balancer.swapDRBound();
+        expect(swapBound.lower).to.eq(toPerc("0.5"));
+        expect(swapBound.upper).to.eq(toPerc("1.33"));
+      });
+    });
+  });
+
+  describe("#updateRebalanceDRLimits", function () {
+    describe("when triggered by non-owner", function () {
+      it("should revert", async function () {
+        await expect(
+          balancer.connect(otherUser).updateRebalanceDRLimits([toPerc("1"), toPerc("1")]),
+        ).to.be.revertedWith("Ownable: caller is not the owner");
+      });
+    });
+
+    describe("when triggered by owner", function () {
+      it("should update rebalance dr limits", async function () {
+        const _rebalBound = await balancer.rebalanceDRBound();
+        expect(_rebalBound.lower).to.eq(toPerc("1.5"));
+        expect(_rebalBound.upper).to.eq(toPerc("1"));
+        await balancer.connect(deployer).updateRebalanceDRLimits([toPerc("1.25"), toPerc("0.9")]);
+        const rebalBound = await balancer.rebalanceDRBound();
+        expect(rebalBound.lower).to.eq(toPerc("1.25"));
+        expect(rebalBound.upper).to.eq(toPerc("0.9"));
+      });
+    });
+  });
+
+  describe("#updateFees", function () {
+    const flattenFees = f => [
+      f.perpMintFeePerc,
+      f.perpBurnFeePerc,
+      f.vaultMintFeePerc,
+      f.vaultBurnFeePerc,
+      [f.rolloverFee.lower, f.rolloverFee.upper, f.rolloverFee.growth],
+      [f.underlyingToPerpSwapFeePercs.lower, f.underlyingToPerpSwapFeePercs.upper],
+      [f.perpToUnderlyingSwapFeePercs.lower, f.perpToUnderlyingSwapFeePercs.upper],
+      f.protocolSwapSharePerc,
+    ];
+
+    let fees: any;
+    beforeEach(async function () {
+      fees = {
+        perpMintFeePerc: toPerc("0.03"),
+        perpBurnFeePerc: toPerc("0.03"),
+        vaultMintFeePerc: toPerc("0.01"),
+        vaultBurnFeePerc: toPerc("0.05"),
+        rolloverFee: {
+          lower: toPerc("-0.009"),
+          upper: toPerc("0.009"),
+          growth: toPerc("3"),
+        },
+        underlyingToPerpSwapFeePercs: {
+          lower: toPerc("0.05"),
+          upper: toPerc("0.15"),
+        },
+        perpToUnderlyingSwapFeePercs: {
+          lower: toPerc("0.1"),
+          upper: toPerc("0.2"),
+        },
+        protocolSwapSharePerc: toPerc("0.05"),
+      };
+    });
+
+    describe("when triggered by non-owner", function () {
+      it("should revert", async function () {
+        await expect(balancer.connect(otherUser).updateFees(fees)).to.be.revertedWith(
+          "Ownable: caller is not the owner",
+        );
+      });
+    });
+
+    describe("when parameters are invalid", function () {
+      beforeEach(async function () {
+        fees.perpMintFeePerc = toFixedPtAmt("1.01");
+      });
+      it("should revert", async function () {
+        await expect(balancer.connect(deployer).updateFees(fees)).to.be.revertedWithCustomError(
+          balancer,
+          "InvalidPerc",
+        );
+      });
+    });
+
+    describe("when parameters are invalid", function () {
+      beforeEach(async function () {
+        fees.perpBurnFeePerc = toFixedPtAmt("1.01");
+      });
+      it("should revert", async function () {
+        await expect(balancer.connect(deployer).updateFees(fees)).to.be.revertedWithCustomError(
+          balancer,
+          "InvalidPerc",
+        );
+      });
+    });
+
+    describe("when parameters are invalid", function () {
+      beforeEach(async function () {
+        fees.vaultMintFeePerc = toFixedPtAmt("1.01");
+      });
+      it("should revert", async function () {
+        await expect(balancer.connect(deployer).updateFees(fees)).to.be.revertedWithCustomError(
+          balancer,
+          "InvalidPerc",
+        );
+      });
+    });
+
+    describe("when parameters are invalid", function () {
+      beforeEach(async function () {
+        fees.vaultBurnFeePerc = toFixedPtAmt("1.01");
+      });
+      it("should revert", async function () {
+        await expect(balancer.connect(deployer).updateFees(fees)).to.be.revertedWithCustomError(
+          balancer,
+          "InvalidPerc",
+        );
+      });
+    });
+
+    describe("when parameters are invalid", function () {
+      beforeEach(async function () {
+        fees.underlyingToPerpSwapFeePercs.lower = toFixedPtAmt("1.01");
+      });
+      it("should revert", async function () {
+        await expect(balancer.connect(deployer).updateFees(fees)).to.be.revertedWithCustomError(
+          balancer,
+          "InvalidPerc",
+        );
+      });
+    });
+
+    describe("when parameters are invalid", function () {
+      beforeEach(async function () {
+        fees.underlyingToPerpSwapFeePercs.upper = toFixedPtAmt("1.01");
+      });
+      it("should revert", async function () {
+        await expect(balancer.connect(deployer).updateFees(fees)).to.be.revertedWithCustomError(
+          balancer,
+          "InvalidPerc",
+        );
+      });
+    });
+
+    describe("when parameters are invalid", function () {
+      beforeEach(async function () {
+        fees.underlyingToPerpSwapFeePercs.lower = toFixedPtAmt("0.05");
+        fees.underlyingToPerpSwapFeePercs.upper = toFixedPtAmt("0.01");
+      });
+      it("should revert", async function () {
+        await expect(balancer.connect(deployer).updateFees(fees)).to.be.revertedWithCustomError(
+          balancer,
+          "InvalidPerc",
+        );
+      });
+    });
+
+    describe("when parameters are invalid", function () {
+      beforeEach(async function () {
+        fees.perpToUnderlyingSwapFeePercs.lower = toFixedPtAmt("1.01");
+      });
+      it("should revert", async function () {
+        await expect(balancer.connect(deployer).updateFees(fees)).to.be.revertedWithCustomError(
+          balancer,
+          "InvalidPerc",
+        );
+      });
+    });
+
+    describe("when parameters are invalid", function () {
+      beforeEach(async function () {
+        fees.perpToUnderlyingSwapFeePercs.upper = toFixedPtAmt("1.01");
+      });
+      it("should revert", async function () {
+        await expect(balancer.connect(deployer).updateFees(fees)).to.be.revertedWithCustomError(
+          balancer,
+          "InvalidPerc",
+        );
+      });
+    });
+
+    describe("when parameters are invalid", function () {
+      beforeEach(async function () {
+        fees.perpToUnderlyingSwapFeePercs.lower = toFixedPtAmt("0.05");
+        fees.perpToUnderlyingSwapFeePercs.upper = toFixedPtAmt("0.01");
+      });
+      it("should revert", async function () {
+        await expect(balancer.connect(deployer).updateFees(fees)).to.be.revertedWithCustomError(
+          balancer,
+          "InvalidPerc",
+        );
+      });
+    });
+
+    describe("when parameters are invalid", function () {
+      beforeEach(async function () {
+        fees.protocolSwapSharePerc = toFixedPtAmt("1.01");
+      });
+      it("should revert", async function () {
+        await expect(balancer.connect(deployer).updateFees(fees)).to.be.revertedWithCustomError(
+          balancer,
+          "InvalidPerc",
+        );
+      });
+    });
+
+    describe("when parameters are invalid", function () {
+      beforeEach(async function () {
+        fees.rolloverFee.lower = toFixedPtAmt("-0.02");
+      });
+      it("should revert", async function () {
+        await expect(balancer.connect(deployer).updateFees(fees)).to.be.revertedWithCustomError(
+          balancer,
+          "InvalidSigmoidAsymptotes",
+        );
+      });
+    });
+
+    describe("when parameters are invalid", function () {
+      beforeEach(async function () {
+        fees.rolloverFee.upper = toFixedPtAmt("0.02");
+      });
+      it("should revert", async function () {
+        await expect(balancer.connect(deployer).updateFees(fees)).to.be.revertedWithCustomError(
+          balancer,
+          "InvalidSigmoidAsymptotes",
+        );
+      });
+    });
+
+    describe("when parameters are invalid", function () {
+      beforeEach(async function () {
+        fees.rolloverFee.lower = toFixedPtAmt("0.01");
+        fees.rolloverFee.upper = toFixedPtAmt("0.009");
+      });
+      it("should revert", async function () {
+        await expect(balancer.connect(deployer).updateFees(fees)).to.be.revertedWithCustomError(
+          balancer,
+          "InvalidSigmoidAsymptotes",
+        );
+      });
+    });
+
+    describe("when triggered by owner", function () {
+      it("should update the fees", async function () {
+        expect(await balancer.fees()).to.not.deep.eq(flattenFees(fees));
+        await expect(balancer.connect(deployer).updateFees(fees)).to.not.be.reverted;
+        expect(await balancer.fees()).to.deep.eq(flattenFees(fees));
+      });
+    });
+  });
+
+  describe("fee logic", function () {
+    let fees: any;
+
+    beforeEach(async function () {
+      fees = {
+        perpMintFeePerc: toPerc("0.03"),
+        perpBurnFeePerc: toPerc("0.03"),
+        vaultMintFeePerc: toPerc("0.01"),
+        vaultBurnFeePerc: toPerc("0.05"),
+        rolloverFee: {
+          lower: toPerc("-0.00253"),
+          upper: toPerc("0.00769"),
+          growth: toPerc("5"),
+        },
+        underlyingToPerpSwapFeePercs: {
+          lower: toPerc("0.05"),
+          upper: toPerc("0.15"),
+        },
+        perpToUnderlyingSwapFeePercs: {
+          lower: toPerc("0.1"),
+          upper: toPerc("0.2"),
+        },
+        protocolSwapSharePerc: 0n,
+      };
+      await balancer.updateFees(fees);
+      await balancer.updateSwapDRLimits([toPerc("0.75"), toPerc("1.5")]);
+    });
+
+    describe("static mint/burn fees", async function () {
+      it("should return the fee percentage", async function () {
+        expect(await balancer.computePerpMintFeePerc()).to.eq(toPerc("0.03"));
+        expect(await balancer.computePerpBurnFeePerc()).to.eq(toPerc("0.03"));
+        expect(await balancer.computeVaultMintFeePerc()).to.eq(toPerc("0.01"));
+        expect(await balancer.computeVaultBurnFeePerc()).to.eq(toPerc("0.05"));
+      });
+    });
+
+    describe("rollover fee", function () {
+      it("should compute fees as expected", async function () {
+        expect(await balancer.computePerpRolloverFeePerc(toPerc("0.01"))).to.eq(toPerc("-0.00242144"));
+        expect(await balancer.computePerpRolloverFeePerc(toPerc("0.25"))).to.eq(toPerc("-0.00228606"));
+        expect(await balancer.computePerpRolloverFeePerc(toPerc("0.5"))).to.eq(toPerc("-0.00196829"));
+        expect(await balancer.computePerpRolloverFeePerc(toPerc("0.75"))).to.eq(toPerc("-0.00128809"));
+        expect(await balancer.computePerpRolloverFeePerc(toPerc("0.9"))).to.eq(toPerc("-0.00060117"));
+        expect(await balancer.computePerpRolloverFeePerc(toPerc("0.99"))).to.eq(toPerc("-0.00004101"));
+        expect(await balancer.computePerpRolloverFeePerc(toPerc("1"))).to.eq("0");
+        expect(await balancer.computePerpRolloverFeePerc(toPerc("1.01"))).to.eq(toPerc("0.00004146"));
+        expect(await balancer.computePerpRolloverFeePerc(toPerc("1.05"))).to.eq(toPerc("0.00034407"));
+        expect(await balancer.computePerpRolloverFeePerc(toPerc("1.1"))).to.eq(toPerc("0.00071519"));
+        expect(await balancer.computePerpRolloverFeePerc(toPerc("1.25"))).to.eq(toPerc("0.00195646"));
+        expect(await balancer.computePerpRolloverFeePerc(toPerc("1.5"))).to.eq(toPerc("0.00411794"));
+        expect(await balancer.computePerpRolloverFeePerc(toPerc("1.75"))).to.eq(toPerc("0.00580663"));
+        expect(await balancer.computePerpRolloverFeePerc(toPerc("2"))).to.eq(toPerc("0.00680345"));
+        expect(await balancer.computePerpRolloverFeePerc(toPerc("5"))).to.eq(toPerc("0.00768997"));
+      });
+    });
+
+    describe("computeUnderlyingToPerpSwapFeePerc", function () {
+      describe("when protocol fee is zero", function () {
+        describe("when drPost is higher than ONE", function () {
+          it("should compute swap fees", async function () {
+            const s = await balancer.computeUnderlyingToPerpSwapFeePerc(toPerc("1.3"), toPerc("1.1"));
+            expect(s[0]).to.eq(toPerc("0.05"));
+            expect(s[1]).to.eq(0n);
+          });
+        });
+
+        describe("when drPre is lower than ONE", function () {
+          it("should compute swap fees", async function () {
+            const s = await balancer.computeUnderlyingToPerpSwapFeePerc(toPerc("1"), toPerc("0.9"));
+            expect(s[0]).to.eq(toPerc("0.07"));
+            expect(s[1]).to.eq(0n);
+          });
+        });
+
+        describe("when drPre is lower than ONE", function () {
+          it("should compute swap fees", async function () {
+            const s = await balancer.computeUnderlyingToPerpSwapFeePerc(toPerc("1"), toPerc("0.75"));
+            expect(s[0]).to.eq(toPerc("0.1"));
+            expect(s[1]).to.eq(0n);
+          });
+        });
+
+        describe("when drPre is lower than ONE", function () {
+          it("should compute swap fees", async function () {
+            const s = await balancer.computeUnderlyingToPerpSwapFeePerc(toPerc("1"), toPerc("0"));
+            expect(s[0]).to.eq(toPerc("0.25"));
+            expect(s[1]).to.eq(0n);
+          });
+        });
+
+        describe("when drPre > ONE and drPost < ONE", function () {
+          it("should compute swap fees", async function () {
+            const s = await balancer.computeUnderlyingToPerpSwapFeePerc(toPerc("1.1"), toPerc("0.9"));
+            expect(s[0]).to.eq(toPerc("0.06"));
+            expect(s[1]).to.eq(0n);
+          });
+        });
+
+        describe("when drPre > ONE and drPost < ONE", function () {
+          it("should compute swap fees", async function () {
+            const s = await balancer.computeUnderlyingToPerpSwapFeePerc(toPerc("1.4"), toPerc("0.9"));
+            expect(s[0]).to.eq(toPerc("0.054"));
+            expect(s[1]).to.eq(0n);
+          });
+        });
+
+        describe("when drPre > ONE and drPost < ONE", function () {
+          it("should compute swap fees", async function () {
+            const s = await balancer.computeUnderlyingToPerpSwapFeePerc(toPerc("1.1"), toPerc("0.6"));
+            expect(s[0]).to.eq(toPerc("0.114"));
+            expect(s[1]).to.eq(0n);
+          });
+        });
+      });
+
+      describe("when protocol fee is non zero", function () {
+        beforeEach(async function () {
+          fees.protocolSwapSharePerc = toPerc("0.1");
+          await balancer.updateFees(fees);
+        });
+        describe("when drPost is higher than ONE", function () {
+          it("should compute swap fees", async function () {
+            const s = await balancer.computeUnderlyingToPerpSwapFeePerc(toPerc("1.3"), toPerc("1.1"));
+            expect(s[0]).to.eq(toPerc("0.045"));
+            expect(s[1]).to.eq(toPerc("0.005"));
+          });
+        });
+
+        describe("when drPre is lower than ONE", function () {
+          it("should compute swap fees", async function () {
+            const s = await balancer.computeUnderlyingToPerpSwapFeePerc(toPerc("1"), toPerc("0.9"));
+            expect(s[0]).to.eq(toPerc("0.063"));
+            expect(s[1]).to.eq(toPerc("0.007"));
+          });
+        });
+
+        describe("when drPre is lower than ONE", function () {
+          it("should compute swap fees", async function () {
+            const s = await balancer.computeUnderlyingToPerpSwapFeePerc(toPerc("1"), toPerc("0.75"));
+            expect(s[0]).to.eq(toPerc("0.09"));
+            expect(s[1]).to.eq(toPerc("0.01"));
+          });
+        });
+
+        describe("when drPre is lower than ONE", function () {
+          it("should compute swap fees", async function () {
+            const s = await balancer.computeUnderlyingToPerpSwapFeePerc(toPerc("1"), toPerc("0"));
+            expect(s[0]).to.eq(toPerc("0.225"));
+            expect(s[1]).to.eq(toPerc("0.025"));
+          });
+        });
+
+        describe("when drPre > ONE and drPost < ONE", function () {
+          it("should compute swap fees", async function () {
+            const s = await balancer.computeUnderlyingToPerpSwapFeePerc(toPerc("1.1"), toPerc("0.9"));
+            expect(s[0]).to.eq(toPerc("0.054"));
+            expect(s[1]).to.eq(toPerc("0.006"));
+          });
+        });
+
+        describe("when drPre > ONE and drPost < ONE", function () {
+          it("should compute swap fees", async function () {
+            const s = await balancer.computeUnderlyingToPerpSwapFeePerc(toPerc("1.4"), toPerc("0.9"));
+            expect(s[0]).to.eq(toPerc("0.0486"));
+            expect(s[1]).to.eq(toPerc("0.0054"));
+          });
+        });
+
+        describe("when drPre > ONE and drPost < ONE", function () {
+          it("should compute swap fees", async function () {
+            const s = await balancer.computeUnderlyingToPerpSwapFeePerc(toPerc("1.1"), toPerc("0.6"));
+            expect(s[0]).to.eq(toPerc("0.1026"));
+            expect(s[1]).to.eq(toPerc("0.0114"));
+          });
+        });
+      });
+    });
+
+    describe("computePerpToUnderlyingSwapFeePerc", function () {
+      describe("when protocol fee is zero", function () {
+        describe("when drPre is higher than ONE", function () {
+          it("should compute swap fees", async function () {
+            const s = await balancer.computePerpToUnderlyingSwapFeePerc(toPerc("1.1"), toPerc("1.3"));
+            expect(s[0]).to.eq(toPerc("0.14"));
+            expect(s[1]).to.eq(0n);
+          });
+        });
+
+        describe("when drPre is higher than ONE", function () {
+          it("should compute swap fees", async function () {
+            const s = await balancer.computePerpToUnderlyingSwapFeePerc(toPerc("1"), toPerc("1.5"));
+            expect(s[0]).to.eq(toPerc("0.15"));
+            expect(s[1]).to.eq(0n);
+          });
+        });
+
+        describe("when drPre is higher than ONE", function () {
+          it("should compute swap fees", async function () {
+            const s = await balancer.computePerpToUnderlyingSwapFeePerc(toPerc("1"), toPerc("2"));
+            expect(s[0]).to.eq(toPerc("0.2"));
+            expect(s[1]).to.eq(0n);
+          });
+        });
+
+        describe("when drPre is higher than ONE", function () {
+          it("should compute swap fees", async function () {
+            const s = await balancer.computePerpToUnderlyingSwapFeePerc(toPerc("1"), toPerc("10"));
+            expect(s[0]).to.eq(toPerc("1"));
+            expect(s[1]).to.eq(0n);
+          });
+        });
+
+        describe("when drPost is lower than ONE", function () {
+          it("should compute swap fees", async function () {
+            const s = await balancer.computePerpToUnderlyingSwapFeePerc(toPerc("0.9"), toPerc("1"));
+            expect(s[0]).to.eq(toPerc("0.1"));
+            expect(s[1]).to.eq(0n);
+          });
+        });
+
+        describe("when drPre < ONE and drPost > ONE", function () {
+          it("should compute swap fees", async function () {
+            const s = await balancer.computePerpToUnderlyingSwapFeePerc(toPerc("0.9"), toPerc("1.1"));
+            expect(s[0]).to.eq(toPerc("0.105"));
+            expect(s[1]).to.eq(0n);
+          });
+        });
+
+        describe("when drPre > ONE and drPost < ONE", function () {
+          it("should compute swap fees", async function () {
+            const s = await balancer.computePerpToUnderlyingSwapFeePerc(toPerc("0.9"), toPerc("1.4"));
+            expect(s[0]).to.eq(toPerc("0.132"));
+            expect(s[1]).to.eq(0n);
+          });
+        });
+
+        describe("when drPre > ONE and drPost < ONE", function () {
+          it("should compute swap fees", async function () {
+            const s = await balancer.computePerpToUnderlyingSwapFeePerc(toPerc("0.6"), toPerc("1.1"));
+            expect(s[0]).to.eq(toPerc("0.102"));
+            expect(s[1]).to.eq(0n);
+          });
+        });
+      });
+
+      describe("when protocol fee is non zero", function () {
+        beforeEach(async function () {
+          fees.protocolSwapSharePerc = toPerc("0.1");
+          await balancer.updateFees(fees);
+        });
+
+        describe("when drPre is higher than ONE", function () {
+          it("should compute swap fees", async function () {
+            const s = await balancer.computePerpToUnderlyingSwapFeePerc(toPerc("1.1"), toPerc("1.3"));
+            expect(s[0]).to.eq(toPerc("0.126"));
+            expect(s[1]).to.eq(toPerc("0.014"));
+          });
+        });
+
+        describe("when drPre is higher than ONE", function () {
+          it("should compute swap fees", async function () {
+            const s = await balancer.computePerpToUnderlyingSwapFeePerc(toPerc("1"), toPerc("1.5"));
+            expect(s[0]).to.eq(toPerc("0.135"));
+            expect(s[1]).to.eq(toPerc("0.015"));
+          });
+        });
+
+        describe("when drPre is higher than ONE", function () {
+          it("should compute swap fees", async function () {
+            const s = await balancer.computePerpToUnderlyingSwapFeePerc(toPerc("1"), toPerc("2"));
+            expect(s[0]).to.eq(toPerc("0.18"));
+            expect(s[1]).to.eq(toPerc("0.02"));
+          });
+        });
+
+        describe("when drPre is higher than ONE", function () {
+          it("should compute swap fees", async function () {
+            const s = await balancer.computePerpToUnderlyingSwapFeePerc(toPerc("1"), toPerc("10"));
+            expect(s[0]).to.eq(toPerc("0.9"));
+            expect(s[1]).to.eq(toPerc("0.1"));
+          });
+        });
+
+        describe("when drPost is lower than ONE", function () {
+          it("should compute swap fees", async function () {
+            const s = await balancer.computePerpToUnderlyingSwapFeePerc(toPerc("0.9"), toPerc("1"));
+            expect(s[0]).to.eq(toPerc("0.09"));
+            expect(s[1]).to.eq(toPerc("0.01"));
+          });
+        });
+
+        describe("when drPost > ONE and drPre < ONE", function () {
+          it("should compute swap fees", async function () {
+            const s = await balancer.computePerpToUnderlyingSwapFeePerc(toPerc("0.9"), toPerc("1.1"));
+            expect(s[0]).to.eq(toPerc("0.0945"));
+            expect(s[1]).to.eq(toPerc("0.0105"));
+          });
+        });
+
+        describe("when drPost > ONE and drPre < ONE", function () {
+          it("should compute swap fees", async function () {
+            const s = await balancer.computePerpToUnderlyingSwapFeePerc(toPerc("0.9"), toPerc("1.4"));
+            expect(s[0]).to.eq(toPerc("0.1188"));
+            expect(s[1]).to.eq(toPerc("0.0132"));
+          });
+        });
+
+        describe("when drPost > ONE and drPre < ONE", function () {
+          it("should compute swap fees", async function () {
+            const s = await balancer.computePerpToUnderlyingSwapFeePerc(toPerc("0.6"), toPerc("1.1"));
+            expect(s[0]).to.eq(toPerc("0.0918"));
+            expect(s[1]).to.eq(toPerc("0.0102"));
+          });
+        });
+      });
+    });
+  });
+
+  describe("#computeDeviationRatio", async function () {
+    beforeEach(async function () {
+      await balancer.updateTargetSubscriptionRatio(toPerc("1.25"));
+    });
+
+    describe("when deviation = 1.0", function () {
+      it("should return 1", async function () {
+        const r = await balancer["computeDeviationRatio((uint256,uint256,uint256))"]({
+          perpTVL: toAmt("100"),
+          vaultTVL: toAmt("500"),
+          seniorTR: 200,
+        });
+        expect(r).to.eq(toPerc("1"));
+      });
+    });
+
+    describe("when deviation > 1.0", function () {
+      it("should compute dr", async function () {
+        const r = await balancer["computeDeviationRatio((uint256,uint256,uint256))"]({
+          perpTVL: toAmt("100"),
+          vaultTVL: toAmt("1000"),
+          seniorTR: 200,
+        });
+        expect(r).to.eq(toPerc("2"));
+      });
+    });
+
+    describe("when deviation < 1.0", function () {
+      it("should compute dr", async function () {
+        const r = await balancer["computeDeviationRatio((uint256,uint256,uint256))"]({
+          perpTVL: toAmt("100"),
+          vaultTVL: toAmt("250"),
+          seniorTR: 200,
+        });
+        expect(r).to.eq(toPerc("0.5"));
+      });
+    });
+  });
+});
diff --git a/spot-contracts/test/balancer/Balancer_mint_redeem.ts b/spot-contracts/test/balancer/Balancer_mint_redeem.ts
new file mode 100644
index 00000000..2a5d125d
--- /dev/null
+++ b/spot-contracts/test/balancer/Balancer_mint_redeem.ts
@@ -0,0 +1,1294 @@
+import { expect } from "chai";
+import { ethers, upgrades } from "hardhat";
+import { Contract, Signer } from "ethers";
+import {
+  toPercFixedPtAmt,
+  toFixedPtAmt,
+  setupCollateralToken,
+  setupBondFactory,
+  advancePerpQueueToBondMaturity,
+  getDepositBond,
+  getTranches,
+  depositIntoBond,
+  advancePerpQueue,
+  checkPerpComposition,
+  bondAt,
+  mintCollteralToken,
+  checkVaultComposition,
+  mintPerps,
+  mintVaultNotes,
+} from "../helpers";
+
+let collateralToken: Contract,
+  issuer: Contract,
+  perp: Contract,
+  vault: Contract,
+  balancer: Contract,
+  deployer: Signer,
+  otherUser: Signer,
+  perpTranches: Contract[],
+  remTranches: Contract[],
+  depositBond: Contract,
+  depositTranches: Contract[];
+const toPerc = toPercFixedPtAmt;
+
+async function setFees(balancer: Contract, fees: any = {}) {
+  const defaultFees = {
+    perpMintFeePerc: 0n,
+    perpBurnFeePerc: 0n,
+    vaultMintFeePerc: 0n,
+    vaultBurnFeePerc: 0n,
+    rolloverFee: {
+      lower: toPerc("-0.009"),
+      upper: toPerc("0.009"),
+      growth: 0n,
+    },
+    underlyingToPerpSwapFeePercs: {
+      lower: 0n,
+      upper: 0n,
+    },
+    perpToUnderlyingSwapFeePercs: {
+      lower: 0n,
+      upper: 0n,
+    },
+    protocolSwapSharePerc: 0n,
+  };
+  await balancer.updateFees({
+    ...defaultFees,
+    ...fees,
+  });
+}
+
+describe("Balancer", function () {
+  beforeEach(async function () {
+    const accounts = await ethers.getSigners();
+    deployer = accounts[0];
+    otherUser = accounts[1];
+
+    const bondFactory = await setupBondFactory();
+    ({ collateralToken } = await setupCollateralToken("Bitcoin", "BTC"));
+
+    const BondIssuer = await ethers.getContractFactory("BondIssuer");
+    issuer = await upgrades.deployProxy(
+      BondIssuer.connect(deployer),
+      [bondFactory.target, collateralToken.target, 4800, [200, 800], 1200, 0],
+      {
+        initializer: "init(address,address,uint256,uint256[],uint256,uint256)",
+      },
+    );
+
+    const PerpetualTranche = await ethers.getContractFactory("PerpetualTranche");
+    perp = await upgrades.deployProxy(
+      PerpetualTranche.connect(deployer),
+      ["PerpetualTranche", "PERP", collateralToken.target, issuer.target],
+      {
+        initializer: "init(string,string,address,address)",
+      },
+    );
+    await perp.updateTolerableTrancheMaturity(1200, 4800);
+    await advancePerpQueueToBondMaturity(perp, await getDepositBond(perp));
+
+    const RolloverVault = await ethers.getContractFactory("RolloverVault");
+    vault = await upgrades.deployProxy(RolloverVault.connect(deployer));
+    await vault.init("RolloverVault", "VSHARE", perp.target);
+    await perp.updateVault(vault.target);
+
+    const Balancer = await ethers.getContractFactory("Balancer");
+    balancer = await upgrades.deployProxy(Balancer.connect(deployer), [perp.target], {
+      initializer: "init(address)",
+    });
+    await setFees(balancer);
+    await perp.updateBalancer(balancer.target);
+    await vault.updateBalancer(balancer.target);
+
+    perpTranches = [];
+    remTranches = [];
+    for (let i = 0; i < 4; i++) {
+      const bond = await getDepositBond(perp);
+      const tranches = await getTranches(bond);
+      await depositIntoBond(bond, toFixedPtAmt("1000"), deployer);
+      await mintPerps(perp, tranches[0], toFixedPtAmt("200"), deployer);
+      perpTranches.push(tranches[0]);
+      remTranches.push(tranches[1]);
+      await advancePerpQueue(perp, 1200);
+    }
+
+    await checkPerpComposition(
+      perp,
+      [collateralToken, ...perpTranches.slice(-3)],
+      [toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("200")],
+    );
+    depositBond = await bondAt(await perp.depositBond());
+    depositTranches = await getTranches(depositBond);
+
+    await mintCollteralToken(collateralToken, toFixedPtAmt("100000"), deployer);
+    await checkVaultComposition(vault, [collateralToken], [0n]);
+    expect(await vault.assetCount()).to.eq(1);
+  });
+
+  describe("mint2", function () {
+    let mintAmts: any;
+    describe("when dr = 0", function () {
+      beforeEach(async function () {
+        expect(await balancer.deviationRatio()).to.eq(0n);
+        await collateralToken.approve(balancer.target, toFixedPtAmt("1000"));
+      });
+
+      it("should move dr closer to 1", async function () {
+        await balancer.mint2(toFixedPtAmt("1000"));
+        expect(await balancer.deviationRatio()).to.eq(toPerc("0.17241379"));
+      });
+    });
+
+    describe("when dr > 1", function () {
+      beforeEach(async function () {
+        await mintVaultNotes(vault, toFixedPtAmt("5000"), deployer);
+        expect(await balancer.deviationRatio()).to.eq(toPerc("1.25"));
+        await collateralToken.approve(balancer.target, toFixedPtAmt("1000"));
+      });
+
+      it("should move dr closer to 1", async function () {
+        await balancer.mint2(toFixedPtAmt("1000"));
+        expect(await balancer.deviationRatio()).to.eq(toPerc("1.20689654"));
+      });
+    });
+
+    describe("when dr < 1", function () {
+      beforeEach(async function () {
+        await mintVaultNotes(vault, toFixedPtAmt("2000"), deployer);
+        expect(await balancer.deviationRatio()).to.eq(toPerc("0.5"));
+        await collateralToken.approve(balancer.target, toFixedPtAmt("1000"));
+      });
+
+      it("should move dr closer to 1", async function () {
+        await balancer.mint2(toFixedPtAmt("1000"));
+        expect(await balancer.deviationRatio()).to.eq(toPerc("0.58620689"));
+      });
+    });
+
+    describe("when fees = 0", function () {
+      beforeEach(async function () {
+        await collateralToken.approve(balancer.target, toFixedPtAmt("1000"));
+        mintAmts = await balancer.mint2.staticCall(toFixedPtAmt("1000"));
+      });
+
+      it("should transfer underlying", async function () {
+        await expect(() => balancer.mint2(toFixedPtAmt("1000"))).to.changeTokenBalances(
+          collateralToken,
+          [deployer],
+          [toFixedPtAmt("-1000")],
+        );
+      });
+
+      it("should mint perps", async function () {
+        await expect(() => balancer.mint2(toFixedPtAmt("1000"))).to.changeTokenBalances(
+          perp,
+          [deployer],
+          [toFixedPtAmt("166.666666666666666666")],
+        );
+      });
+
+      it("should mint notes", async function () {
+        await expect(() => balancer.mint2(toFixedPtAmt("1000"))).to.changeTokenBalances(
+          vault,
+          [deployer],
+          [toFixedPtAmt("833333333.333333333334")],
+        );
+      });
+
+      it("should return the mint amounts", async function () {
+        expect(mintAmts.perpAmt).to.eq(toFixedPtAmt("166.666666666666666666"));
+        expect(mintAmts.noteAmt).to.eq(toFixedPtAmt("833333333.333333333334"));
+      });
+
+      it("should have the updated composition", async function () {
+        await balancer.mint2(toFixedPtAmt("1000"));
+        await checkPerpComposition(
+          perp,
+          [collateralToken, ...perpTranches.slice(-3), depositTranches[0]],
+          [
+            toFixedPtAmt("200"),
+            toFixedPtAmt("200"),
+            toFixedPtAmt("200"),
+            toFixedPtAmt("200"),
+            toFixedPtAmt("166.666666666666666666"),
+          ],
+        );
+        await checkVaultComposition(
+          vault,
+          [collateralToken, depositTranches[1]],
+          [toFixedPtAmt("166.66666666666666667"), toFixedPtAmt("666.666666666666666664")],
+        );
+      });
+    });
+
+    describe("when fee > 0", function () {
+      beforeEach(async function () {
+        await mintVaultNotes(vault, toFixedPtAmt("3000"), deployer);
+        await setFees(balancer, {
+          perpMintFeePerc: toPerc("0.01"),
+          vaultMintFeePerc: toPerc("0.1"),
+        });
+        await collateralToken.approve(balancer.target, toFixedPtAmt("1000"));
+        mintAmts = await balancer.mint2.staticCall(toFixedPtAmt("1000"));
+      });
+
+      it("should transfer underlying", async function () {
+        await expect(() => balancer.mint2(toFixedPtAmt("1000"))).to.changeTokenBalances(
+          collateralToken,
+          [deployer],
+          [toFixedPtAmt("-1000")],
+        );
+      });
+
+      it("should mint perps", async function () {
+        await expect(() => balancer.mint2(toFixedPtAmt("1000"))).to.changeTokenBalances(
+          perp,
+          [deployer],
+          [toFixedPtAmt("164.999999999999999999")],
+        );
+      });
+
+      it("should mint notes", async function () {
+        await expect(() => balancer.mint2(toFixedPtAmt("1000"))).to.changeTokenBalances(
+          vault,
+          [deployer],
+          [toFixedPtAmt("750000000.0000000000006")],
+        );
+      });
+
+      it("should burn perp fees", async function () {
+        await expect(balancer.mint2(toFixedPtAmt("1000")))
+          .to.emit(balancer, "Fee")
+          .withArgs(perp.target, perp.target, toFixedPtAmt("1.666666666666666667"));
+      });
+
+      it("should burn perp fees", async function () {
+        await expect(balancer.mint2(toFixedPtAmt("1000")))
+          .to.emit(perp, "Transfer")
+          .withArgs(balancer.target, ethers.ZeroAddress, toFixedPtAmt("1.666666666666666667"));
+      });
+
+      it("should burn vault fees", async function () {
+        await expect(balancer.mint2(toFixedPtAmt("1000")))
+          .to.emit(balancer, "Fee")
+          .withArgs(vault.target, vault.target, toFixedPtAmt("83333333.3333333333334"));
+      });
+
+      it("should burn vault fees", async function () {
+        await expect(balancer.mint2(toFixedPtAmt("1000")))
+          .to.emit(vault, "Transfer")
+          .withArgs(balancer.target, ethers.ZeroAddress, toFixedPtAmt("83333333.3333333333334"));
+      });
+
+      it("should return the mint amounts", async function () {
+        expect(mintAmts.perpAmt).to.eq(toFixedPtAmt("164.999999999999999999"));
+        expect(mintAmts.noteAmt).to.eq(toFixedPtAmt("750000000.0000000000006"));
+      });
+
+      it("should have the updated composition", async function () {
+        await balancer.mint2(toFixedPtAmt("1000"));
+        await checkPerpComposition(
+          perp,
+          [collateralToken, ...perpTranches.slice(-3), depositTranches[0]],
+          [
+            toFixedPtAmt("200"),
+            toFixedPtAmt("200"),
+            toFixedPtAmt("200"),
+            toFixedPtAmt("200"),
+            toFixedPtAmt("166.666666666666666666"),
+          ],
+        );
+        await checkVaultComposition(
+          vault,
+          [collateralToken, depositTranches[1]],
+          [toFixedPtAmt("3166.66666666666666667"), toFixedPtAmt("666.666666666666666664")],
+        );
+      });
+    });
+  });
+
+  describe("mint2WithPerps", function () {
+    let mintAmts: any;
+    describe("on successful mint", function () {
+      beforeEach(async function () {
+        await mintVaultNotes(vault, toFixedPtAmt("2000"), deployer);
+        expect(await balancer.deviationRatio()).to.eq(toPerc("0.5"));
+        await perp.approve(balancer.target, toFixedPtAmt("100"));
+        mintAmts = await balancer.mint2WithPerps.staticCall(toFixedPtAmt("100"));
+      });
+
+      it("should transfer perp and mint", async function () {
+        await expect(() => balancer.mint2WithPerps(toFixedPtAmt("100"))).to.changeTokenBalances(
+          perp,
+          [deployer],
+          [toFixedPtAmt("-83.333333333333333334")],
+        );
+      });
+
+      it("should mint notes", async function () {
+        await expect(() => balancer.mint2WithPerps(toFixedPtAmt("100"))).to.changeTokenBalances(
+          vault,
+          [deployer],
+          [toFixedPtAmt("83333333.333333333334")],
+        );
+      });
+
+      it("should return the mint amounts", async function () {
+        expect(mintAmts.perpAmt).to.eq(toFixedPtAmt("16.666666666666666666"));
+        expect(mintAmts.noteAmt).to.eq(toFixedPtAmt("83333333.333333333334"));
+      });
+
+      it("should move dr closer to 1", async function () {
+        await balancer.mint2WithPerps(toFixedPtAmt("100"));
+        expect(await balancer.deviationRatio()).to.eq(toPerc("0.58139534"));
+      });
+
+      it("should have the updated composition", async function () {
+        await balancer.mint2WithPerps(toFixedPtAmt("100"));
+        await checkPerpComposition(
+          perp,
+          [collateralToken, ...perpTranches.slice(-3), depositTranches[0]],
+          [
+            toFixedPtAmt("175"),
+            toFixedPtAmt("175"),
+            toFixedPtAmt("175"),
+            toFixedPtAmt("175"),
+            toFixedPtAmt("16.666666666666666666"),
+          ],
+        );
+        await checkVaultComposition(
+          vault,
+          [collateralToken, ...perpTranches.slice(-3), depositTranches[1]],
+          [
+            toFixedPtAmt("1941.66666666666666667"),
+            toFixedPtAmt("25"),
+            toFixedPtAmt("25"),
+            toFixedPtAmt("25"),
+            toFixedPtAmt("66.666666666666666664"),
+          ],
+        );
+      });
+    });
+
+    describe("when dr grows above upper bound", function () {
+      beforeEach(async function () {
+        await mintVaultNotes(vault, toFixedPtAmt("4000"), deployer);
+        expect(await balancer.deviationRatio()).to.eq(toPerc("1"));
+        await perp.approve(balancer.target, toFixedPtAmt("100"));
+      });
+
+      it("should revert", async function () {
+        await expect(balancer.mint2WithPerps(toFixedPtAmt("100"))).to.be.revertedWithCustomError(
+          balancer,
+          "DROutsideBound",
+        );
+      });
+    });
+
+    describe("when liquidity becomes too low", function () {
+      beforeEach(async function () {
+        await balancer.updateVaultMinUnderlyingPerc(toPerc("0.23"));
+        await mintVaultNotes(vault, toFixedPtAmt("100"), deployer);
+        await perp.approve(balancer.target, toFixedPtAmt("100"));
+      });
+
+      it("should revert", async function () {
+        await expect(balancer.mint2WithPerps(toFixedPtAmt("100"))).to.be.revertedWithCustomError(
+          balancer,
+          "InsufficientLiquidity",
+        );
+      });
+    });
+  });
+
+  describe("mint2WithVaultNotes", function () {
+    let mintAmts: any;
+    describe("on successful mint", function () {
+      beforeEach(async function () {
+        await mintVaultNotes(vault, toFixedPtAmt("10000"), deployer);
+        expect(await balancer.deviationRatio()).to.eq(toPerc("2.5"));
+        await vault.approve(balancer.target, toFixedPtAmt("100000000"));
+        mintAmts = await balancer.mint2WithVaultNotes.staticCall(toFixedPtAmt("100000000"));
+      });
+
+      it("should mint perps", async function () {
+        await expect(() => balancer.mint2WithVaultNotes(toFixedPtAmt("100000000"))).to.changeTokenBalances(
+          perp,
+          [deployer],
+          [toFixedPtAmt("16.666666666666666666")],
+        );
+      });
+
+      it("should transfer vault notes and mint", async function () {
+        await expect(() => balancer.mint2WithVaultNotes(toFixedPtAmt("100000000"))).to.changeTokenBalances(
+          vault,
+          [deployer],
+          [toFixedPtAmt("-16666666.666666666666")],
+        );
+      });
+
+      it("should return the mint amounts", async function () {
+        expect(mintAmts.perpAmt).to.eq(toFixedPtAmt("16.666666666666666666"));
+        expect(mintAmts.noteAmt).to.eq(toFixedPtAmt("83333333.333333333334"));
+      });
+
+      it("should move dr closer to 1", async function () {
+        await balancer.mint2WithVaultNotes(toFixedPtAmt("100000000"));
+        expect(await balancer.deviationRatio()).to.eq(toPerc("2.44489795"));
+      });
+
+      it("should have the updated composition", async function () {
+        await balancer.mint2WithVaultNotes(toFixedPtAmt("100000000"));
+        await checkPerpComposition(
+          perp,
+          [collateralToken, ...perpTranches.slice(-3), depositTranches[0]],
+          [
+            toFixedPtAmt("200"),
+            toFixedPtAmt("200"),
+            toFixedPtAmt("200"),
+            toFixedPtAmt("200"),
+            toFixedPtAmt("16.666666666666666666"),
+          ],
+        );
+        await checkVaultComposition(
+          vault,
+          [collateralToken, depositTranches[1]],
+          [toFixedPtAmt("9916.66666666666666667"), toFixedPtAmt("66.666666666666666664")],
+        );
+      });
+    });
+
+    describe("when dr grows above upper bound", function () {
+      beforeEach(async function () {
+        await mintVaultNotes(vault, toFixedPtAmt("5000"), deployer);
+        expect(await balancer.deviationRatio()).to.eq(toPerc("1.25"));
+        await vault.approve(balancer.target, toFixedPtAmt("100000000"));
+      });
+
+      it("should revert", async function () {
+        await expect(balancer.mint2WithVaultNotes(toFixedPtAmt("100000000"))).to.be.revertedWithCustomError(
+          balancer,
+          "DROutsideBound",
+        );
+      });
+    });
+
+    describe("when liquidity has been deployed", function () {
+      beforeEach(async function () {
+        await balancer.updateRebalanceDRLimits([toPerc("0"), toPerc("1")]);
+        await mintVaultNotes(vault, toFixedPtAmt("100"), deployer);
+        await vault.deploy();
+        await vault.deploy();
+        await vault.approve(balancer.target, toFixedPtAmt("10000000"));
+      });
+
+      it("should revert", async function () {
+        await expect(balancer.mint2WithVaultNotes(toFixedPtAmt("10000000"))).to.be.revertedWithCustomError(
+          balancer,
+          "InsufficientLiquidity",
+        );
+      });
+    });
+
+    describe("when liquidity goes below the enforced perc", function () {
+      beforeEach(async function () {
+        await balancer.updateVaultMinUnderlyingPerc(toPerc("0.95"));
+        await balancer.updateRebalanceDRLimits([toPerc("1"), toPerc("1")]);
+        await mintVaultNotes(vault, toFixedPtAmt("5000"), deployer);
+        await vault.approve(balancer.target, toFixedPtAmt("500000000"));
+      });
+
+      it("should revert", async function () {
+        await expect(balancer.mint2WithVaultNotes(toFixedPtAmt("500000000"))).to.be.revertedWithCustomError(
+          balancer,
+          "InsufficientLiquidity",
+        );
+      });
+    });
+  });
+
+  describe("mintPerps", function () {
+    let mintAmt: BigInt;
+    describe("when fees = 0", function () {
+      beforeEach(async function () {
+        await depositIntoBond(depositBond, toFixedPtAmt("1000"), deployer);
+        await depositTranches[0].approve(balancer.target, toFixedPtAmt("100"));
+        mintAmt = await balancer.mintPerps.staticCall(depositTranches[0].target, toFixedPtAmt("100"));
+      });
+
+      it("should transfer depositTranche", async function () {
+        await expect(() => balancer.mintPerps(depositTranches[0].target, toFixedPtAmt("100"))).to.changeTokenBalances(
+          depositTranches[0],
+          [deployer],
+          [toFixedPtAmt("-100")],
+        );
+      });
+
+      it("should mint perps", async function () {
+        await expect(() => balancer.mintPerps(depositTranches[0].target, toFixedPtAmt("100"))).to.changeTokenBalances(
+          perp,
+          [deployer],
+          [toFixedPtAmt("100")],
+        );
+      });
+
+      it("should return the mint amount", async function () {
+        expect(mintAmt).to.eq(toFixedPtAmt("100"));
+      });
+
+      it("should have the updated composition", async function () {
+        await balancer.mintPerps(depositTranches[0].target, toFixedPtAmt("100"));
+        await checkPerpComposition(
+          perp,
+          [collateralToken, ...perpTranches.slice(-3), depositTranches[0]],
+          [toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("100")],
+        );
+      });
+    });
+
+    describe("when fee > 0", function () {
+      beforeEach(async function () {
+        await setFees(balancer, {
+          perpMintFeePerc: toPerc("0.1"),
+        });
+        await depositIntoBond(depositBond, toFixedPtAmt("1000"), deployer);
+        await depositTranches[0].approve(balancer.target, toFixedPtAmt("100"));
+        mintAmt = await balancer.mintPerps.staticCall(depositTranches[0].target, toFixedPtAmt("100"));
+      });
+
+      it("should transfer depositTranche", async function () {
+        await expect(() => balancer.mintPerps(depositTranches[0].target, toFixedPtAmt("100"))).to.changeTokenBalances(
+          depositTranches[0],
+          [deployer],
+          [toFixedPtAmt("-100")],
+        );
+      });
+
+      it("should mint perps", async function () {
+        await expect(() => balancer.mintPerps(depositTranches[0].target, toFixedPtAmt("100"))).to.changeTokenBalances(
+          perp,
+          [deployer],
+          [toFixedPtAmt("90")],
+        );
+      });
+
+      it("should return the mint amount", async function () {
+        expect(mintAmt).to.eq(toFixedPtAmt("90"));
+      });
+
+      it("should have the updated composition", async function () {
+        await balancer.mintPerps(depositTranches[0].target, toFixedPtAmt("100"));
+        await checkPerpComposition(
+          perp,
+          [collateralToken, ...perpTranches.slice(-3), depositTranches[0]],
+          [toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("100")],
+        );
+      });
+
+      it("should burn perp fees", async function () {
+        await expect(balancer.mintPerps(depositTranches[0].target, toFixedPtAmt("100")))
+          .to.emit(balancer, "Fee")
+          .withArgs(perp.target, perp.target, toFixedPtAmt("10"));
+      });
+
+      it("should burn perp fees", async function () {
+        await expect(balancer.mintPerps(depositTranches[0].target, toFixedPtAmt("100")))
+          .to.emit(perp, "Transfer")
+          .withArgs(balancer.target, ethers.ZeroAddress, toFixedPtAmt("10"));
+      });
+    });
+  });
+
+  describe("redeemPerps", function () {
+    let redemptionAmts: BigInt;
+    describe("when fees = 0", function () {
+      beforeEach(async function () {
+        await perp.approve(balancer.target, toFixedPtAmt("100"));
+        redemptionAmts = await balancer.redeemPerps.staticCall(toFixedPtAmt("100"));
+      });
+
+      it("should burn perps", async function () {
+        await expect(() => balancer.redeemPerps(toFixedPtAmt("100"))).to.changeTokenBalances(
+          perp,
+          [deployer],
+          [toFixedPtAmt("-100")],
+        );
+      });
+
+      it("should collateralToken", async function () {
+        await expect(() => balancer.redeemPerps(toFixedPtAmt("100"))).to.changeTokenBalances(
+          collateralToken,
+          [deployer],
+          [toFixedPtAmt("25")],
+        );
+      });
+
+      it("should transfer tranches", async function () {
+        await expect(() => balancer.redeemPerps(toFixedPtAmt("100"))).to.changeTokenBalances(
+          perpTranches[1],
+          [deployer],
+          [toFixedPtAmt("25")],
+        );
+      });
+
+      it("should transfer tranches", async function () {
+        await expect(() => balancer.redeemPerps(toFixedPtAmt("100"))).to.changeTokenBalances(
+          perpTranches[2],
+          [deployer],
+          [toFixedPtAmt("25")],
+        );
+      });
+
+      it("should transfer tranches", async function () {
+        await expect(() => balancer.redeemPerps(toFixedPtAmt("100"))).to.changeTokenBalances(
+          perpTranches[3],
+          [deployer],
+          [toFixedPtAmt("25")],
+        );
+      });
+
+      it("should return the redemptionAmts amount", async function () {
+        expect(redemptionAmts[0].token).to.eq(collateralToken.target);
+        expect(redemptionAmts[0].amount).to.eq(toFixedPtAmt("25"));
+        expect(redemptionAmts[1].token).to.eq(perpTranches[3].target);
+        expect(redemptionAmts[1].amount).to.eq(toFixedPtAmt("25"));
+        expect(redemptionAmts[2].token).to.eq(perpTranches[1].target);
+        expect(redemptionAmts[2].amount).to.eq(toFixedPtAmt("25"));
+        expect(redemptionAmts[3].token).to.eq(perpTranches[2].target);
+        expect(redemptionAmts[3].amount).to.eq(toFixedPtAmt("25"));
+      });
+
+      it("should have the updated composition", async function () {
+        await balancer.redeemPerps(toFixedPtAmt("100"));
+        await checkPerpComposition(
+          perp,
+          [collateralToken, ...perpTranches.slice(-3)],
+          [toFixedPtAmt("175"), toFixedPtAmt("175"), toFixedPtAmt("175"), toFixedPtAmt("175")],
+        );
+      });
+    });
+
+    describe("when fees > 0", function () {
+      beforeEach(async function () {
+        await setFees(balancer, {
+          perpBurnFeePerc: toPerc("0.1"),
+        });
+        await perp.approve(balancer.target, toFixedPtAmt("100"));
+        redemptionAmts = await balancer.redeemPerps.staticCall(toFixedPtAmt("100"));
+      });
+
+      it("should burn perps", async function () {
+        await expect(() => balancer.redeemPerps(toFixedPtAmt("100"))).to.changeTokenBalances(
+          perp,
+          [deployer],
+          [toFixedPtAmt("-100")],
+        );
+      });
+
+      it("should collateralToken", async function () {
+        await expect(() => balancer.redeemPerps(toFixedPtAmt("100"))).to.changeTokenBalances(
+          collateralToken,
+          [deployer],
+          [toFixedPtAmt("22.5")],
+        );
+      });
+
+      it("should transfer tranches", async function () {
+        await expect(() => balancer.redeemPerps(toFixedPtAmt("100"))).to.changeTokenBalances(
+          perpTranches[1],
+          [deployer],
+          [toFixedPtAmt("22.5")],
+        );
+      });
+
+      it("should transfer tranches", async function () {
+        await expect(() => balancer.redeemPerps(toFixedPtAmt("100"))).to.changeTokenBalances(
+          perpTranches[2],
+          [deployer],
+          [toFixedPtAmt("22.5")],
+        );
+      });
+
+      it("should transfer tranches", async function () {
+        await expect(() => balancer.redeemPerps(toFixedPtAmt("100"))).to.changeTokenBalances(
+          perpTranches[3],
+          [deployer],
+          [toFixedPtAmt("22.5")],
+        );
+      });
+
+      it("should return the redemptionAmts amount", async function () {
+        expect(redemptionAmts[0].token).to.eq(collateralToken.target);
+        expect(redemptionAmts[0].amount).to.eq(toFixedPtAmt("22.5"));
+        expect(redemptionAmts[1].token).to.eq(perpTranches[3].target);
+        expect(redemptionAmts[1].amount).to.eq(toFixedPtAmt("22.5"));
+        expect(redemptionAmts[2].token).to.eq(perpTranches[1].target);
+        expect(redemptionAmts[2].amount).to.eq(toFixedPtAmt("22.5"));
+        expect(redemptionAmts[3].token).to.eq(perpTranches[2].target);
+        expect(redemptionAmts[3].amount).to.eq(toFixedPtAmt("22.5"));
+      });
+
+      it("should have the updated composition", async function () {
+        await balancer.redeemPerps(toFixedPtAmt("100"));
+        await checkPerpComposition(
+          perp,
+          [collateralToken, ...perpTranches.slice(-3)],
+          [toFixedPtAmt("177.5"), toFixedPtAmt("177.5"), toFixedPtAmt("177.5"), toFixedPtAmt("177.5")],
+        );
+      });
+
+      it("should burn perp fees", async function () {
+        await expect(balancer.redeemPerps(toFixedPtAmt("100")))
+          .to.emit(balancer, "Fee")
+          .withArgs(perp.target, perp.target, toFixedPtAmt("10"));
+      });
+
+      it("should burn perp fees", async function () {
+        await expect(balancer.redeemPerps(toFixedPtAmt("100")))
+          .to.emit(perp, "Transfer")
+          .withArgs(balancer.target, ethers.ZeroAddress, toFixedPtAmt("10"));
+      });
+    });
+  });
+
+  describe("mintVaultNotes", function () {
+    let mintAmt: BigInt;
+    describe("when fees = 0", function () {
+      beforeEach(async function () {
+        await collateralToken.approve(balancer.target, toFixedPtAmt("1000"));
+        mintAmt = await balancer.mintVaultNotes.staticCall(toFixedPtAmt("1000"));
+      });
+
+      it("should transfer underlying", async function () {
+        await expect(() => balancer.mintVaultNotes(toFixedPtAmt("1000"))).to.changeTokenBalances(
+          collateralToken,
+          [deployer],
+          [toFixedPtAmt("-1000")],
+        );
+      });
+
+      it("should mint vault notes", async function () {
+        await expect(() => balancer.mintVaultNotes(toFixedPtAmt("1000"))).to.changeTokenBalances(
+          vault,
+          [deployer],
+          [toFixedPtAmt("1000000000")],
+        );
+      });
+
+      it("should return the mint amount", async function () {
+        expect(mintAmt).to.eq(toFixedPtAmt("1000000000"));
+      });
+
+      it("should have the updated composition", async function () {
+        await balancer.mintVaultNotes(toFixedPtAmt("1000"));
+        await checkVaultComposition(vault, [collateralToken], [toFixedPtAmt("1000")]);
+      });
+    });
+
+    describe("when fee > 0", function () {
+      beforeEach(async function () {
+        await setFees(balancer, {
+          vaultMintFeePerc: toPerc("0.1"),
+        });
+        await collateralToken.approve(balancer.target, toFixedPtAmt("1000"));
+        mintAmt = await balancer.mintVaultNotes.staticCall(toFixedPtAmt("1000"));
+      });
+
+      it("should transfer underlying", async function () {
+        await expect(() => balancer.mintVaultNotes(toFixedPtAmt("1000"))).to.changeTokenBalances(
+          collateralToken,
+          [deployer],
+          [toFixedPtAmt("-1000")],
+        );
+      });
+
+      it("should mint vault notes", async function () {
+        await expect(() => balancer.mintVaultNotes(toFixedPtAmt("1000"))).to.changeTokenBalances(
+          vault,
+          [deployer],
+          [toFixedPtAmt("900000000")],
+        );
+      });
+
+      it("should return the mint amount", async function () {
+        expect(mintAmt).to.eq(toFixedPtAmt("900000000"));
+      });
+
+      it("should have the updated composition", async function () {
+        await balancer.mintVaultNotes(toFixedPtAmt("1000"));
+        await checkVaultComposition(vault, [collateralToken], [toFixedPtAmt("1000")]);
+      });
+
+      it("should burn vault fees", async function () {
+        await expect(balancer.mintVaultNotes(toFixedPtAmt("1000")))
+          .to.emit(balancer, "Fee")
+          .withArgs(vault.target, vault.target, toFixedPtAmt("100000000"));
+      });
+
+      it("should burn vault fees", async function () {
+        await expect(balancer.mintVaultNotes(toFixedPtAmt("1000")))
+          .to.emit(vault, "Transfer")
+          .withArgs(balancer.target, ethers.ZeroAddress, toFixedPtAmt("100000000"));
+      });
+    });
+  });
+
+  describe("redeemVaultNotes", function () {
+    let redemptionAmts: BigInt;
+    describe("when fees = 0", function () {
+      beforeEach(async function () {
+        await mintVaultNotes(vault, toFixedPtAmt("1000"), deployer);
+        await vault.deploy();
+        await vault.approve(balancer.target, toFixedPtAmt("100000000"));
+        redemptionAmts = await balancer.redeemVaultNotes.staticCall(toFixedPtAmt("100000000"));
+      });
+
+      it("should burn vault notes", async function () {
+        await expect(() => balancer.redeemVaultNotes(toFixedPtAmt("100000000"))).to.changeTokenBalances(
+          vault,
+          [deployer],
+          [toFixedPtAmt("-100000000")],
+        );
+      });
+
+      it("should collateralToken", async function () {
+        await expect(() => balancer.redeemVaultNotes(toFixedPtAmt("100000000"))).to.changeTokenBalances(
+          collateralToken,
+          [deployer],
+          [toFixedPtAmt("20")],
+        );
+      });
+
+      it("should transfer tranches", async function () {
+        await expect(() => balancer.redeemVaultNotes(toFixedPtAmt("100000000"))).to.changeTokenBalances(
+          depositTranches[1],
+          [deployer],
+          [toFixedPtAmt("80")],
+        );
+      });
+
+      it("should return the redemptionAmts amount", async function () {
+        expect(redemptionAmts[0].token).to.eq(collateralToken.target);
+        expect(redemptionAmts[0].amount).to.eq(toFixedPtAmt("20"));
+        expect(redemptionAmts[1].token).to.eq(depositTranches[1].target);
+        expect(redemptionAmts[1].amount).to.eq(toFixedPtAmt("80"));
+      });
+
+      it("should have the updated composition", async function () {
+        await balancer.redeemVaultNotes(toFixedPtAmt("100000000"));
+        await checkVaultComposition(
+          vault,
+          [collateralToken, depositTranches[1]],
+          [toFixedPtAmt("180"), toFixedPtAmt("720")],
+        );
+      });
+    });
+
+    describe("when fees > 0", function () {
+      beforeEach(async function () {
+        await setFees(balancer, {
+          vaultBurnFeePerc: toPerc("0.1"),
+        });
+        await mintVaultNotes(vault, toFixedPtAmt("1000"), deployer);
+        await vault.deploy();
+        await vault.approve(balancer.target, toFixedPtAmt("100000000"));
+        redemptionAmts = await balancer.redeemVaultNotes.staticCall(toFixedPtAmt("100000000"));
+      });
+
+      it("should burn vault notes", async function () {
+        await expect(() => balancer.redeemVaultNotes(toFixedPtAmt("100000000"))).to.changeTokenBalances(
+          vault,
+          [deployer],
+          [toFixedPtAmt("-100000000")],
+        );
+      });
+
+      it("should collateralToken", async function () {
+        await expect(() => balancer.redeemVaultNotes(toFixedPtAmt("100000000"))).to.changeTokenBalances(
+          collateralToken,
+          [deployer],
+          [toFixedPtAmt("18")],
+        );
+      });
+
+      it("should transfer tranches", async function () {
+        await expect(() => balancer.redeemVaultNotes(toFixedPtAmt("100000000"))).to.changeTokenBalances(
+          depositTranches[1],
+          [deployer],
+          [toFixedPtAmt("72")],
+        );
+      });
+
+      it("should return the redemptionAmts amount", async function () {
+        expect(redemptionAmts[0].token).to.eq(collateralToken.target);
+        expect(redemptionAmts[0].amount).to.eq(toFixedPtAmt("18"));
+        expect(redemptionAmts[1].token).to.eq(depositTranches[1].target);
+        expect(redemptionAmts[1].amount).to.eq(toFixedPtAmt("72"));
+      });
+
+      it("should have the updated composition", async function () {
+        await balancer.redeemVaultNotes(toFixedPtAmt("100000000"));
+        await checkVaultComposition(
+          vault,
+          [collateralToken, depositTranches[1]],
+          [toFixedPtAmt("182"), toFixedPtAmt("728")],
+        );
+      });
+
+      it("should burn vault fees", async function () {
+        await expect(balancer.redeemVaultNotes(toFixedPtAmt("100000000")))
+          .to.emit(balancer, "Fee")
+          .withArgs(vault.target, vault.target, toFixedPtAmt("10000000"));
+      });
+
+      it("should burn vault fees", async function () {
+        await expect(balancer.redeemVaultNotes(toFixedPtAmt("100000000")))
+          .to.emit(vault, "Transfer")
+          .withArgs(balancer.target, ethers.ZeroAddress, toFixedPtAmt("10000000"));
+      });
+    });
+  });
+
+  describe("swapUnderlyingForPerps", function () {
+    let swapAmt: any;
+    describe("when fee = 0", function () {
+      beforeEach(async function () {
+        await mintVaultNotes(vault, toFixedPtAmt("4000"), deployer);
+        expect(await balancer.deviationRatio()).to.eq(toPerc("1"));
+        await collateralToken.approve(balancer.target, toFixedPtAmt("100"));
+        swapAmt = await balancer.swapUnderlyingForPerps.staticCall(toFixedPtAmt("100"));
+      });
+
+      it("should transfer underlying", async function () {
+        await expect(() => balancer.swapUnderlyingForPerps(toFixedPtAmt("100"))).to.changeTokenBalances(
+          collateralToken,
+          [deployer],
+          [toFixedPtAmt("-100")],
+        );
+      });
+
+      it("should mint perps", async function () {
+        await expect(() => balancer.swapUnderlyingForPerps(toFixedPtAmt("100"))).to.changeTokenBalances(
+          perp,
+          [deployer],
+          [toFixedPtAmt("100")],
+        );
+      });
+
+      it("should return the swap amount", async function () {
+        expect(swapAmt).to.eq(toFixedPtAmt("100"));
+      });
+
+      it("should have the updated composition", async function () {
+        await balancer.swapUnderlyingForPerps(toFixedPtAmt("100"));
+        await checkPerpComposition(
+          perp,
+          [collateralToken, ...perpTranches.slice(-3), depositTranches[0]],
+          [toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("100")],
+        );
+        await checkVaultComposition(
+          vault,
+          [collateralToken, depositTranches[1]],
+          [toFixedPtAmt("3600"), toFixedPtAmt("400")],
+        );
+      });
+
+      it("should reduce the system dr", async function () {
+        await balancer.swapUnderlyingForPerps(toFixedPtAmt("100"));
+        expect(await balancer.deviationRatio()).to.eq(toPerc("0.88888888"));
+      });
+    });
+
+    describe("when fee > 0", function () {
+      beforeEach(async function () {
+        await setFees(balancer, {
+          perpMintFeePerc: toPerc("0.05"),
+          protocolSwapSharePerc: toPerc("0.25"),
+          underlyingToPerpSwapFeePercs: { lower: toPerc("0.1"), upper: toPerc("0.1") },
+        });
+        await mintVaultNotes(vault, toFixedPtAmt("4000"), deployer);
+        expect(await balancer.deviationRatio()).to.eq(toPerc("1"));
+        await vault.transferOwnership(await otherUser.getAddress());
+        await collateralToken.approve(balancer.target, toFixedPtAmt("100"));
+        swapAmt = await balancer.swapUnderlyingForPerps.staticCall(toFixedPtAmt("100"));
+      });
+
+      it("should transfer underlying", async function () {
+        await expect(() => balancer.swapUnderlyingForPerps(toFixedPtAmt("100"))).to.changeTokenBalances(
+          collateralToken,
+          [deployer],
+          [toFixedPtAmt("-100")],
+        );
+      });
+
+      it("should mint perps", async function () {
+        await expect(() => balancer.swapUnderlyingForPerps(toFixedPtAmt("100"))).to.changeTokenBalances(
+          perp,
+          [deployer],
+          [toFixedPtAmt("85")],
+        );
+      });
+
+      it("should return the swap amount", async function () {
+        expect(swapAmt).to.eq(toFixedPtAmt("85"));
+      });
+
+      it("should have the updated composition", async function () {
+        await balancer.swapUnderlyingForPerps(toFixedPtAmt("100"));
+        await checkPerpComposition(
+          perp,
+          [collateralToken, ...perpTranches.slice(-3), depositTranches[0]],
+          [toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("90")],
+        );
+        await checkVaultComposition(
+          vault,
+          [collateralToken, depositTranches[1]],
+          [toFixedPtAmt("3647.5"), toFixedPtAmt("360.0")],
+        );
+      });
+
+      it("should reduce the system dr", async function () {
+        await balancer.swapUnderlyingForPerps(toFixedPtAmt("100"));
+        expect(await balancer.deviationRatio()).to.eq(toPerc("0.90056179"));
+      });
+
+      it("should burn perp fees", async function () {
+        await expect(balancer.swapUnderlyingForPerps(toFixedPtAmt("100")))
+          .to.emit(balancer, "Fee")
+          .withArgs(perp.target, perp.target, toFixedPtAmt("5"));
+      });
+
+      it("should burn perp fees", async function () {
+        await expect(balancer.swapUnderlyingForPerps(toFixedPtAmt("100")))
+          .to.emit(perp, "Transfer")
+          .withArgs(balancer.target, ethers.ZeroAddress, toFixedPtAmt("5"));
+      });
+
+      it("should settle vault fees", async function () {
+        await expect(balancer.swapUnderlyingForPerps(toFixedPtAmt("100")))
+          .to.emit(balancer, "Fee")
+          .withArgs(vault.target, collateralToken.target, toFixedPtAmt("7.5"));
+      });
+
+      it("should settle vault fees", async function () {
+        await expect(balancer.swapUnderlyingForPerps(toFixedPtAmt("100")))
+          .to.emit(collateralToken, "Transfer")
+          .withArgs(balancer.target, vault.target, toFixedPtAmt("7.5"));
+      });
+
+      it("should settle protocol fees", async function () {
+        await expect(balancer.swapUnderlyingForPerps(toFixedPtAmt("100")))
+          .to.emit(balancer, "Fee")
+          .withArgs(await otherUser.getAddress(), collateralToken.target, toFixedPtAmt("2.5"));
+      });
+
+      it("should settle protocol fees", async function () {
+        await expect(balancer.swapUnderlyingForPerps(toFixedPtAmt("100")))
+          .to.emit(collateralToken, "Transfer")
+          .withArgs(balancer.target, await otherUser.getAddress(), toFixedPtAmt("2.5"));
+      });
+    });
+
+    describe("when dr reduces below lower bound", function () {
+      beforeEach(async function () {
+        await mintVaultNotes(vault, toFixedPtAmt("3000"), deployer);
+        expect(await balancer.deviationRatio()).to.eq(toPerc("0.75"));
+        await collateralToken.approve(balancer.target, toFixedPtAmt("100"));
+      });
+
+      it("should revert", async function () {
+        await expect(balancer.swapUnderlyingForPerps(toFixedPtAmt("100"))).to.be.revertedWithCustomError(
+          balancer,
+          "DROutsideBound",
+        );
+      });
+    });
+
+    describe("when liquidity becomes too low", function () {
+      beforeEach(async function () {
+        await balancer.updateVaultMinUnderlyingPerc(toPerc("0.91"));
+        await mintVaultNotes(vault, toFixedPtAmt("4000"), deployer);
+        await collateralToken.approve(balancer.target, toFixedPtAmt("100"));
+      });
+
+      it("should revert", async function () {
+        await expect(balancer.swapUnderlyingForPerps(toFixedPtAmt("100"))).to.be.revertedWithCustomError(
+          balancer,
+          "InsufficientLiquidity",
+        );
+      });
+    });
+  });
+
+  describe("swapPerpsForUnderlying", function () {
+    let swapAmt: any;
+    describe("when fee = 0", function () {
+      beforeEach(async function () {
+        await mintVaultNotes(vault, toFixedPtAmt("4000"), deployer);
+        expect(await balancer.deviationRatio()).to.eq(toPerc("1"));
+        await perp.approve(balancer.target, toFixedPtAmt("100"));
+        swapAmt = await balancer.swapPerpsForUnderlying.staticCall(toFixedPtAmt("100"));
+      });
+
+      it("should transfer perps", async function () {
+        await expect(() => balancer.swapPerpsForUnderlying(toFixedPtAmt("100"))).to.changeTokenBalances(
+          perp,
+          [deployer],
+          [toFixedPtAmt("-100")],
+        );
+      });
+
+      it("should return underlying", async function () {
+        await expect(() => balancer.swapPerpsForUnderlying(toFixedPtAmt("100"))).to.changeTokenBalances(
+          collateralToken,
+          [deployer],
+          [toFixedPtAmt("100")],
+        );
+      });
+
+      it("should return the swap amount", async function () {
+        expect(swapAmt).to.eq(toFixedPtAmt("100"));
+      });
+
+      it("should have the updated composition", async function () {
+        await balancer.swapPerpsForUnderlying(toFixedPtAmt("100"));
+        await checkPerpComposition(
+          perp,
+          [collateralToken, ...perpTranches.slice(-3)],
+          [toFixedPtAmt("175"), toFixedPtAmt("175"), toFixedPtAmt("175"), toFixedPtAmt("175")],
+        );
+        await checkVaultComposition(
+          vault,
+          [collateralToken, ...perpTranches.slice(-3)],
+          [toFixedPtAmt("3925"), toFixedPtAmt("25"), toFixedPtAmt("25"), toFixedPtAmt("25")],
+        );
+      });
+
+      it("should increase the system dr", async function () {
+        await balancer.swapPerpsForUnderlying(toFixedPtAmt("100"));
+        expect(await balancer.deviationRatio()).to.eq(toPerc("1.14285713"));
+      });
+    });
+
+    describe("when fee > 0", function () {
+      beforeEach(async function () {
+        await setFees(balancer, {
+          perpBurnFeePerc: toPerc("0.05"),
+          protocolSwapSharePerc: toPerc("0.25"),
+          perpToUnderlyingSwapFeePercs: { lower: toPerc("0.1"), upper: toPerc("0.1") },
+        });
+        await mintVaultNotes(vault, toFixedPtAmt("4000"), deployer);
+        expect(await balancer.deviationRatio()).to.eq(toPerc("1"));
+        await vault.transferOwnership(await otherUser.getAddress());
+        await perp.approve(balancer.target, toFixedPtAmt("100"));
+        swapAmt = await balancer.swapPerpsForUnderlying.staticCall(toFixedPtAmt("100"));
+      });
+
+      it("should transfer perps", async function () {
+        await expect(() => balancer.swapPerpsForUnderlying(toFixedPtAmt("100"))).to.changeTokenBalances(
+          perp,
+          [deployer],
+          [toFixedPtAmt("-100")],
+        );
+      });
+
+      it("should return underlying", async function () {
+        await expect(() => balancer.swapPerpsForUnderlying(toFixedPtAmt("100"))).to.changeTokenBalances(
+          collateralToken,
+          [deployer],
+          [toFixedPtAmt("85")],
+        );
+      });
+
+      it("should return the swap amount", async function () {
+        expect(swapAmt).to.eq(toFixedPtAmt("85"));
+      });
+
+      it("should have the updated composition", async function () {
+        await balancer.swapPerpsForUnderlying(toFixedPtAmt("100"));
+        await checkPerpComposition(
+          perp,
+          [collateralToken, ...perpTranches.slice(-3)],
+          [toFixedPtAmt("176.25"), toFixedPtAmt("176.25"), toFixedPtAmt("176.25"), toFixedPtAmt("176.25")],
+        );
+        await checkVaultComposition(
+          vault,
+          [collateralToken, ...perpTranches.slice(-3)],
+          [toFixedPtAmt("3936.25"), toFixedPtAmt("23.75"), toFixedPtAmt("23.75"), toFixedPtAmt("23.75")],
+        );
+      });
+
+      it("should increase the system dr", async function () {
+        await balancer.swapPerpsForUnderlying(toFixedPtAmt("100"));
+        expect(await balancer.deviationRatio()).to.eq(toPerc("1.13687943"));
+      });
+
+      it("should burn perp fees", async function () {
+        await expect(balancer.swapPerpsForUnderlying(toFixedPtAmt("100")))
+          .to.emit(balancer, "Fee")
+          .withArgs(perp.target, perp.target, toFixedPtAmt("5"));
+      });
+
+      it("should burn perp fees", async function () {
+        await expect(balancer.swapPerpsForUnderlying(toFixedPtAmt("100")))
+          .to.emit(perp, "Transfer")
+          .withArgs(balancer.target, ethers.ZeroAddress, toFixedPtAmt("5"));
+      });
+
+      it("should settle vault fees", async function () {
+        await expect(balancer.swapPerpsForUnderlying(toFixedPtAmt("100")))
+          .to.emit(balancer, "Fee")
+          .withArgs(vault.target, collateralToken.target, toFixedPtAmt("7.5"));
+      });
+
+      it("should settle vault fees", async function () {
+        await expect(balancer.swapPerpsForUnderlying(toFixedPtAmt("100")))
+          .to.emit(collateralToken, "Transfer")
+          .withArgs(balancer.target, vault.target, toFixedPtAmt("7.5"));
+      });
+
+      it("should settle protocol fees", async function () {
+        await expect(balancer.swapPerpsForUnderlying(toFixedPtAmt("100")))
+          .to.emit(balancer, "Fee")
+          .withArgs(await otherUser.getAddress(), collateralToken.target, toFixedPtAmt("2.5"));
+      });
+
+      it("should settle protocol fees", async function () {
+        await expect(balancer.swapPerpsForUnderlying(toFixedPtAmt("100")))
+          .to.emit(collateralToken, "Transfer")
+          .withArgs(balancer.target, await otherUser.getAddress(), toFixedPtAmt("2.5"));
+      });
+    });
+
+    describe("when dr increases above upper bound", function () {
+      beforeEach(async function () {
+        await mintVaultNotes(vault, toFixedPtAmt("6000"), deployer);
+        expect(await balancer.deviationRatio()).to.eq(toPerc("1.5"));
+        await perp.approve(balancer.target, toFixedPtAmt("100"));
+      });
+
+      it("should revert", async function () {
+        await expect(balancer.swapPerpsForUnderlying(toFixedPtAmt("100"))).to.be.revertedWithCustomError(
+          balancer,
+          "DROutsideBound",
+        );
+      });
+    });
+
+    describe("when liquidity becomes too low", function () {
+      beforeEach(async function () {
+        await balancer.updateVaultMinUnderlyingPerc(toPerc("0.99"));
+        await mintVaultNotes(vault, toFixedPtAmt("4000"), deployer);
+        await perp.approve(balancer.target, toFixedPtAmt("100"));
+      });
+
+      it("should revert", async function () {
+        await expect(balancer.swapPerpsForUnderlying(toFixedPtAmt("100"))).to.be.revertedWithCustomError(
+          balancer,
+          "InsufficientLiquidity",
+        );
+      });
+    });
+  });
+});
diff --git a/spot-contracts/test/helpers.ts b/spot-contracts/test/helpers.ts
index 52b40ed6..d07c029b 100644
--- a/spot-contracts/test/helpers.ts
+++ b/spot-contracts/test/helpers.ts
@@ -1,25 +1,27 @@
-import { expect, use } from "chai";
+import { expect } from "chai";
 import hre, { ethers } from "hardhat";
-import { Signer, Contract, BigNumber, ContractFactory, Transaction, utils } from "ethers";
+import { Signer, Contract, ContractFactory, Transaction } from "ethers";
 import * as fs from "fs";
 import * as path from "path";
-import { smock, FakeContract } from "@defi-wonderland/smock";
-use(smock.matchers);
 
 const TOKEN_DECIMALS = 18;
 const PRICE_DECIMALS = 8;
 const DISCOUNT_DECIMALS = 18;
 const PERC_DECIMALS = 8;
 
-const sciParseFloat = (a: string): BigNumber => (a.includes("e") ? parseFloat(a).toFixed(18) : a);
-export const toFixedPtAmt = (a: string): BigNumber => utils.parseUnits(sciParseFloat(a), TOKEN_DECIMALS);
-export const toPriceFixedPtAmt = (a: string): BigNumber => utils.parseUnits(sciParseFloat(a), PRICE_DECIMALS);
-export const toDiscountFixedPtAmt = (a: string): BigNumber => utils.parseUnits(sciParseFloat(a), DISCOUNT_DECIMALS);
-export const toPercFixedPtAmt = (a: string): BigNumber => utils.parseUnits(sciParseFloat(a), PERC_DECIMALS);
+const sciParseFloat = (a: string): BigInt => (a.includes("e") ? parseFloat(a).toFixed(18) : a);
+export const toFixedPtAmt = (a: string): BigInt => ethers.parseUnits(sciParseFloat(a), TOKEN_DECIMALS);
+export const toPriceFixedPtAmt = (a: string): BigInt => ethers.parseUnits(sciParseFloat(a), PRICE_DECIMALS);
+export const toDiscountFixedPtAmt = (a: string): BigInt => ethers.parseUnits(sciParseFloat(a), DISCOUNT_DECIMALS);
+export const toPercFixedPtAmt = (a: string): BigInt => ethers.parseUnits(sciParseFloat(a), PERC_DECIMALS);
 
 const ORACLE_BASE_PRICE = toPriceFixedPtAmt("1");
 
 const EXTERNAL_ARTIFACTS_PATH = path.join(__dirname, "/../external-artifacts");
+export const getAbiFromExternalArtifacts = (name: string): Promise<ContractFactory> => {
+  const artifact = JSON.parse(fs.readFileSync(`${EXTERNAL_ARTIFACTS_PATH}/${name}.json`).toString());
+  return artifact.abi;
+};
 export const getContractFactoryFromExternalArtifacts = (name: string): Promise<ContractFactory> => {
   const artifact = JSON.parse(fs.readFileSync(`${EXTERNAL_ARTIFACTS_PATH}/${name}.json`).toString());
   return ethers.getContractFactoryFromArtifact(artifact);
@@ -31,26 +33,84 @@ export const TimeHelpers = {
   },
 
   increaseTime: async (seconds: number): Promise<void> => {
-    await hre.network.provider.send("evm_increaseTime", [seconds]);
-    await hre.network.provider.send("evm_mine");
+    await hre.network.provider.request({ method: "evm_increaseTime", params: [seconds] });
+    await hre.network.provider.request({ method: "evm_mine" });
   },
 
   setNextBlockTimestamp: async (timestamp: number): Promise<void> => {
-    await ethers.provider.send("evm_setNextBlockTimestamp", [timestamp]);
-    await hre.network.provider.send("evm_mine");
+    await hre.network.provider.request({ method: "evm_setNextBlockTimestamp", params: [timestamp] });
+    await hre.network.provider.request({ method: "evm_mine" });
   },
 
   currentTime: async (): Promise<number> => {
-    const res = await hre.network.provider.send("eth_getBlockByNumber", ["latest", false]);
+    const res = await hre.network.provider.request({ method: "eth_getBlockByNumber", params: ["latest", false] });
     const timestamp = parseInt(res.timestamp, 16);
     return timestamp;
   },
 };
 
+export interface DMockMethod {
+  methodName: string;
+  parameters: any[];
+  returnType: string;
+  returnValue: any;
+}
+
+export class DMock {
+  private refFactory: string;
+  private contract: Contract | null = null;
+  private target: string | null = null;
+
+  constructor(refFactory: ContractFactory) {
+    this.refFactory = refFactory;
+  }
+
+  public async deploy(): Promise<void> {
+    this.contract = await (await ethers.getContractFactory("DMock")).deploy();
+    this.target = this.contract.target;
+  }
+
+  public async mockMethod(methodFragment: string, returnValue: any = []): Promise<void> {
+    if (!this.contract) {
+      await this.deploy();
+    }
+    const methodFragmentObj = this.refFactory.interface.fragments.filter(
+      f => f.type === "function" && f.format("sighash") === methodFragment,
+    )[0];
+    if (!methodFragmentObj) {
+      throw Error(`Unkown function fragment ${methodFragment}, not part of the contract abi`);
+    }
+    const encodedReturnValue = ethers.AbiCoder.defaultAbiCoder().encode(methodFragmentObj.outputs, returnValue);
+    await this.contract.mockMethod(methodFragmentObj.selector, encodedReturnValue);
+  }
+
+  public async mockCall(methodFragment: string, parameters: any, returnValue: any = []): Promise<void> {
+    if (!this.contract) {
+      await this.deploy();
+    }
+    const methodFragmentObj = this.refFactory.interface.fragments.filter(
+      f => f.type === "function" && f.format("sighash") === methodFragment,
+    )[0];
+    if (!methodFragmentObj) {
+      throw Error(`Unkown function fragment ${methodFragment}, not part of the contract abi`);
+    }
+    const encodedData = this.refFactory.interface.encodeFunctionData(methodFragmentObj, parameters);
+    await this.contract.mockCall(
+      encodedData,
+      ethers.AbiCoder.defaultAbiCoder().encode(methodFragmentObj.outputs, returnValue),
+    );
+  }
+
+  public async staticCall(methodFragment: string, parameters: any = []): Promise<any> {
+    const mock = this.refFactory.attach(this.contract.target);
+    return mock[methodFragment].staticCall(...parameters);
+  }
+}
+
 // Rebasing collateral token (button tokens)
 interface ButtonTokenContracts {
   underlyingToken: Contract;
-  rebaseOracle: FakeContract;
+  rebaseOracle: Contract;
   collateralToken: Contract;
 }
 export const setupCollateralToken = async (name: string, symbol: string): Promise<ButtonTokenContracts> => {
@@ -58,13 +118,13 @@ export const setupCollateralToken = async (name: string, symbol: string): Promis
   const underlyingToken = await ERC20.deploy();
   await underlyingToken.init(name, symbol);
 
-  const MedianOracle = await getContractFactoryFromExternalArtifacts("MedianOracle");
-  const rebaseOracle = await smock.fake(MedianOracle);
-  await rebaseOracle.getData.returns([ORACLE_BASE_PRICE, true]);
+  const rebaseOracle = new DMock(await getContractFactoryFromExternalArtifacts("MedianOracle"));
+  await rebaseOracle.deploy();
+  await rebaseOracle.mockMethod("getData()", [ORACLE_BASE_PRICE, true]);
 
   const ButtonToken = await getContractFactoryFromExternalArtifacts("ButtonToken");
   const collateralToken = await ButtonToken.deploy();
-  await collateralToken.initialize(underlyingToken.address, `Button ${name}`, `btn-${symbol}`, rebaseOracle.address);
+  await collateralToken.initialize(underlyingToken.target, `Button ${name}`, `btn-${symbol}`, rebaseOracle.target);
 
   return {
     underlyingToken,
@@ -73,20 +133,21 @@ export const setupCollateralToken = async (name: string, symbol: string): Promis
   };
 };
 
-export const mintCollteralToken = async (collateralToken: Contract, amount: BigNumber, from: Signer) => {
+export const mintCollteralToken = async (collateralToken: Contract, amount: BigInt, from: Signer) => {
   const fromAddress = await from.getAddress();
   const ERC20 = await ethers.getContractFactory("MockERC20");
   const underlyingToken = await ERC20.attach(await collateralToken.underlying());
   const cAmount = await collateralToken.wrapperToUnderlying(amount);
   await underlyingToken.connect(from).mint(fromAddress, cAmount);
-  await underlyingToken.connect(from).approve(collateralToken.address, cAmount);
+  await underlyingToken.connect(from).approve(collateralToken.target, cAmount);
   await collateralToken.connect(from).mint(amount);
 };
 
-export const rebase = async (token: Contract, oracle: FakeContract, perc: number) => {
+export const rebase = async (token: Contract, oracle: Contract, perc: number) => {
   const p = await token.lastPrice();
-  const newPrice = p.mul(ORACLE_BASE_PRICE.add(ORACLE_BASE_PRICE.toNumber() * perc)).div(ORACLE_BASE_PRICE);
-  await oracle.getData.returns([newPrice, true]);
+  const delta = BigInt(Number(ORACLE_BASE_PRICE) * perc);
+  const newPrice = (p * (ORACLE_BASE_PRICE + delta)) / ORACLE_BASE_PRICE;
+  await oracle.mockMethod("getData()", [newPrice, true]);
   await token.rebase();
 };
 
@@ -94,20 +155,15 @@ export const rebase = async (token: Contract, oracle: FakeContract, perc: number
 export const setupBondFactory = async (): Promise<Contract> => {
   const BondController = await getContractFactoryFromExternalArtifacts("BondController");
   const bondController = await BondController.deploy();
-  await bondController.deployed();
 
   const Tranche = await getContractFactoryFromExternalArtifacts("Tranche");
   const tranche = await Tranche.deploy();
-  await tranche.deployed();
 
   const TrancheFactory = await getContractFactoryFromExternalArtifacts("TrancheFactory");
-  const trancheFactory = await TrancheFactory.deploy(tranche.address);
-  await trancheFactory.deployed();
+  const trancheFactory = await TrancheFactory.deploy(tranche.target);
 
   const BondFactory = await getContractFactoryFromExternalArtifacts("BondFactory");
-  const bondFactory = await BondFactory.deploy(bondController.address, trancheFactory.address);
-  await bondFactory.deployed();
-
+  const bondFactory = await BondFactory.deploy(bondController.target, trancheFactory.target);
   return bondFactory;
 };
 
@@ -129,31 +185,29 @@ export const createBondWithFactory = async (
 ): Promise<Contract> => {
   const timeNow = await TimeHelpers.secondsFromNow(0);
   const maturityDate = timeNow + bondLength;
-
-  const bondAddress = await bondFactory.callStatic.createBond(collateralToken.address, trancheRatios, maturityDate);
-  await bondFactory.createBond(collateralToken.address, trancheRatios, maturityDate);
-
+  const bondAddress = await bondFactory.createBond.staticCall(collateralToken.target, trancheRatios, maturityDate);
+  await bondFactory.createBond(collateralToken.target, trancheRatios, maturityDate);
   return bondAt(bondAddress);
 };
 
 // Bond interaction helpers
 export interface BondDeposit {
-  amount: BigNumber;
-  feeBps: BigNumber;
+  amount: BigInt;
+  feeBps: BigInt;
   from: string;
 }
 
-export const depositIntoBond = async (bond: Contract, amount: BigNumber, from: Signer): Promise<BondDeposit> => {
+export const depositIntoBond = async (bond: Contract, amount: BigInt, from: Signer): Promise<BondDeposit> => {
   const ButtonToken = await getContractFactoryFromExternalArtifacts("ButtonToken");
   const collateralToken = await ButtonToken.attach(await bond.collateralToken());
 
   await mintCollteralToken(collateralToken, amount, from);
 
-  await collateralToken.connect(from).approve(bond.address, amount);
+  await collateralToken.connect(from).approve(bond.target, amount);
   const tx = await bond.connect(from).deposit(amount);
   const txR = await tx.wait();
 
-  const depositEvent = txR.events[txR.events.length - 1].args;
+  const depositEvent = txR.logs[txR.logs.length - 1].args;
   return depositEvent;
 };
 
@@ -168,9 +222,9 @@ export const getTranches = async (bond: Contract): Promise<Contract[]> => {
   return tranches;
 };
 
-export const getTrancheBalances = async (bond: Contract, user: string): Promise<BigNumber[]> => {
+export const getTrancheBalances = async (bond: Contract, user: string): Promise<BigInt[]> => {
   const tranches = await getTranches(bond);
-  const balances: BigNumber[] = [];
+  const balances: BigInt[] = [];
   for (let i = 0; i < tranches.length; i++) {
     balances.push(await tranches[i].balanceOf(user));
   }
@@ -178,11 +232,11 @@ export const getTrancheBalances = async (bond: Contract, user: string): Promise<
 };
 
 export const timeToMaturity = async (bond: Contract): Promise<number> => {
-  return (await bond.maturityDate()).toNumber() - (await TimeHelpers.currentTime());
+  return Number(await bond.maturityDate()) - (await TimeHelpers.currentTime());
 };
 
 export const getDepositBond = async (perp: Contract): Contract => {
-  return bondAt(await perp.callStatic.getDepositBond());
+  return bondAt(await perp.depositBond());
 };
 
 export const advanceTime = async (time: number): Promise<Transaction> => {
@@ -197,7 +251,7 @@ export const advancePerpQueue = async (perp: Contract, time: number): Promise<Tr
 export const advancePerpQueueUpToBondMaturity = async (perp: Contract, bond: Contract): Promise<Transaction> => {
   await perp.updateState();
   const matuirtyDate = await bond.maturityDate();
-  await TimeHelpers.setNextBlockTimestamp(matuirtyDate.toNumber());
+  await TimeHelpers.setNextBlockTimestamp(Number(matuirtyDate));
 };
 
 export const advancePerpQueueToBondMaturity = async (perp: Contract, bond: Contract): Promise<Transaction> => {
@@ -210,60 +264,60 @@ export const advancePerpQueueToRollover = async (perp: Contract, bond: Contract)
   await perp.updateState();
   const bufferSec = await perp.minTrancheMaturitySec();
   const matuirtyDate = await bond.maturityDate();
-  await TimeHelpers.setNextBlockTimestamp(matuirtyDate.sub(bufferSec).toNumber());
+  await TimeHelpers.setNextBlockTimestamp(Number(matuirtyDate - bufferSec));
   await perp.updateState();
   await TimeHelpers.increaseTime(1);
   return perp.updateState();
 };
 
-export const logReserveComposition = async (perp: Contract) => {
+export const logPerpAssets = async (perp: Contract) => {
   const ERC20 = await ethers.getContractFactory("MockERC20");
-  const count = await perp.callStatic.getReserveCount();
-  console.log("Reserve count", count);
+  const count = await perp.reserveCount();
+  console.log("Perp assets", count);
   for (let i = 0; i < count; i++) {
-    const token = await ERC20.attach(await perp.callStatic.getReserveAt(i));
-    const ONE = BigNumber.from(`${10 ** (await perp.decimals())}`);
-    const tokenVal = await perp.callStatic.getReserveTokenValue(token.address);
-    const tokenBal = await perp.callStatic.getReserveTokenBalance(token.address);
-    const tokenPrice = tokenBal.gt("0") ? tokenVal.mul(ONE).div(tokenBal) : BigNumber.from(0);
+    const token = await ERC20.attach(await perp.reserveAt(i));
+    const ONE = ethers.parseUnits("1", await perp.decimals());
+    const tokenVal = await perp.reserveTokenValue(token.target);
+    const tokenBal = await perp.reserveTokenBalance(token.target);
+    const tokenPrice = tokenBal > 0n ? (tokenVal * ONE) / tokenBal : 0n;
     console.log(
       i,
-      token.address,
-      utils.formatUnits(await token.balanceOf(perp.address), await perp.decimals()),
-      utils.formatUnits(tokenPrice, await perp.decimals()),
+      token.target,
+      ethers.formatUnits(await token.balanceOf(perp.target), await perp.decimals()),
+      ethers.formatUnits(tokenPrice, await perp.decimals()),
     );
   }
 };
 
-export const checkReserveComposition = async (perp: Contract, tokens: Contract[], balances: BigNumber[] = []) => {
+export const checkPerpComposition = async (perp: Contract, tokens: Contract[], balances: BigInt[] = []) => {
   const checkBalances = balances.length > 0;
-  expect(await perp.callStatic.getReserveCount()).to.eq(tokens.length);
+  expect(await perp.reserveCount()).to.eq(tokens.length);
 
   const tokenMap = {};
   const tokenBalanceMap = {};
   for (const i in tokens) {
-    tokenMap[tokens[i].address] = true;
+    tokenMap[tokens[i].target] = true;
     if (checkBalances) {
-      tokenBalanceMap[tokens[i].address] = balances[i];
+      tokenBalanceMap[tokens[i].target] = balances[i];
     }
   }
 
   const ERC20 = await ethers.getContractFactory("MockERC20");
   for (let j = 0; j < tokens.length; j++) {
-    const reserveToken = ERC20.attach(await perp.callStatic.getReserveAt(j));
-    expect(tokenMap[reserveToken.address]).to.eq(true);
+    const reserveToken = ERC20.attach(await perp.reserveAt(j));
+    expect(tokenMap[reserveToken.target]).to.eq(true);
     if (checkBalances) {
-      expect(await reserveToken.balanceOf(perp.address)).to.eq(tokenBalanceMap[reserveToken.address]);
+      expect(await reserveToken.balanceOf(perp.target)).to.eq(tokenBalanceMap[reserveToken.target]);
     }
   }
-  await expect(perp.callStatic.getReserveAt(tokens.length)).to.be.reverted;
+  await expect(perp.reserveAt(tokens.length)).to.be.reverted;
 };
 
 export const getReserveTokens = async (perp: Contract) => {
   const ERC20 = await ethers.getContractFactory("MockERC20");
   const reserves: Contract[] = [];
-  for (let i = 0; i < (await perp.callStatic.getReserveCount()); i++) {
-    reserves.push(await ERC20.attach(await perp.callStatic.getReserveAt(i)));
+  for (let i = 0; i < (await perp.reserveCount()); i++) {
+    reserves.push(await ERC20.attach(await perp.reserveAt(i)));
   }
   return reserves;
 };
@@ -272,28 +326,28 @@ export const logVaultAssets = async (vault: Contract) => {
   const ERC20 = await ethers.getContractFactory("MockERC20");
   const count = await vault.assetCount();
   const assetCount = await vault.assetCount();
-  console.log("Asset count", count);
+  console.log("Vault assets", count);
 
   const underlying = await ERC20.attach(await vault.underlying());
   console.log(
     0,
-    underlying.address,
-    utils.formatUnits(await vault.vaultAssetBalance(underlying.address), await underlying.decimals()),
+    underlying.target,
+    ethers.formatUnits(await vault.vaultAssetBalance(underlying.target), await underlying.decimals()),
   );
   for (let i = 1; i < assetCount; i++) {
     const token = await ERC20.attach(await vault.assetAt(i));
     console.log(
       i + 1,
-      token.address,
-      utils.formatUnits(await vault.vaultAssetBalance(token.address), await token.decimals()),
+      token.target,
+      ethers.formatUnits(await vault.vaultAssetBalance(token.target), await token.decimals()),
     );
   }
 };
 
-export const checkVaultAssetComposition = async (vault: Contract, tokens: Contract[], balances: BigNumber[] = []) => {
+export const checkVaultComposition = async (vault: Contract, tokens: Contract[], balances: BigInt[] = []) => {
   expect(await vault.assetCount()).to.eq(tokens.length);
   for (const i in tokens) {
-    expect(await vault.vaultAssetBalance(tokens[i].address)).to.eq(balances[i]);
+    expect(await vault.vaultAssetBalance(tokens[i].target)).to.eq(balances[i]);
   }
 };
 
@@ -305,3 +359,46 @@ export const getVaultAssets = async (vault: Contract) => {
   }
   return assets;
 };
+
+// NOTE: Only protocol callers can mint/redeem and swap by interacting with the perp and vault,
+// for testing we update the reference of the whitelisted caller, perform the operation and change it back.
+export const mintPerps = async (
+  perp: Contract,
+  tranche: Contract,
+  amount: BigInt,
+  from: Signer,
+): Promise<Transaction> => {
+  const _vault = await perp.vault();
+  await perp.updateVault(await from.getAddress());
+  await tranche.connect(from).approve(perp.target, amount);
+  const tx = await perp.connect(from).deposit(tranche.target, amount);
+  await perp.updateVault(_vault);
+  return tx;
+};
+
+export const redeemPerps = async (perp: Contract, amount: BigInt, from: Signer): Promise<Transaction> => {
+  const _vault = await perp.vault();
+  await perp.updateVault(await from.getAddress());
+  const tx = await perp.connect(from).redeem(amount);
+  await perp.updateVault(_vault);
+  return tx;
+};
+
+export const mintVaultNotes = async (vault: Contract, amount: Contract, from: Signer) => {
+  const ERC20 = await ethers.getContractFactory("MockERC20");
+  const collateralToken = ERC20.attach(await vault.underlying());
+  const _balancer = await vault.balancer();
+  await vault.updateBalancer(await from.getAddress());
+  await collateralToken.connect(from).approve(vault.target, amount);
+  const tx = await vault.connect(from)["deposit(uint256)"](amount);
+  await vault.updateBalancer(_balancer);
+  return tx;
+};
+
+export const redeemVaultNotes = async (vault: Contract, amount: Contract, from: Signer) => {
+  const _balancer = await vault.balancer();
+  await vault.updateBalancer(await from.getAddress());
+  const tx = await vault.connect(from).redeem(amount);
+  await vault.updateBalancer(_balancer);
+  return tx;
+};
diff --git a/spot-contracts/test/perp/PerpetualTranche.ts b/spot-contracts/test/perp/PerpetualTranche.ts
index d64f7e9c..69ac35b4 100644
--- a/spot-contracts/test/perp/PerpetualTranche.ts
+++ b/spot-contracts/test/perp/PerpetualTranche.ts
@@ -1,7 +1,6 @@
-import { expect, use } from "chai";
+import { expect } from "chai";
 import { network, ethers, upgrades } from "hardhat";
-import { Contract, Transaction, Signer, constants } from "ethers";
-import { smock } from "@defi-wonderland/smock";
+import { Contract, Transaction, Signer } from "ethers";
 import {
   setupCollateralToken,
   setupBondFactory,
@@ -11,23 +10,24 @@ import {
   toFixedPtAmt,
   advancePerpQueue,
   bondAt,
-  checkReserveComposition,
+  checkPerpComposition,
   TimeHelpers,
   rebase,
   advancePerpQueueToRollover,
+  mintPerps,
+  DMock,
 } from "../helpers";
-use(smock.matchers);
 
 let perp: Contract,
   collateralToken: Contract,
   rebaseOracle: Contract,
   issuer: Contract,
-  feePolicy: Contract,
+  balancer: Contract,
   deployer: Signer,
   otherUser: Signer;
 describe("PerpetualTranche", function () {
   beforeEach(async function () {
-    await network.provider.send("hardhat_reset");
+    await network.provider.request({ method: "hardhat_reset" });
 
     const accounts = await ethers.getSigners();
     deployer = accounts[0];
@@ -35,31 +35,30 @@ describe("PerpetualTranche", function () {
 
     ({ collateralToken, rebaseOracle } = await setupCollateralToken("Bitcoin", "BTC"));
 
-    const BondIssuer = await ethers.getContractFactory("BondIssuer");
-    issuer = await smock.fake(BondIssuer);
-    await issuer.collateral.returns(collateralToken.address);
-
-    const FeePolicy = await ethers.getContractFactory("FeePolicy");
-    feePolicy = await smock.fake(FeePolicy);
-    await feePolicy.decimals.returns(8);
+    issuer = new DMock(await ethers.getContractFactory("BondIssuer"));
+    await issuer.deploy();
+    await issuer.mockMethod("collateral()", [collateralToken.target]);
+    await issuer.mockMethod("getLatestBond()", [ethers.ZeroAddress]);
 
     const PerpetualTranche = await ethers.getContractFactory("PerpetualTranche");
     perp = await upgrades.deployProxy(
       PerpetualTranche.connect(deployer),
-      ["PerpetualTranche", "PERP", collateralToken.address, issuer.address, feePolicy.address],
+      ["PerpetualTranche", "PERP", collateralToken.target, issuer.target],
       {
-        initializer: "init(string,string,address,address,address)",
+        initializer: "init(string,string,address,address)",
       },
     );
 
-    const RolloverVault = await ethers.getContractFactory("RolloverVault");
-    const vault = await smock.fake(RolloverVault);
-    await vault.getTVL.returns("0");
-    await perp.updateVault(vault.address);
+    balancer = new DMock(await ethers.getContractFactory("Balancer"));
+    await balancer.deploy();
+    await balancer.mockMethod("decimals()", [8]);
+
+    await perp.updateBalancer(balancer.target);
+    await perp.updateVault(await deployer.getAddress());
   });
 
   afterEach(async function () {
-    await network.provider.send("hardhat_reset");
+    await network.provider.request({ method: "hardhat_reset" });
   });
 
   describe("#init", function () {
@@ -74,23 +73,22 @@ describe("PerpetualTranche", function () {
     });
 
     it("should set ext service references", async function () {
-      expect(await perp.bondIssuer()).to.eq(issuer.address);
-      expect(await perp.feePolicy()).to.eq(feePolicy.address);
+      expect(await perp.bondIssuer()).to.eq(issuer.target);
+      expect(await perp.balancer()).to.eq(balancer.target);
     });
 
     it("should set underlying collateral reference", async function () {
-      expect(await perp.underlying()).to.eq(collateralToken.address);
+      expect(await perp.underlying()).to.eq(collateralToken.target);
     });
 
     it("should initialize lists", async function () {
-      expect(await perp.callStatic.getReserveCount()).to.eq(1);
+      expect(await perp.reserveCount()).to.eq(1);
     });
 
     it("should set hyper parameters", async function () {
       expect(await perp.minTrancheMaturitySec()).to.eq(1);
-      expect(await perp.maxTrancheMaturitySec()).to.eq(constants.MaxUint256);
-      expect(await perp.maxSupply()).to.eq(constants.MaxUint256);
-      expect(await perp.maxMintAmtPerTranche()).to.eq(constants.MaxUint256);
+      expect(await perp.maxTrancheMaturitySec()).to.eq(ethers.MaxUint256);
+      expect(await perp.maxMintAmtPerTranche()).to.eq(ethers.MaxUint256);
     });
 
     it("should NOT be paused", async function () {
@@ -180,7 +178,7 @@ describe("PerpetualTranche", function () {
 
     describe("when triggered by non-owner", function () {
       it("should revert", async function () {
-        await expect(perp.connect(otherUser).updateKeeper(constants.AddressZero)).to.be.revertedWith(
+        await expect(perp.connect(otherUser).updateKeeper(ethers.ZeroAddress)).to.be.revertedWith(
           "Ownable: caller is not the owner",
         );
       });
@@ -200,7 +198,7 @@ describe("PerpetualTranche", function () {
   describe("#updateVault", function () {
     describe("when triggered by non-owner", function () {
       it("should revert", async function () {
-        await expect(perp.connect(otherUser).updateVault(constants.AddressZero)).to.be.revertedWith(
+        await expect(perp.connect(otherUser).updateVault(ethers.ZeroAddress)).to.be.revertedWith(
           "Ownable: caller is not the owner",
         );
       });
@@ -209,15 +207,13 @@ describe("PerpetualTranche", function () {
     describe("when vault reference is set", function () {
       let tx: Transaction, vault: Contract;
       beforeEach(async function () {
-        const RolloverVault = await ethers.getContractFactory("RolloverVault");
-        vault = await smock.fake(RolloverVault);
-        await vault.getTVL.returns(0);
-
-        tx = perp.connect(deployer).updateVault(vault.address);
+        vault = new DMock(await ethers.getContractFactory("RolloverVault"));
+        await vault.deploy();
+        tx = perp.connect(deployer).updateVault(vault.target);
         await tx;
       });
       it("should update vault reference", async function () {
-        expect(await perp.vault()).to.eq(vault.address);
+        expect(await perp.vault()).to.eq(vault.target);
       });
     });
   });
@@ -227,7 +223,7 @@ describe("PerpetualTranche", function () {
 
     describe("when triggered by non-owner", function () {
       it("should revert", async function () {
-        await expect(perp.connect(otherUser).updateBondIssuer(constants.AddressZero)).to.be.revertedWith(
+        await expect(perp.connect(otherUser).updateBondIssuer(ethers.ZeroAddress)).to.be.revertedWith(
           "Ownable: caller is not the owner",
         );
       });
@@ -235,62 +231,61 @@ describe("PerpetualTranche", function () {
 
     describe("when set address is valid", function () {
       beforeEach(async function () {
-        const BondIssuer = await ethers.getContractFactory("BondIssuer");
-        newIssuer = await smock.fake(BondIssuer);
-        await newIssuer.collateral.returns(collateralToken.address);
-        tx = perp.updateBondIssuer(newIssuer.address);
+        newIssuer = new DMock(await ethers.getContractFactory("BondIssuer"));
+        await newIssuer.deploy();
+        await newIssuer.mockMethod("collateral()", [collateralToken.target]);
+        await newIssuer.mockMethod("getLatestBond()", [ethers.ZeroAddress]);
+        tx = perp.updateBondIssuer(newIssuer.target);
         await tx;
       });
       it("should update reference", async function () {
-        expect(await perp.bondIssuer()).to.eq(newIssuer.address);
+        expect(await perp.bondIssuer()).to.eq(newIssuer.target);
       });
     });
 
     describe("when collateral is NOT valid", function () {
       beforeEach(async function () {
-        const BondIssuer = await ethers.getContractFactory("BondIssuer");
-        newIssuer = await smock.fake(BondIssuer);
-        await newIssuer.collateral.returns(constants.AddressZero);
+        newIssuer = new DMock(await ethers.getContractFactory("BondIssuer"));
+        await newIssuer.deploy();
+        await newIssuer.mockMethod("collateral()", [ethers.ZeroAddress]);
+        await newIssuer.mockMethod("getLatestBond()", [ethers.ZeroAddress]);
       });
       it("should revert", async function () {
-        await expect(perp.updateBondIssuer(newIssuer.address)).to.be.revertedWithCustomError(perp, "UnexpectedAsset");
+        await expect(perp.updateBondIssuer(newIssuer.target)).to.be.revertedWithCustomError(perp, "UnexpectedAsset");
       });
     });
   });
 
-  describe("#updateFeePolicy", function () {
-    let newFeePolicy: Contract, tx: Transaction;
+  describe("#updateBalancer", function () {
+    let newBalancer: Contract, tx: Transaction;
 
     describe("when triggered by non-owner", function () {
       it("should revert", async function () {
-        await expect(perp.connect(otherUser).updateFeePolicy(constants.AddressZero)).to.be.revertedWith(
+        await expect(perp.connect(otherUser).updateBalancer(ethers.ZeroAddress)).to.be.revertedWith(
           "Ownable: caller is not the owner",
         );
       });
     });
 
-    describe("when set strategy decimals dont match", function () {
+    describe("when balancer decimals dont match", function () {
       it("should revert", async function () {
-        const FeePolicy = await ethers.getContractFactory("FeePolicy");
-        newFeePolicy = await smock.fake(FeePolicy);
-        await newFeePolicy.decimals.returns(7);
-        await expect(perp.updateFeePolicy(newFeePolicy.address)).to.be.revertedWithCustomError(
-          perp,
-          "UnexpectedDecimals",
-        );
+        newBalancer = new DMock(await ethers.getContractFactory("Balancer"));
+        await newBalancer.deploy();
+        await newBalancer.mockMethod("decimals()", [7]);
+        await expect(perp.updateBalancer(newBalancer.target)).to.be.revertedWithCustomError(perp, "UnexpectedDecimals");
       });
     });
 
     describe("when set address is valid", function () {
       beforeEach(async function () {
-        const FeePolicy = await ethers.getContractFactory("FeePolicy");
-        newFeePolicy = await smock.fake(FeePolicy);
-        await newFeePolicy.decimals.returns(8);
-        tx = perp.updateFeePolicy(newFeePolicy.address);
+        newBalancer = new DMock(await ethers.getContractFactory("Balancer"));
+        await newBalancer.deploy();
+        await newBalancer.mockMethod("decimals()", [8]);
+        tx = perp.updateBalancer(newBalancer.target);
         await tx;
       });
       it("should update reference", async function () {
-        expect(await perp.feePolicy()).to.eq(newFeePolicy.address);
+        expect(await perp.balancer()).to.eq(newBalancer.target);
       });
     });
   });
@@ -327,24 +322,23 @@ describe("PerpetualTranche", function () {
     });
   });
 
-  describe("#updateMintingLimits", function () {
+  describe("#updatePerTrancheMintCap", function () {
     let tx: Transaction;
 
     describe("when triggered by non-owner", function () {
       it("should revert", async function () {
-        await expect(
-          perp.connect(otherUser).updateMintingLimits(constants.MaxUint256, constants.MaxUint256),
-        ).to.be.revertedWith("Ownable: caller is not the owner");
+        await expect(perp.connect(otherUser).updatePerTrancheMintCap(ethers.MaxUint256)).to.be.revertedWith(
+          "Ownable: caller is not the owner",
+        );
       });
     });
 
     describe("when triggered by owner", function () {
       beforeEach(async function () {
-        tx = perp.updateMintingLimits(toFixedPtAmt("100"), toFixedPtAmt("20"));
+        tx = perp.updatePerTrancheMintCap(toFixedPtAmt("20"));
         await tx;
       });
       it("should update reference", async function () {
-        expect(await perp.maxSupply()).to.eq(toFixedPtAmt("100"));
         expect(await perp.maxMintAmtPerTranche()).to.eq(toFixedPtAmt("20"));
       });
     });
@@ -357,13 +351,13 @@ describe("PerpetualTranche", function () {
       const Token = await ethers.getContractFactory("MockERC20");
       transferToken = await Token.deploy();
       await transferToken.init("Mock Token", "MOCK");
-      await transferToken.mint(perp.address, "100");
+      await transferToken.mint(perp.target, "100");
       toAddress = await deployer.getAddress();
     });
 
     describe("when triggered by non-owner", function () {
       it("should revert", async function () {
-        await expect(perp.connect(otherUser).transferERC20(transferToken.address, toAddress, "100")).to.be.revertedWith(
+        await expect(perp.connect(otherUser).transferERC20(transferToken.target, toAddress, "100")).to.be.revertedWith(
           "Ownable: caller is not the owner",
         );
       });
@@ -371,7 +365,7 @@ describe("PerpetualTranche", function () {
 
     describe("when non reserve asset", function () {
       it("should transfer", async function () {
-        await expect(() => perp.transferERC20(transferToken.address, toAddress, "100")).to.changeTokenBalance(
+        await expect(() => perp.transferERC20(transferToken.target, toAddress, "100")).to.changeTokenBalance(
           transferToken,
           deployer,
           "100",
@@ -381,9 +375,9 @@ describe("PerpetualTranche", function () {
 
     describe("when reserve asset", function () {
       it("should revert", async function () {
-        expect(await perp.callStatic.inReserve(collateralToken.address)).to.eq(true);
+        expect(await perp.inReserve(collateralToken.target)).to.eq(true);
         await expect(
-          perp.transferERC20(collateralToken.address, toAddress, toFixedPtAmt("100")),
+          perp.transferERC20(collateralToken.target, toAddress, toFixedPtAmt("100")),
         ).to.be.revertedWithCustomError(perp, "UnauthorizedTransferOut");
       });
     });
@@ -393,12 +387,11 @@ describe("PerpetualTranche", function () {
         const bondFactory = await setupBondFactory();
         const bond = await createBondWithFactory(bondFactory, collateralToken, [200, 800], 3600);
         const tranches = await getTranches(bond);
-        await issuer.getLatestBond.returns(bond.address);
+        await issuer.mockMethod("getLatestBond()", [bond.target]);
         await depositIntoBond(bond, toFixedPtAmt("1000"), deployer);
-        await tranches[0].approve(perp.address, toFixedPtAmt("100"));
-        await perp.deposit(tranches[0].address, toFixedPtAmt("100"));
-        await perp.transfer(perp.address, toFixedPtAmt("100"));
-        await expect(perp.transferERC20(perp.address, toAddress, toFixedPtAmt("100"))).not.to.be.reverted;
+        await mintPerps(perp, tranches[0], toFixedPtAmt("100"), deployer);
+        await perp.transfer(perp.target, toFixedPtAmt("100"));
+        await expect(perp.transferERC20(perp.target, toAddress, toFixedPtAmt("100"))).not.to.be.reverted;
       });
     });
   });
@@ -411,10 +404,10 @@ describe("PerpetualTranche", function () {
 
     describe("when reserve has no tranches", function () {
       it("should have expected reserve composition", async function () {
-        await checkReserveComposition(perp, [collateralToken], ["0"]);
+        await checkPerpComposition(perp, [collateralToken], ["0"]);
       });
       it("should calculate the tvl", async function () {
-        expect(await perp.callStatic.getTVL()).to.eq(0);
+        expect(await perp.getTVL()).to.eq(0);
       });
     });
 
@@ -422,18 +415,17 @@ describe("PerpetualTranche", function () {
       beforeEach(async function () {
         bond = await createBondWithFactory(bondFactory, collateralToken, [200, 800], 3600);
         tranches = await getTranches(bond);
-        await issuer.getLatestBond.returns(bond.address);
+        await issuer.mockMethod("getLatestBond()", [bond.target]);
 
         await depositIntoBond(bond, toFixedPtAmt("1000"), deployer);
-        await tranches[0].approve(perp.address, toFixedPtAmt("200"));
-        await perp.deposit(tranches[0].address, toFixedPtAmt("200"));
+        await mintPerps(perp, tranches[0], toFixedPtAmt("200"), deployer);
       });
 
       it("should have expected reserve composition", async function () {
-        await checkReserveComposition(perp, [collateralToken, tranches[0]], ["0", toFixedPtAmt("200")]);
+        await checkPerpComposition(perp, [collateralToken, tranches[0]], ["0", toFixedPtAmt("200")]);
       });
       it("should calculate the tvl", async function () {
-        expect(await perp.callStatic.getTVL()).to.eq(toFixedPtAmt("200"));
+        expect(await perp.getTVL()).to.eq(toFixedPtAmt("200"));
       });
     });
 
@@ -441,32 +433,30 @@ describe("PerpetualTranche", function () {
       beforeEach(async function () {
         bond = await createBondWithFactory(bondFactory, collateralToken, [200, 800], 3600);
         tranches = await getTranches(bond);
-        await issuer.getLatestBond.returns(bond.address);
+        await issuer.mockMethod("getLatestBond()", [bond.target]);
 
         await depositIntoBond(bond, toFixedPtAmt("1000"), deployer);
-        await tranches[0].approve(perp.address, toFixedPtAmt("200"));
-        await perp.deposit(tranches[0].address, toFixedPtAmt("200"));
+        await mintPerps(perp, tranches[0], toFixedPtAmt("200"), deployer);
 
         await rebase(collateralToken, rebaseOracle, -0.9);
 
         bondNext = await createBondWithFactory(bondFactory, collateralToken, [200, 800], 3600);
         tranchesNext = await getTranches(bondNext);
-        await issuer.getLatestBond.returns(bondNext.address);
+        await issuer.mockMethod("getLatestBond()", [bondNext.target]);
 
         await depositIntoBond(bondNext, toFixedPtAmt("1000"), deployer);
-        await tranchesNext[0].approve(perp.address, toFixedPtAmt("100"));
-        await perp.deposit(tranchesNext[0].address, toFixedPtAmt("100"));
+        await mintPerps(perp, tranchesNext[0], toFixedPtAmt("100"), deployer);
       });
 
       it("should have expected reserve composition", async function () {
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, tranches[0], tranchesNext[0]],
           ["0", toFixedPtAmt("200"), toFixedPtAmt("100")],
         );
       });
       it("should calculate the tvl", async function () {
-        expect(await perp.callStatic.getTVL()).to.eq(toFixedPtAmt("200"));
+        expect(await perp.getTVL()).to.eq(toFixedPtAmt("200"));
       });
     });
 
@@ -476,37 +466,35 @@ describe("PerpetualTranche", function () {
         const BondIssuer = await ethers.getContractFactory("BondIssuer");
         issuer = await upgrades.deployProxy(
           BondIssuer.connect(deployer),
-          [bondFactory.address, collateralToken.address, 3600, [200, 800], 1200, 0],
+          [bondFactory.target, collateralToken.target, 3600, [200, 800], 1200, 0],
           {
             initializer: "init(address,address,uint256,uint256[],uint256,uint256)",
           },
         );
-        await perp.updateBondIssuer(issuer.address);
+        await perp.updateBondIssuer(issuer.target);
 
         await advancePerpQueue(perp, 1200);
-        bond = await bondAt(await perp.callStatic.getDepositBond());
+        bond = await bondAt(await perp.depositBond());
         tranches = await getTranches(bond);
 
         await depositIntoBond(bond, toFixedPtAmt("1000"), deployer);
-        await tranches[0].approve(perp.address, toFixedPtAmt("200"));
-        await perp.deposit(tranches[0].address, toFixedPtAmt("200"));
+        await mintPerps(perp, tranches[0], toFixedPtAmt("200"), deployer);
 
         await advancePerpQueue(perp, 1200);
-        bondNext = await bondAt(await perp.callStatic.getDepositBond());
+        bondNext = await bondAt(await perp.depositBond());
         tranchesNext = await getTranches(bondNext);
 
         await depositIntoBond(bondNext, toFixedPtAmt("1000"), deployer);
-        await tranchesNext[0].approve(perp.address, toFixedPtAmt("100"));
-        await perp.deposit(tranchesNext[0].address, toFixedPtAmt("100"));
+        await mintPerps(perp, tranchesNext[0], toFixedPtAmt("100"), deployer);
 
         await advancePerpQueue(perp, 36000);
       });
 
       it("should have expected reserve composition", async function () {
-        await checkReserveComposition(perp, [collateralToken], [toFixedPtAmt("300")]);
+        await checkPerpComposition(perp, [collateralToken], [toFixedPtAmt("300")]);
       });
       it("should calculate the tvl", async function () {
-        expect(await perp.callStatic.getTVL()).to.eq(toFixedPtAmt("300"));
+        expect(await perp.getTVL()).to.eq(toFixedPtAmt("300"));
       });
     });
 
@@ -516,41 +504,39 @@ describe("PerpetualTranche", function () {
         const BondIssuer = await ethers.getContractFactory("BondIssuer");
         issuer = await upgrades.deployProxy(
           BondIssuer.connect(deployer),
-          [bondFactory.address, collateralToken.address, 3600, [200, 800], 1200, 0],
+          [bondFactory.target, collateralToken.target, 3600, [200, 800], 1200, 0],
           {
             initializer: "init(address,address,uint256,uint256[],uint256,uint256)",
           },
         );
-        await perp.updateBondIssuer(issuer.address);
+        await perp.updateBondIssuer(issuer.target);
 
         await advancePerpQueue(perp, 3600);
-        bond = await bondAt(await perp.callStatic.getDepositBond());
+        bond = await bondAt(await perp.depositBond());
         tranches = await getTranches(bond);
 
         await depositIntoBond(bond, toFixedPtAmt("1000"), deployer);
-        await tranches[0].approve(perp.address, toFixedPtAmt("200"));
-        await perp.deposit(tranches[0].address, toFixedPtAmt("200"));
+        await mintPerps(perp, tranches[0], toFixedPtAmt("200"), deployer);
 
         await advancePerpQueue(perp, 1200);
-        bondNext = await bondAt(await perp.callStatic.getDepositBond());
+        bondNext = await bondAt(await perp.depositBond());
         tranchesNext = await getTranches(bondNext);
 
         await depositIntoBond(bondNext, toFixedPtAmt("1000"), deployer);
-        await tranchesNext[0].approve(perp.address, toFixedPtAmt("100"));
-        await perp.deposit(tranchesNext[0].address, toFixedPtAmt("100"));
+        await mintPerps(perp, tranchesNext[0], toFixedPtAmt("100"), deployer);
 
         await advancePerpQueue(perp, 2400);
       });
 
       it("should have expected reserve composition", async function () {
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, tranchesNext[0]],
           [toFixedPtAmt("200"), toFixedPtAmt("100")],
         );
       });
       it("should calculate the tvl", async function () {
-        expect(await perp.callStatic.getTVL()).to.eq(toFixedPtAmt("300"));
+        expect(await perp.getTVL()).to.eq(toFixedPtAmt("300"));
       });
     });
 
@@ -560,27 +546,25 @@ describe("PerpetualTranche", function () {
         const BondIssuer = await ethers.getContractFactory("BondIssuer");
         issuer = await upgrades.deployProxy(
           BondIssuer.connect(deployer),
-          [bondFactory.address, collateralToken.address, 3600, [200, 800], 1200, 0],
+          [bondFactory.target, collateralToken.target, 3600, [200, 800], 1200, 0],
           {
             initializer: "init(address,address,uint256,uint256[],uint256,uint256)",
           },
         );
-        await perp.updateBondIssuer(issuer.address);
+        await perp.updateBondIssuer(issuer.target);
         await advancePerpQueue(perp, 3600);
-        bond = await bondAt(await perp.callStatic.getDepositBond());
+        bond = await bondAt(await perp.depositBond());
         tranches = await getTranches(bond);
 
         await depositIntoBond(bond, toFixedPtAmt("1000"), deployer);
-        await tranches[0].approve(perp.address, toFixedPtAmt("200"));
-        await perp.deposit(tranches[0].address, toFixedPtAmt("200"));
+        await mintPerps(perp, tranches[0], toFixedPtAmt("200"), deployer);
 
         await advancePerpQueue(perp, 1200);
-        bondNext = await bondAt(await perp.callStatic.getDepositBond());
+        bondNext = await bondAt(await perp.depositBond());
         tranchesNext = await getTranches(bondNext);
 
         await depositIntoBond(bondNext, toFixedPtAmt("1000"), deployer);
-        await tranchesNext[0].approve(perp.address, toFixedPtAmt("100"));
-        await perp.deposit(tranchesNext[0].address, toFixedPtAmt("100"));
+        await mintPerps(perp, tranchesNext[0], toFixedPtAmt("100"), deployer);
 
         await advancePerpQueue(perp, 2400);
 
@@ -588,14 +572,14 @@ describe("PerpetualTranche", function () {
       });
 
       it("should have expected reserve composition", async function () {
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, tranchesNext[0]],
           [toFixedPtAmt("220"), toFixedPtAmt("100")],
         );
       });
       it("should calculate the tvl", async function () {
-        expect(await perp.callStatic.getTVL()).to.eq(toFixedPtAmt("320"));
+        expect(await perp.getTVL()).to.eq(toFixedPtAmt("320"));
       });
     });
 
@@ -605,28 +589,26 @@ describe("PerpetualTranche", function () {
         const BondIssuer = await ethers.getContractFactory("BondIssuer");
         issuer = await upgrades.deployProxy(
           BondIssuer.connect(deployer),
-          [bondFactory.address, collateralToken.address, 3600, [200, 800], 1200, 0],
+          [bondFactory.target, collateralToken.target, 3600, [200, 800], 1200, 0],
           {
             initializer: "init(address,address,uint256,uint256[],uint256,uint256)",
           },
         );
-        await perp.updateBondIssuer(issuer.address);
+        await perp.updateBondIssuer(issuer.target);
 
         await advancePerpQueue(perp, 3600);
-        bond = await bondAt(await perp.callStatic.getDepositBond());
+        bond = await bondAt(await perp.depositBond());
         tranches = await getTranches(bond);
 
         await depositIntoBond(bond, toFixedPtAmt("1000"), deployer);
-        await tranches[0].approve(perp.address, toFixedPtAmt("200"));
-        await perp.deposit(tranches[0].address, toFixedPtAmt("200"));
+        await mintPerps(perp, tranches[0], toFixedPtAmt("200"), deployer);
 
         await advancePerpQueue(perp, 1200);
-        bondNext = await bondAt(await perp.callStatic.getDepositBond());
+        bondNext = await bondAt(await perp.depositBond());
         tranchesNext = await getTranches(bondNext);
 
         await depositIntoBond(bondNext, toFixedPtAmt("1000"), deployer);
-        await tranchesNext[0].approve(perp.address, toFixedPtAmt("100"));
-        await perp.deposit(tranchesNext[0].address, toFixedPtAmt("100"));
+        await mintPerps(perp, tranchesNext[0], toFixedPtAmt("100"), deployer);
 
         await advancePerpQueue(perp, 2400);
 
@@ -634,14 +616,14 @@ describe("PerpetualTranche", function () {
       });
 
       it("should have expected reserve composition", async function () {
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, tranchesNext[0]],
           [toFixedPtAmt("180"), toFixedPtAmt("100")],
         );
       });
       it("should calculate the tvl", async function () {
-        expect(await perp.callStatic.getTVL()).to.eq(toFixedPtAmt("280"));
+        expect(await perp.getTVL()).to.eq(toFixedPtAmt("280"));
       });
     });
   });
@@ -659,12 +641,12 @@ describe("PerpetualTranche", function () {
         beforeEach(async function () {
           await perp.updateTolerableTrancheMaturity(1200, 7200);
           bond = await createBondWithFactory(bondFactory, collateralToken, [200, 800], 7210);
-          await issuer.getLatestBond.returns(bond.address);
+          await issuer.mockMethod("getLatestBond()", [bond.target]);
           await perp.updateState();
         });
 
         it("should NOT update the deposit bond", async function () {
-          expect(await perp.callStatic.getDepositBond()).to.not.eq(bond.address);
+          expect(await perp.depositBond()).to.not.eq(bond.target);
         });
       });
 
@@ -673,12 +655,12 @@ describe("PerpetualTranche", function () {
           await perp.updateTolerableTrancheMaturity(1200, 7200);
           const r = await setupCollateralToken("Ethereum", "ETH");
           bond = await createBondWithFactory(bondFactory, r.collateralToken, [200, 800], 3600);
-          await issuer.getLatestBond.returns(bond.address);
+          await issuer.mockMethod("getLatestBond()", [bond.target]);
           await perp.updateState();
         });
 
         it("should NOT update the deposit bond", async function () {
-          expect(await perp.callStatic.getDepositBond()).to.not.eq(bond.address);
+          expect(await perp.depositBond()).to.not.eq(bond.target);
         });
       });
 
@@ -687,17 +669,17 @@ describe("PerpetualTranche", function () {
         beforeEach(async function () {
           await perp.updateTolerableTrancheMaturity(1200, 7200);
           bond = await createBondWithFactory(bondFactory, collateralToken, [200, 800], 3600);
-          await issuer.getLatestBond.returns(bond.address);
+          await issuer.mockMethod("getLatestBond()", [bond.target]);
           tx = perp.updateState();
           await tx;
         });
 
         it("should update the deposit bond", async function () {
-          expect(await perp.callStatic.getDepositBond()).to.eq(bond.address);
+          expect(await perp.depositBond()).to.eq(bond.target);
         });
 
         it("should emit event", async function () {
-          await expect(tx).to.emit(perp, "UpdatedDepositBond").withArgs(bond.address);
+          await expect(tx).to.emit(perp, "UpdatedDepositBond").withArgs(bond.target);
         });
       });
     });
@@ -709,26 +691,25 @@ describe("PerpetualTranche", function () {
         const BondIssuer = await ethers.getContractFactory("BondIssuer");
         issuer = await upgrades.deployProxy(
           BondIssuer.connect(deployer),
-          [bondFactory.address, collateralToken.address, 10800, [500, 500], 1200, 0],
+          [bondFactory.target, collateralToken.target, 10800, [500, 500], 1200, 0],
           {
             initializer: "init(address,address,uint256,uint256[],uint256,uint256)",
           },
         );
 
-        await perp.updateBondIssuer(issuer.address);
+        await perp.updateBondIssuer(issuer.target);
         await perp.updateTolerableTrancheMaturity(0, 10800);
         await advancePerpQueue(perp, 10900);
         for (let i = 0; i < 5; i++) {
-          const depositBond = await bondAt(await perp.callStatic.getDepositBond());
+          const depositBond = await bondAt(await perp.depositBond());
           const tranches = await getTranches(depositBond);
           await depositIntoBond(depositBond, toFixedPtAmt("1000"), deployer);
-          await tranches[0].approve(perp.address, toFixedPtAmt("500"));
-          await perp.deposit(tranches[0].address, toFixedPtAmt("500"));
+          await mintPerps(perp, tranches[0], toFixedPtAmt("500"), deployer);
           reserveTranches[i] = tranches[0];
           await advancePerpQueue(perp, 1200);
         }
 
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, ...reserveTranches],
           [
@@ -741,8 +722,8 @@ describe("PerpetualTranche", function () {
           ],
         );
 
-        expect(await perp.callStatic.getReserveCount()).to.eq("6");
-        expect(await collateralToken.balanceOf(perp.address)).to.eq("0");
+        expect(await perp.reserveCount()).to.eq("6");
+        expect(await collateralToken.balanceOf(perp.target)).to.eq("0");
 
         await TimeHelpers.increaseTime(1200);
         tx = await perp.updateState();
@@ -750,7 +731,7 @@ describe("PerpetualTranche", function () {
       });
 
       it("should have expected reserve composition", async function () {
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, ...reserveTranches],
           [
@@ -765,17 +746,17 @@ describe("PerpetualTranche", function () {
       });
 
       it("should NOT change reserveCount", async function () {
-        expect(await perp.callStatic.getReserveCount()).to.eq("6");
+        expect(await perp.reserveCount()).to.eq("6");
       });
 
       it("should NOT change tranche balances", async function () {});
 
       it("should emit ReserveSynced", async function () {
-        await expect(tx).to.emit(perp, "ReserveSynced").withArgs(collateralToken.address, "0");
+        await expect(tx).to.emit(perp, "ReserveSynced").withArgs(collateralToken.target, "0");
       });
 
       it("should NOT update the reserve balance", async function () {
-        expect(await collateralToken.balanceOf(perp.address)).to.eq("0");
+        expect(await collateralToken.balanceOf(perp.target)).to.eq("0");
       });
     });
 
@@ -787,25 +768,24 @@ describe("PerpetualTranche", function () {
         const BondIssuer = await ethers.getContractFactory("BondIssuer");
         issuer = await upgrades.deployProxy(
           BondIssuer.connect(deployer),
-          [bondFactory.address, collateralToken.address, 10800, [500, 500], 1200, 0],
+          [bondFactory.target, collateralToken.target, 10800, [500, 500], 1200, 0],
           {
             initializer: "init(address,address,uint256,uint256[],uint256,uint256)",
           },
         );
-        await perp.updateBondIssuer(issuer.address);
+        await perp.updateBondIssuer(issuer.target);
         await perp.updateTolerableTrancheMaturity(0, 10800);
         await advancePerpQueue(perp, 10900);
         for (let i = 0; i < 5; i++) {
-          const depositBond = await bondAt(await perp.callStatic.getDepositBond());
+          const depositBond = await bondAt(await perp.depositBond());
           const tranches = await getTranches(depositBond);
           await depositIntoBond(depositBond, toFixedPtAmt("1000"), deployer);
-          await tranches[0].approve(perp.address, toFixedPtAmt("500"));
-          await perp.deposit(tranches[0].address, toFixedPtAmt("500"));
+          await mintPerps(perp, tranches[0], toFixedPtAmt("500"), deployer);
           reserveTranches[i] = tranches[0];
           await advancePerpQueue(perp, 1200);
         }
 
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, ...reserveTranches],
           [
@@ -817,8 +797,8 @@ describe("PerpetualTranche", function () {
             toFixedPtAmt("500"),
           ],
         );
-        expect(await perp.callStatic.getReserveCount()).to.eq("6");
-        expect(await collateralToken.balanceOf(perp.address)).to.eq("0");
+        expect(await perp.reserveCount()).to.eq("6");
+        expect(await collateralToken.balanceOf(perp.target)).to.eq("0");
 
         await TimeHelpers.increaseTime(6000);
         // NOTE: invoking mature on reserveTranches[0],
@@ -830,7 +810,7 @@ describe("PerpetualTranche", function () {
       });
 
       it("should have expected reserve composition", async function () {
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, reserveTranches[3], reserveTranches[4], reserveTranches[2]],
           [toFixedPtAmt("1000"), toFixedPtAmt("500"), toFixedPtAmt("500"), toFixedPtAmt("500")],
@@ -838,27 +818,27 @@ describe("PerpetualTranche", function () {
       });
 
       it("should change reserveCount", async function () {
-        expect(await perp.callStatic.getReserveCount()).to.eq("4");
+        expect(await perp.reserveCount()).to.eq("4");
       });
 
       it("should call mature if not already called", async function () {
         await expect(tx)
           .to.emit(await bondAt(await reserveTranches[1].bond()), "Mature")
-          .withArgs(perp.address);
+          .withArgs(perp.target);
       });
 
       it("should emit ReserveSynced", async function () {
         await expect(tx)
           .to.emit(perp, "ReserveSynced")
-          .withArgs(collateralToken.address, toFixedPtAmt("1000"))
+          .withArgs(collateralToken.target, toFixedPtAmt("1000"))
           .to.emit(perp, "ReserveSynced")
-          .withArgs(reserveTranches[0].address, "0")
+          .withArgs(reserveTranches[0].target, "0")
           .to.emit(perp, "ReserveSynced")
-          .withArgs(reserveTranches[1].address, "0");
+          .withArgs(reserveTranches[1].target, "0");
       });
 
       it("should update the reserve balance", async function () {
-        expect(await collateralToken.balanceOf(perp.address)).to.eq(toFixedPtAmt("1000"));
+        expect(await collateralToken.balanceOf(perp.target)).to.eq(toFixedPtAmt("1000"));
       });
     });
 
@@ -870,26 +850,25 @@ describe("PerpetualTranche", function () {
         const BondIssuer = await ethers.getContractFactory("BondIssuer");
         issuer = await upgrades.deployProxy(
           BondIssuer.connect(deployer),
-          [bondFactory.address, collateralToken.address, 10800, [500, 500], 1200, 0],
+          [bondFactory.target, collateralToken.target, 10800, [500, 500], 1200, 0],
           {
             initializer: "init(address,address,uint256,uint256[],uint256,uint256)",
           },
         );
-        await perp.updateBondIssuer(issuer.address);
+        await perp.updateBondIssuer(issuer.target);
         await perp.updateTolerableTrancheMaturity(0, 10800);
         await advancePerpQueue(perp, 10900);
         for (let i = 0; i < 5; i++) {
-          const depositBond = await bondAt(await perp.callStatic.getDepositBond());
+          const depositBond = await bondAt(await perp.depositBond());
           const tranches = await getTranches(depositBond);
           await depositIntoBond(depositBond, toFixedPtAmt("1000"), deployer);
-          await tranches[0].approve(perp.address, toFixedPtAmt("500"));
-          await perp.deposit(tranches[0].address, toFixedPtAmt("500"));
+          await mintPerps(perp, tranches[0], toFixedPtAmt("500"), deployer);
           reserveTranches[i] = tranches[0];
           await advancePerpQueue(perp, 1200);
           await rebase(collateralToken, rebaseOracle, -0.25);
         }
 
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, ...reserveTranches],
           [
@@ -901,8 +880,8 @@ describe("PerpetualTranche", function () {
             toFixedPtAmt("500"),
           ],
         );
-        expect(await perp.callStatic.getReserveCount()).to.eq("6");
-        expect(await collateralToken.balanceOf(perp.address)).to.eq("0");
+        expect(await perp.reserveCount()).to.eq("6");
+        expect(await collateralToken.balanceOf(perp.target)).to.eq("0");
 
         await TimeHelpers.increaseTime(6000);
         tx = perp.updateState();
@@ -910,7 +889,7 @@ describe("PerpetualTranche", function () {
       });
 
       it("should have expected reserve composition", async function () {
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, reserveTranches[3], reserveTranches[4], reserveTranches[2]],
           [toFixedPtAmt("553.710919999999999999"), toFixedPtAmt("500"), toFixedPtAmt("500"), toFixedPtAmt("500")],
@@ -918,29 +897,29 @@ describe("PerpetualTranche", function () {
       });
 
       it("should change reserveCount", async function () {
-        expect(await perp.callStatic.getReserveCount()).to.eq("4");
+        expect(await perp.reserveCount()).to.eq("4");
       });
 
       it("should call mature if not already called", async function () {
         await expect(tx)
           .to.emit(await bondAt(await reserveTranches[0].bond()), "Mature")
-          .withArgs(perp.address)
+          .withArgs(perp.target)
           .to.emit(await bondAt(await reserveTranches[1].bond()), "Mature")
-          .withArgs(perp.address);
+          .withArgs(perp.target);
       });
 
       it("should emit ReserveSynced", async function () {
         await expect(tx)
           .to.emit(perp, "ReserveSynced")
-          .withArgs(collateralToken.address, "553710919999999999999")
+          .withArgs(collateralToken.target, "553710919999999999999")
           .to.emit(perp, "ReserveSynced")
-          .withArgs(reserveTranches[0].address, "0")
+          .withArgs(reserveTranches[0].target, "0")
           .to.emit(perp, "ReserveSynced")
-          .withArgs(reserveTranches[1].address, "0");
+          .withArgs(reserveTranches[1].target, "0");
       });
 
       it("should update the reserve balance", async function () {
-        expect(await collateralToken.balanceOf(perp.address)).to.eq("553710919999999999999");
+        expect(await collateralToken.balanceOf(perp.target)).to.eq("553710919999999999999");
       });
     });
 
@@ -952,25 +931,24 @@ describe("PerpetualTranche", function () {
         const BondIssuer = await ethers.getContractFactory("BondIssuer");
         issuer = await upgrades.deployProxy(
           BondIssuer.connect(deployer),
-          [bondFactory.address, collateralToken.address, 10800, [500, 500], 1200, 0],
+          [bondFactory.target, collateralToken.target, 10800, [500, 500], 1200, 0],
           {
             initializer: "init(address,address,uint256,uint256[],uint256,uint256)",
           },
         );
-        await perp.updateBondIssuer(issuer.address);
+        await perp.updateBondIssuer(issuer.target);
         await perp.updateTolerableTrancheMaturity(0, 10800);
         await advancePerpQueue(perp, 10900);
         for (let i = 0; i < 5; i++) {
-          const depositBond = await bondAt(await perp.callStatic.getDepositBond());
+          const depositBond = await bondAt(await perp.depositBond());
           const tranches = await getTranches(depositBond);
           await depositIntoBond(depositBond, toFixedPtAmt("1000"), deployer);
-          await tranches[0].approve(perp.address, toFixedPtAmt("500"));
-          await perp.deposit(tranches[0].address, toFixedPtAmt("500"));
+          await mintPerps(perp, tranches[0], toFixedPtAmt("500"), deployer);
           reserveTranches[i] = tranches[0];
           await advancePerpQueue(perp, 1200);
         }
 
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, ...reserveTranches],
           [
@@ -982,8 +960,8 @@ describe("PerpetualTranche", function () {
             toFixedPtAmt("500"),
           ],
         );
-        expect(await perp.callStatic.getReserveCount()).to.eq("6");
-        expect(await collateralToken.balanceOf(perp.address)).to.eq("0");
+        expect(await perp.reserveCount()).to.eq("6");
+        expect(await collateralToken.balanceOf(perp.target)).to.eq("0");
 
         await TimeHelpers.increaseTime(6000);
         tx = perp.updateState();
@@ -991,7 +969,7 @@ describe("PerpetualTranche", function () {
       });
 
       it("should have expected reserve composition", async function () {
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, reserveTranches[3], reserveTranches[4], reserveTranches[2]],
           [toFixedPtAmt("1000"), toFixedPtAmt("500"), toFixedPtAmt("500"), toFixedPtAmt("500")],
@@ -999,7 +977,7 @@ describe("PerpetualTranche", function () {
       });
 
       it("should change reserveCount", async function () {
-        expect(await perp.callStatic.getReserveCount()).to.eq("4");
+        expect(await perp.reserveCount()).to.eq("4");
       });
 
       it("should change mature tranche balances", async function () {});
@@ -1007,53 +985,51 @@ describe("PerpetualTranche", function () {
       it("should call mature if not already called", async function () {
         await expect(tx)
           .to.emit(await bondAt(await reserveTranches[0].bond()), "Mature")
-          .withArgs(perp.address)
+          .withArgs(perp.target)
           .to.emit(await bondAt(await reserveTranches[1].bond()), "Mature")
-          .withArgs(perp.address);
+          .withArgs(perp.target);
       });
 
       it("should emit ReserveSynced", async function () {
         await expect(tx)
           .to.emit(perp, "ReserveSynced")
-          .withArgs(collateralToken.address, toFixedPtAmt("1000"))
+          .withArgs(collateralToken.target, toFixedPtAmt("1000"))
           .to.emit(perp, "ReserveSynced")
-          .withArgs(reserveTranches[0].address, "0")
+          .withArgs(reserveTranches[0].target, "0")
           .to.emit(perp, "ReserveSynced")
-          .withArgs(reserveTranches[1].address, "0");
+          .withArgs(reserveTranches[1].target, "0");
       });
 
       it("should update the reserve balance", async function () {
-        expect(await collateralToken.balanceOf(perp.address)).to.eq(toFixedPtAmt("1000"));
+        expect(await collateralToken.balanceOf(perp.target)).to.eq(toFixedPtAmt("1000"));
       });
     });
 
     describe("when paused", async function () {
       let issuer: Contract;
-      let tx: Transaction;
       const reserveTranches: Contract[] = [];
       beforeEach(async function () {
         const BondIssuer = await ethers.getContractFactory("BondIssuer");
         issuer = await upgrades.deployProxy(
           BondIssuer.connect(deployer),
-          [bondFactory.address, collateralToken.address, 10800, [500, 500], 1200, 0],
+          [bondFactory.target, collateralToken.target, 10800, [500, 500], 1200, 0],
           {
             initializer: "init(address,address,uint256,uint256[],uint256,uint256)",
           },
         );
-        await perp.updateBondIssuer(issuer.address);
+        await perp.updateBondIssuer(issuer.target);
         await perp.updateTolerableTrancheMaturity(0, 10800);
         await advancePerpQueue(perp, 10900);
         for (let i = 0; i < 5; i++) {
-          const depositBond = await bondAt(await perp.callStatic.getDepositBond());
+          const depositBond = await bondAt(await perp.depositBond());
           const tranches = await getTranches(depositBond);
           await depositIntoBond(depositBond, toFixedPtAmt("1000"), deployer);
-          await tranches[0].approve(perp.address, toFixedPtAmt("500"));
-          await perp.deposit(tranches[0].address, toFixedPtAmt("500"));
+          await mintPerps(perp, tranches[0], toFixedPtAmt("500"), deployer);
           reserveTranches[i] = tranches[0];
           await advancePerpQueue(perp, 1200);
         }
 
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, ...reserveTranches],
           [
@@ -1065,18 +1041,17 @@ describe("PerpetualTranche", function () {
             toFixedPtAmt("500"),
           ],
         );
-        expect(await perp.callStatic.getReserveCount()).to.eq("6");
-        expect(await collateralToken.balanceOf(perp.address)).to.eq("0");
+        expect(await perp.reserveCount()).to.eq("6");
+        expect(await collateralToken.balanceOf(perp.target)).to.eq("0");
 
         await TimeHelpers.increaseTime(6000);
         await perp.updateKeeper(await deployer.getAddress());
         await perp.pause();
-        tx = perp.updateState();
-        await tx;
       });
 
-      it("should have not updated composition", async function () {
-        await checkReserveComposition(
+      it("should should be reverted", async function () {
+        await expect(perp.updateState()).to.be.revertedWith("Pausable: paused");
+        await checkPerpComposition(
           perp,
           [collateralToken, ...reserveTranches],
           [
@@ -1092,118 +1067,115 @@ describe("PerpetualTranche", function () {
     });
   });
 
-  describe("#getReserveTokensUpForRollover", async function () {
+  describe("#reserveTokensUpForRollover", async function () {
     const depositTranches: Contract[] = [];
     beforeEach(async function () {
       const bondFactory = await setupBondFactory();
       const BondIssuer = await ethers.getContractFactory("BondIssuer");
       issuer = await upgrades.deployProxy(
         BondIssuer.connect(deployer),
-        [bondFactory.address, collateralToken.address, 10800, [500, 500], 1200, 0],
+        [bondFactory.target, collateralToken.target, 10800, [500, 500], 1200, 0],
         {
           initializer: "init(address,address,uint256,uint256[],uint256,uint256)",
         },
       );
-      await perp.updateBondIssuer(issuer.address);
+      await perp.updateBondIssuer(issuer.target);
       await perp.updateTolerableTrancheMaturity(600, 10800);
       await advancePerpQueue(perp, 10900);
       for (let i = 0; i < 5; i++) {
-        const depositBond = await bondAt(await perp.callStatic.getDepositBond());
+        const depositBond = await bondAt(await perp.depositBond());
         const tranches = await getTranches(depositBond);
         await depositIntoBond(depositBond, toFixedPtAmt("1000"), deployer);
-        await tranches[0].approve(perp.address, toFixedPtAmt("500"));
-        await perp.deposit(tranches[0].address, toFixedPtAmt("500"));
+        await mintPerps(perp, tranches[0], toFixedPtAmt("500"), deployer);
         depositTranches[i] = tranches[0];
         await advancePerpQueue(perp, 1200);
       }
-      await advancePerpQueueToRollover(perp, await bondAt(depositTranches[2].bond()));
+      await advancePerpQueueToRollover(perp, await bondAt(await depositTranches[2].bond()));
     });
 
     it("should get the rollover ready tranches", async function () {
-      const r = await perp.callStatic.getReserveTokensUpForRollover();
-      expect(r).to.include(collateralToken.address);
-      expect(r).to.include(depositTranches[2].address);
-      expect(r).not.to.include(depositTranches[0].address);
-      expect(r).not.to.include(depositTranches[1].address);
-      expect(r).not.to.include(depositTranches[3].address);
-      expect(r).not.to.include(depositTranches[4].address);
+      const r = await perp.reserveTokensUpForRollover();
+      expect(r).to.include(collateralToken.target);
+      expect(r).to.include(depositTranches[2].target);
+      expect(r).not.to.include(depositTranches[0].target);
+      expect(r).not.to.include(depositTranches[1].target);
+      expect(r).not.to.include(depositTranches[3].target);
+      expect(r).not.to.include(depositTranches[4].target);
     });
   });
 
-  describe("#getReserveTokenBalance", async function () {
+  describe("#reserveTokenBalance", async function () {
     const depositTranches: Contract[] = [];
     beforeEach(async function () {
       const bondFactory = await setupBondFactory();
       const BondIssuer = await ethers.getContractFactory("BondIssuer");
       issuer = await upgrades.deployProxy(
         BondIssuer.connect(deployer),
-        [bondFactory.address, collateralToken.address, 10800, [500, 500], 1200, 0],
+        [bondFactory.target, collateralToken.target, 10800, [500, 500], 1200, 0],
         {
           initializer: "init(address,address,uint256,uint256[],uint256,uint256)",
         },
       );
-      await perp.updateBondIssuer(issuer.address);
+      await perp.updateBondIssuer(issuer.target);
       await perp.updateTolerableTrancheMaturity(600, 10800);
       await advancePerpQueue(perp, 10900);
       for (let i = 0; i < 5; i++) {
-        const depositBond = await bondAt(await perp.callStatic.getDepositBond());
+        const depositBond = await bondAt(await perp.depositBond());
         const tranches = await getTranches(depositBond);
         await depositIntoBond(depositBond, toFixedPtAmt("1000"), deployer);
-        await tranches[0].approve(perp.address, toFixedPtAmt("500"));
-        await perp.deposit(tranches[0].address, toFixedPtAmt("500"));
+        await mintPerps(perp, tranches[0], toFixedPtAmt("500"), deployer);
         depositTranches[i] = tranches[0];
         await advancePerpQueue(perp, 1200);
       }
-      await advancePerpQueueToRollover(perp, await bondAt(depositTranches[2].bond()));
+      await advancePerpQueueToRollover(perp, await bondAt(await depositTranches[2].bond()));
     });
 
     it("should return the token balance", async function () {
-      expect(await perp.callStatic.getReserveTokenBalance(perp.address)).to.eq("0");
-      expect(await perp.callStatic.getReserveTokenBalance(collateralToken.address)).to.eq(toFixedPtAmt("1000"));
-      expect(await perp.callStatic.getReserveTokenBalance(depositTranches[0].address)).to.eq("0");
-      expect(await perp.callStatic.getReserveTokenBalance(depositTranches[1].address)).to.eq("0");
-      expect(await perp.callStatic.getReserveTokenBalance(depositTranches[2].address)).to.eq(toFixedPtAmt("500"));
-      expect(await perp.callStatic.getReserveTokenBalance(depositTranches[3].address)).to.eq(toFixedPtAmt("500"));
-      expect(await perp.callStatic.getReserveTokenBalance(depositTranches[4].address)).to.eq(toFixedPtAmt("500"));
+      expect(await perp.reserveTokenBalance(perp.target)).to.eq("0");
+      expect(await perp.reserveTokenBalance(collateralToken.target)).to.eq(toFixedPtAmt("1000"));
+      expect(await perp.reserveTokenBalance(depositTranches[0].target)).to.eq("0");
+      expect(await perp.reserveTokenBalance(depositTranches[1].target)).to.eq("0");
+      expect(await perp.reserveTokenBalance(depositTranches[2].target)).to.eq(toFixedPtAmt("500"));
+      expect(await perp.reserveTokenBalance(depositTranches[3].target)).to.eq(toFixedPtAmt("500"));
+      expect(await perp.reserveTokenBalance(depositTranches[4].target)).to.eq(toFixedPtAmt("500"));
     });
   });
 
-  describe("#getReserveTokenValue", async function () {
+  describe("#reserveTokenValue", async function () {
     const depositTranches: Contract[] = [];
     beforeEach(async function () {
       const bondFactory = await setupBondFactory();
       const BondIssuer = await ethers.getContractFactory("BondIssuer");
       issuer = await upgrades.deployProxy(
         BondIssuer.connect(deployer),
-        [bondFactory.address, collateralToken.address, 10800, [500, 500], 1200, 0],
+        [bondFactory.target, collateralToken.target, 10800, [500, 500], 1200, 0],
         {
           initializer: "init(address,address,uint256,uint256[],uint256,uint256)",
         },
       );
-      await perp.updateBondIssuer(issuer.address);
+      await perp.updateBondIssuer(issuer.target);
       await perp.updateTolerableTrancheMaturity(600, 10800);
       await advancePerpQueue(perp, 10900);
       for (let i = 0; i < 5; i++) {
-        const depositBond = await bondAt(await perp.callStatic.getDepositBond());
+        const depositBond = await bondAt(await perp.depositBond());
         const tranches = await getTranches(depositBond);
         await depositIntoBond(depositBond, toFixedPtAmt("1000"), deployer);
-        await tranches[0].approve(perp.address, toFixedPtAmt("500"));
-        await perp.deposit(tranches[0].address, toFixedPtAmt("500"));
+        await mintPerps(perp, tranches[0], toFixedPtAmt("500"), deployer);
         depositTranches[i] = tranches[0];
         await advancePerpQueue(perp, 1200);
         await rebase(collateralToken, rebaseOracle, -0.5);
       }
-      await advancePerpQueueToRollover(perp, await bondAt(depositTranches[2].bond()));
+      await advancePerpQueueToRollover(perp, await bondAt(await depositTranches[2].bond()));
     });
 
     it("should return the tranche value", async function () {
-      expect(await perp.callStatic.getReserveTokenValue(perp.address)).to.eq("0");
-      expect(await perp.callStatic.getReserveTokenValue(collateralToken.address)).to.eq(toFixedPtAmt("93.75"));
-      expect(await perp.callStatic.getReserveTokenValue(depositTranches[0].address)).to.eq("0");
-      expect(await perp.callStatic.getReserveTokenValue(depositTranches[1].address)).to.eq("0");
-      expect(await perp.callStatic.getReserveTokenValue(depositTranches[2].address)).to.eq(toFixedPtAmt("125"));
-      expect(await perp.callStatic.getReserveTokenValue(depositTranches[3].address)).to.eq(toFixedPtAmt("250"));
-      expect(await perp.callStatic.getReserveTokenValue(depositTranches[4].address)).to.eq(toFixedPtAmt("500"));
+      expect(await perp.reserveTokenValue(perp.target)).to.eq("0");
+      expect(await perp.reserveTokenValue(collateralToken.target)).to.eq(toFixedPtAmt("93.75"));
+      expect(await perp.reserveTokenValue(depositTranches[0].target)).to.eq("0");
+      expect(await perp.reserveTokenValue(depositTranches[1].target)).to.eq("0");
+      expect(await perp.reserveTokenValue(depositTranches[2].target)).to.eq(toFixedPtAmt("125"));
+      expect(await perp.reserveTokenValue(depositTranches[3].target)).to.eq(toFixedPtAmt("250"));
+      expect(await perp.reserveTokenValue(depositTranches[4].target)).to.eq(toFixedPtAmt("500"));
     });
   });
 });
diff --git a/spot-contracts/test/perp/PerpetualTranche_deposit.ts b/spot-contracts/test/perp/PerpetualTranche_deposit.ts
index c6a860be..b770ccfd 100644
--- a/spot-contracts/test/perp/PerpetualTranche_deposit.ts
+++ b/spot-contracts/test/perp/PerpetualTranche_deposit.ts
@@ -1,7 +1,6 @@
-import { expect, use } from "chai";
+import { expect } from "chai";
 import { network, ethers, upgrades } from "hardhat";
 import { Contract, Transaction, Signer } from "ethers";
-import { smock } from "@defi-wonderland/smock";
 import {
   setupCollateralToken,
   setupBondFactory,
@@ -9,33 +8,35 @@ import {
   depositIntoBond,
   bondAt,
   getTranches,
-  toPercFixedPtAmt,
   toFixedPtAmt,
   advancePerpQueue,
-  checkReserveComposition,
+  checkPerpComposition,
   rebase,
   mintCollteralToken,
+  mintPerps,
+  DMock,
 } from "../helpers";
-use(smock.matchers);
 
 let perp: Contract,
   bondFactory: Contract,
   rebaseOracle: Contract,
   collateralToken: Contract,
   issuer: Contract,
-  feePolicy: Contract,
+  balancer: Contract,
   deployer: Signer,
   deployerAddress: string,
+  otherUser: Signer,
   depositBond: Contract,
   depositTrancheA: Contract,
   depositTrancheZ: Contract;
 describe("PerpetualTranche", function () {
   beforeEach(async function () {
-    await network.provider.send("hardhat_reset");
+    await network.provider.request({ method: "hardhat_reset" });
 
     const accounts = await ethers.getSigners();
     deployer = accounts[0];
     deployerAddress = await deployer.getAddress();
+    otherUser = accounts[1];
 
     bondFactory = await setupBondFactory();
     ({ collateralToken, rebaseOracle } = await setupCollateralToken("Bitcoin", "BTC"));
@@ -43,71 +44,65 @@ describe("PerpetualTranche", function () {
     const BondIssuer = await ethers.getContractFactory("BondIssuer");
     issuer = await upgrades.deployProxy(
       BondIssuer.connect(deployer),
-      [bondFactory.address, collateralToken.address, 3600, [500, 500], 1200, 0],
+      [bondFactory.target, collateralToken.target, 3600, [500, 500], 1200, 0],
       {
         initializer: "init(address,address,uint256,uint256[],uint256,uint256)",
       },
     );
 
-    const FeePolicy = await ethers.getContractFactory("FeePolicy");
-    feePolicy = await smock.fake(FeePolicy);
-    await feePolicy.decimals.returns(8);
-
     const PerpetualTranche = await ethers.getContractFactory("PerpetualTranche");
     perp = await upgrades.deployProxy(
       PerpetualTranche.connect(deployer),
-      ["PerpetualTranche", "PERP", collateralToken.address, issuer.address, feePolicy.address],
+      ["PerpetualTranche", "PERP", collateralToken.target, issuer.target],
       {
-        initializer: "init(string,string,address,address,address)",
+        initializer: "init(string,string,address,address)",
       },
     );
     await advancePerpQueue(perp, 3600);
 
-    const RolloverVault = await ethers.getContractFactory("RolloverVault");
-    const vault = await smock.fake(RolloverVault);
-    await vault.getTVL.returns("0");
-    await perp.updateVault(vault.address);
+    balancer = new DMock(await ethers.getContractFactory("Balancer"));
+    await balancer.deploy();
+    await balancer.mockMethod("decimals()", [8]);
+
+    await perp.updateBalancer(balancer.target);
+    await perp.updateVault(deployerAddress);
 
-    depositBond = await bondAt(await perp.callStatic.getDepositBond());
+    depositBond = await bondAt(await perp.depositBond());
     [depositTrancheA, depositTrancheZ] = await getTranches(depositBond);
 
     await depositIntoBond(depositBond, toFixedPtAmt("1000"), deployer);
-    await depositTrancheA.approve(perp.address, toFixedPtAmt("500"));
-    await depositTrancheZ.approve(perp.address, toFixedPtAmt("500"));
-
-    await feePolicy.computePerpMintFeePerc.returns("0");
   });
 
   afterEach(async function () {
-    await network.provider.send("hardhat_reset");
+    await network.provider.request({ method: "hardhat_reset" });
   });
 
   describe("#deposit", function () {
     describe("when paused", function () {
       beforeEach(async function () {
-        await perp.updateKeeper(deployerAddress);
         await perp.pause();
       });
 
       it("should revert", async function () {
-        await expect(perp.deposit(depositTrancheA.address, toFixedPtAmt("500"))).to.revertedWith("Pausable: paused");
+        await expect(mintPerps(perp, depositTrancheA, toFixedPtAmt("500"), deployer)).to.revertedWith(
+          "Pausable: paused",
+        );
       });
     });
 
     describe("when bond issuer is NOT set correctly", function () {
       let bond: Contract;
       beforeEach(async function () {
-        const BondIssuer = await ethers.getContractFactory("BondIssuer");
-        const newIssuer = await smock.fake(BondIssuer);
-        await newIssuer.collateral.returns(collateralToken.address);
-        await perp.updateBondIssuer(newIssuer.address);
         bond = await createBondWithFactory(bondFactory, perp, [200, 300, 500], 3600);
-        await newIssuer.getLatestBond.returns(bond.address);
+        const newIssuer = new DMock(await ethers.getContractFactory("BondIssuer"));
+        await newIssuer.deploy();
+        await newIssuer.mockMethod("collateral()", [collateralToken.target]);
+        await newIssuer.mockMethod("getLatestBond()", [bond.target]);
+        await perp.updateBondIssuer(newIssuer.target);
       });
       it("should not update the deposit bond", async function () {
-        await depositTrancheA.approve(perp.address, toFixedPtAmt("500"));
-        await expect(perp.deposit(depositTrancheA.address, toFixedPtAmt("500"))).to.not.be.reverted;
-        expect(await perp.callStatic.getDepositBond()).to.not.eq(bond.address);
+        await expect(mintPerps(perp, depositTrancheA, toFixedPtAmt("500"), deployer)).to.not.be.reverted;
+        expect(await perp.depositBond()).to.not.eq(bond.target);
       });
     });
 
@@ -118,10 +113,18 @@ describe("PerpetualTranche", function () {
         depositTrancheA = (await getTranches(bond))[0];
       });
       it("should revert", async function () {
-        await depositTrancheA.approve(perp.address, toFixedPtAmt("500"));
-        await expect(perp.deposit(depositTrancheA.address, toFixedPtAmt("500"))).to.revertedWithCustomError(
+        await expect(mintPerps(perp, depositTrancheA, toFixedPtAmt("500"), deployer)).to.revertedWithCustomError(
           perp,
-          "UnexpectedAsset",
+          "UnacceptableDeposit",
+        );
+      });
+    });
+
+    describe("when depositing a junior", function () {
+      it("should return without minting", async function () {
+        await expect(mintPerps(perp, depositTrancheZ, toFixedPtAmt("500"), deployer)).to.revertedWithCustomError(
+          perp,
+          "UnacceptableDeposit",
         );
       });
     });
@@ -132,21 +135,18 @@ describe("PerpetualTranche", function () {
         const maliciousTranche = await ERC20.deploy();
         await maliciousTranche.init("Tranche", "TRA");
         await maliciousTranche.mint(deployerAddress, toFixedPtAmt("500"));
-        await maliciousTranche.setBond(await perp.callStatic.getDepositBond());
-        await maliciousTranche.approve(perp.address, toFixedPtAmt("500"));
-        await expect(perp.deposit(maliciousTranche.address, toFixedPtAmt("500"))).to.revertedWithCustomError(
+        await maliciousTranche.setBond(await perp.depositBond());
+        await expect(mintPerps(perp, maliciousTranche, toFixedPtAmt("500"), deployer)).to.revertedWithCustomError(
           perp,
-          "UnexpectedAsset",
+          "UnacceptableDeposit",
         );
       });
     });
 
     describe("when user has not approved sufficient tranche tokens", function () {
-      beforeEach(async function () {
-        await depositTrancheA.approve(perp.address, "0");
-      });
+      beforeEach(async function () {});
       it("should revert", async function () {
-        await expect(perp.deposit(depositTrancheA.address, toFixedPtAmt("500"))).to.revertedWith(
+        await expect(perp.deposit(depositTrancheA.target, toFixedPtAmt("500"))).to.revertedWith(
           "ERC20: transfer amount exceeds allowance",
         );
       });
@@ -154,50 +154,23 @@ describe("PerpetualTranche", function () {
 
     describe("when user has insufficient balance", function () {
       beforeEach(async function () {
-        await depositTrancheA.transfer(perp.address, toFixedPtAmt("500"));
+        await depositTrancheA.transfer(perp.target, toFixedPtAmt("500"));
       });
       it("should revert", async function () {
         expect(await depositTrancheA.balanceOf(deployerAddress)).to.eq("0");
-        await expect(perp.deposit(depositTrancheA.address, toFixedPtAmt("500"))).to.revertedWith(
+        await expect(mintPerps(perp, depositTrancheA, toFixedPtAmt("500"), deployer)).to.revertedWith(
           "ERC20: transfer amount exceeds balance",
         );
       });
     });
 
-    describe("when the supply cap is exceeded", function () {
-      beforeEach(async function () {
-        await perp.updateMintingLimits(toFixedPtAmt("499"), toFixedPtAmt("1000"));
-      });
-
-      it("should revert", async function () {
-        await expect(perp.deposit(depositTrancheA.address, toFixedPtAmt("500"))).to.revertedWithCustomError(
-          perp,
-          "ExceededMaxSupply",
-        );
-      });
-    });
-
-    describe("when the supply cap is exceeded and existing supply > 0", function () {
-      beforeEach(async function () {
-        await perp.deposit(depositTrancheA.address, toFixedPtAmt("400"));
-        await perp.updateMintingLimits(toFixedPtAmt("499"), toFixedPtAmt("1000"));
-      });
-
-      it("should revert", async function () {
-        await expect(perp.deposit(depositTrancheA.address, toFixedPtAmt("100"))).to.revertedWithCustomError(
-          perp,
-          "ExceededMaxSupply",
-        );
-      });
-    });
-
     describe("when the tranche mint limit is exceeded", function () {
       beforeEach(async function () {
-        await perp.updateMintingLimits(toFixedPtAmt("1000"), toFixedPtAmt("499"));
+        await perp.updatePerTrancheMintCap(toFixedPtAmt("499"));
       });
 
       it("should revert", async function () {
-        await expect(perp.deposit(depositTrancheA.address, toFixedPtAmt("500"))).to.revertedWithCustomError(
+        await expect(mintPerps(perp, depositTrancheA, toFixedPtAmt("500"), deployer)).to.revertedWithCustomError(
           perp,
           "ExceededMaxMintPerTranche",
         );
@@ -206,12 +179,12 @@ describe("PerpetualTranche", function () {
 
     describe("when the tranche mint limit is exceeded and existing supply > 0", function () {
       beforeEach(async function () {
-        await perp.deposit(depositTrancheA.address, toFixedPtAmt("400"));
-        await perp.updateMintingLimits(toFixedPtAmt("1000"), toFixedPtAmt("499"));
+        await mintPerps(perp, depositTrancheA, toFixedPtAmt("400"), deployer);
+        await perp.updatePerTrancheMintCap(toFixedPtAmt("499"));
       });
 
       it("should revert", async function () {
-        await expect(perp.deposit(depositTrancheA.address, toFixedPtAmt("100"))).to.revertedWithCustomError(
+        await expect(mintPerps(perp, depositTrancheA, toFixedPtAmt("100"), deployer)).to.revertedWithCustomError(
           perp,
           `ExceededMaxMintPerTranche`,
         );
@@ -220,23 +193,14 @@ describe("PerpetualTranche", function () {
 
     describe("when tranche amount is zero", function () {
       it("should return without minting", async function () {
-        expect(await perp.callStatic.deposit(depositTrancheA.address, "0")).to.eq("0");
-      });
-    });
-
-    describe("when depositing a junior", function () {
-      it("should return without minting", async function () {
-        await expect(perp.deposit(depositTrancheZ.address, toFixedPtAmt("500"))).to.revertedWithCustomError(
-          perp,
-          "UnexpectedAsset",
-        );
+        expect(await perp.deposit.staticCall(depositTrancheA.target, "0")).to.eq("0");
       });
     });
 
     describe("when total supply is zero", function () {
       describe("when tranche price is 1", function () {
         it("should mint the correct amount", async function () {
-          const r = await perp.callStatic.computeMintAmt(depositTrancheA.address, toFixedPtAmt("500"));
+          const r = await perp.computeMintAmt.staticCall(depositTrancheA.target, toFixedPtAmt("500"));
           expect(r).to.eq(toFixedPtAmt("500"));
         });
       });
@@ -247,7 +211,7 @@ describe("PerpetualTranche", function () {
         });
 
         it("should mint the correct amount", async function () {
-          const r = await perp.callStatic.computeMintAmt(depositTrancheA.address, toFixedPtAmt("500"));
+          const r = await perp.computeMintAmt.staticCall(depositTrancheA.target, toFixedPtAmt("500"));
           expect(r).to.eq(toFixedPtAmt("250"));
         });
       });
@@ -256,19 +220,18 @@ describe("PerpetualTranche", function () {
     describe("when total supply > zero", function () {
       let newBond: Contract, newTranche: Contract;
       beforeEach(async function () {
-        await perp.deposit(depositTrancheA.address, toFixedPtAmt("200"));
+        await mintPerps(perp, depositTrancheA, toFixedPtAmt("200"), deployer);
 
         await advancePerpQueue(perp, 1200);
-        newBond = await bondAt(await perp.callStatic.getDepositBond());
+        newBond = await bondAt(await perp.depositBond());
         await depositIntoBond(newBond, toFixedPtAmt("1000"), deployer);
         const tranches = await getTranches(newBond);
         newTranche = tranches[0];
-        await newTranche.approve(perp.address, toFixedPtAmt("250"));
       });
 
       describe("when price is eql to avg reserve price", function () {
         it("should mint the correct amount", async function () {
-          const r = await perp.callStatic.computeMintAmt(newTranche.address, toFixedPtAmt("250"));
+          const r = await perp.computeMintAmt.staticCall(newTranche.target, toFixedPtAmt("250"));
           expect(r).to.eq(toFixedPtAmt("250"));
         });
       });
@@ -276,11 +239,11 @@ describe("PerpetualTranche", function () {
       describe("when price is < avg reserve price", function () {
         beforeEach(async function () {
           await mintCollteralToken(collateralToken, toFixedPtAmt("500"), deployer);
-          await collateralToken.transfer(perp.address, toFixedPtAmt("200"));
+          await collateralToken.transfer(perp.target, toFixedPtAmt("200"));
         });
 
         it("should mint the correct amount", async function () {
-          const r = await perp.callStatic.computeMintAmt(newTranche.address, toFixedPtAmt("250"));
+          const r = await perp.computeMintAmt.staticCall(newTranche.target, toFixedPtAmt("250"));
           expect(r).to.eq(toFixedPtAmt("125"));
         });
       });
@@ -290,15 +253,14 @@ describe("PerpetualTranche", function () {
           await rebase(collateralToken, rebaseOracle, -0.75);
 
           await advancePerpQueue(perp, 1200);
-          newBond = await bondAt(await perp.callStatic.getDepositBond());
+          newBond = await bondAt(await perp.depositBond());
           await depositIntoBond(newBond, toFixedPtAmt("1000"), deployer);
           const tranches = await getTranches(newBond);
           newTranche = tranches[0];
-          await newTranche.approve(perp.address, toFixedPtAmt("250"));
         });
 
         it("should mint the correct amount", async function () {
-          const r = await perp.callStatic.computeMintAmt(newTranche.address, toFixedPtAmt("250"));
+          const r = await perp.computeMintAmt.staticCall(newTranche.target, toFixedPtAmt("250"));
           expect(r).to.eq(toFixedPtAmt("500"));
         });
       });
@@ -306,28 +268,28 @@ describe("PerpetualTranche", function () {
 
     describe("on successful deposit", function () {
       it("should mint perp tokens", async function () {
-        await expect(() => perp.deposit(depositTrancheA.address, toFixedPtAmt("500"))).to.changeTokenBalance(
+        await expect(() => mintPerps(perp, depositTrancheA, toFixedPtAmt("500"), deployer)).to.changeTokenBalance(
           perp,
           deployer,
           toFixedPtAmt("500"),
         );
       });
       it("should NOT withhold any fee amount", async function () {
-        await expect(() => perp.deposit(depositTrancheA.address, toFixedPtAmt("500"))).to.changeTokenBalance(
+        await expect(() => mintPerps(perp, depositTrancheA, toFixedPtAmt("500"), deployer)).to.changeTokenBalance(
           perp,
           perp,
           "0",
         );
       });
       it("should transfer the tranches in", async function () {
-        await expect(() => perp.deposit(depositTrancheA.address, toFixedPtAmt("500"))).to.changeTokenBalances(
+        await expect(() => mintPerps(perp, depositTrancheA, toFixedPtAmt("500"), deployer)).to.changeTokenBalances(
           depositTrancheA,
           [deployer, perp],
           [toFixedPtAmt("-500"), toFixedPtAmt("500")],
         );
       });
       it("should return the mintAmt", async function () {
-        const r = await perp.callStatic.computeMintAmt(depositTrancheA.address, toFixedPtAmt("500"));
+        const r = await perp.computeMintAmt.staticCall(depositTrancheA.target, toFixedPtAmt("500"));
         expect(r).to.eq(toFixedPtAmt("500"));
       });
     });
@@ -335,24 +297,24 @@ describe("PerpetualTranche", function () {
     describe("when the reserve has no tranches", function () {
       let tx: Transaction;
       beforeEach(async function () {
-        expect(await perp.callStatic.getDepositBond()).to.eq(depositBond.address);
+        expect(await perp.depositBond()).to.eq(depositBond.target);
 
-        await checkReserveComposition(perp, [collateralToken], ["0"]);
+        await checkPerpComposition(perp, [collateralToken], ["0"]);
         expect(await perp.totalSupply()).to.eq(0);
 
-        tx = perp.deposit(depositTrancheA.address, toFixedPtAmt("500"));
+        tx = mintPerps(perp, depositTrancheA, toFixedPtAmt("500"), deployer);
         await tx;
       });
 
       it("should NOT update the deposit bond", async function () {
-        expect(await perp.callStatic.getDepositBond()).to.eq(depositBond.address);
+        expect(await perp.depositBond()).to.eq(depositBond.target);
       });
 
       it("should emit reserve synced", async function () {
-        await expect(tx).to.emit(perp, "ReserveSynced").withArgs(depositTrancheA.address, toFixedPtAmt("500"));
+        await expect(tx).to.emit(perp, "ReserveSynced").withArgs(depositTrancheA.target, toFixedPtAmt("500"));
       });
       it("should update the reserve", async function () {
-        await checkReserveComposition(perp, [collateralToken, depositTrancheA], ["0", toFixedPtAmt("500")]);
+        await checkPerpComposition(perp, [collateralToken, depositTrancheA], ["0", toFixedPtAmt("500")]);
       });
       it("should update the total supply", async function () {
         expect(await perp.totalSupply()).to.eq(toFixedPtAmt("500"));
@@ -361,121 +323,78 @@ describe("PerpetualTranche", function () {
 
     describe("when the reserve has tranches", function () {
       beforeEach(async function () {
-        await perp.deposit(depositTrancheA.address, toFixedPtAmt("200"));
+        await mintPerps(perp, depositTrancheA, toFixedPtAmt("200"), deployer);
 
-        expect(await perp.callStatic.getDepositBond()).to.eq(depositBond.address);
-        await checkReserveComposition(perp, [collateralToken, depositTrancheA], ["0", toFixedPtAmt("200")]);
+        expect(await perp.depositBond()).to.eq(depositBond.target);
+        await checkPerpComposition(perp, [collateralToken, depositTrancheA], ["0", toFixedPtAmt("200")]);
 
         expect(await perp.totalSupply()).to.eq(toFixedPtAmt("200"));
       });
 
-      describe("when inserting the an existing tranche", async function () {
+      describe("when depositing the an existing tranche", async function () {
         let tx: Transaction;
         beforeEach(async function () {
-          tx = perp.deposit(depositTrancheA.address, toFixedPtAmt("300"));
+          tx = mintPerps(perp, depositTrancheA, toFixedPtAmt("300"), deployer);
           await tx;
         });
 
         it("should NOT update the deposit bond", async function () {
-          expect(await perp.callStatic.getDepositBond()).to.eq(depositBond.address);
+          expect(await perp.depositBond()).to.eq(depositBond.target);
         });
         it("should emit reserve synced", async function () {
-          await expect(tx).to.emit(perp, "ReserveSynced").withArgs(depositTrancheA.address, toFixedPtAmt("500"));
+          await expect(tx).to.emit(perp, "ReserveSynced").withArgs(depositTrancheA.target, toFixedPtAmt("500"));
         });
         it("should update the reserve", async function () {
-          await checkReserveComposition(perp, [collateralToken, depositTrancheA], ["0", toFixedPtAmt("500")]);
+          await checkPerpComposition(perp, [collateralToken, depositTrancheA], ["0", toFixedPtAmt("500")]);
         });
         it("should update the total supply", async function () {
           expect(await perp.totalSupply()).to.eq(toFixedPtAmt("500"));
         });
       });
 
-      describe("when inserting a new tranche", function () {
-        let newBond: Contract, newTranche: Contract, tx: Transaction;
+      describe("when depositing a new tranche", function () {
+        let newBond: Contract, newTranche: Contract, txFn: Promise<Transaction>;
         beforeEach(async function () {
           await advancePerpQueue(perp, 1200);
 
-          newBond = await bondAt(await perp.callStatic.getDepositBond());
+          newBond = await bondAt(await perp.depositBond());
           await depositIntoBond(newBond, toFixedPtAmt("1000"), deployer);
           const tranches = await getTranches(newBond);
           newTranche = tranches[0];
-          await checkReserveComposition(perp, [collateralToken, depositTrancheA], ["0", toFixedPtAmt("200")]);
+          await checkPerpComposition(perp, [collateralToken, depositTrancheA], ["0", toFixedPtAmt("200")]);
           expect(await perp.totalSupply()).to.eq(toFixedPtAmt("200"));
-          await newTranche.approve(perp.address, toFixedPtAmt("250"));
-          tx = perp.deposit(newTranche.address, toFixedPtAmt("250"));
-          await tx;
+          await newTranche.transfer(await otherUser.getAddress(), toFixedPtAmt("250"));
+          txFn = () => mintPerps(perp, newTranche, toFixedPtAmt("250"), otherUser);
+        });
+
+        it("should mint perps", async function () {
+          await expect(txFn).to.changeTokenBalance(perp, otherUser, toFixedPtAmt("250"));
+        });
+
+        it("should not change other balances", async function () {
+          await expect(txFn).to.changeTokenBalance(perp, deployer, "0");
         });
 
         it("should update the deposit bond", async function () {
-          expect(await perp.callStatic.getDepositBond()).to.eq(newBond.address);
+          expect(await perp.depositBond()).to.eq(newBond.target);
         });
+
         it("should emit reserve synced", async function () {
-          await expect(tx).to.emit(perp, "ReserveSynced").withArgs(newTranche.address, toFixedPtAmt("250"));
+          await expect(txFn()).to.emit(perp, "ReserveSynced").withArgs(newTranche.target, toFixedPtAmt("250"));
         });
         it("should update the reserve", async function () {
-          await checkReserveComposition(
+          await txFn();
+          await checkPerpComposition(
             perp,
             [collateralToken, depositTrancheA, newTranche],
             ["0", toFixedPtAmt("200"), toFixedPtAmt("250")],
           );
         });
         it("should update the total supply", async function () {
+          await txFn();
           expect(await perp.totalSupply()).to.eq(toFixedPtAmt("450"));
         });
       });
     });
-
-    describe("when fee is set", function () {
-      beforeEach(async function () {
-        await feePolicy.computePerpMintFeePerc.returns(toPercFixedPtAmt("0.01"));
-      });
-      it("should mint perp tokens", async function () {
-        await expect(() => perp.deposit(depositTrancheA.address, toFixedPtAmt("500"))).to.changeTokenBalance(
-          perp,
-          deployer,
-          toFixedPtAmt("495"),
-        );
-      });
-      it("should transfer the tranches in", async function () {
-        await expect(() => perp.deposit(depositTrancheA.address, toFixedPtAmt("500"))).to.changeTokenBalances(
-          depositTrancheA,
-          [deployer, perp],
-          [toFixedPtAmt("-500"), toFixedPtAmt("500")],
-        );
-      });
-      it("should return the mintAmt", async function () {
-        const r = await perp.callStatic.computeMintAmt(depositTrancheA.address, toFixedPtAmt("500"));
-        expect(r).to.eq(toFixedPtAmt("495"));
-      });
-    });
-
-    describe("when fee is set and caller is the vault", function () {
-      let mockVault: Contract;
-      beforeEach(async function () {
-        const MockVault = await ethers.getContractFactory("MockVault");
-        mockVault = await MockVault.deploy();
-        await perp.updateVault(mockVault.address);
-        await depositTrancheA.approve(mockVault.address, toFixedPtAmt("500"));
-        await feePolicy.computePerpMintFeePerc.returns(toPercFixedPtAmt("1"));
-      });
-      it("should mint perp tokens", async function () {
-        await expect(() =>
-          mockVault.mintPerps(perp.address, depositTrancheA.address, toFixedPtAmt("500")),
-        ).to.changeTokenBalance(perp, deployer, toFixedPtAmt("500"));
-      });
-      it("should transfer the tranches in", async function () {
-        await expect(() =>
-          mockVault.mintPerps(perp.address, depositTrancheA.address, toFixedPtAmt("500")),
-        ).to.changeTokenBalances(depositTrancheA, [deployer, perp], [toFixedPtAmt("-500"), toFixedPtAmt("500")]);
-      });
-      it("should return the mintAmt", async function () {
-        const r = await mockVault.callStatic.computePerpMintAmt(
-          perp.address,
-          depositTrancheA.address,
-          toFixedPtAmt("500"),
-        );
-        expect(r).to.eq(toFixedPtAmt("500"));
-      });
-    });
   });
 });
diff --git a/spot-contracts/test/perp/PerpetualTranche_redeem.ts b/spot-contracts/test/perp/PerpetualTranche_redeem.ts
index 61291431..3143131c 100644
--- a/spot-contracts/test/perp/PerpetualTranche_redeem.ts
+++ b/spot-contracts/test/perp/PerpetualTranche_redeem.ts
@@ -1,28 +1,29 @@
-import { expect, use } from "chai";
+import { expect } from "chai";
 import { network, ethers, upgrades } from "hardhat";
 import { Contract, Transaction, Signer } from "ethers";
-import { smock } from "@defi-wonderland/smock";
 import {
   setupCollateralToken,
   setupBondFactory,
   depositIntoBond,
   bondAt,
   getTranches,
-  toPercFixedPtAmt,
   toFixedPtAmt,
   advancePerpQueue,
-  checkReserveComposition,
+  advancePerpQueueUpToBondMaturity,
+  checkPerpComposition,
   rebase,
   mintCollteralToken,
+  mintPerps,
+  redeemPerps,
+  DMock,
 } from "../helpers";
-use(smock.matchers);
 
 let perp: Contract,
   bondFactory: Contract,
   collateralToken: Contract,
   rebaseOracle: Contract,
   issuer: Contract,
-  feePolicy: Contract,
+  balancer: Contract,
   deployer: Signer,
   otherUser: Signer,
   deployerAddress: string,
@@ -31,7 +32,7 @@ let perp: Contract,
 
 describe("PerpetualTranche", function () {
   beforeEach(async function () {
-    await network.provider.send("hardhat_reset");
+    await network.provider.request({ method: "hardhat_reset" });
 
     const accounts = await ethers.getSigners();
     deployer = accounts[0];
@@ -44,93 +45,91 @@ describe("PerpetualTranche", function () {
     const BondIssuer = await ethers.getContractFactory("BondIssuer");
     issuer = await upgrades.deployProxy(
       BondIssuer.connect(deployer),
-      [bondFactory.address, collateralToken.address, 3600, [500, 500], 1200, 0],
+      [bondFactory.target, collateralToken.target, 3600, [500, 500], 1200, 0],
       {
         initializer: "init(address,address,uint256,uint256[],uint256,uint256)",
       },
     );
 
-    const FeePolicy = await ethers.getContractFactory("FeePolicy");
-    feePolicy = await smock.fake(FeePolicy);
-    await feePolicy.decimals.returns(8);
-
     const PerpetualTranche = await ethers.getContractFactory("PerpetualTranche");
     perp = await upgrades.deployProxy(
       PerpetualTranche.connect(deployer),
-      ["PerpetualTranche", "PERP", collateralToken.address, issuer.address, feePolicy.address],
+      ["PerpetualTranche", "PERP", collateralToken.target, issuer.target],
       {
-        initializer: "init(string,string,address,address,address)",
+        initializer: "init(string,string,address,address)",
       },
     );
+    await perp.updateTolerableTrancheMaturity(1200, 3600);
     await advancePerpQueue(perp, 3600);
+    await perp.updateState();
+
+    balancer = new DMock(await ethers.getContractFactory("Balancer"));
+    await balancer.deploy();
+    await balancer.mockMethod("decimals()", [8]);
 
-    const RolloverVault = await ethers.getContractFactory("RolloverVault");
-    const vault = await smock.fake(RolloverVault);
-    await vault.getTVL.returns("0");
-    await perp.updateVault(vault.address);
+    await perp.updateBalancer(balancer.target);
+    await perp.updateVault(deployerAddress);
 
-    depositBond = await bondAt(await perp.callStatic.getDepositBond());
+    depositBond = await bondAt(await perp.depositBond());
     [initialDepositTranche] = await getTranches(depositBond);
 
     await depositIntoBond(depositBond, toFixedPtAmt("1000"), deployer);
-    await initialDepositTranche.approve(perp.address, toFixedPtAmt("500"));
-    await perp.deposit(initialDepositTranche.address, toFixedPtAmt("500"));
-    await feePolicy.computePerpBurnFeePerc.returns("0");
+    await mintPerps(perp, initialDepositTranche, toFixedPtAmt("500"), deployer);
+
     await mintCollteralToken(collateralToken, toFixedPtAmt("1000"), deployer);
   });
 
   afterEach(async function () {
-    await network.provider.send("hardhat_reset");
+    await network.provider.request({ method: "hardhat_reset" });
   });
 
   describe("#burn", function () {
     it("should burn tokens without redemption", async function () {
-      await checkReserveComposition(perp, [collateralToken, initialDepositTranche], ["0", toFixedPtAmt("500")]);
+      await checkPerpComposition(perp, [collateralToken, initialDepositTranche], ["0", toFixedPtAmt("500")]);
       expect(await perp.balanceOf(deployerAddress)).to.eq(toFixedPtAmt("500"));
       await perp.burn(toFixedPtAmt("500"));
       expect(await perp.balanceOf(deployerAddress)).to.eq("0");
-      await checkReserveComposition(perp, [collateralToken, initialDepositTranche], ["0", toFixedPtAmt("500")]);
+      await checkPerpComposition(perp, [collateralToken, initialDepositTranche], ["0", toFixedPtAmt("500")]);
     });
   });
 
   describe("#burnFrom", function () {
     it("should burn tokens without redemption from authorized wallet", async function () {
-      await checkReserveComposition(perp, [collateralToken, initialDepositTranche], ["0", toFixedPtAmt("500")]);
+      await checkPerpComposition(perp, [collateralToken, initialDepositTranche], ["0", toFixedPtAmt("500")]);
       expect(await perp.balanceOf(deployerAddress)).to.eq(toFixedPtAmt("500"));
       await perp.approve(await otherUser.getAddress(), toFixedPtAmt("500"));
       await perp.connect(otherUser).burnFrom(deployerAddress, toFixedPtAmt("200"));
       expect(await perp.balanceOf(deployerAddress)).to.eq(toFixedPtAmt("300"));
       expect(await perp.allowance(deployerAddress, await otherUser.getAddress())).to.eq(toFixedPtAmt("300"));
-      await checkReserveComposition(perp, [collateralToken, initialDepositTranche], ["0", toFixedPtAmt("500")]);
+      await checkPerpComposition(perp, [collateralToken, initialDepositTranche], ["0", toFixedPtAmt("500")]);
     });
   });
 
   describe("#redeem", function () {
     describe("when paused", function () {
       beforeEach(async function () {
-        await perp.updateKeeper(deployerAddress);
         await perp.pause();
       });
 
       it("should revert", async function () {
-        await expect(perp.redeem(toFixedPtAmt("500"))).to.be.revertedWith("Pausable: paused");
+        await expect(redeemPerps(perp, toFixedPtAmt("500"), deployer)).to.be.revertedWith("Pausable: paused");
       });
     });
 
     describe("when user has insufficient balance", function () {
       beforeEach(async function () {
-        await perp.redeem(toFixedPtAmt("250"));
+        await redeemPerps(perp, toFixedPtAmt("250"), deployer);
       });
 
       it("should revert", async function () {
         expect(await perp.balanceOf(deployerAddress)).to.lte(toFixedPtAmt("500"));
-        await expect(perp.redeem(toFixedPtAmt("500"))).to.be.reverted;
+        await expect(redeemPerps(perp, toFixedPtAmt("500"), deployer)).to.be.reverted;
       });
     });
 
     describe("when requested amount is zero", function () {
       it("should return without redeeming", async function () {
-        expect(await perp.callStatic.redeem("0")).to.deep.eq([]);
+        expect(await perp.redeem.staticCall("0")).to.deep.eq([]);
       });
     });
 
@@ -140,47 +139,40 @@ describe("PerpetualTranche", function () {
       });
 
       it("should revert", async function () {
-        await expect(perp.redeem(toFixedPtAmt("100"))).to.be.reverted;
+        await expect(redeemPerps(perp, toFixedPtAmt("100"), deployer)).to.be.reverted;
       });
 
       it("should revert", async function () {
-        await expect(perp.callStatic.computeRedemptionAmts(toFixedPtAmt("100"))).to.be.reverted;
+        await expect(perp.computeRedemptionAmts.staticCall(toFixedPtAmt("100"))).to.be.reverted;
       });
     });
 
     describe("on successful redeem", function () {
       it("should burn perp tokens", async function () {
-        await expect(() => perp.redeem(toFixedPtAmt("500"))).to.changeTokenBalance(
+        await expect(() => redeemPerps(perp, toFixedPtAmt("500"), deployer)).to.changeTokenBalance(
           perp,
           deployer,
           toFixedPtAmt("-500"),
         );
       });
       it("should transfer the tranches out", async function () {
-        await expect(() => perp.redeem(toFixedPtAmt("500"))).to.changeTokenBalances(
+        await expect(() => redeemPerps(perp, toFixedPtAmt("500"), deployer)).to.changeTokenBalances(
           initialDepositTranche,
           [deployer, perp],
           [toFixedPtAmt("500"), toFixedPtAmt("-500")],
         );
       });
       it("should emit reserve synced", async function () {
-        await expect(perp.redeem(toFixedPtAmt("500")))
+        await expect(redeemPerps(perp, toFixedPtAmt("500"), deployer))
           .to.emit(perp, "ReserveSynced")
-          .withArgs(collateralToken.address, "0")
+          .withArgs(collateralToken.target, "0")
           .to.emit(perp, "ReserveSynced")
-          .withArgs(initialDepositTranche.address, "0");
-      });
-      it("should return the redemption amounts", async function () {
-        const r = await perp.callStatic.redeem(toFixedPtAmt("500"));
-        expect(r[0].token).to.eq(collateralToken.address);
-        expect(r[1].token).to.eq(initialDepositTranche.address);
-        expect(r[0].amount).to.eq("0");
-        expect(r[1].amount).to.eq(toFixedPtAmt("500"));
+          .withArgs(initialDepositTranche.target, "0");
       });
       it("should return the redemption amounts", async function () {
-        const r = await perp.callStatic.computeRedemptionAmts(toFixedPtAmt("500"));
-        expect(r[0].token).to.eq(collateralToken.address);
-        expect(r[1].token).to.eq(initialDepositTranche.address);
+        const r = await perp.computeRedemptionAmts.staticCall(toFixedPtAmt("500"));
+        expect(r[0].token).to.eq(collateralToken.target);
+        expect(r[1].token).to.eq(initialDepositTranche.target);
         expect(r[0].amount).to.eq("0");
         expect(r[1].amount).to.eq(toFixedPtAmt("500"));
       });
@@ -189,31 +181,28 @@ describe("PerpetualTranche", function () {
     describe("when reserve has more than one tranche", function () {
       let newRedemptionTranche: Contract, txFn: Promise<Transaction>;
       beforeEach(async function () {
-        await perp.updateTolerableTrancheMaturity(1200, 3600);
-
         await advancePerpQueue(perp, 1200);
 
-        const newBond = await bondAt(await perp.callStatic.getDepositBond());
+        const newBond = await bondAt(await perp.depositBond());
         await depositIntoBond(newBond, toFixedPtAmt("1000"), deployer);
         const tranches = await getTranches(newBond);
         newRedemptionTranche = tranches[0];
 
-        await newRedemptionTranche.approve(perp.address, toFixedPtAmt("500"));
-        await perp.deposit(newRedemptionTranche.address, toFixedPtAmt("500"));
+        await mintPerps(perp, newRedemptionTranche, toFixedPtAmt("500"), deployer);
 
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, initialDepositTranche, newRedemptionTranche],
           ["0", toFixedPtAmt("500"), toFixedPtAmt("500")],
         );
         expect(await perp.totalSupply()).to.eq(toFixedPtAmt("1000"));
 
-        txFn = () => perp.redeem(toFixedPtAmt("375"));
+        txFn = () => redeemPerps(perp, toFixedPtAmt("375"), deployer);
       });
 
       it("should update the reserve composition", async function () {
         await txFn();
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, initialDepositTranche, newRedemptionTranche],
           ["0", toFixedPtAmt("312.5"), toFixedPtAmt("312.5")],
@@ -253,31 +242,29 @@ describe("PerpetualTranche", function () {
     describe("when reserve has mature collateral and tranches", function () {
       let newRedemptionTranche: Contract, txFn: Promise<Transaction>;
       beforeEach(async function () {
-        await perp.updateTolerableTrancheMaturity(1200, 3600);
         await advancePerpQueue(perp, 1200);
 
-        const newBond = await bondAt(await perp.callStatic.getDepositBond());
+        const newBond = await bondAt(await perp.depositBond());
         await depositIntoBond(newBond, toFixedPtAmt("1000"), deployer);
         const tranches = await getTranches(newBond);
         newRedemptionTranche = tranches[0];
 
-        await newRedemptionTranche.approve(perp.address, toFixedPtAmt("500"));
-        await perp.deposit(newRedemptionTranche.address, toFixedPtAmt("500"));
+        await mintPerps(perp, newRedemptionTranche, toFixedPtAmt("500"), deployer);
 
-        await collateralToken.transfer(perp.address, toFixedPtAmt("100"));
-        await checkReserveComposition(
+        await collateralToken.transfer(perp.target, toFixedPtAmt("100"));
+        await checkPerpComposition(
           perp,
           [collateralToken, initialDepositTranche, newRedemptionTranche],
           [toFixedPtAmt("100"), toFixedPtAmt("500"), toFixedPtAmt("500")],
         );
         expect(await perp.totalSupply()).to.eq(toFixedPtAmt("1000"));
 
-        txFn = () => perp.redeem(toFixedPtAmt("500"));
+        txFn = () => redeemPerps(perp, toFixedPtAmt("500"), deployer);
       });
 
       it("should update the reserve composition", async function () {
         await txFn();
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, initialDepositTranche, newRedemptionTranche],
           [toFixedPtAmt("50"), toFixedPtAmt("250"), toFixedPtAmt("250")],
@@ -320,19 +307,16 @@ describe("PerpetualTranche", function () {
     describe("when the collateralToken balance has rebased up", function () {
       let newRedemptionTranche: Contract, txFn: Promise<Transaction>;
       beforeEach(async function () {
-        await perp.updateTolerableTrancheMaturity(1200, 3600);
-
         await advancePerpQueue(perp, 1200);
 
-        const newBond = await bondAt(await perp.callStatic.getDepositBond());
+        const newBond = await bondAt(await perp.depositBond());
         await depositIntoBond(newBond, toFixedPtAmt("1000"), deployer);
         const tranches = await getTranches(newBond);
         newRedemptionTranche = tranches[0];
 
-        await newRedemptionTranche.approve(perp.address, toFixedPtAmt("500"));
-        await perp.deposit(newRedemptionTranche.address, toFixedPtAmt("500"));
+        await mintPerps(perp, newRedemptionTranche, toFixedPtAmt("500"), deployer);
 
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, initialDepositTranche, newRedemptionTranche],
           ["0", toFixedPtAmt("500"), toFixedPtAmt("500")],
@@ -340,19 +324,19 @@ describe("PerpetualTranche", function () {
 
         await advancePerpQueue(perp, 2400);
         await rebase(collateralToken, rebaseOracle, +0.5);
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, newRedemptionTranche],
           [toFixedPtAmt("750"), toFixedPtAmt("500")],
         );
         expect(await perp.totalSupply()).to.eq(toFixedPtAmt("1000"));
 
-        txFn = () => perp.redeem(toFixedPtAmt("375"));
+        txFn = () => redeemPerps(perp, toFixedPtAmt("375"), deployer);
       });
 
       it("should update the reserve composition", async function () {
         await txFn();
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, newRedemptionTranche],
           [toFixedPtAmt("468.75"), toFixedPtAmt("312.5")],
@@ -384,19 +368,16 @@ describe("PerpetualTranche", function () {
     describe("when the collateralToken balance has rebased down", function () {
       let newRedemptionTranche: Contract, txFn: Promise<Transaction>;
       beforeEach(async function () {
-        await perp.updateTolerableTrancheMaturity(1200, 3600);
-
         await advancePerpQueue(perp, 1200);
 
-        const newBond = await bondAt(await perp.callStatic.getDepositBond());
+        const newBond = await bondAt(await perp.depositBond());
         await depositIntoBond(newBond, toFixedPtAmt("1000"), deployer);
         const tranches = await getTranches(newBond);
         newRedemptionTranche = tranches[0];
 
-        await newRedemptionTranche.approve(perp.address, toFixedPtAmt("500"));
-        await perp.deposit(newRedemptionTranche.address, toFixedPtAmt("500"));
+        await mintPerps(perp, newRedemptionTranche, toFixedPtAmt("500"), deployer);
 
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, initialDepositTranche, newRedemptionTranche],
           ["0", toFixedPtAmt("500"), toFixedPtAmt("500")],
@@ -404,19 +385,19 @@ describe("PerpetualTranche", function () {
 
         await advancePerpQueue(perp, 2400);
         await rebase(collateralToken, rebaseOracle, -0.5);
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, newRedemptionTranche],
           [toFixedPtAmt("250"), toFixedPtAmt("500")],
         );
         expect(await perp.totalSupply()).to.eq(toFixedPtAmt("1000"));
 
-        txFn = () => perp.redeem(toFixedPtAmt("375"));
+        txFn = () => redeemPerps(perp, toFixedPtAmt("375"), deployer);
       });
 
       it("should update the reserve composition", async function () {
         await txFn();
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, newRedemptionTranche],
           [toFixedPtAmt("156.25"), toFixedPtAmt("312.5")],
@@ -444,34 +425,31 @@ describe("PerpetualTranche", function () {
     describe("when reserve has only mature collateral", function () {
       let newRedemptionTranche: Contract, txFn: Promise<Transaction>;
       beforeEach(async function () {
-        await perp.updateTolerableTrancheMaturity(1200, 3600);
-
         await advancePerpQueue(perp, 1200);
 
-        const newBond = await bondAt(await perp.callStatic.getDepositBond());
+        const newBond = await bondAt(await perp.depositBond());
         await depositIntoBond(newBond, toFixedPtAmt("1000"), deployer);
         const tranches = await getTranches(newBond);
         newRedemptionTranche = tranches[0];
 
-        await newRedemptionTranche.approve(perp.address, toFixedPtAmt("500"));
-        await perp.deposit(newRedemptionTranche.address, toFixedPtAmt("500"));
+        await mintPerps(perp, newRedemptionTranche, toFixedPtAmt("500"), deployer);
 
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, initialDepositTranche, newRedemptionTranche],
           ["0", toFixedPtAmt("500"), toFixedPtAmt("500")],
         );
         await advancePerpQueue(perp, 7200);
 
-        await checkReserveComposition(perp, [collateralToken], [toFixedPtAmt("1000")]);
+        await checkPerpComposition(perp, [collateralToken], [toFixedPtAmt("1000")]);
         expect(await perp.totalSupply()).to.eq(toFixedPtAmt("1000"));
 
-        txFn = () => perp.redeem(toFixedPtAmt("375"));
+        txFn = () => redeemPerps(perp, toFixedPtAmt("375"), deployer);
       });
 
       it("should update the reserve composition", async function () {
         await txFn();
-        await checkReserveComposition(perp, [collateralToken], [toFixedPtAmt("625")]);
+        await checkPerpComposition(perp, [collateralToken], [toFixedPtAmt("625")]);
       });
 
       it("should transfer tokens out", async function () {
@@ -495,19 +473,16 @@ describe("PerpetualTranche", function () {
     describe("when redeeming entire supply", function () {
       let newRedemptionTranche: Contract, txFn: Promise<Transaction>;
       beforeEach(async function () {
-        await perp.updateTolerableTrancheMaturity(1200, 3600);
-
         await advancePerpQueue(perp, 1200);
 
-        const newBond = await bondAt(await perp.callStatic.getDepositBond());
+        const newBond = await bondAt(await perp.depositBond());
         await depositIntoBond(newBond, toFixedPtAmt("1000"), deployer);
         const tranches = await getTranches(newBond);
         newRedemptionTranche = tranches[0];
 
-        await newRedemptionTranche.approve(perp.address, toFixedPtAmt("500"));
-        await perp.deposit(newRedemptionTranche.address, toFixedPtAmt("500"));
+        await mintPerps(perp, newRedemptionTranche, toFixedPtAmt("500"), deployer);
 
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, initialDepositTranche, newRedemptionTranche],
           ["0", toFixedPtAmt("500"), toFixedPtAmt("500")],
@@ -515,12 +490,12 @@ describe("PerpetualTranche", function () {
         expect(await perp.totalSupply()).to.eq(toFixedPtAmt("1000"));
 
         const bal = await perp.balanceOf(deployerAddress);
-        txFn = () => perp.redeem(bal);
+        txFn = () => redeemPerps(perp, bal, deployer);
       });
 
       it("should update the reserve composition", async function () {
         await txFn();
-        await checkReserveComposition(perp, [collateralToken], ["0"]);
+        await checkPerpComposition(perp, [collateralToken], ["0"]);
       });
 
       it("should transfer tokens out", async function () {
@@ -553,119 +528,43 @@ describe("PerpetualTranche", function () {
       });
     });
 
-    describe("when fee is set", function () {
+    describe("when redeeming a tranche which has matured but has not been recovered", function () {
       let newRedemptionTranche: Contract, txFn: Promise<Transaction>;
       beforeEach(async function () {
-        await perp.updateTolerableTrancheMaturity(1200, 3600);
         await advancePerpQueue(perp, 1200);
 
-        const newBond = await bondAt(await perp.callStatic.getDepositBond());
+        const newBond = await bondAt(await perp.depositBond());
         await depositIntoBond(newBond, toFixedPtAmt("1000"), deployer);
         const tranches = await getTranches(newBond);
         newRedemptionTranche = tranches[0];
 
-        await newRedemptionTranche.approve(perp.address, toFixedPtAmt("500"));
-        await perp.deposit(newRedemptionTranche.address, toFixedPtAmt("500"));
+        await mintPerps(perp, newRedemptionTranche, toFixedPtAmt("500"), deployer);
 
-        await collateralToken.transfer(perp.address, toFixedPtAmt("100"));
-        await checkReserveComposition(
+        await collateralToken.transfer(perp.target, toFixedPtAmt("100"));
+        await checkPerpComposition(
           perp,
           [collateralToken, initialDepositTranche, newRedemptionTranche],
           [toFixedPtAmt("100"), toFixedPtAmt("500"), toFixedPtAmt("500")],
         );
         expect(await perp.totalSupply()).to.eq(toFixedPtAmt("1000"));
 
-        await feePolicy.computePerpBurnFeePerc.returns(toPercFixedPtAmt("0.1"));
-        txFn = () => perp.redeem(toFixedPtAmt("500"));
+        await advancePerpQueueUpToBondMaturity(perp, depositBond);
+        txFn = () => redeemPerps(perp, toFixedPtAmt("500"), deployer);
       });
 
       it("should update the reserve composition", async function () {
         await txFn();
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
-          [collateralToken, initialDepositTranche, newRedemptionTranche],
-          [toFixedPtAmt("55"), toFixedPtAmt("275"), toFixedPtAmt("275")],
-        );
-      });
-
-      it("should transfer tokens out", async function () {
-        await expect(txFn).to.changeTokenBalances(
-          collateralToken,
-          [deployer, perp],
-          [toFixedPtAmt("45"), toFixedPtAmt("-45")],
-        );
-      });
-
-      it("should transfer tokens out", async function () {
-        await expect(txFn).to.changeTokenBalances(
-          initialDepositTranche,
-          [deployer, perp],
-          [toFixedPtAmt("225"), toFixedPtAmt("-225")],
-        );
-      });
-
-      it("should transfer tokens out", async function () {
-        await expect(txFn).to.changeTokenBalances(
-          newRedemptionTranche,
-          [deployer, perp],
-          [toFixedPtAmt("225"), toFixedPtAmt("-225")],
-        );
-      });
-
-      it("should update the total supply", async function () {
-        await txFn();
-        expect(await perp.totalSupply()).to.eq(toFixedPtAmt("500"));
-      });
-
-      it("should burn perp tokens", async function () {
-        await expect(txFn).to.changeTokenBalances(perp, [deployer], [toFixedPtAmt("-500")]);
-      });
-    });
-
-    describe("when fee is set and caller is vault", function () {
-      let newRedemptionTranche: Contract, txFn: Promise<Transaction>, mockVault: Contract;
-      beforeEach(async function () {
-        await perp.updateTolerableTrancheMaturity(1200, 3600);
-        await advancePerpQueue(perp, 1200);
-
-        const newBond = await bondAt(await perp.callStatic.getDepositBond());
-        await depositIntoBond(newBond, toFixedPtAmt("1000"), deployer);
-        const tranches = await getTranches(newBond);
-        newRedemptionTranche = tranches[0];
-
-        await newRedemptionTranche.approve(perp.address, toFixedPtAmt("500"));
-        await perp.deposit(newRedemptionTranche.address, toFixedPtAmt("500"));
-
-        await collateralToken.transfer(perp.address, toFixedPtAmt("100"));
-        await checkReserveComposition(
-          perp,
-          [collateralToken, initialDepositTranche, newRedemptionTranche],
-          [toFixedPtAmt("100"), toFixedPtAmt("500"), toFixedPtAmt("500")],
-        );
-        expect(await perp.totalSupply()).to.eq(toFixedPtAmt("1000"));
-        await feePolicy.computePerpBurnFeePerc.returns(toPercFixedPtAmt("1"));
-
-        const MockVault = await ethers.getContractFactory("MockVault");
-        mockVault = await MockVault.deploy();
-        await perp.updateVault(mockVault.address);
-        await perp.approve(mockVault.address, toFixedPtAmt("500"));
-        txFn = () => mockVault.redeemPerps(perp.address, toFixedPtAmt("500"));
-      });
-
-      it("should update the reserve composition", async function () {
-        await txFn();
-        await checkReserveComposition(
-          perp,
-          [collateralToken, initialDepositTranche, newRedemptionTranche],
-          [toFixedPtAmt("50"), toFixedPtAmt("250"), toFixedPtAmt("250")],
+          [collateralToken, newRedemptionTranche],
+          [toFixedPtAmt("300"), toFixedPtAmt("250")],
         );
       });
-
       it("should transfer tokens out", async function () {
         await expect(txFn).to.changeTokenBalances(
           collateralToken,
           [deployer, perp],
-          [toFixedPtAmt("50"), toFixedPtAmt("-50")],
+          [toFixedPtAmt("300"), toFixedPtAmt("200")],
         );
       });
 
@@ -673,7 +572,7 @@ describe("PerpetualTranche", function () {
         await expect(txFn).to.changeTokenBalances(
           initialDepositTranche,
           [deployer, perp],
-          [toFixedPtAmt("250"), toFixedPtAmt("-250")],
+          [toFixedPtAmt("0"), toFixedPtAmt("-500")],
         );
       });
 
@@ -693,16 +592,6 @@ describe("PerpetualTranche", function () {
       it("should burn perp tokens", async function () {
         await expect(txFn).to.changeTokenBalances(perp, [deployer], [toFixedPtAmt("-500")]);
       });
-
-      it("should return the redemption amounts", async function () {
-        const r = await mockVault.callStatic.computePerpRedemptionAmts(perp.address, toFixedPtAmt("500"));
-        expect(r[0].token).to.eq(collateralToken.address);
-        expect(r[1].token).to.eq(initialDepositTranche.address);
-        expect(r[2].token).to.eq(newRedemptionTranche.address);
-        expect(r[0].amount).to.eq(toFixedPtAmt("50"));
-        expect(r[1].amount).to.eq(toFixedPtAmt("250"));
-        expect(r[2].amount).to.eq(toFixedPtAmt("250"));
-      });
     });
   });
 });
diff --git a/spot-contracts/test/perp/PerpetualTranche_rollover.ts b/spot-contracts/test/perp/PerpetualTranche_rollover.ts
index c6a2787d..202448da 100644
--- a/spot-contracts/test/perp/PerpetualTranche_rollover.ts
+++ b/spot-contracts/test/perp/PerpetualTranche_rollover.ts
@@ -1,7 +1,6 @@
-import { expect, use } from "chai";
+import { expect } from "chai";
 import { network, ethers, upgrades } from "hardhat";
 import { Contract, Transaction, Signer } from "ethers";
-import { smock } from "@defi-wonderland/smock";
 import {
   setupCollateralToken,
   setupBondFactory,
@@ -14,18 +13,18 @@ import {
   advancePerpQueue,
   advancePerpQueueToBondMaturity,
   advancePerpQueueToRollover,
-  checkReserveComposition,
+  checkPerpComposition,
   rebase,
   mintCollteralToken,
+  DMock,
 } from "../helpers";
-use(smock.matchers);
 
 let perp: Contract,
   bondFactory: Contract,
   collateralToken: Contract,
   rebaseOracle: Contract,
   issuer: Contract,
-  feePolicy: Contract,
+  balancer: DMock,
   deployer: Signer,
   deployerAddress: string,
   holdingPenBond: Contract,
@@ -38,7 +37,7 @@ let perp: Contract,
 
 describe("PerpetualTranche", function () {
   beforeEach(async function () {
-    await network.provider.send("hardhat_reset");
+    await network.provider.request({ method: "hardhat_reset" });
 
     const accounts = await ethers.getSigners();
     deployer = accounts[0];
@@ -50,101 +49,101 @@ describe("PerpetualTranche", function () {
     const BondIssuer = await ethers.getContractFactory("BondIssuer");
     issuer = await upgrades.deployProxy(
       BondIssuer.connect(deployer),
-      [bondFactory.address, collateralToken.address, 10800, [500, 500], 1200, 0],
+      [bondFactory.target, collateralToken.target, 10800, [500, 500], 1200, 0],
       {
         initializer: "init(address,address,uint256,uint256[],uint256,uint256)",
       },
     );
 
-    const FeePolicy = await ethers.getContractFactory("FeePolicy");
-    feePolicy = await smock.fake(FeePolicy);
-    await feePolicy.decimals.returns(8);
-
-    const MockVault = await ethers.getContractFactory("MockVault");
-    mockVault = await MockVault.deploy();
-
     const PerpetualTranche = await ethers.getContractFactory("PerpetualTranche");
     perp = await upgrades.deployProxy(
       PerpetualTranche.connect(deployer),
-      ["PerpetualTranche", "PERP", collateralToken.address, issuer.address, feePolicy.address],
+      ["PerpetualTranche", "PERP", collateralToken.target, issuer.target],
       {
-        initializer: "init(string,string,address,address,address)",
+        initializer: "init(string,string,address,address)",
       },
     );
 
     await perp.updateTolerableTrancheMaturity(1200, 10800);
     await advancePerpQueue(perp, 10900);
-    await perp.updateVault(mockVault.address);
 
-    holdingPenBond = await bondAt(await perp.callStatic.getDepositBond());
-    [holdingPenTranche1] = await getTranches(holdingPenBond);
+    const Vault = await ethers.getContractFactory("MockVault");
+    mockVault = await Vault.deploy();
+    await perp.updateVault(mockVault.target);
 
-    await depositIntoBond(holdingPenBond, toFixedPtAmt("2000"), deployer);
+    balancer = new DMock(await ethers.getContractFactory("Balancer"));
+    await balancer.deploy();
+    await balancer.mockMethod("decimals()", [8]);
+    await balancer.mockMethod("computePerpRolloverFeePerc(uint256)", [0n]);
+    await balancer.mockMethod("computeDeviationRatio(uint256,uint256,uint256)", [toPercFixedPtAmt("1")]);
+
+    await perp.updateVault(deployerAddress);
 
-    await holdingPenTranche1.approve(perp.address, toFixedPtAmt("500"));
-    await perp.deposit(holdingPenTranche1.address, toFixedPtAmt("500"));
+    holdingPenBond = await bondAt(await perp.depositBond());
+    [holdingPenTranche1] = await getTranches(holdingPenBond);
+    await depositIntoBond(holdingPenBond, toFixedPtAmt("2000"), deployer);
 
+    await holdingPenTranche1.approve(perp.target, toFixedPtAmt("500"));
+    await perp.deposit(holdingPenTranche1.target, toFixedPtAmt("500"));
     await advancePerpQueue(perp, 1200);
 
-    reserveBond = await bondAt(await perp.callStatic.getDepositBond());
+    reserveBond = await bondAt(await perp.depositBond());
     [reserveTranche] = await getTranches(reserveBond);
-
     await depositIntoBond(reserveBond, toFixedPtAmt("2000"), deployer);
 
-    await reserveTranche.approve(perp.address, toFixedPtAmt("500"));
-    await perp.deposit(reserveTranche.address, toFixedPtAmt("500"));
+    await reserveTranche.approve(perp.target, toFixedPtAmt("500"));
+    await perp.deposit(reserveTranche.target, toFixedPtAmt("500"));
     await advancePerpQueueToBondMaturity(perp, holdingPenBond);
 
-    rolloverInBond = await bondAt(await perp.callStatic.getDepositBond());
+    rolloverInBond = await bondAt(await perp.depositBond());
     [rolloverInTranche] = await getTranches(rolloverInBond);
-
     await depositIntoBond(rolloverInBond, toFixedPtAmt("5000"), deployer);
-    await rolloverInTranche.approve(perp.address, toFixedPtAmt("5000"));
-    await perp.deposit(rolloverInTranche.address, toFixedPtAmt("500"));
-
-    await checkReserveComposition(
+    await rolloverInTranche.approve(perp.target, toFixedPtAmt("5000"));
+    await perp.deposit(rolloverInTranche.target, toFixedPtAmt("500"));
+    await checkPerpComposition(
       perp,
       [collateralToken, reserveTranche, rolloverInTranche],
       [toFixedPtAmt("500"), toFixedPtAmt("500"), toFixedPtAmt("500")],
     );
 
-    await rolloverInTranche.approve(mockVault.address, toFixedPtAmt("5000"));
-    await reserveTranche.approve(mockVault.address, toFixedPtAmt("5000"));
+    await rolloverInTranche.approve(mockVault.target, toFixedPtAmt("5000"));
+    await reserveTranche.approve(mockVault.target, toFixedPtAmt("5000"));
+    await perp.updateBalancer(balancer.target);
+    await perp.updateVault(mockVault.target);
   });
 
   afterEach(async function () {
-    await network.provider.send("hardhat_reset");
+    await network.provider.request({ method: "hardhat_reset" });
   });
 
   describe("#rollover", function () {
     describe("when paused", function () {
       beforeEach(async function () {
-        await perp.updateKeeper(deployerAddress);
         await perp.pause();
       });
 
       it("should revert", async function () {
         await expect(
-          mockVault.rollover(perp.address, rolloverInTranche.address, reserveTranche.address, toFixedPtAmt("500")),
+          mockVault.rollover(perp.target, rolloverInTranche.target, reserveTranche.target, toFixedPtAmt("500")),
         ).to.revertedWith("Pausable: paused");
       });
     });
 
     describe("when rollover vault reference is set", function () {
       beforeEach(async function () {
-        await perp.updateVault(mockVault.address);
+        await perp.updateVault(mockVault.target);
       });
 
       it("should revert when invoked from other addresses", async function () {
         await expect(
-          perp.rollover(rolloverInTranche.address, reserveTranche.address, toFixedPtAmt("500")),
+          perp.rollover(rolloverInTranche.target, reserveTranche.target, toFixedPtAmt("500")),
         ).to.revertedWithCustomError(perp, "UnauthorizedCall");
       });
 
       it("should NOT revert when invoked from the vault ", async function () {
-        await rolloverInTranche.approve(mockVault.address, toFixedPtAmt("500"));
+        await rolloverInTranche.approve(mockVault.target, toFixedPtAmt("500"));
         await expect(
-          mockVault.rollover(perp.address, rolloverInTranche.address, reserveTranche.address, toFixedPtAmt("500")),
+          mockVault.rollover(perp.target, rolloverInTranche.target, reserveTranche.target, toFixedPtAmt("500")),
         ).not.to.be.reverted;
       });
     });
@@ -156,7 +155,7 @@ describe("PerpetualTranche", function () {
       });
       it("should revert", async function () {
         await expect(
-          mockVault.rollover(perp.address, rolloverInTranche.address, tranches[1].address, toFixedPtAmt("500")),
+          mockVault.rollover(perp.target, rolloverInTranche.target, tranches[1].target, toFixedPtAmt("500")),
         ).to.revertedWithCustomError(perp, "UnacceptableRollover");
       });
     });
@@ -164,16 +163,16 @@ describe("PerpetualTranche", function () {
     describe("when trancheIn is NOT of deposit bond", function () {
       it("should revert", async function () {
         await expect(
-          mockVault.rollover(perp.address, reserveTranche.address, collateralToken.address, toFixedPtAmt("500")),
+          mockVault.rollover(perp.target, reserveTranche.target, collateralToken.target, toFixedPtAmt("500")),
         ).to.revertedWithCustomError(perp, "UnacceptableRollover");
         await expect(
-          mockVault.rollover(perp.address, reserveTranche.address, reserveTranche.address, toFixedPtAmt("500")),
+          mockVault.rollover(perp.target, reserveTranche.target, reserveTranche.target, toFixedPtAmt("500")),
         ).to.revertedWithCustomError(perp, "UnacceptableRollover");
         await expect(
-          mockVault.rollover(perp.address, reserveTranche.address, reserveTranche.address, toFixedPtAmt("500")),
+          mockVault.rollover(perp.target, reserveTranche.target, reserveTranche.target, toFixedPtAmt("500")),
         ).to.revertedWithCustomError(perp, "UnacceptableRollover");
         await expect(
-          mockVault.rollover(perp.address, reserveTranche.address, holdingPenTranche1.address, toFixedPtAmt("500")),
+          mockVault.rollover(perp.target, reserveTranche.target, holdingPenTranche1.target, toFixedPtAmt("500")),
         ).to.revertedWithCustomError(perp, "UnacceptableRollover");
       });
     });
@@ -186,7 +185,7 @@ describe("PerpetualTranche", function () {
       });
       it("should revert", async function () {
         await expect(
-          mockVault.rollover(perp.address, rolloverInTranche.address, maliciousTranche.address, toFixedPtAmt("500")),
+          mockVault.rollover(perp.target, rolloverInTranche.target, maliciousTranche.target, toFixedPtAmt("500")),
         ).to.revertedWithCustomError(perp, "UnacceptableRollover");
       });
     });
@@ -195,19 +194,14 @@ describe("PerpetualTranche", function () {
       let newRotationInTranche: Contract;
       beforeEach(async function () {
         await advancePerpQueue(perp, 1200);
-        const newRotationInBond = await bondAt(await perp.callStatic.getDepositBond());
+        const newRotationInBond = await bondAt(await perp.depositBond());
         [newRotationInTranche] = await getTranches(newRotationInBond);
         await depositIntoBond(newRotationInBond, toFixedPtAmt("2000"), deployer);
-        await newRotationInTranche.approve(mockVault.address, toFixedPtAmt("500"));
+        await newRotationInTranche.approve(mockVault.target, toFixedPtAmt("500"));
       });
       it("should revert", async function () {
         await expect(
-          mockVault.rollover(
-            perp.address,
-            newRotationInTranche.address,
-            rolloverInTranche.address,
-            toFixedPtAmt("500"),
-          ),
+          mockVault.rollover(perp.target, newRotationInTranche.target, rolloverInTranche.target, toFixedPtAmt("500")),
         ).to.revertedWithCustomError(perp, "UnacceptableRollover");
       });
     });
@@ -219,12 +213,12 @@ describe("PerpetualTranche", function () {
         maliciousTranche = await ERC20.deploy();
         await maliciousTranche.init("Tranche", "TRA");
         await maliciousTranche.mint(deployerAddress, toFixedPtAmt("500"));
-        await maliciousTranche.setBond(await perp.callStatic.getDepositBond());
-        await maliciousTranche.approve(mockVault.address, toFixedPtAmt("500"));
+        await maliciousTranche.setBond(await perp.depositBond());
+        await maliciousTranche.approve(mockVault.target, toFixedPtAmt("500"));
       });
       it("should revert", async function () {
         await expect(
-          mockVault.rollover(perp.address, maliciousTranche.address, reserveTranche.address, toFixedPtAmt("500")),
+          mockVault.rollover(perp.target, maliciousTranche.target, reserveTranche.target, toFixedPtAmt("500")),
         ).to.revertedWithCustomError(perp, "UnacceptableRollover");
       });
     });
@@ -237,26 +231,26 @@ describe("PerpetualTranche", function () {
       it("should revert", async function () {
         expect(await rolloverInTranche.balanceOf(deployerAddress)).to.lt(toFixedPtAmt("500"));
         await expect(
-          mockVault.rollover(perp.address, rolloverInTranche.address, reserveTranche.address, toFixedPtAmt("500")),
+          mockVault.rollover(perp.target, rolloverInTranche.target, reserveTranche.target, toFixedPtAmt("500")),
         ).to.revertedWith("ERC20: transfer amount exceeds balance");
       });
     });
 
     describe("when approval is insufficient", function () {
       it("should return without rollover", async function () {
-        await rolloverInTranche.transfer(mockVault.address, toFixedPtAmt("500"));
+        await rolloverInTranche.transfer(mockVault.target, toFixedPtAmt("500"));
         await expect(
-          mockVault.callRollover(perp.address, rolloverInTranche.address, reserveTranche.address, toFixedPtAmt("500")),
+          mockVault.callRollover(perp.target, rolloverInTranche.target, reserveTranche.target, toFixedPtAmt("500")),
         ).to.revertedWith("ERC20: transfer amount exceeds allowance");
       });
     });
 
     describe("when trancheInAmt is zero", function () {
       it("should return without rollover", async function () {
-        const r = await mockVault.callStatic.rollover(
-          perp.address,
-          rolloverInTranche.address,
-          reserveTranche.address,
+        const r = await mockVault.rollover.staticCall(
+          perp.target,
+          rolloverInTranche.target,
+          reserveTranche.target,
           "0",
         );
         expect(r.tokenOutAmt).to.eq("0");
@@ -269,12 +263,12 @@ describe("PerpetualTranche", function () {
       beforeEach(async function () {
         const tranches = await getTranches(rolloverInBond);
         newRotationInTranche = tranches[1];
-        await newRotationInTranche.approve(mockVault.address, toFixedPtAmt("500"));
+        await newRotationInTranche.approve(mockVault.target, toFixedPtAmt("500"));
       });
 
       it("should revert", async function () {
         await expect(
-          mockVault.rollover(perp.address, newRotationInTranche.address, reserveTranche.address, toFixedPtAmt("500")),
+          mockVault.rollover(perp.target, newRotationInTranche.target, reserveTranche.target, toFixedPtAmt("500")),
         ).to.revertedWithCustomError(perp, "UnacceptableRollover");
       });
     });
@@ -283,15 +277,11 @@ describe("PerpetualTranche", function () {
       beforeEach(async function () {
         await rebase(collateralToken, rebaseOracle, -0.75);
         await mintCollteralToken(collateralToken, toFixedPtAmt("1000"), deployer);
-        await collateralToken.transfer(perp.address, toFixedPtAmt("1000"));
+        await collateralToken.transfer(perp.target, toFixedPtAmt("1000"));
       });
 
       it("should rollover the correct amount", async function () {
-        const r = await perp.callStatic.computeRolloverAmt(
-          rolloverInTranche.address,
-          collateralToken.address,
-          toFixedPtAmt("500"),
-        );
+        const r = await perp.computeRolloverAmt(rolloverInTranche.target, collateralToken.target, toFixedPtAmt("500"));
         expect(r.tokenOutAmt).to.eq(toFixedPtAmt("250"));
         expect(r.trancheInAmt).to.eq(toFixedPtAmt("500"));
       });
@@ -304,14 +294,14 @@ describe("PerpetualTranche", function () {
         await advancePerpQueueToRollover(perp, await bondAt(await rolloverInTranche.bond()));
 
         newReserveTranche = rolloverInTranche;
-        const newDepositBond = await bondAt(await perp.callStatic.getDepositBond());
+        const newDepositBond = await bondAt(await perp.depositBond());
         [newRotationInTranche] = await getTranches(newDepositBond);
       });
 
       it("should rollover the correct amount", async function () {
-        const r = await perp.callStatic.computeRolloverAmt(
-          newRotationInTranche.address,
-          newReserveTranche.address,
+        const r = await perp.computeRolloverAmt(
+          newRotationInTranche.target,
+          newReserveTranche.target,
           toFixedPtAmt("500"),
         );
         expect(r.tokenOutAmt).to.eq(toFixedPtAmt("500"));
@@ -325,11 +315,7 @@ describe("PerpetualTranche", function () {
       });
 
       it("should rollover the correct amount", async function () {
-        const r = await perp.callStatic.computeRolloverAmt(
-          rolloverInTranche.address,
-          collateralToken.address,
-          toFixedPtAmt("500"),
-        );
+        const r = await perp.computeRolloverAmt(rolloverInTranche.target, collateralToken.target, toFixedPtAmt("500"));
         expect(r.tokenOutAmt).to.eq(toFixedPtAmt("500"));
         expect(r.trancheInAmt).to.eq(toFixedPtAmt("500"));
       });
@@ -341,11 +327,7 @@ describe("PerpetualTranche", function () {
       });
 
       it("should rollover the correct amount", async function () {
-        const r = await perp.callStatic.computeRolloverAmt(
-          rolloverInTranche.address,
-          collateralToken.address,
-          toFixedPtAmt("500"),
-        );
+        const r = await perp.computeRolloverAmt(rolloverInTranche.target, collateralToken.target, toFixedPtAmt("500"));
         expect(r.tokenOutAmt).to.eq(toFixedPtAmt("250"));
         expect(r.trancheInAmt).to.eq(toFixedPtAmt("250"));
       });
@@ -356,15 +338,11 @@ describe("PerpetualTranche", function () {
         await rebase(collateralToken, rebaseOracle, -0.75);
         // simulating collateral rebase up, by just transferring some tokens in
         await mintCollteralToken(collateralToken, toFixedPtAmt("1000"), deployer);
-        await collateralToken.transfer(perp.address, toFixedPtAmt("1000"));
+        await collateralToken.transfer(perp.target, toFixedPtAmt("1000"));
       });
 
       it("should rollover the correct amount", async function () {
-        const r = await perp.callStatic.computeRolloverAmt(
-          rolloverInTranche.address,
-          collateralToken.address,
-          toFixedPtAmt("500"),
-        );
+        const r = await perp.computeRolloverAmt(rolloverInTranche.target, collateralToken.target, toFixedPtAmt("500"));
         expect(r.tokenOutAmt).to.eq(toFixedPtAmt("250"));
         expect(r.trancheInAmt).to.eq(toFixedPtAmt("500"));
       });
@@ -373,16 +351,12 @@ describe("PerpetualTranche", function () {
     describe("when trancheIn price is 0.5 and tokenOut is collateral which rebased down", function () {
       beforeEach(async function () {
         await mintCollteralToken(collateralToken, toFixedPtAmt("1000"), deployer);
-        await collateralToken.transfer(perp.address, toFixedPtAmt("1000"));
+        await collateralToken.transfer(perp.target, toFixedPtAmt("1000"));
         await rebase(collateralToken, rebaseOracle, -0.75);
       });
 
       it("should rollover the correct amount", async function () {
-        const r = await perp.callStatic.computeRolloverAmt(
-          rolloverInTranche.address,
-          collateralToken.address,
-          toFixedPtAmt("500"),
-        );
+        const r = await perp.computeRolloverAmt(rolloverInTranche.target, collateralToken.target, toFixedPtAmt("500"));
         expect(r.tokenOutAmt).to.eq(toFixedPtAmt("250"));
         expect(r.trancheInAmt).to.eq(toFixedPtAmt("500"));
       });
@@ -393,11 +367,7 @@ describe("PerpetualTranche", function () {
         await rebase(collateralToken, rebaseOracle, -0.25);
       });
       it("should rollover the correct amount", async function () {
-        const r = await perp.callStatic.computeRolloverAmt(
-          rolloverInTranche.address,
-          collateralToken.address,
-          toFixedPtAmt("500"),
-        );
+        const r = await perp.computeRolloverAmt(rolloverInTranche.target, collateralToken.target, toFixedPtAmt("500"));
         expect(r.tokenOutAmt).to.eq(toFixedPtAmt("375"));
         expect(r.trancheInAmt).to.eq(toFixedPtAmt("375"));
       });
@@ -408,11 +378,7 @@ describe("PerpetualTranche", function () {
         await rebase(collateralToken, rebaseOracle, 0.25);
       });
       it("should rollover the correct amount", async function () {
-        const r = await perp.callStatic.computeRolloverAmt(
-          rolloverInTranche.address,
-          collateralToken.address,
-          toFixedPtAmt("500"),
-        );
+        const r = await perp.computeRolloverAmt(rolloverInTranche.target, collateralToken.target, toFixedPtAmt("500"));
         expect(r.tokenOutAmt).to.eq(toFixedPtAmt("500"));
         expect(r.trancheInAmt).to.eq(toFixedPtAmt("500"));
       });
@@ -420,29 +386,25 @@ describe("PerpetualTranche", function () {
 
     describe("when fee is zero", function () {
       beforeEach(async function () {
-        await feePolicy.computePerpRolloverFeePerc.returns("0");
+        await balancer.mockMethod("computePerpRolloverFeePerc(uint256)", [0n]);
       });
       it("should transfer the tranches in", async function () {
         await expect(() =>
-          mockVault.rollover(perp.address, rolloverInTranche.address, reserveTranche.address, toFixedPtAmt("500")),
+          mockVault.rollover(perp.target, rolloverInTranche.target, reserveTranche.target, toFixedPtAmt("500")),
         ).to.changeTokenBalances(rolloverInTranche, [deployer, perp], [toFixedPtAmt("-500"), toFixedPtAmt("500")]);
       });
       it("should transfer the tranches out", async function () {
         await expect(() =>
-          mockVault.rollover(perp.address, rolloverInTranche.address, reserveTranche.address, toFixedPtAmt("500")),
+          mockVault.rollover(perp.target, rolloverInTranche.target, reserveTranche.target, toFixedPtAmt("500")),
         ).to.changeTokenBalances(reserveTranche, [deployer, perp], [toFixedPtAmt("500"), toFixedPtAmt("-500")]);
       });
       it("should charge fee", async function () {
         await expect(() =>
-          mockVault.rollover(perp.address, rolloverInTranche.address, reserveTranche.address, toFixedPtAmt("500")),
+          mockVault.rollover(perp.target, rolloverInTranche.target, reserveTranche.target, toFixedPtAmt("500")),
         ).to.changeTokenBalance(perp, perp, "0");
       });
       it("should calculate rollover amt", async function () {
-        const r = await perp.callStatic.computeRolloverAmt(
-          rolloverInTranche.address,
-          reserveTranche.address,
-          toFixedPtAmt("500"),
-        );
+        const r = await perp.computeRolloverAmt(rolloverInTranche.target, reserveTranche.target, toFixedPtAmt("500"));
         expect(r.tokenOutAmt).to.eq(toFixedPtAmt("500"));
         expect(r.trancheInAmt).to.eq(toFixedPtAmt("500"));
       });
@@ -450,24 +412,20 @@ describe("PerpetualTranche", function () {
 
     describe("when fee > 0", function () {
       beforeEach(async function () {
-        await feePolicy.computePerpRolloverFeePerc.returns(toPercFixedPtAmt("0.01"));
+        await balancer.mockMethod("computePerpRolloverFeePerc(uint256)", [toPercFixedPtAmt("0.01")]);
       });
       it("should transfer the tranches in", async function () {
         await expect(() =>
-          mockVault.rollover(perp.address, rolloverInTranche.address, reserveTranche.address, toFixedPtAmt("500")),
+          mockVault.rollover(perp.target, rolloverInTranche.target, reserveTranche.target, toFixedPtAmt("500")),
         ).to.changeTokenBalances(rolloverInTranche, [deployer, perp], [toFixedPtAmt("-500"), toFixedPtAmt("500")]);
       });
       it("should transfer the tranches out", async function () {
         await expect(() =>
-          mockVault.rollover(perp.address, rolloverInTranche.address, reserveTranche.address, toFixedPtAmt("500")),
+          mockVault.rollover(perp.target, rolloverInTranche.target, reserveTranche.target, toFixedPtAmt("500")),
         ).to.changeTokenBalances(reserveTranche, [deployer, perp], [toFixedPtAmt("495"), toFixedPtAmt("-495")]);
       });
       it("should calculate rollover amt", async function () {
-        const r = await perp.callStatic.computeRolloverAmt(
-          rolloverInTranche.address,
-          reserveTranche.address,
-          toFixedPtAmt("500"),
-        );
+        const r = await perp.computeRolloverAmt(rolloverInTranche.target, reserveTranche.target, toFixedPtAmt("500"));
         expect(r.tokenOutAmt).to.eq(toFixedPtAmt("495"));
         expect(r.trancheInAmt).to.eq(toFixedPtAmt("500"));
       });
@@ -475,11 +433,11 @@ describe("PerpetualTranche", function () {
 
     describe("when fee < 0", function () {
       beforeEach(async function () {
-        await feePolicy.computePerpRolloverFeePerc.returns(toPercFixedPtAmt("-0.01"));
+        await balancer.mockMethod("computePerpRolloverFeePerc(uint256)", [toPercFixedPtAmt("-0.01")]);
       });
       it("should transfer the tranches in", async function () {
         await expect(() =>
-          mockVault.rollover(perp.address, rolloverInTranche.address, reserveTranche.address, toFixedPtAmt("500")),
+          mockVault.rollover(perp.target, rolloverInTranche.target, reserveTranche.target, toFixedPtAmt("500")),
         ).to.changeTokenBalances(
           rolloverInTranche,
           [deployer, perp],
@@ -488,15 +446,11 @@ describe("PerpetualTranche", function () {
       });
       it("should transfer the tranches out", async function () {
         await expect(() =>
-          mockVault.rollover(perp.address, rolloverInTranche.address, reserveTranche.address, toFixedPtAmt("500")),
+          mockVault.rollover(perp.target, rolloverInTranche.target, reserveTranche.target, toFixedPtAmt("500")),
         ).to.changeTokenBalances(reserveTranche, [deployer, perp], [toFixedPtAmt("500"), toFixedPtAmt("-500")]);
       });
       it("should calculate rollover amt", async function () {
-        const r = await perp.callStatic.computeRolloverAmt(
-          rolloverInTranche.address,
-          reserveTranche.address,
-          toFixedPtAmt("500"),
-        );
+        const r = await perp.computeRolloverAmt(rolloverInTranche.target, reserveTranche.target, toFixedPtAmt("500"));
         expect(r.tokenOutAmt).to.eq(toFixedPtAmt("500"));
         expect(r.trancheInAmt).to.eq(toFixedPtAmt("495.049504950495049505"));
       });
@@ -506,25 +460,16 @@ describe("PerpetualTranche", function () {
       let tx: Transaction, newRotationInTranche: Contract, r: any;
       beforeEach(async function () {
         await advancePerpQueueToBondMaturity(perp, rolloverInBond); // advancing to next issuance
-        const newRolloverInBond = await bondAt(await perp.callStatic.getDepositBond());
+        const newRolloverInBond = await bondAt(await perp.depositBond());
         await depositIntoBond(newRolloverInBond, toFixedPtAmt("1000"), deployer);
         [newRotationInTranche] = await getTranches(newRolloverInBond);
-        await newRotationInTranche.approve(mockVault.address, toFixedPtAmt("250"));
-        r = await perp.callStatic.computeRolloverAmt(
-          newRotationInTranche.address,
-          collateralToken.address,
-          toFixedPtAmt("250"),
-        );
-        tx = mockVault.rollover(
-          perp.address,
-          newRotationInTranche.address,
-          collateralToken.address,
-          toFixedPtAmt("250"),
-        );
+        await newRotationInTranche.approve(mockVault.target, toFixedPtAmt("250"));
+        r = await perp.computeRolloverAmt(newRotationInTranche.target, collateralToken.target, toFixedPtAmt("250"));
+        tx = mockVault.rollover(perp.target, newRotationInTranche.target, collateralToken.target, toFixedPtAmt("250"));
         await tx;
       });
       it("should update the reserve", async function () {
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, newRotationInTranche],
           [toFixedPtAmt("1250"), toFixedPtAmt("250")],
@@ -533,9 +478,9 @@ describe("PerpetualTranche", function () {
       it("should emit reserve synced", async function () {
         await expect(tx)
           .to.emit(perp, "ReserveSynced")
-          .withArgs(newRotationInTranche.address, toFixedPtAmt("250"))
+          .withArgs(newRotationInTranche.target, toFixedPtAmt("250"))
           .to.emit(perp, "ReserveSynced")
-          .withArgs(collateralToken.address, toFixedPtAmt("1250"));
+          .withArgs(collateralToken.target, toFixedPtAmt("1250"));
       });
       it("should compute the rollover amounts", async function () {
         expect(r.tokenOutAmt).to.eq(toFixedPtAmt("250"));
@@ -546,17 +491,13 @@ describe("PerpetualTranche", function () {
     describe("when tokenOut is a reserve tranche", async function () {
       let tx: Transaction, r: any;
       beforeEach(async function () {
-        r = await perp.callStatic.computeRolloverAmt(
-          rolloverInTranche.address,
-          reserveTranche.address,
-          toFixedPtAmt("250"),
-        );
-        tx = mockVault.rollover(perp.address, rolloverInTranche.address, reserveTranche.address, toFixedPtAmt("250"));
+        r = await perp.computeRolloverAmt(rolloverInTranche.target, reserveTranche.target, toFixedPtAmt("250"));
+        tx = mockVault.rollover(perp.target, rolloverInTranche.target, reserveTranche.target, toFixedPtAmt("250"));
         await tx;
       });
 
       it("should update the reserve", async function () {
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, reserveTranche, rolloverInTranche],
           [toFixedPtAmt("500"), toFixedPtAmt("250"), toFixedPtAmt("750")],
@@ -565,9 +506,9 @@ describe("PerpetualTranche", function () {
       it("should emit reserve synced", async function () {
         await expect(tx)
           .to.emit(perp, "ReserveSynced")
-          .withArgs(rolloverInTranche.address, toFixedPtAmt("750"))
+          .withArgs(rolloverInTranche.target, toFixedPtAmt("750"))
           .to.emit(perp, "ReserveSynced")
-          .withArgs(reserveTranche.address, toFixedPtAmt("250"));
+          .withArgs(reserveTranche.target, toFixedPtAmt("250"));
       });
       it("should compute the rollover amounts", async function () {
         expect(r.tokenOutAmt).to.eq(toFixedPtAmt("250"));
@@ -578,17 +519,13 @@ describe("PerpetualTranche", function () {
     describe("when tokenOut is the mature collateral", async function () {
       let tx: Transaction, r: any;
       beforeEach(async function () {
-        r = await perp.callStatic.computeRolloverAmt(
-          rolloverInTranche.address,
-          collateralToken.address,
-          toFixedPtAmt("250"),
-        );
-        tx = mockVault.rollover(perp.address, rolloverInTranche.address, collateralToken.address, toFixedPtAmt("250"));
+        r = await perp.computeRolloverAmt(rolloverInTranche.target, collateralToken.target, toFixedPtAmt("250"));
+        tx = mockVault.rollover(perp.target, rolloverInTranche.target, collateralToken.target, toFixedPtAmt("250"));
         await tx;
       });
 
       it("should update the reserve", async function () {
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, reserveTranche, rolloverInTranche],
           [toFixedPtAmt("250"), toFixedPtAmt("500"), toFixedPtAmt("750")],
@@ -597,9 +534,9 @@ describe("PerpetualTranche", function () {
       it("should emit reserve synced", async function () {
         await expect(tx)
           .to.emit(perp, "ReserveSynced")
-          .withArgs(rolloverInTranche.address, toFixedPtAmt("750"))
+          .withArgs(rolloverInTranche.target, toFixedPtAmt("750"))
           .to.emit(perp, "ReserveSynced")
-          .withArgs(collateralToken.address, toFixedPtAmt("250"));
+          .withArgs(collateralToken.target, toFixedPtAmt("250"));
       });
       it("should compute the rollover amounts", async function () {
         expect(r.tokenOutAmt).to.eq(toFixedPtAmt("250"));
@@ -611,17 +548,13 @@ describe("PerpetualTranche", function () {
       let tx: Transaction, r: any;
       beforeEach(async function () {
         await rebase(collateralToken, rebaseOracle, +0.5);
-        r = await perp.callStatic.computeRolloverAmt(
-          rolloverInTranche.address,
-          collateralToken.address,
-          toFixedPtAmt("250"),
-        );
-        tx = mockVault.rollover(perp.address, rolloverInTranche.address, collateralToken.address, toFixedPtAmt("250"));
+        r = await perp.computeRolloverAmt(rolloverInTranche.target, collateralToken.target, toFixedPtAmt("250"));
+        tx = mockVault.rollover(perp.target, rolloverInTranche.target, collateralToken.target, toFixedPtAmt("250"));
         await tx;
       });
 
       it("should update the reserve", async function () {
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, reserveTranche, rolloverInTranche],
           [toFixedPtAmt("500"), toFixedPtAmt("500"), toFixedPtAmt("750")],
@@ -630,9 +563,9 @@ describe("PerpetualTranche", function () {
       it("should emit reserve synced", async function () {
         await expect(tx)
           .to.emit(perp, "ReserveSynced")
-          .withArgs(rolloverInTranche.address, toFixedPtAmt("750"))
+          .withArgs(rolloverInTranche.target, toFixedPtAmt("750"))
           .to.emit(perp, "ReserveSynced")
-          .withArgs(collateralToken.address, toFixedPtAmt("500"));
+          .withArgs(collateralToken.target, toFixedPtAmt("500"));
       });
       it("should compute the rollover amounts", async function () {
         expect(r.tokenOutAmt).to.eq(toFixedPtAmt("250"));
@@ -644,17 +577,13 @@ describe("PerpetualTranche", function () {
       let tx: Transaction, r: any;
       beforeEach(async function () {
         await rebase(collateralToken, rebaseOracle, -0.5);
-        r = await perp.callStatic.computeRolloverAmt(
-          rolloverInTranche.address,
-          collateralToken.address,
-          toFixedPtAmt("250"),
-        );
-        tx = mockVault.rollover(perp.address, rolloverInTranche.address, collateralToken.address, toFixedPtAmt("250"));
+        r = await perp.computeRolloverAmt(rolloverInTranche.target, collateralToken.target, toFixedPtAmt("250"));
+        tx = mockVault.rollover(perp.target, rolloverInTranche.target, collateralToken.target, toFixedPtAmt("250"));
         await tx;
       });
 
       it("should update the reserve", async function () {
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, reserveTranche, rolloverInTranche],
           ["0", toFixedPtAmt("500"), toFixedPtAmt("750")],
@@ -663,9 +592,9 @@ describe("PerpetualTranche", function () {
       it("should emit reserve synced", async function () {
         await expect(tx)
           .to.emit(perp, "ReserveSynced")
-          .withArgs(rolloverInTranche.address, toFixedPtAmt("750"))
+          .withArgs(rolloverInTranche.target, toFixedPtAmt("750"))
           .to.emit(perp, "ReserveSynced")
-          .withArgs(collateralToken.address, "0");
+          .withArgs(collateralToken.target, "0");
       });
       it("should compute the rollover amounts", async function () {
         expect(r.tokenOutAmt).to.eq(toFixedPtAmt("250"));
@@ -676,17 +605,13 @@ describe("PerpetualTranche", function () {
     describe("when tokenOut is tranche and fully withdrawn", async function () {
       let tx: Transaction, r: any;
       beforeEach(async function () {
-        r = await perp.callStatic.computeRolloverAmt(
-          rolloverInTranche.address,
-          reserveTranche.address,
-          toFixedPtAmt("500"),
-        );
-        tx = mockVault.rollover(perp.address, rolloverInTranche.address, reserveTranche.address, toFixedPtAmt("500"));
+        r = await perp.computeRolloverAmt(rolloverInTranche.target, reserveTranche.target, toFixedPtAmt("500"));
+        tx = mockVault.rollover(perp.target, rolloverInTranche.target, reserveTranche.target, toFixedPtAmt("500"));
         await tx;
       });
 
       it("should update the reserve", async function () {
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, rolloverInTranche],
           [toFixedPtAmt("500"), toFixedPtAmt("1000")],
@@ -696,9 +621,9 @@ describe("PerpetualTranche", function () {
       it("should emit reserve synced", async function () {
         await expect(tx)
           .to.emit(perp, "ReserveSynced")
-          .withArgs(rolloverInTranche.address, toFixedPtAmt("1000"))
+          .withArgs(rolloverInTranche.target, toFixedPtAmt("1000"))
           .to.emit(perp, "ReserveSynced")
-          .withArgs(reserveTranche.address, "0");
+          .withArgs(reserveTranche.target, "0");
       });
       it("should compute the rollover amounts", async function () {
         expect(r.tokenOutAmt).to.eq(toFixedPtAmt("500"));
@@ -709,17 +634,13 @@ describe("PerpetualTranche", function () {
     describe("when tokenOut is collateral and fully withdrawn", async function () {
       let tx: Transaction, r: any;
       beforeEach(async function () {
-        r = await perp.callStatic.computeRolloverAmt(
-          rolloverInTranche.address,
-          collateralToken.address,
-          toFixedPtAmt("500"),
-        );
-        tx = mockVault.rollover(perp.address, rolloverInTranche.address, collateralToken.address, toFixedPtAmt("500"));
+        r = await perp.computeRolloverAmt(rolloverInTranche.target, collateralToken.target, toFixedPtAmt("500"));
+        tx = mockVault.rollover(perp.target, rolloverInTranche.target, collateralToken.target, toFixedPtAmt("500"));
         await tx;
       });
 
       it("should update the reserve", async function () {
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, reserveTranche, rolloverInTranche],
           ["0", toFixedPtAmt("500"), toFixedPtAmt("1000")],
@@ -728,9 +649,9 @@ describe("PerpetualTranche", function () {
       it("should emit reserve synced", async function () {
         await expect(tx)
           .to.emit(perp, "ReserveSynced")
-          .withArgs(rolloverInTranche.address, toFixedPtAmt("1000"))
+          .withArgs(rolloverInTranche.target, toFixedPtAmt("1000"))
           .to.emit(perp, "ReserveSynced")
-          .withArgs(collateralToken.address, "0");
+          .withArgs(collateralToken.target, "0");
       });
       it("should compute the rollover amounts", async function () {
         expect(r.tokenOutAmt).to.eq(toFixedPtAmt("500"));
@@ -741,17 +662,13 @@ describe("PerpetualTranche", function () {
     describe("when tokenOut is partially redeemed", async function () {
       let tx: Transaction, r: any;
       beforeEach(async function () {
-        r = await perp.callStatic.computeRolloverAmt(
-          rolloverInTranche.address,
-          reserveTranche.address,
-          toFixedPtAmt("100"),
-        );
-        tx = mockVault.rollover(perp.address, rolloverInTranche.address, reserveTranche.address, toFixedPtAmt("100"));
+        r = await perp.computeRolloverAmt(rolloverInTranche.target, reserveTranche.target, toFixedPtAmt("100"));
+        tx = mockVault.rollover(perp.target, rolloverInTranche.target, reserveTranche.target, toFixedPtAmt("100"));
         await tx;
       });
 
       it("should update the reserve", async function () {
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, reserveTranche, rolloverInTranche],
           [toFixedPtAmt("500"), toFixedPtAmt("400"), toFixedPtAmt("600")],
@@ -761,9 +678,9 @@ describe("PerpetualTranche", function () {
       it("should emit reserve synced", async function () {
         await expect(tx)
           .to.emit(perp, "ReserveSynced")
-          .withArgs(rolloverInTranche.address, toFixedPtAmt("600"))
+          .withArgs(rolloverInTranche.target, toFixedPtAmt("600"))
           .to.emit(perp, "ReserveSynced")
-          .withArgs(reserveTranche.address, toFixedPtAmt("400"));
+          .withArgs(reserveTranche.target, toFixedPtAmt("400"));
       });
       it("should compute the rollover amounts", async function () {
         expect(r.tokenOutAmt).to.eq(toFixedPtAmt("100"));
@@ -774,17 +691,13 @@ describe("PerpetualTranche", function () {
     describe("when tokenOut is NOT covered", async function () {
       let tx: Transaction, r: any;
       beforeEach(async function () {
-        r = await perp.callStatic.computeRolloverAmt(
-          rolloverInTranche.address,
-          reserveTranche.address,
-          toFixedPtAmt("2000"),
-        );
-        tx = mockVault.rollover(perp.address, rolloverInTranche.address, reserveTranche.address, toFixedPtAmt("2000"));
+        r = await perp.computeRolloverAmt(rolloverInTranche.target, reserveTranche.target, toFixedPtAmt("2000"));
+        tx = mockVault.rollover(perp.target, rolloverInTranche.target, reserveTranche.target, toFixedPtAmt("2000"));
         await tx;
       });
 
       it("should update the reserve (only transfers covered amount)", async function () {
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, rolloverInTranche],
           [toFixedPtAmt("500"), toFixedPtAmt("1000")],
@@ -794,9 +707,9 @@ describe("PerpetualTranche", function () {
       it("should emit reserve synced", async function () {
         await expect(tx)
           .to.emit(perp, "ReserveSynced")
-          .withArgs(rolloverInTranche.address, toFixedPtAmt("1000"))
+          .withArgs(rolloverInTranche.target, toFixedPtAmt("1000"))
           .to.emit(perp, "ReserveSynced")
-          .withArgs(reserveTranche.address, "0");
+          .withArgs(reserveTranche.target, "0");
       });
       it("should compute the rollover amounts", async function () {
         expect(r.tokenOutAmt).to.eq(toFixedPtAmt("500"));
@@ -807,18 +720,14 @@ describe("PerpetualTranche", function () {
     describe("when tokenOut is NOT covered and fee > 0", async function () {
       let tx: Transaction, r: any;
       beforeEach(async function () {
-        await feePolicy.computePerpRolloverFeePerc.returns(toPercFixedPtAmt("0.01"));
-        r = await perp.callStatic.computeRolloverAmt(
-          rolloverInTranche.address,
-          reserveTranche.address,
-          toFixedPtAmt("2000"),
-        );
-        tx = mockVault.rollover(perp.address, rolloverInTranche.address, reserveTranche.address, toFixedPtAmt("2000"));
+        await balancer.mockMethod("computePerpRolloverFeePerc(uint256)", [toPercFixedPtAmt("0.01")]);
+        r = await perp.computeRolloverAmt(rolloverInTranche.target, reserveTranche.target, toFixedPtAmt("2000"));
+        tx = mockVault.rollover(perp.target, rolloverInTranche.target, reserveTranche.target, toFixedPtAmt("2000"));
         await tx;
       });
 
       it("should update the reserve (only transfers covered amount)", async function () {
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, rolloverInTranche],
           [toFixedPtAmt("500"), toFixedPtAmt("1005.050505050505050506")],
@@ -828,9 +737,9 @@ describe("PerpetualTranche", function () {
       it("should emit reserve synced", async function () {
         await expect(tx)
           .to.emit(perp, "ReserveSynced")
-          .withArgs(rolloverInTranche.address, toFixedPtAmt("1005.050505050505050506"))
+          .withArgs(rolloverInTranche.target, toFixedPtAmt("1005.050505050505050506"))
           .to.emit(perp, "ReserveSynced")
-          .withArgs(reserveTranche.address, "0");
+          .withArgs(reserveTranche.target, "0");
       });
       it("should compute the rollover amounts", async function () {
         expect(r.tokenOutAmt).to.eq(toFixedPtAmt("500"));
@@ -841,18 +750,14 @@ describe("PerpetualTranche", function () {
     describe("when tokenOut is NOT covered and fee < 0", async function () {
       let tx: Transaction, r: any;
       beforeEach(async function () {
-        await feePolicy.computePerpRolloverFeePerc.returns(toPercFixedPtAmt("-0.01"));
-        r = await perp.callStatic.computeRolloverAmt(
-          rolloverInTranche.address,
-          reserveTranche.address,
-          toFixedPtAmt("2000"),
-        );
-        tx = mockVault.rollover(perp.address, rolloverInTranche.address, reserveTranche.address, toFixedPtAmt("2000"));
+        await balancer.mockMethod("computePerpRolloverFeePerc(uint256)", [toPercFixedPtAmt("-0.01")]);
+        r = await perp.computeRolloverAmt(rolloverInTranche.target, reserveTranche.target, toFixedPtAmt("2000"));
+        tx = mockVault.rollover(perp.target, rolloverInTranche.target, reserveTranche.target, toFixedPtAmt("2000"));
         await tx;
       });
 
       it("should update the reserve (only transfers covered amount)", async function () {
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, rolloverInTranche],
           [toFixedPtAmt("500"), toFixedPtAmt("995.049504950495049505")],
@@ -862,9 +767,9 @@ describe("PerpetualTranche", function () {
       it("should emit reserve synced", async function () {
         await expect(tx)
           .to.emit(perp, "ReserveSynced")
-          .withArgs(rolloverInTranche.address, toFixedPtAmt("995.049504950495049505"))
+          .withArgs(rolloverInTranche.target, toFixedPtAmt("995.049504950495049505"))
           .to.emit(perp, "ReserveSynced")
-          .withArgs(reserveTranche.address, "0");
+          .withArgs(reserveTranche.target, "0");
       });
       it("should compute the rollover amounts", async function () {
         expect(r.tokenOutAmt).to.eq(toFixedPtAmt("500"));
@@ -875,17 +780,13 @@ describe("PerpetualTranche", function () {
     describe("when valid rollover", async function () {
       let tx: Transaction, r: any;
       beforeEach(async function () {
-        r = await perp.callStatic.computeRolloverAmt(
-          rolloverInTranche.address,
-          collateralToken.address,
-          toFixedPtAmt("100"),
-        );
-        tx = mockVault.rollover(perp.address, rolloverInTranche.address, collateralToken.address, toFixedPtAmt("100"));
+        r = await perp.computeRolloverAmt(rolloverInTranche.target, collateralToken.target, toFixedPtAmt("100"));
+        tx = mockVault.rollover(perp.target, rolloverInTranche.target, collateralToken.target, toFixedPtAmt("100"));
         await tx;
       });
 
       it("should update the reserve", async function () {
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, reserveTranche, rolloverInTranche],
           [toFixedPtAmt("400"), toFixedPtAmt("500"), toFixedPtAmt("600")],
@@ -895,9 +796,9 @@ describe("PerpetualTranche", function () {
       it("should emit reserve synced", async function () {
         await expect(tx)
           .to.emit(perp, "ReserveSynced")
-          .withArgs(rolloverInTranche.address, toFixedPtAmt("600"))
+          .withArgs(rolloverInTranche.target, toFixedPtAmt("600"))
           .to.emit(perp, "ReserveSynced")
-          .withArgs(collateralToken.address, toFixedPtAmt("400"));
+          .withArgs(collateralToken.target, toFixedPtAmt("400"));
       });
       it("should compute the rollover amounts", async function () {
         expect(r.tokenOutAmt).to.eq(toFixedPtAmt("100"));
diff --git a/spot-contracts/test/rollover-vault/RolloverVault.ts b/spot-contracts/test/rollover-vault/RolloverVault.ts
index 9c17b9d7..48a3b436 100644
--- a/spot-contracts/test/rollover-vault/RolloverVault.ts
+++ b/spot-contracts/test/rollover-vault/RolloverVault.ts
@@ -1,6 +1,6 @@
-import { expect, use } from "chai";
+import { expect } from "chai";
 import { network, ethers, upgrades } from "hardhat";
-import { Contract, Transaction, Signer, constants } from "ethers";
+import { Contract, Transaction, Signer } from "ethers";
 import {
   setupCollateralToken,
   mintCollteralToken,
@@ -11,20 +11,13 @@ import {
   getTranches,
   getDepositBond,
   advancePerpQueueToBondMaturity,
+  DMock,
 } from "../helpers";
-import { smock, FakeContract } from "@defi-wonderland/smock";
 
-use(smock.matchers);
-
-let vault: Contract,
-  perp: FakeContract,
-  feePolicy: FakeContract,
-  collateralToken: Contract,
-  deployer: Signer,
-  otherUser: Signer;
+let vault: Contract, perp: Contract, balancer: Contract, collateralToken: Contract, deployer: Signer, otherUser: Signer;
 describe("RolloverVault", function () {
   beforeEach(async function () {
-    await network.provider.send("hardhat_reset");
+    await network.provider.request({ method: "hardhat_reset" });
 
     const accounts = await ethers.getSigners();
     deployer = accounts[0];
@@ -33,23 +26,26 @@ describe("RolloverVault", function () {
     ({ collateralToken } = await setupCollateralToken("Bitcoin", "BTC"));
     await mintCollteralToken(collateralToken, toFixedPtAmt("1000"), deployer);
 
-    const PerpetualTranche = await ethers.getContractFactory("PerpetualTranche");
-    perp = await smock.fake(PerpetualTranche);
-    await perp.underlying.returns(collateralToken.address);
+    perp = new DMock(await ethers.getContractFactory("PerpetualTranche"));
+    await perp.deploy();
+    await perp.mockMethod("underlying()", [collateralToken.target]);
 
-    const FeePolicy = await ethers.getContractFactory("FeePolicy");
-    feePolicy = await smock.fake(FeePolicy);
-    await feePolicy.decimals.returns(8);
+    balancer = new DMock(await ethers.getContractFactory("Balancer"));
+    await balancer.deploy();
+    await balancer.mockMethod("decimals()", [8]);
 
     const RolloverVault = await ethers.getContractFactory("RolloverVault");
     vault = await upgrades.deployProxy(RolloverVault.connect(deployer));
-    await collateralToken.approve(vault.address, toFixedPtAmt("1"));
-    await vault.init("RolloverVault", "VSHARE", perp.address, feePolicy.address);
-    await perp.vault.returns(vault.address);
+    await collateralToken.approve(vault.target, toFixedPtAmt("1"));
+    await vault.init("RolloverVault", "VSHARE", perp.target);
+    await vault.updateBalancer(balancer.target);
+
+    await perp.mockMethod("balancer()", [balancer.target]);
+    await perp.mockMethod("vault()", [vault.target]);
   });
 
   afterEach(async function () {
-    await network.provider.send("hardhat_reset");
+    await network.provider.request({ method: "hardhat_reset" });
   });
 
   describe("#init", function () {
@@ -64,24 +60,23 @@ describe("RolloverVault", function () {
     });
 
     it("should set ext service references", async function () {
-      expect(await vault.perp()).to.eq(perp.address);
+      expect(await vault.perp()).to.eq(perp.target);
     });
 
     it("should set deposit asset reference", async function () {
-      expect(await vault.underlying()).to.eq(collateralToken.address);
+      expect(await vault.underlying()).to.eq(collateralToken.target);
     });
 
     it("should set initial param values", async function () {
-      expect(await vault.minUnderlyingPerc()).to.eq(toPercFixedPtAmt("0.33333333"));
       expect(await vault.minDeploymentAmt()).to.eq("0");
       expect(await vault.minUnderlyingBal()).to.eq("0");
     });
 
     it("should initialize lists", async function () {
       expect(await vault.assetCount()).to.eq(1);
-      expect(await vault.assetAt(0)).to.eq(collateralToken.address);
-      expect(await vault.isVaultAsset(collateralToken.address)).to.eq(true);
-      expect(await vault.isVaultAsset(perp.address)).to.eq(false);
+      expect(await vault.assetAt(0)).to.eq(collateralToken.target);
+      expect(await vault.isVaultAsset(collateralToken.target)).to.eq(true);
+      expect(await vault.isVaultAsset(perp.target)).to.eq(false);
     });
 
     it("should NOT be paused", async function () {
@@ -174,21 +169,21 @@ describe("RolloverVault", function () {
       const Token = await ethers.getContractFactory("MockERC20");
       transferToken = await Token.deploy();
       await transferToken.init("Mock Token", "MOCK");
-      await transferToken.mint(vault.address, "100");
+      await transferToken.mint(vault.target, "100");
       toAddress = await deployer.getAddress();
     });
 
     describe("when triggered by non-owner", function () {
       it("should revert", async function () {
-        await expect(
-          vault.connect(otherUser).transferERC20(transferToken.address, toAddress, "100"),
-        ).to.be.revertedWith("Ownable: caller is not the owner");
+        await expect(vault.connect(otherUser).transferERC20(transferToken.target, toAddress, "100")).to.be.revertedWith(
+          "Ownable: caller is not the owner",
+        );
       });
     });
 
     describe("when non vault asset", function () {
       it("should transfer", async function () {
-        await expect(() => vault.transferERC20(transferToken.address, toAddress, "100")).to.changeTokenBalance(
+        await expect(() => vault.transferERC20(transferToken.target, toAddress, "100")).to.changeTokenBalance(
           transferToken,
           deployer,
           "100",
@@ -206,8 +201,8 @@ describe("RolloverVault", function () {
 
     describe("when perp", function () {
       it("should not revert", async function () {
-        await perp.transfer.returns(() => true);
-        await expect(vault.transferERC20(perp.address, toAddress, toFixedPtAmt("100"))).not.to.be.reverted;
+        await perp.mockMethod("transfer(address,uint256)", [true]);
+        await expect(vault.transferERC20(perp.target, toAddress, toFixedPtAmt("100"))).not.to.be.reverted;
       });
     });
 
@@ -219,7 +214,7 @@ describe("RolloverVault", function () {
         const BondIssuer = await ethers.getContractFactory("BondIssuer");
         const issuer = await upgrades.deployProxy(
           BondIssuer.connect(deployer),
-          [bondFactory.address, collateralToken.address, 4800, [200, 800], 1200, 0],
+          [bondFactory.target, collateralToken.target, 4800, [200, 800], 1200, 0],
           {
             initializer: "init(address,address,uint256,uint256[],uint256,uint256)",
           },
@@ -228,29 +223,41 @@ describe("RolloverVault", function () {
         const PerpetualTranche = await ethers.getContractFactory("PerpetualTranche");
         perp = await upgrades.deployProxy(
           PerpetualTranche.connect(deployer),
-          ["PerpetualTranche", "PERP", collateralToken.address, issuer.address, feePolicy.address],
+          ["PerpetualTranche", "PERP", collateralToken.target, issuer.target],
           {
-            initializer: "init(string,string,address,address,address)",
+            initializer: "init(string,string,address,address)",
           },
         );
-
         await perp.updateTolerableTrancheMaturity(1200, 4800);
+        await perp.updateDepositBond();
         await advancePerpQueueToBondMaturity(perp, await getDepositBond(perp));
 
+        balancer = new DMock(await ethers.getContractFactory("Balancer"));
+        await balancer.deploy();
+        await balancer.mockMethod("decimals()", [8]);
+        await balancer.mockMethod("computePerpRolloverFeePerc(uint256)", [0n]);
+        await balancer.mockMethod("computeDeviationRatio(uint256,uint256,uint256)", [toPercFixedPtAmt("1")]);
+
         const RolloverVault = await ethers.getContractFactory("RolloverVault");
         vault = await upgrades.deployProxy(RolloverVault.connect(deployer));
-        await vault.init("RolloverVault", "VSHARE", perp.address, feePolicy.address);
-        await perp.updateVault(vault.address);
+        await vault.init("RolloverVault", "VSHARE", perp.target);
+        await vault.updateBalancer(balancer.target);
+        await perp.updateVault(vault.target);
+        await perp.updateBalancer(balancer.target);
 
         await mintCollteralToken(collateralToken, toFixedPtAmt("100000"), deployer);
         const bond = await getDepositBond(perp);
         const tranches = await getTranches(bond);
         await depositIntoBond(bond, toFixedPtAmt("1000"), deployer);
-        await tranches[0].approve(perp.address, toFixedPtAmt("200"));
-        await perp.deposit(tranches[0].address, toFixedPtAmt("200"));
+        await tranches[0].approve(perp.target, toFixedPtAmt("200"));
+
+        await perp.updateVault(await deployer.getAddress());
+        await perp.deposit(tranches[0].target, toFixedPtAmt("200"));
         await advancePerpQueueToBondMaturity(perp, bond);
 
-        await collateralToken.transfer(vault.address, toFixedPtAmt("1000"));
+        await perp.updateBalancer(balancer.target);
+        await perp.updateVault(vault.target);
+        await collateralToken.transfer(vault.target, toFixedPtAmt("1000"));
         await vault.deploy();
         expect(await vault.assetCount()).to.eq(2);
       });
@@ -262,7 +269,7 @@ describe("RolloverVault", function () {
     });
   });
 
-  describe("#updateFeePolicy", function () {
+  describe("#updateBalancer", function () {
     let tx: Transaction;
     beforeEach(async function () {
       await vault.connect(deployer).transferOwnership(await otherUser.getAddress());
@@ -270,23 +277,23 @@ describe("RolloverVault", function () {
 
     describe("when triggered by non-owner", function () {
       it("should revert", async function () {
-        await expect(vault.connect(deployer).updateFeePolicy(constants.AddressZero)).to.be.revertedWith(
+        await expect(vault.connect(deployer).updateBalancer(ethers.ZeroAddress)).to.be.revertedWith(
           "Ownable: caller is not the owner",
         );
       });
     });
 
     describe("when triggered by owner", function () {
-      let newFeePolicy: Contract;
+      let newBalancer: Contract;
       beforeEach(async function () {
-        const FeePolicy = await ethers.getContractFactory("FeePolicy");
-        newFeePolicy = await smock.fake(FeePolicy);
-        await newFeePolicy.decimals.returns(8);
-        tx = await vault.connect(otherUser).updateFeePolicy(newFeePolicy.address);
+        newBalancer = new DMock(await ethers.getContractFactory("Balancer"));
+        await newBalancer.deploy();
+        await newBalancer.mockMethod("decimals()", [8]);
+        tx = await vault.connect(otherUser).updateBalancer(newBalancer.target);
         await tx;
       });
       it("should update the fee policy", async function () {
-        expect(await vault.feePolicy()).to.eq(newFeePolicy.address);
+        expect(await vault.balancer()).to.eq(newBalancer.target);
       });
     });
   });
@@ -341,31 +348,6 @@ describe("RolloverVault", function () {
     });
   });
 
-  describe("#updateMinUnderlyingPerc", function () {
-    let tx: Transaction;
-    beforeEach(async function () {
-      await vault.connect(deployer).transferOwnership(await otherUser.getAddress());
-    });
-
-    describe("when triggered by non-owner", function () {
-      it("should revert", async function () {
-        await expect(vault.connect(deployer).updateMinUnderlyingPerc(0)).to.be.revertedWith(
-          "Ownable: caller is not the owner",
-        );
-      });
-    });
-
-    describe("when triggered by owner", function () {
-      beforeEach(async function () {
-        tx = await vault.connect(otherUser).updateMinUnderlyingPerc(toPercFixedPtAmt("0.1"));
-        await tx;
-      });
-      it("should update the min underlying balance", async function () {
-        expect(await vault.minUnderlyingPerc()).to.eq(toPercFixedPtAmt("0.1"));
-      });
-    });
-  });
-
   describe("#updateKeeper", function () {
     let tx: Transaction;
     beforeEach(async function () {
@@ -374,7 +356,7 @@ describe("RolloverVault", function () {
 
     describe("when triggered by non-owner", function () {
       it("should revert", async function () {
-        await expect(vault.connect(deployer).updateKeeper(constants.AddressZero)).to.be.revertedWith(
+        await expect(vault.connect(deployer).updateKeeper(ethers.ZeroAddress)).to.be.revertedWith(
           "Ownable: caller is not the owner",
         );
       });
diff --git a/spot-contracts/test/rollover-vault/RolloverVault_deploy.ts b/spot-contracts/test/rollover-vault/RolloverVault_deploy.ts
index c2e356c4..1d10edfc 100644
--- a/spot-contracts/test/rollover-vault/RolloverVault_deploy.ts
+++ b/spot-contracts/test/rollover-vault/RolloverVault_deploy.ts
@@ -1,8 +1,6 @@
-import { expect, use } from "chai";
+import { expect } from "chai";
 import { network, ethers, upgrades } from "hardhat";
 import { Contract, Signer, Transaction } from "ethers";
-import { smock } from "@defi-wonderland/smock";
-
 import {
   setupCollateralToken,
   mintCollteralToken,
@@ -16,18 +14,18 @@ import {
   advancePerpQueue,
   advancePerpQueueToBondMaturity,
   advancePerpQueueToRollover,
-  checkReserveComposition,
-  checkVaultAssetComposition,
+  checkPerpComposition,
+  checkVaultComposition,
   rebase,
+  DMock,
 } from "../helpers";
-use(smock.matchers);
 
 let vault: Contract;
 let perp: Contract;
 let bondFactory: Contract;
 let collateralToken: Contract;
 let issuer: Contract;
-let feePolicy: Contract;
+let balancer: Contract;
 let deployer: Signer;
 let reserveTranches: Contract[][] = [];
 let rolloverInBond: Contract;
@@ -36,7 +34,7 @@ let rebaseOracle: Contract;
 
 describe("RolloverVault", function () {
   beforeEach(async function () {
-    await network.provider.send("hardhat_reset");
+    await network.provider.request({ method: "hardhat_reset" });
 
     const accounts = await ethers.getSigners();
     deployer = accounts[0];
@@ -47,64 +45,67 @@ describe("RolloverVault", function () {
     const BondIssuer = await ethers.getContractFactory("BondIssuer");
     issuer = await upgrades.deployProxy(
       BondIssuer.connect(deployer),
-      [bondFactory.address, collateralToken.address, 4800, [200, 800], 1200, 0],
+      [bondFactory.target, collateralToken.target, 4800, [200, 800], 1200, 0],
       {
         initializer: "init(address,address,uint256,uint256[],uint256,uint256)",
       },
     );
 
-    const FeePolicy = await ethers.getContractFactory("FeePolicy");
-    feePolicy = await smock.fake(FeePolicy);
-    await feePolicy.decimals.returns(8);
-    await feePolicy.computePerpRolloverFeePerc.returns("0");
+    balancer = new DMock(await ethers.getContractFactory("Balancer"));
+    await balancer.deploy();
+    await balancer.mockMethod("decimals()", [8]);
+    await balancer.mockMethod("computeDeviationRatio(uint256,uint256,uint256)", [toPercFixedPtAmt("1")]);
+    await balancer.mockMethod("computePerpRolloverFeePerc(uint256)", [0n]);
 
     const PerpetualTranche = await ethers.getContractFactory("PerpetualTranche");
     perp = await upgrades.deployProxy(
       PerpetualTranche.connect(deployer),
-      ["PerpetualTranche", "PERP", collateralToken.address, issuer.address, feePolicy.address],
+      ["PerpetualTranche", "PERP", collateralToken.target, issuer.target],
       {
-        initializer: "init(string,string,address,address,address)",
+        initializer: "init(string,string,address,address)",
       },
     );
-
     await perp.updateTolerableTrancheMaturity(1200, 4800);
     await advancePerpQueueToBondMaturity(perp, await getDepositBond(perp));
 
     const RolloverVault = await ethers.getContractFactory("RolloverVault");
     vault = await upgrades.deployProxy(RolloverVault.connect(deployer));
-    await vault.init("RolloverVault", "VSHARE", perp.address, feePolicy.address);
-    await perp.updateVault(vault.address);
+    await vault.init("RolloverVault", "VSHARE", perp.target);
+    await vault.updateBalancer(balancer.target);
 
     reserveTranches = [];
+    await perp.updateVault(await deployer.getAddress());
     for (let i = 0; i < 4; i++) {
       const bond = await getDepositBond(perp);
       const tranches = await getTranches(bond);
       await depositIntoBond(bond, toFixedPtAmt("1000"), deployer);
 
-      await tranches[0].approve(perp.address, toFixedPtAmt("200"));
-      await perp.deposit(tranches[0].address, toFixedPtAmt("200"));
+      await tranches[0].approve(perp.target, toFixedPtAmt("200"));
+      await perp.deposit(tranches[0].target, toFixedPtAmt("200"));
 
       reserveTranches.push(tranches[0]);
       await advancePerpQueue(perp, 1200);
     }
+    await perp.updateVault(vault.target);
+    await perp.updateBalancer(balancer.target);
 
-    await checkReserveComposition(
+    await checkPerpComposition(
       perp,
       [collateralToken, ...reserveTranches.slice(-3)],
       [toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("200")],
     );
 
-    rolloverInBond = await bondAt(await perp.callStatic.getDepositBond());
+    rolloverInBond = await bondAt(await perp.depositBond());
     rolloverInTranches = await getTranches(rolloverInBond);
     await mintCollteralToken(collateralToken, toFixedPtAmt("100000"), deployer);
-    await collateralToken.approve(vault.address, toFixedPtAmt("1"));
+    await collateralToken.approve(vault.target, toFixedPtAmt("1"));
 
-    await checkVaultAssetComposition(vault, [collateralToken], ["0"]);
+    await checkVaultComposition(vault, [collateralToken], ["0"]);
     expect(await vault.assetCount()).to.eq(1);
   });
 
   afterEach(async function () {
-    await network.provider.send("hardhat_reset");
+    await network.provider.request({ method: "hardhat_reset" });
   });
 
   describe("#deploy", function () {
@@ -121,7 +122,7 @@ describe("RolloverVault", function () {
 
       describe("when usable balance is lower than the min deployment", function () {
         beforeEach(async function () {
-          await collateralToken.transfer(vault.address, toFixedPtAmt("999"));
+          await collateralToken.transfer(vault.target, toFixedPtAmt("999"));
           await vault.updateMinDeploymentAmt(toFixedPtAmt("1000"));
         });
         it("should revert", async function () {
@@ -131,7 +132,7 @@ describe("RolloverVault", function () {
 
       describe("when usable balance is higher than the min deployment", function () {
         beforeEach(async function () {
-          await collateralToken.transfer(vault.address, toFixedPtAmt("1000"));
+          await collateralToken.transfer(vault.target, toFixedPtAmt("1000"));
           await vault.updateMinDeploymentAmt(toFixedPtAmt("100"));
         });
         it("should not revert", async function () {
@@ -147,7 +148,7 @@ describe("RolloverVault", function () {
 
       describe("when usable balance is lower than the minUnderlyingBal", function () {
         beforeEach(async function () {
-          await collateralToken.transfer(vault.address, toFixedPtAmt("20"));
+          await collateralToken.transfer(vault.target, toFixedPtAmt("20"));
           await vault.updateMinDeploymentAmt(toFixedPtAmt("1"));
         });
         it("should revert", async function () {
@@ -157,7 +158,7 @@ describe("RolloverVault", function () {
 
       describe("when usable balance is lower than the min deployment", function () {
         beforeEach(async function () {
-          await collateralToken.transfer(vault.address, toFixedPtAmt("125"));
+          await collateralToken.transfer(vault.target, toFixedPtAmt("125"));
           await vault.updateMinDeploymentAmt(toFixedPtAmt("100"));
         });
         it("should revert", async function () {
@@ -167,7 +168,7 @@ describe("RolloverVault", function () {
 
       describe("when usable balance is higher than the min deployment", function () {
         beforeEach(async function () {
-          await collateralToken.transfer(vault.address, toFixedPtAmt("126"));
+          await collateralToken.transfer(vault.target, toFixedPtAmt("126"));
           await vault.updateMinDeploymentAmt(toFixedPtAmt("100"));
         });
         it("should not revert", async function () {
@@ -180,23 +181,23 @@ describe("RolloverVault", function () {
       let newTranchesIn;
       beforeEach(async function () {
         await advancePerpQueueToBondMaturity(perp, rolloverInBond);
-        const newBondIn = await bondAt(await perp.callStatic.getDepositBond());
+        const newBondIn = await bondAt(await perp.depositBond());
         newTranchesIn = await getTranches(newBondIn);
-        await checkReserveComposition(perp, [collateralToken], [toFixedPtAmt("800")]);
+        await checkPerpComposition(perp, [collateralToken], [toFixedPtAmt("800")]);
       });
 
       describe("when balance covers just 1 token", function () {
         beforeEach(async function () {
-          await collateralToken.transfer(vault.address, toFixedPtAmt("10"));
+          await collateralToken.transfer(vault.target, toFixedPtAmt("10"));
         });
         it("should rollover", async function () {
           await expect(vault.deploy()).not.to.be.reverted;
-          await checkVaultAssetComposition(
+          await checkVaultComposition(
             vault,
             [collateralToken, newTranchesIn[1]],
             [toFixedPtAmt("2"), toFixedPtAmt("8")],
           );
-          await checkReserveComposition(
+          await checkPerpComposition(
             perp,
             [collateralToken, newTranchesIn[0]],
             [toFixedPtAmt("798"), toFixedPtAmt("2")],
@@ -206,16 +207,16 @@ describe("RolloverVault", function () {
 
       describe("when balance covers just 1 token exactly", function () {
         beforeEach(async function () {
-          await collateralToken.transfer(vault.address, toFixedPtAmt("10000"));
+          await collateralToken.transfer(vault.target, toFixedPtAmt("10000"));
         });
         it("should rollover", async function () {
           await expect(vault.deploy()).not.to.be.reverted;
-          await checkVaultAssetComposition(
+          await checkVaultComposition(
             vault,
             [collateralToken, newTranchesIn[1]],
             [toFixedPtAmt("6800"), toFixedPtAmt("3200")],
           );
-          await checkReserveComposition(perp, [collateralToken, newTranchesIn[0]], ["0", toFixedPtAmt("800")]);
+          await checkPerpComposition(perp, [collateralToken, newTranchesIn[0]], ["0", toFixedPtAmt("800")]);
         });
       });
     });
@@ -223,48 +224,48 @@ describe("RolloverVault", function () {
     describe("when one trancheIn one tokenOut (near mature tranche)", function () {
       let curTranchesIn, newTranchesIn;
       beforeEach(async function () {
-        await advancePerpQueueToBondMaturity(perp, await bondAt(reserveTranches[2].bond()));
-        const curBondIn = await bondAt(await perp.callStatic.getDepositBond());
+        await advancePerpQueueToBondMaturity(perp, await bondAt(await reserveTranches[2].bond()));
+        const curBondIn = await bondAt(await perp.depositBond());
         curTranchesIn = await getTranches(curBondIn);
-        await collateralToken.transfer(vault.address, toFixedPtAmt("10000"));
+        await collateralToken.transfer(vault.target, toFixedPtAmt("10000"));
         await vault.deploy();
 
         await advancePerpQueueToRollover(perp, curBondIn);
-        const newBondIn = await bondAt(await perp.callStatic.getDepositBond());
+        const newBondIn = await bondAt(await perp.depositBond());
 
         newTranchesIn = await getTranches(newBondIn);
-        await checkVaultAssetComposition(
+        await checkVaultComposition(
           vault,
           [collateralToken, reserveTranches[3], curTranchesIn[1]],
           [toFixedPtAmt("6600"), toFixedPtAmt("200"), toFixedPtAmt("3200")],
         );
-        await checkReserveComposition(perp, [collateralToken, curTranchesIn[0]], ["0", toFixedPtAmt("800")]);
+        await checkPerpComposition(perp, [collateralToken, curTranchesIn[0]], ["0", toFixedPtAmt("800")]);
       });
 
       describe("when balance covers just 1 token", function () {
         it("should rollover", async function () {
           await expect(vault.deploy()).not.to.be.reverted;
-          await checkVaultAssetComposition(
+          await checkVaultComposition(
             vault,
             [collateralToken, newTranchesIn[1], reserveTranches[3]],
             [toFixedPtAmt("6600"), toFixedPtAmt("3200"), toFixedPtAmt("200")],
           );
-          await checkReserveComposition(perp, [collateralToken, newTranchesIn[0]], ["0", toFixedPtAmt("800")]);
+          await checkPerpComposition(perp, [collateralToken, newTranchesIn[0]], ["0", toFixedPtAmt("800")]);
         });
       });
 
       describe("when balance covers just 1 token exactly", function () {
         beforeEach(async function () {
-          await collateralToken.transfer(vault.address, toFixedPtAmt("8500"));
+          await collateralToken.transfer(vault.target, toFixedPtAmt("8500"));
         });
         it("should rollover", async function () {
           await expect(vault.deploy()).not.to.be.reverted;
-          await checkVaultAssetComposition(
+          await checkVaultComposition(
             vault,
             [collateralToken, reserveTranches[3], newTranchesIn[1]],
             [toFixedPtAmt("15100"), toFixedPtAmt("200"), toFixedPtAmt("3200")],
           );
-          await checkReserveComposition(perp, [collateralToken, newTranchesIn[0]], ["0", toFixedPtAmt("800")]);
+          await checkPerpComposition(perp, [collateralToken, newTranchesIn[0]], ["0", toFixedPtAmt("800")]);
         });
       });
     });
@@ -272,16 +273,16 @@ describe("RolloverVault", function () {
     describe("when one trancheIn many tokenOut", function () {
       describe("when balance covers just 1 token", function () {
         beforeEach(async function () {
-          await collateralToken.transfer(vault.address, toFixedPtAmt("10"));
+          await collateralToken.transfer(vault.target, toFixedPtAmt("10"));
         });
         it("should rollover", async function () {
           await expect(vault.deploy()).not.to.be.reverted;
-          await checkVaultAssetComposition(
+          await checkVaultComposition(
             vault,
             [collateralToken, rolloverInTranches[1]],
             [toFixedPtAmt("2"), toFixedPtAmt("8")],
           );
-          await checkReserveComposition(
+          await checkPerpComposition(
             perp,
             [collateralToken, ...reserveTranches.slice(-3), rolloverInTranches[0]],
             [toFixedPtAmt("198"), toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("2")],
@@ -291,16 +292,16 @@ describe("RolloverVault", function () {
 
       describe("when balance covers just 1 token exactly", function () {
         beforeEach(async function () {
-          await collateralToken.transfer(vault.address, toFixedPtAmt("1000"));
+          await collateralToken.transfer(vault.target, toFixedPtAmt("1000"));
         });
         it("should rollover", async function () {
           await expect(vault.deploy()).not.to.be.reverted;
-          await checkVaultAssetComposition(
+          await checkVaultComposition(
             vault,
             [collateralToken, rolloverInTranches[1]],
             [toFixedPtAmt("200"), toFixedPtAmt("800")],
           );
-          await checkReserveComposition(
+          await checkPerpComposition(
             perp,
             [collateralToken, ...reserveTranches.slice(-3), rolloverInTranches[0]],
             ["0", toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("200")],
@@ -310,16 +311,16 @@ describe("RolloverVault", function () {
 
       describe("when balance covers many tokens", function () {
         beforeEach(async function () {
-          await collateralToken.transfer(vault.address, toFixedPtAmt("4000"));
+          await collateralToken.transfer(vault.target, toFixedPtAmt("4000"));
         });
         it("should rollover", async function () {
           await expect(vault.deploy()).not.to.be.reverted;
-          await checkVaultAssetComposition(
+          await checkVaultComposition(
             vault,
             [collateralToken, reserveTranches[1], rolloverInTranches[1]],
             [toFixedPtAmt("2200"), toFixedPtAmt("200"), toFixedPtAmt("1600")],
           );
-          await checkReserveComposition(
+          await checkPerpComposition(
             perp,
             [collateralToken, ...reserveTranches.slice(-2), rolloverInTranches[0]],
             ["0", toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("400")],
@@ -332,16 +333,16 @@ describe("RolloverVault", function () {
       describe("when balance covers many tokens", async function () {
         beforeEach(async function () {
           await rebase(collateralToken, rebaseOracle, -0.9);
-          await collateralToken.transfer(vault.address, toFixedPtAmt("600"));
+          await collateralToken.transfer(vault.target, toFixedPtAmt("600"));
         });
         it("should rollover", async function () {
           await expect(vault.deploy()).not.to.be.reverted;
-          await checkVaultAssetComposition(
+          await checkVaultComposition(
             vault,
             [collateralToken, reserveTranches[1], rolloverInTranches[1]],
             [toFixedPtAmt("20"), toFixedPtAmt("200"), toFixedPtAmt("480")],
           );
-          await checkReserveComposition(
+          await checkPerpComposition(
             perp,
             [collateralToken, ...reserveTranches.slice(-2), rolloverInTranches[0]],
             ["0", toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("120")],
@@ -352,18 +353,18 @@ describe("RolloverVault", function () {
 
     describe("when rollover fee is +ve", function () {
       beforeEach(async function () {
-        await feePolicy.computePerpRolloverFeePerc.returns(toPercFixedPtAmt("0.01"));
-        await collateralToken.transfer(vault.address, toFixedPtAmt("1500"));
+        await balancer.mockMethod("computePerpRolloverFeePerc(uint256)", [toPercFixedPtAmt("0.01")]);
+        await collateralToken.transfer(vault.target, toFixedPtAmt("1500"));
       });
 
       it("should rollover", async function () {
         await expect(vault.deploy()).not.to.be.reverted;
-        await checkVaultAssetComposition(
+        await checkVaultComposition(
           vault,
           [collateralToken, reserveTranches[1], rolloverInTranches[1]],
           [toFixedPtAmt("200"), toFixedPtAmt("96.999999999999999999"), toFixedPtAmt("1200")],
         );
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, reserveTranches[1], reserveTranches[2], reserveTranches[3], rolloverInTranches[0]],
           ["0", toFixedPtAmt("103.000000000000000001"), toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("300")],
@@ -373,18 +374,18 @@ describe("RolloverVault", function () {
 
     describe("when rollover fee is -ve", function () {
       beforeEach(async function () {
-        await feePolicy.computePerpRolloverFeePerc.returns(toPercFixedPtAmt("-0.01"));
-        await collateralToken.transfer(vault.address, toFixedPtAmt("1500"));
+        await balancer.mockMethod("computePerpRolloverFeePerc(uint256)", [toPercFixedPtAmt("-0.01")]);
+        await collateralToken.transfer(vault.target, toFixedPtAmt("1500"));
       });
 
       it("should rollover", async function () {
         await expect(vault.deploy()).not.to.be.reverted;
-        await checkVaultAssetComposition(
+        await checkVaultComposition(
           vault,
           [collateralToken, reserveTranches[1], rolloverInTranches[1]],
           [toFixedPtAmt("200"), toFixedPtAmt("102.999999999999999999"), toFixedPtAmt("1200")],
         );
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, reserveTranches[1], reserveTranches[2], reserveTranches[3], rolloverInTranches[0]],
           ["0", toFixedPtAmt("97.000000000000000001"), toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("300")],
@@ -396,8 +397,8 @@ describe("RolloverVault", function () {
       let txFn: Promise<Transaction>;
       beforeEach(async function () {
         await rebase(collateralToken, rebaseOracle, -0.9);
-        await feePolicy.computePerpRolloverFeePerc.returns(toPercFixedPtAmt("-0.01"));
-        await collateralToken.transfer(vault.address, toFixedPtAmt("1000"));
+        await balancer.mockMethod("computePerpRolloverFeePerc(uint256)", [toPercFixedPtAmt("-0.01")]);
+        await collateralToken.transfer(vault.target, toFixedPtAmt("1000"));
 
         txFn = () => vault.deploy();
       });
@@ -406,30 +407,30 @@ describe("RolloverVault", function () {
         const tx = txFn();
 
         // Tranche
-        await expect(tx).to.emit(vault, "AssetSynced").withArgs(rolloverInTranches[0].address, toFixedPtAmt("200"));
-        await expect(tx).to.emit(vault, "AssetSynced").withArgs(rolloverInTranches[1].address, toFixedPtAmt("800"));
+        await expect(tx).to.emit(vault, "AssetSynced").withArgs(rolloverInTranches[0].target, toFixedPtAmt("200"));
+        await expect(tx).to.emit(vault, "AssetSynced").withArgs(rolloverInTranches[1].target, toFixedPtAmt("800"));
 
         // Rollover
-        await expect(tx).to.emit(vault, "AssetSynced").withArgs(reserveTranches[1].address, toFixedPtAmt("200"));
+        await expect(tx).to.emit(vault, "AssetSynced").withArgs(reserveTranches[1].target, toFixedPtAmt("200"));
 
         // Recover
         await expect(tx)
           .to.emit(vault, "AssetSynced")
-          .withArgs(rolloverInTranches[0].address, toFixedPtAmt("0.000000000000000118"));
+          .withArgs(rolloverInTranches[0].target, toFixedPtAmt("0.000000000000000118"));
         await expect(tx)
           .to.emit(vault, "AssetSynced")
-          .withArgs(rolloverInTranches[1].address, toFixedPtAmt("475.247524752475248"));
+          .withArgs(rolloverInTranches[1].target, toFixedPtAmt("475.247524752475248"));
 
         // Final
         await expect(tx)
           .to.emit(vault, "AssetSynced")
-          .withArgs(collateralToken.address, toFixedPtAmt("425.940594059405940000"));
+          .withArgs(collateralToken.target, toFixedPtAmt("425.940594059405940000"));
       });
 
       it("should update the list of deployed assets", async function () {
         await txFn();
 
-        await checkVaultAssetComposition(
+        await checkVaultComposition(
           vault,
           [collateralToken, reserveTranches[1], rolloverInTranches[0], rolloverInTranches[1]],
           [
@@ -440,7 +441,7 @@ describe("RolloverVault", function () {
           ],
         );
 
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, reserveTranches[2], reserveTranches[3], rolloverInTranches[0]],
           ["0", toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("118.811881188118811882")],
@@ -451,9 +452,9 @@ describe("RolloverVault", function () {
 
   describe("deploy limit", function () {
     async function setupDeployment() {
-      const curBondIn = await bondAt(await perp.callStatic.getDepositBond());
+      const curBondIn = await bondAt(await perp.depositBond());
       await advancePerpQueueToRollover(perp, curBondIn);
-      await collateralToken.transfer(vault.address, toFixedPtAmt("10"));
+      await collateralToken.transfer(vault.target, toFixedPtAmt("10"));
     }
 
     beforeEach(async function () {
@@ -468,9 +469,11 @@ describe("RolloverVault", function () {
       await setupDeployment();
       await expect(vault.deploy()).to.be.revertedWithCustomError(vault, "DeployedCountOverLimit");
     });
+
     it("redemption should be within gas limit", async function () {
-      await collateralToken.approve(vault.address, toFixedPtAmt("10"));
-      await vault.deposit(toFixedPtAmt("10"));
+      await collateralToken.approve(vault.target, toFixedPtAmt("10"));
+      await vault.updateBalancer(await deployer.getAddress());
+      await vault["deposit(uint256)"](toFixedPtAmt("10"));
       await expect(vault.redeem(await vault.balanceOf(await deployer.getAddress()))).not.to.be.reverted;
     });
 
diff --git a/spot-contracts/test/rollover-vault/RolloverVault_deposit_redeem.ts b/spot-contracts/test/rollover-vault/RolloverVault_deposit_redeem.ts
index 80ec756e..e7d7288f 100644
--- a/spot-contracts/test/rollover-vault/RolloverVault_deposit_redeem.ts
+++ b/spot-contracts/test/rollover-vault/RolloverVault_deposit_redeem.ts
@@ -1,8 +1,6 @@
-import { expect, use } from "chai";
+import { expect } from "chai";
 import { network, ethers, upgrades } from "hardhat";
 import { Contract, Signer, BigNumber } from "ethers";
-import { smock } from "@defi-wonderland/smock";
-
 import {
   setupCollateralToken,
   mintCollteralToken,
@@ -11,16 +9,17 @@ import {
   bondAt,
   getTranches,
   toFixedPtAmt,
+  toPercFixedPtAmt,
   getDepositBond,
   advancePerpQueue,
   advancePerpQueueToBondMaturity,
-  checkReserveComposition,
-  checkVaultAssetComposition,
+  checkPerpComposition,
+  checkVaultComposition,
   rebase,
-  toPercFixedPtAmt,
-  advancePerpQueueUpToBondMaturity,
+  mintVaultNotes,
+  redeemVaultNotes,
+  DMock,
 } from "../helpers";
-use(smock.matchers);
 
 let deployer: Signer;
 let deployerAddress: string;
@@ -32,15 +31,15 @@ let bondFactory: Contract;
 let collateralToken: Contract;
 let rebaseOracle: Contract;
 let issuer: Contract;
-let feePolicy: Contract;
+let balancer: Contract;
 
 let reserveTranches: Contract[][] = [];
 let rolloverInBond: Contract;
-let rolloverInTranches: Contract;
+let rolloverInTranches: Contract[];
 
 describe("RolloverVault", function () {
   beforeEach(async function () {
-    await network.provider.send("hardhat_reset");
+    await network.provider.request({ method: "hardhat_reset" });
 
     const accounts = await ethers.getSigners();
     deployer = accounts[0];
@@ -54,33 +53,34 @@ describe("RolloverVault", function () {
     const BondIssuer = await ethers.getContractFactory("BondIssuer");
     issuer = await upgrades.deployProxy(
       BondIssuer.connect(deployer),
-      [bondFactory.address, collateralToken.address, 4800, [200, 800], 1200, 0],
+      [bondFactory.target, collateralToken.target, 4800, [200, 800], 1200, 0],
       {
         initializer: "init(address,address,uint256,uint256[],uint256,uint256)",
       },
     );
 
-    const FeePolicy = await ethers.getContractFactory("FeePolicy");
-    feePolicy = await smock.fake(FeePolicy);
-    await feePolicy.decimals.returns(8);
-    await feePolicy.computePerpRolloverFeePerc.returns("0");
+    balancer = new DMock(await ethers.getContractFactory("Balancer"));
+    await balancer.deploy();
+    await balancer.mockMethod("decimals()", [8]);
+    await balancer.mockMethod("computeDeviationRatio(uint256,uint256,uint256)", [toPercFixedPtAmt("1")]);
+    await balancer.mockMethod("computePerpRolloverFeePerc(uint256)", [0n]);
 
     const PerpetualTranche = await ethers.getContractFactory("PerpetualTranche");
     perp = await upgrades.deployProxy(
       PerpetualTranche.connect(deployer),
-      ["PerpetualTranche", "PERP", collateralToken.address, issuer.address, feePolicy.address],
+      ["PerpetualTranche", "PERP", collateralToken.target, issuer.target],
       {
-        initializer: "init(string,string,address,address,address)",
+        initializer: "init(string,string,address,address)",
       },
     );
-
     await perp.updateTolerableTrancheMaturity(1200, 4800);
     await advancePerpQueueToBondMaturity(perp, await getDepositBond(perp));
 
     const RolloverVault = await ethers.getContractFactory("RolloverVault");
     vault = await upgrades.deployProxy(RolloverVault.connect(deployer));
-    await vault.init("RolloverVault", "VSHARE", perp.address, feePolicy.address);
-    await perp.updateVault(vault.address);
+    await vault.init("RolloverVault", "VSHARE", perp.target);
+    await vault.updateBalancer(balancer.target);
+    await perp.updateVault(deployerAddress);
 
     reserveTranches = [];
     for (let i = 0; i < 3; i++) {
@@ -88,24 +88,26 @@ describe("RolloverVault", function () {
       const tranches = await getTranches(bond);
       await depositIntoBond(bond, toFixedPtAmt("1000"), deployer);
 
-      await tranches[0].approve(perp.address, toFixedPtAmt("200"));
-      await perp.deposit(tranches[0].address, toFixedPtAmt("200"));
+      await tranches[0].approve(perp.target, toFixedPtAmt("200"));
+      await perp.deposit(tranches[0].target, toFixedPtAmt("200"));
 
       reserveTranches.push(tranches[0]);
       await advancePerpQueue(perp, 1200);
     }
 
-    await checkReserveComposition(
+    await checkPerpComposition(
       perp,
       [collateralToken, ...reserveTranches],
       ["0", toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("200")],
     );
 
-    rolloverInBond = await bondAt(await perp.callStatic.getDepositBond());
+    rolloverInBond = await bondAt(await perp.depositBond());
     rolloverInTranches = await getTranches(rolloverInBond);
 
     await mintCollteralToken(collateralToken, toFixedPtAmt("100000"), deployer);
-    await collateralToken.approve(vault.address, toFixedPtAmt("1"));
+
+    await perp.updateBalancer(balancer.target);
+    await perp.updateVault(vault.target);
 
     expect(await vault.assetCount()).to.eq(1);
     expect(await vault.vaultAssetBalance(await vault.underlying())).to.eq(0);
@@ -114,125 +116,125 @@ describe("RolloverVault", function () {
   describe("#getTVL", function () {
     describe("when vault is empty", function () {
       it("should return 0 vaule", async function () {
-        expect(await vault.callStatic.getTVL()).to.eq(0);
-        expect(await vault.callStatic.getVaultAssetValue(collateralToken.address)).to.eq(0);
-        expect(await vault.callStatic.getVaultAssetValue(perp.address)).to.eq(0);
+        expect(await vault.getTVL()).to.eq(0);
+        expect(await vault.vaultAssetValue(collateralToken.target)).to.eq(0);
+        expect(await vault.vaultAssetValue(perp.target)).to.eq(0);
       });
     });
 
     describe("when vault has only usable balance", function () {
       beforeEach(async function () {
-        await collateralToken.transfer(vault.address, toFixedPtAmt("100"));
+        await collateralToken.transfer(vault.target, toFixedPtAmt("100"));
       });
       it("should return tvl", async function () {
-        expect(await vault.callStatic.getTVL()).to.eq(toFixedPtAmt("100"));
+        expect(await vault.getTVL()).to.eq(toFixedPtAmt("100"));
       });
       it("should return asset value", async function () {
-        expect(await vault.callStatic.getVaultAssetValue(collateralToken.address)).to.eq(toFixedPtAmt("100"));
-        expect(await vault.callStatic.getVaultAssetValue(perp.address)).to.eq(0);
+        expect(await vault.vaultAssetValue(collateralToken.target)).to.eq(toFixedPtAmt("100"));
+        expect(await vault.vaultAssetValue(perp.target)).to.eq(0);
       });
     });
 
     describe("when vault has only deployed balance", function () {
       beforeEach(async function () {
-        await collateralToken.transfer(vault.address, toFixedPtAmt("100"));
+        await collateralToken.transfer(vault.target, toFixedPtAmt("100"));
         await vault.deploy();
         expect(await vault.vaultAssetBalance(await vault.underlying())).to.eq(0);
         expect(await vault.assetCount()).to.eq(3);
       });
       it("should return tvl", async function () {
-        expect(await vault.callStatic.getTVL()).to.eq(toFixedPtAmt("100"));
+        expect(await vault.getTVL()).to.eq(toFixedPtAmt("100"));
       });
       it("should return asset value", async function () {
-        expect(await vault.callStatic.getVaultAssetValue(collateralToken.address)).to.eq(0);
-        expect(await vault.callStatic.getVaultAssetValue(reserveTranches[0].address)).to.eq(toFixedPtAmt("20"));
-        expect(await vault.callStatic.getVaultAssetValue(rolloverInTranches[1].address)).to.eq(toFixedPtAmt("80"));
-        expect(await vault.callStatic.getVaultAssetValue(perp.address)).to.eq(0);
+        expect(await vault.vaultAssetValue(collateralToken.target)).to.eq(0);
+        expect(await vault.vaultAssetValue(reserveTranches[0].target)).to.eq(toFixedPtAmt("20"));
+        expect(await vault.vaultAssetValue(rolloverInTranches[1].target)).to.eq(toFixedPtAmt("80"));
+        expect(await vault.vaultAssetValue(perp.target)).to.eq(0);
       });
     });
 
     describe("when vault has many balances", function () {
       beforeEach(async function () {
-        await perp.transfer(vault.address, toFixedPtAmt("100"));
-        await collateralToken.transfer(vault.address, toFixedPtAmt("2000"));
+        await perp.transfer(vault.target, toFixedPtAmt("100"));
+        await collateralToken.transfer(vault.target, toFixedPtAmt("2000"));
         await vault.deploy();
-        await collateralToken.transfer(vault.address, toFixedPtAmt("100"));
+        await collateralToken.transfer(vault.target, toFixedPtAmt("100"));
       });
       it("should return tvl", async function () {
-        expect(await vault.callStatic.getTVL()).to.eq(toFixedPtAmt("2100"));
+        expect(await vault.getTVL()).to.eq(toFixedPtAmt("2100"));
       });
       it("should return asset value", async function () {
-        expect(await vault.callStatic.getVaultAssetValue(perp.address)).to.eq("0");
-        expect(await vault.callStatic.getVaultAssetValue(collateralToken.address)).to.eq(toFixedPtAmt("1100"));
-        expect(await vault.callStatic.getVaultAssetValue(reserveTranches[0].address)).to.eq(toFixedPtAmt("200"));
-        expect(await vault.callStatic.getVaultAssetValue(rolloverInTranches[1].address)).to.eq(toFixedPtAmt("800"));
+        expect(await vault.vaultAssetValue(perp.target)).to.eq("0");
+        expect(await vault.vaultAssetValue(collateralToken.target)).to.eq(toFixedPtAmt("1100"));
+        expect(await vault.vaultAssetValue(reserveTranches[0].target)).to.eq(toFixedPtAmt("200"));
+        expect(await vault.vaultAssetValue(rolloverInTranches[1].target)).to.eq(toFixedPtAmt("800"));
       });
     });
 
     describe("when vault has many balances and rebases up", function () {
       beforeEach(async function () {
-        await collateralToken.transfer(vault.address, toFixedPtAmt("2000"));
+        await collateralToken.transfer(vault.target, toFixedPtAmt("2000"));
         await vault.deploy();
-        await collateralToken.transfer(vault.address, toFixedPtAmt("100"));
+        await collateralToken.transfer(vault.target, toFixedPtAmt("100"));
         await rebase(collateralToken, rebaseOracle, 0.1);
       });
       it("should return tvl", async function () {
-        expect(await vault.callStatic.getTVL()).to.eq(toFixedPtAmt("2310"));
+        expect(await vault.getTVL()).to.eq(toFixedPtAmt("2310"));
       });
       it("should return asset value", async function () {
-        expect(await vault.callStatic.getVaultAssetValue(collateralToken.address)).to.eq(toFixedPtAmt("1210"));
-        expect(await vault.callStatic.getVaultAssetValue(reserveTranches[0].address)).to.eq(toFixedPtAmt("200"));
-        expect(await vault.callStatic.getVaultAssetValue(rolloverInTranches[1].address)).to.eq(toFixedPtAmt("900"));
+        expect(await vault.vaultAssetValue(collateralToken.target)).to.eq(toFixedPtAmt("1210"));
+        expect(await vault.vaultAssetValue(reserveTranches[0].target)).to.eq(toFixedPtAmt("200"));
+        expect(await vault.vaultAssetValue(rolloverInTranches[1].target)).to.eq(toFixedPtAmt("900"));
       });
     });
 
     describe("when vault has many balances and rebases down", function () {
       beforeEach(async function () {
-        await collateralToken.transfer(vault.address, toFixedPtAmt("2000"));
+        await collateralToken.transfer(vault.target, toFixedPtAmt("2000"));
         await vault.deploy();
-        await collateralToken.transfer(vault.address, toFixedPtAmt("100"));
+        await collateralToken.transfer(vault.target, toFixedPtAmt("100"));
         await rebase(collateralToken, rebaseOracle, -0.1);
       });
       it("should return tvl", async function () {
-        expect(await vault.callStatic.getTVL()).to.eq(toFixedPtAmt("1890"));
+        expect(await vault.getTVL()).to.eq(toFixedPtAmt("1890"));
       });
       it("should return asset value", async function () {
-        expect(await vault.callStatic.getVaultAssetValue(collateralToken.address)).to.eq(toFixedPtAmt("990"));
-        expect(await vault.callStatic.getVaultAssetValue(reserveTranches[0].address)).to.eq(toFixedPtAmt("200"));
-        expect(await vault.callStatic.getVaultAssetValue(rolloverInTranches[1].address)).to.eq(toFixedPtAmt("700"));
+        expect(await vault.vaultAssetValue(collateralToken.target)).to.eq(toFixedPtAmt("990"));
+        expect(await vault.vaultAssetValue(reserveTranches[0].target)).to.eq(toFixedPtAmt("200"));
+        expect(await vault.vaultAssetValue(rolloverInTranches[1].target)).to.eq(toFixedPtAmt("700"));
       });
     });
 
     describe("when vault has many balances and rebases down below threshold", function () {
       beforeEach(async function () {
-        await collateralToken.transfer(vault.address, toFixedPtAmt("5000"));
+        await collateralToken.transfer(vault.target, toFixedPtAmt("5000"));
         await vault.deploy();
-        await collateralToken.transfer(vault.address, toFixedPtAmt("100"));
+        await collateralToken.transfer(vault.target, toFixedPtAmt("100"));
         await rebase(collateralToken, rebaseOracle, -0.9);
       });
 
       it("should return tvl", async function () {
-        expect(await vault.callStatic.getTVL()).to.eq(toFixedPtAmt("510"));
+        expect(await vault.getTVL()).to.eq(toFixedPtAmt("510"));
       });
 
       it("should return asset value", async function () {
-        expect(await vault.callStatic.getVaultAssetValue(collateralToken.address)).to.eq(toFixedPtAmt("410"));
-        expect(await vault.callStatic.getVaultAssetValue(reserveTranches[0].address)).to.eq(toFixedPtAmt("100"));
-        expect(await vault.callStatic.getVaultAssetValue(reserveTranches[1].address)).to.eq("0");
-        expect(await vault.callStatic.getVaultAssetValue(reserveTranches[2].address)).to.eq("0");
-        expect(await vault.callStatic.getVaultAssetValue(rolloverInTranches[0].address)).to.eq(toFixedPtAmt("0"));
-        expect(await vault.callStatic.getVaultAssetValue(rolloverInTranches[1].address)).to.eq("0");
+        expect(await vault.vaultAssetValue(collateralToken.target)).to.eq(toFixedPtAmt("410"));
+        expect(await vault.vaultAssetValue(reserveTranches[0].target)).to.eq(toFixedPtAmt("100"));
+        expect(await vault.vaultAssetValue(reserveTranches[1].target)).to.eq("0");
+        expect(await vault.vaultAssetValue(reserveTranches[2].target)).to.eq("0");
+        expect(await vault.vaultAssetValue(rolloverInTranches[0].target)).to.eq(toFixedPtAmt("0"));
+        expect(await vault.vaultAssetValue(rolloverInTranches[1].target)).to.eq("0");
       });
     });
 
     describe("when vault has some dust balances", function () {
       beforeEach(async function () {
-        await perp.transfer(vault.address, toFixedPtAmt("100"));
-        await collateralToken.transfer(vault.address, toFixedPtAmt("2000"));
+        await perp.transfer(vault.target, toFixedPtAmt("100"));
+        await collateralToken.transfer(vault.target, toFixedPtAmt("2000"));
         await vault.deploy();
-        await vault["recover(address)"](perp.address);
-        await collateralToken.transfer(vault.address, toFixedPtAmt("100"));
-        await checkVaultAssetComposition(
+        await vault["recover(address)"](perp.target);
+        await collateralToken.transfer(vault.target, toFixedPtAmt("100"));
+        await checkVaultComposition(
           vault,
           [
             collateralToken,
@@ -254,27 +256,19 @@ describe("RolloverVault", function () {
       });
       it("should return tvl excluding the dust", async function () {
         // balances sum up to 2200 but tvl will exclude 0.000000000000000133
-        expect(await vault.callStatic.getTVL()).to.eq(toFixedPtAmt("2199.999999999999999866"));
+        expect(await vault.getTVL()).to.eq(toFixedPtAmt("2199.999999999999999866"));
       });
       it("should return asset value", async function () {
-        expect(await vault.callStatic.getVaultAssetValue(perp.address)).to.eq("0");
-        expect(await vault.callStatic.getVaultAssetValue(collateralToken.address)).to.eq(
-          toFixedPtAmt("1266.666666666666666"),
-        );
-        expect(await vault.callStatic.getVaultAssetValue(reserveTranches[0].address)).to.eq(toFixedPtAmt("200"));
-        expect(await vault.callStatic.getVaultAssetValue(reserveTranches[1].address)).to.eq(
-          toFixedPtAmt("33.333333333333333333"),
-        );
-        expect(await vault.callStatic.getVaultAssetValue(reserveTranches[2].address)).to.eq(
-          toFixedPtAmt("33.333333333333333333"),
-        );
-        expect(await vault.callStatic.getVaultAssetValue(rolloverInTranches[1].address)).to.eq(
-          toFixedPtAmt("666.6666666666666672"),
-        );
+        expect(await vault.vaultAssetValue(perp.target)).to.eq("0");
+        expect(await vault.vaultAssetValue(collateralToken.target)).to.eq(toFixedPtAmt("1266.666666666666666"));
+        expect(await vault.vaultAssetValue(reserveTranches[0].target)).to.eq(toFixedPtAmt("200"));
+        expect(await vault.vaultAssetValue(reserveTranches[1].target)).to.eq(toFixedPtAmt("33.333333333333333333"));
+        expect(await vault.vaultAssetValue(reserveTranches[2].target)).to.eq(toFixedPtAmt("33.333333333333333333"));
+        expect(await vault.vaultAssetValue(rolloverInTranches[1].target)).to.eq(toFixedPtAmt("666.6666666666666672"));
       });
       it("should return no asset value for dust", async function () {
-        expect(await rolloverInTranches[0].balanceOf(vault.address)).eq("133");
-        expect(await vault.callStatic.getVaultAssetValue(rolloverInTranches[0].address)).to.eq("0");
+        expect(await rolloverInTranches[0].balanceOf(vault.target)).eq("133");
+        expect(await vault.vaultAssetValue(rolloverInTranches[0].target)).to.eq("0");
       });
     });
   });
@@ -284,45 +278,46 @@ describe("RolloverVault", function () {
 
     describe("when deposit amount is zero", async function () {
       it("should return zero", async function () {
-        expect(await vault.callStatic.deposit("0")).to.eq("0");
+        expect(await vault.computeMintAmt("0")).to.eq("0");
       });
     });
 
     describe("when total supply = 0", async function () {
       beforeEach(async function () {
-        await collateralToken.approve(vault.address, toFixedPtAmt("100"));
-        noteAmt = await vault.callStatic.deposit(toFixedPtAmt("100"));
+        noteAmt = await vault.computeMintAmt(toFixedPtAmt("100"));
       });
       it("should transfer underlying", async function () {
-        await expect(() => vault.deposit(toFixedPtAmt("100"))).to.changeTokenBalances(
+        await expect(() => mintVaultNotes(vault, toFixedPtAmt("100"), deployer)).to.changeTokenBalances(
           collateralToken,
           [deployer, vault],
           [toFixedPtAmt("-100"), toFixedPtAmt("100")],
         );
       });
       it("should update vault", async function () {
-        await checkVaultAssetComposition(vault, [collateralToken], ["0"]);
-        await vault.deposit(toFixedPtAmt("100"));
-        await checkVaultAssetComposition(vault, [collateralToken], [toFixedPtAmt("100")]);
+        await checkVaultComposition(vault, [collateralToken], ["0"]);
+        await mintVaultNotes(vault, toFixedPtAmt("100"), deployer);
+        await checkVaultComposition(vault, [collateralToken], [toFixedPtAmt("100")]);
       });
       it("should mint notes", async function () {
-        await expect(() => vault.deposit(toFixedPtAmt("100"))).to.changeTokenBalances(vault, [deployer], [noteAmt]);
+        await expect(() => mintVaultNotes(vault, toFixedPtAmt("100"), deployer)).to.changeTokenBalances(
+          vault,
+          [deployer],
+          [noteAmt],
+        );
       });
       it("should return the note amount", async function () {
-        expect(noteAmt).to.eq(toFixedPtAmt("100").mul("1000000"));
+        expect(noteAmt).to.eq(toFixedPtAmt("100") * 1000000n);
       });
     });
 
     describe("when total supply > 0 and tvl = ts", async function () {
       beforeEach(async function () {
-        await collateralToken.approve(vault.address, toFixedPtAmt("100"));
-        await vault.deposit(toFixedPtAmt("100"));
+        await mintVaultNotes(vault, toFixedPtAmt("100"), deployer);
         await collateralToken.transfer(otherUserAddress, toFixedPtAmt("100"));
-        await collateralToken.connect(otherUser).approve(vault.address, toFixedPtAmt("100"));
-        noteAmt = await vault.connect(otherUser).callStatic.deposit(toFixedPtAmt("100"));
+        noteAmt = await vault.computeMintAmt(toFixedPtAmt("100"));
       });
       it("should transfer underlying", async function () {
-        await expect(() => vault.connect(otherUser).deposit(toFixedPtAmt("100"))).to.changeTokenBalances(
+        await expect(() => mintVaultNotes(vault, toFixedPtAmt("100"), otherUser)).to.changeTokenBalances(
           collateralToken,
           [otherUser, vault],
           [toFixedPtAmt("-100"), toFixedPtAmt("100")],
@@ -330,35 +325,33 @@ describe("RolloverVault", function () {
       });
 
       it("should update vault", async function () {
-        await checkVaultAssetComposition(vault, [collateralToken], [toFixedPtAmt("100")]);
-        await vault.connect(otherUser).deposit(toFixedPtAmt("100"));
-        await checkVaultAssetComposition(vault, [collateralToken], [toFixedPtAmt("200")]);
+        await checkVaultComposition(vault, [collateralToken], [toFixedPtAmt("100")]);
+        await mintVaultNotes(vault, toFixedPtAmt("100"), otherUser);
+        await checkVaultComposition(vault, [collateralToken], [toFixedPtAmt("200")]);
       });
 
       it("should mint notes", async function () {
-        await expect(() => vault.connect(otherUser).deposit(toFixedPtAmt("100"))).to.changeTokenBalances(
+        await expect(() => mintVaultNotes(vault, toFixedPtAmt("100"), otherUser)).to.changeTokenBalances(
           vault,
           [otherUser, deployer],
           [noteAmt, "0"],
         );
       });
       it("should return the note amount", async function () {
-        expect(noteAmt).to.eq(toFixedPtAmt("100").mul("1000000"));
+        expect(noteAmt).to.eq(toFixedPtAmt("100") * 1000000n);
       });
     });
 
     describe("when total supply > 0 and tvl > ts", async function () {
       beforeEach(async function () {
-        await collateralToken.approve(vault.address, toFixedPtAmt("100"));
-        await vault.deposit(toFixedPtAmt("100"));
-        await collateralToken.transfer(vault.address, toFixedPtAmt("100"));
+        await mintVaultNotes(vault, toFixedPtAmt("100"), deployer);
+        await collateralToken.transfer(vault.target, toFixedPtAmt("100"));
         await collateralToken.transfer(otherUserAddress, toFixedPtAmt("100"));
-        await collateralToken.connect(otherUser).approve(vault.address, toFixedPtAmt("100"));
-        noteAmt = await vault.connect(otherUser).callStatic.deposit(toFixedPtAmt("100"));
+        noteAmt = await vault.computeMintAmt(toFixedPtAmt("100"));
       });
 
       it("should transfer underlying", async function () {
-        await expect(() => vault.connect(otherUser).deposit(toFixedPtAmt("100"))).to.changeTokenBalances(
+        await expect(() => mintVaultNotes(vault, toFixedPtAmt("100"), otherUser)).to.changeTokenBalances(
           collateralToken,
           [otherUser, vault],
           [toFixedPtAmt("-100"), toFixedPtAmt("100")],
@@ -366,35 +359,33 @@ describe("RolloverVault", function () {
       });
 
       it("should update vault", async function () {
-        await checkVaultAssetComposition(vault, [collateralToken], [toFixedPtAmt("200")]);
-        await vault.connect(otherUser).deposit(toFixedPtAmt("100"));
-        await checkVaultAssetComposition(vault, [collateralToken], [toFixedPtAmt("300")]);
+        await checkVaultComposition(vault, [collateralToken], [toFixedPtAmt("200")]);
+        await mintVaultNotes(vault, toFixedPtAmt("100"), otherUser);
+        await checkVaultComposition(vault, [collateralToken], [toFixedPtAmt("300")]);
       });
 
       it("should mint notes", async function () {
-        await expect(() => vault.connect(otherUser).deposit(toFixedPtAmt("100"))).to.changeTokenBalances(
+        await expect(() => mintVaultNotes(vault, toFixedPtAmt("100"), otherUser)).to.changeTokenBalances(
           vault,
           [otherUser, deployer],
           [noteAmt, "0"],
         );
       });
       it("should return the note amount", async function () {
-        expect(noteAmt).to.eq(toFixedPtAmt("100").mul("500000"));
+        expect(noteAmt).to.eq(toFixedPtAmt("100") * 500000n);
       });
     });
 
     describe("when total supply > 0 and tvl < ts", async function () {
       beforeEach(async function () {
-        await collateralToken.approve(vault.address, toFixedPtAmt("100"));
-        await vault.deposit(toFixedPtAmt("100"));
+        await mintVaultNotes(vault, toFixedPtAmt("100"), deployer);
         await rebase(collateralToken, rebaseOracle, -0.5);
         await collateralToken.transfer(otherUserAddress, toFixedPtAmt("100"));
-        await collateralToken.connect(otherUser).approve(vault.address, toFixedPtAmt("100"));
-        noteAmt = await vault.connect(otherUser).callStatic.deposit(toFixedPtAmt("100"));
+        noteAmt = await vault.computeMintAmt(toFixedPtAmt("100"));
       });
 
       it("should transfer underlying", async function () {
-        await expect(() => vault.connect(otherUser).deposit(toFixedPtAmt("100"))).to.changeTokenBalances(
+        await expect(() => mintVaultNotes(vault, toFixedPtAmt("100"), otherUser)).to.changeTokenBalances(
           collateralToken,
           [otherUser, vault],
           [toFixedPtAmt("-100"), toFixedPtAmt("100")],
@@ -402,13 +393,13 @@ describe("RolloverVault", function () {
       });
 
       it("should update vault", async function () {
-        await checkVaultAssetComposition(vault, [collateralToken], [toFixedPtAmt("50")]);
-        await vault.connect(otherUser).deposit(toFixedPtAmt("100"));
-        await checkVaultAssetComposition(vault, [collateralToken], [toFixedPtAmt("150")]);
+        await checkVaultComposition(vault, [collateralToken], [toFixedPtAmt("50")]);
+        await mintVaultNotes(vault, toFixedPtAmt("100"), otherUser);
+        await checkVaultComposition(vault, [collateralToken], [toFixedPtAmt("150")]);
       });
 
       it("should mint notes", async function () {
-        await expect(() => vault.connect(otherUser).deposit(toFixedPtAmt("100"))).to.changeTokenBalances(
+        await expect(() => mintVaultNotes(vault, toFixedPtAmt("100"), otherUser)).to.changeTokenBalances(
           vault,
           [otherUser, deployer],
           [noteAmt, "0"],
@@ -416,20 +407,18 @@ describe("RolloverVault", function () {
       });
 
       it("should return the note amount", async function () {
-        expect(noteAmt).to.eq(toFixedPtAmt("100").mul("2000000"));
+        expect(noteAmt).to.eq(toFixedPtAmt("100") * 2000000n);
       });
     });
 
     describe("when total supply > 0 and vault has deployed assets", async function () {
       beforeEach(async function () {
-        await collateralToken.approve(vault.address, toFixedPtAmt("100"));
-        await vault.deposit(toFixedPtAmt("100"));
+        await mintVaultNotes(vault, toFixedPtAmt("100"), deployer);
         await collateralToken.transfer(otherUserAddress, toFixedPtAmt("100"));
-        await collateralToken.connect(otherUser).approve(vault.address, toFixedPtAmt("100"));
-        noteAmt = await vault.connect(otherUser).callStatic.deposit(toFixedPtAmt("100"));
+        noteAmt = await vault.computeMintAmt(toFixedPtAmt("100"));
       });
       it("should transfer underlying", async function () {
-        await expect(() => vault.connect(otherUser).deposit(toFixedPtAmt("100"))).to.changeTokenBalances(
+        await expect(() => mintVaultNotes(vault, toFixedPtAmt("100"), otherUser)).to.changeTokenBalances(
           collateralToken,
           [otherUser, vault],
           [toFixedPtAmt("-100"), toFixedPtAmt("100")],
@@ -437,55 +426,20 @@ describe("RolloverVault", function () {
       });
 
       it("should update vault", async function () {
-        await checkVaultAssetComposition(vault, [collateralToken], [toFixedPtAmt("100")]);
-        await vault.connect(otherUser).deposit(toFixedPtAmt("100"));
-        await checkVaultAssetComposition(vault, [collateralToken], [toFixedPtAmt("200")]);
-      });
-
-      it("should mint notes", async function () {
-        await expect(() => vault.connect(otherUser).deposit(toFixedPtAmt("100"))).to.changeTokenBalances(
-          vault,
-          [otherUser, deployer],
-          [noteAmt, "0"],
-        );
-      });
-      it("should return the note amount", async function () {
-        expect(noteAmt).to.eq(toFixedPtAmt("100").mul("1000000"));
-      });
-    });
-
-    describe("fee > 0", async function () {
-      beforeEach(async function () {
-        await collateralToken.approve(vault.address, toFixedPtAmt("100"));
-        await vault.deposit(toFixedPtAmt("100"));
-
-        await feePolicy.computeVaultMintFeePerc.returns(toPercFixedPtAmt("0.05"));
-        await collateralToken.transfer(otherUserAddress, toFixedPtAmt("100"));
-        await collateralToken.connect(otherUser).approve(vault.address, toFixedPtAmt("100"));
-        noteAmt = await vault.connect(otherUser).callStatic.deposit(toFixedPtAmt("100"));
-      });
-      it("should transfer underlying", async function () {
-        await expect(() => vault.connect(otherUser).deposit(toFixedPtAmt("100"))).to.changeTokenBalances(
-          collateralToken,
-          [otherUser, vault],
-          [toFixedPtAmt("-100"), toFixedPtAmt("100")],
-        );
-      });
-      it("should update vault", async function () {
-        await checkVaultAssetComposition(vault, [collateralToken], [toFixedPtAmt("100")]);
-        await vault.connect(otherUser).deposit(toFixedPtAmt("100"));
-        await checkVaultAssetComposition(vault, [collateralToken], [toFixedPtAmt("200")]);
+        await checkVaultComposition(vault, [collateralToken], [toFixedPtAmt("100")]);
+        await mintVaultNotes(vault, toFixedPtAmt("100"), otherUser);
+        await checkVaultComposition(vault, [collateralToken], [toFixedPtAmt("200")]);
       });
 
       it("should mint notes", async function () {
-        await expect(() => vault.connect(otherUser).deposit(toFixedPtAmt("100"))).to.changeTokenBalances(
+        await expect(() => mintVaultNotes(vault, toFixedPtAmt("100"), otherUser)).to.changeTokenBalances(
           vault,
           [otherUser, deployer],
           [noteAmt, "0"],
         );
       });
       it("should return the note amount", async function () {
-        expect(noteAmt).to.eq(toFixedPtAmt("95").mul("1000000"));
+        expect(noteAmt).to.eq(toFixedPtAmt("100") * 1000000n);
       });
     });
   });
@@ -493,49 +447,47 @@ describe("RolloverVault", function () {
   describe("#redeem", function () {
     let bal: BigNumber;
 
+    beforeEach(async function () {});
+
     describe("when vault is empty", function () {
       it("should revert", async function () {
-        await expect(vault.redeem("1")).to.be.reverted;
+        await expect(redeemVaultNotes(vault, "1", deployer)).to.be.reverted;
       });
     });
 
     describe("when redeem amount is zero", async function () {
       beforeEach(async function () {
-        await collateralToken.approve(vault.address, toFixedPtAmt("100"));
-        await vault.deposit(toFixedPtAmt("100"));
+        await mintVaultNotes(vault, toFixedPtAmt("100"), deployer);
       });
 
       it("should return []", async function () {
-        expect(await vault.callStatic.redeem("0")).to.deep.eq([]);
+        expect(await vault.computeRedemptionAmts("0")).to.deep.eq([[collateralToken.target, 0n]]);
       });
     });
 
     describe("when burning more than balance", function () {
       beforeEach(async function () {
-        await collateralToken.approve(vault.address, toFixedPtAmt("100"));
-        await vault.deposit(toFixedPtAmt("100"));
+        await mintVaultNotes(vault, toFixedPtAmt("100"), deployer);
       });
 
       it("should revert", async function () {
-        await expect(vault.redeem((await vault.balanceOf(deployerAddress)).add("1"))).to.be.reverted;
-        await expect(vault.redeem(await vault.balanceOf(deployerAddress))).not.to.be.reverted;
+        await expect(redeemVaultNotes(vault, (await vault.balanceOf(deployerAddress)) + 1n, deployer)).to.be.reverted;
+        await expect(redeemVaultNotes(vault, await vault.balanceOf(deployerAddress), deployer)).not.to.be.reverted;
       });
     });
 
     describe("when vault has only underlying balance", function () {
       beforeEach(async function () {
-        await collateralToken.approve(vault.address, toFixedPtAmt("100"));
-        await vault.deposit(toFixedPtAmt("100"));
+        await mintVaultNotes(vault, toFixedPtAmt("100"), deployer);
 
         await collateralToken.transfer(otherUserAddress, toFixedPtAmt("100"));
-        await collateralToken.connect(otherUser).approve(vault.address, toFixedPtAmt("100"));
-        await vault.connect(otherUser).deposit(toFixedPtAmt("100"));
+        await mintVaultNotes(vault, toFixedPtAmt("100"), otherUser);
 
         bal = await vault.balanceOf(deployerAddress);
       });
 
       it("should transfer assets", async function () {
-        await expect(() => vault.redeem(bal)).to.changeTokenBalances(
+        await expect(() => redeemVaultNotes(vault, bal, deployer)).to.changeTokenBalances(
           collateralToken,
           [deployer, vault],
           [toFixedPtAmt("100"), toFixedPtAmt("-100")],
@@ -543,20 +495,24 @@ describe("RolloverVault", function () {
       });
 
       it("should update vault", async function () {
-        await checkVaultAssetComposition(vault, [collateralToken], [toFixedPtAmt("200")]);
-        await vault.redeem(bal);
-        await checkVaultAssetComposition(vault, [collateralToken], [toFixedPtAmt("100")]);
+        await checkVaultComposition(vault, [collateralToken], [toFixedPtAmt("200")]);
+        await redeemVaultNotes(vault, bal, deployer);
+        await checkVaultComposition(vault, [collateralToken], [toFixedPtAmt("100")]);
       });
 
       it("should burn users notes", async function () {
-        await expect(() => vault.redeem(bal)).to.changeTokenBalances(vault, [deployer], [bal.mul("-1")]);
-        expect(await vault.balanceOf(otherUserAddress)).to.eq(toFixedPtAmt("100").mul("1000000"));
+        await expect(() => redeemVaultNotes(vault, bal, deployer)).to.changeTokenBalances(
+          vault,
+          [deployer],
+          [bal * -1n],
+        );
+        expect(await vault.balanceOf(otherUserAddress)).to.eq(toFixedPtAmt("100") * 1000000n);
       });
 
       it("should return redemption amounts", async function () {
-        const redemptionAmts = await vault.callStatic.redeem(bal);
+        const redemptionAmts = await vault.computeRedemptionAmts(bal);
         expect(redemptionAmts.length).to.eq(1);
-        expect(redemptionAmts[0].token).to.eq(collateralToken.address);
+        expect(redemptionAmts[0].token).to.eq(collateralToken.target);
         expect(redemptionAmts[0].amount).to.eq(toFixedPtAmt("100"));
       });
     });
@@ -564,12 +520,10 @@ describe("RolloverVault", function () {
     describe("when vault has only deployed balance", function () {
       let bal: BigNumber;
       beforeEach(async function () {
-        await collateralToken.approve(vault.address, toFixedPtAmt("100"));
-        await vault.deposit(toFixedPtAmt("100"));
+        await mintVaultNotes(vault, toFixedPtAmt("100"), deployer);
 
         await collateralToken.transfer(otherUserAddress, toFixedPtAmt("100"));
-        await collateralToken.connect(otherUser).approve(vault.address, toFixedPtAmt("100"));
-        await vault.connect(otherUser).deposit(toFixedPtAmt("100"));
+        await mintVaultNotes(vault, toFixedPtAmt("100"), otherUser);
 
         await vault.deploy();
 
@@ -580,7 +534,7 @@ describe("RolloverVault", function () {
       });
 
       it("should transfer assets", async function () {
-        await expect(() => vault.redeem(bal)).to.changeTokenBalances(
+        await expect(() => redeemVaultNotes(vault, bal, deployer)).to.changeTokenBalances(
           reserveTranches[0],
           [deployer, vault],
           [toFixedPtAmt("20"), toFixedPtAmt("-20")],
@@ -588,7 +542,7 @@ describe("RolloverVault", function () {
       });
 
       it("should transfer assets", async function () {
-        await expect(() => vault.redeem(bal)).to.changeTokenBalances(
+        await expect(() => redeemVaultNotes(vault, bal, deployer)).to.changeTokenBalances(
           rolloverInTranches[1],
           [deployer, vault],
           [toFixedPtAmt("80"), toFixedPtAmt("-80")],
@@ -596,13 +550,13 @@ describe("RolloverVault", function () {
       });
 
       it("should update vault", async function () {
-        await checkVaultAssetComposition(
+        await checkVaultComposition(
           vault,
           [collateralToken, reserveTranches[0], rolloverInTranches[1]],
           ["0", toFixedPtAmt("40"), toFixedPtAmt("160")],
         );
-        await vault.redeem(bal);
-        await checkVaultAssetComposition(
+        await redeemVaultNotes(vault, bal, deployer);
+        await checkVaultComposition(
           vault,
           [collateralToken, reserveTranches[0], rolloverInTranches[1]],
           ["0", toFixedPtAmt("20"), toFixedPtAmt("80")],
@@ -610,18 +564,22 @@ describe("RolloverVault", function () {
       });
 
       it("should burn users notes", async function () {
-        await expect(() => vault.redeem(bal)).to.changeTokenBalances(vault, [deployer], [bal.mul("-1")]);
-        expect(await vault.balanceOf(otherUserAddress)).to.eq(toFixedPtAmt("100").mul("1000000"));
+        await expect(() => redeemVaultNotes(vault, bal, deployer)).to.changeTokenBalances(
+          vault,
+          [deployer],
+          [bal * -1n],
+        );
+        expect(await vault.balanceOf(otherUserAddress)).to.eq(toFixedPtAmt("100") * 1000000n);
       });
 
       it("should return redemption amounts", async function () {
-        const redemptionAmts = await vault.callStatic.redeem(bal);
+        const redemptionAmts = await vault.computeRedemptionAmts(bal);
         expect(redemptionAmts.length).to.eq(3);
-        expect(redemptionAmts[0].token).to.eq(collateralToken.address);
+        expect(redemptionAmts[0].token).to.eq(collateralToken.target);
         expect(redemptionAmts[0].amount).to.eq(0);
-        expect(redemptionAmts[1].token).to.eq(reserveTranches[0].address);
+        expect(redemptionAmts[1].token).to.eq(reserveTranches[0].target);
         expect(redemptionAmts[1].amount).to.eq(toFixedPtAmt("20"));
-        expect(redemptionAmts[2].token).to.eq(rolloverInTranches[1].address);
+        expect(redemptionAmts[2].token).to.eq(rolloverInTranches[1].target);
         expect(redemptionAmts[2].amount).to.eq(toFixedPtAmt("80"));
       });
     });
@@ -629,22 +587,20 @@ describe("RolloverVault", function () {
     describe("when vault has a combination of balances (full balance redemption)", function () {
       let redemptionAmts: [string, BigNumber][];
       beforeEach(async function () {
-        await collateralToken.approve(vault.address, toFixedPtAmt("100"));
-        await vault.deposit(toFixedPtAmt("100"));
+        await mintVaultNotes(vault, toFixedPtAmt("100"), deployer);
 
         await collateralToken.transfer(otherUserAddress, toFixedPtAmt("100"));
-        await collateralToken.connect(otherUser).approve(vault.address, toFixedPtAmt("100"));
-        await vault.connect(otherUser).deposit(toFixedPtAmt("100"));
+        await mintVaultNotes(vault, toFixedPtAmt("100"), otherUser);
 
         await vault.deploy();
-        await collateralToken.transfer(vault.address, toFixedPtAmt("20"));
+        await collateralToken.transfer(vault.target, toFixedPtAmt("20"));
 
-        redemptionAmts = await vault.callStatic.redeem(await vault.balanceOf(deployerAddress));
+        redemptionAmts = await vault.computeRedemptionAmts(await vault.balanceOf(deployerAddress));
         bal = await vault.balanceOf(deployerAddress);
       });
 
       it("should transfer assets", async function () {
-        await expect(() => vault.redeem(bal)).to.changeTokenBalances(
+        await expect(() => redeemVaultNotes(vault, bal, deployer)).to.changeTokenBalances(
           collateralToken,
           [deployer, vault],
           [toFixedPtAmt("10"), toFixedPtAmt("-10")],
@@ -652,7 +608,7 @@ describe("RolloverVault", function () {
       });
 
       it("should transfer assets", async function () {
-        await expect(() => vault.redeem(bal)).to.changeTokenBalances(
+        await expect(() => redeemVaultNotes(vault, bal, deployer)).to.changeTokenBalances(
           reserveTranches[0],
           [deployer, vault],
           [toFixedPtAmt("20"), toFixedPtAmt("-20")],
@@ -660,7 +616,7 @@ describe("RolloverVault", function () {
       });
 
       it("should transfer assets", async function () {
-        await expect(() => vault.redeem(bal)).to.changeTokenBalances(
+        await expect(() => redeemVaultNotes(vault, bal, deployer)).to.changeTokenBalances(
           rolloverInTranches[1],
           [deployer, vault],
           [toFixedPtAmt("80"), toFixedPtAmt("-80")],
@@ -668,13 +624,13 @@ describe("RolloverVault", function () {
       });
 
       it("should update vault", async function () {
-        await checkVaultAssetComposition(
+        await checkVaultComposition(
           vault,
           [collateralToken, reserveTranches[0], rolloverInTranches[1]],
           [toFixedPtAmt("20"), toFixedPtAmt("40"), toFixedPtAmt("160")],
         );
-        await vault.redeem(bal);
-        await checkVaultAssetComposition(
+        await redeemVaultNotes(vault, bal, deployer);
+        await checkVaultComposition(
           vault,
           [collateralToken, reserveTranches[0], rolloverInTranches[1]],
           [toFixedPtAmt("10"), toFixedPtAmt("20"), toFixedPtAmt("80")],
@@ -682,38 +638,40 @@ describe("RolloverVault", function () {
       });
 
       it("should burn users notes", async function () {
-        await expect(() => vault.redeem(bal)).to.changeTokenBalances(vault, [deployer], [bal.mul("-1")]);
-        expect(await vault.balanceOf(otherUserAddress)).to.eq(toFixedPtAmt("100").mul("1000000"));
+        await expect(() => redeemVaultNotes(vault, bal, deployer)).to.changeTokenBalances(
+          vault,
+          [deployer],
+          [bal * -1n],
+        );
+        expect(await vault.balanceOf(otherUserAddress)).to.eq(toFixedPtAmt("100") * 1000000n);
       });
 
       it("should return redemption amounts", async function () {
         expect(redemptionAmts.length).to.eq(3);
-        expect(redemptionAmts[0].token).to.eq(collateralToken.address);
+        expect(redemptionAmts[0].token).to.eq(collateralToken.target);
         expect(redemptionAmts[0].amount).to.eq(toFixedPtAmt("10"));
-        expect(redemptionAmts[1].token).to.eq(reserveTranches[0].address);
+        expect(redemptionAmts[1].token).to.eq(reserveTranches[0].target);
         expect(redemptionAmts[1].amount).to.eq(toFixedPtAmt("20"));
-        expect(redemptionAmts[2].token).to.eq(rolloverInTranches[1].address);
+        expect(redemptionAmts[2].token).to.eq(rolloverInTranches[1].target);
         expect(redemptionAmts[2].amount).to.eq(toFixedPtAmt("80"));
       });
     });
 
     describe("when vault has a combination of balances (partial balance redemption)", function () {
       beforeEach(async function () {
-        await collateralToken.approve(vault.address, toFixedPtAmt("100"));
-        await vault.deposit(toFixedPtAmt("100"));
+        await mintVaultNotes(vault, toFixedPtAmt("100"), deployer);
 
         await collateralToken.transfer(otherUserAddress, toFixedPtAmt("100"));
-        await collateralToken.connect(otherUser).approve(vault.address, toFixedPtAmt("100"));
-        await vault.connect(otherUser).deposit(toFixedPtAmt("100"));
+        await mintVaultNotes(vault, toFixedPtAmt("100"), otherUser);
 
         await vault.deploy();
-        await collateralToken.transfer(vault.address, toFixedPtAmt("20"));
+        await collateralToken.transfer(vault.target, toFixedPtAmt("20"));
 
-        bal = toFixedPtAmt("50").mul("1000000");
+        bal = toFixedPtAmt("50") * 1000000n;
       });
 
       it("should transfer assets", async function () {
-        await expect(() => vault.redeem(bal)).to.changeTokenBalances(
+        await expect(() => redeemVaultNotes(vault, bal, deployer)).to.changeTokenBalances(
           collateralToken,
           [deployer, vault],
           [toFixedPtAmt("5"), toFixedPtAmt("-5")],
@@ -721,7 +679,7 @@ describe("RolloverVault", function () {
       });
 
       it("should transfer assets", async function () {
-        await expect(() => vault.redeem(bal)).to.changeTokenBalances(
+        await expect(() => redeemVaultNotes(vault, bal, deployer)).to.changeTokenBalances(
           reserveTranches[0],
           [deployer, vault],
           [toFixedPtAmt("10"), toFixedPtAmt("-10")],
@@ -729,7 +687,7 @@ describe("RolloverVault", function () {
       });
 
       it("should transfer assets", async function () {
-        await expect(() => vault.redeem(bal)).to.changeTokenBalances(
+        await expect(() => redeemVaultNotes(vault, bal, deployer)).to.changeTokenBalances(
           rolloverInTranches[1],
           [deployer, vault],
           [toFixedPtAmt("40"), toFixedPtAmt("-40")],
@@ -737,13 +695,13 @@ describe("RolloverVault", function () {
       });
 
       it("should update vault", async function () {
-        await checkVaultAssetComposition(
+        await checkVaultComposition(
           vault,
           [collateralToken, reserveTranches[0], rolloverInTranches[1]],
           [toFixedPtAmt("20"), toFixedPtAmt("40"), toFixedPtAmt("160")],
         );
-        await vault.redeem(bal);
-        await checkVaultAssetComposition(
+        await redeemVaultNotes(vault, bal, deployer);
+        await checkVaultComposition(
           vault,
           [collateralToken, reserveTranches[0], rolloverInTranches[1]],
           [toFixedPtAmt("15"), toFixedPtAmt("30"), toFixedPtAmt("120")],
@@ -751,157 +709,24 @@ describe("RolloverVault", function () {
       });
 
       it("should burn users notes", async function () {
-        await expect(() => vault.redeem(bal)).to.changeTokenBalances(vault, [deployer], [bal.mul("-1")]);
-        expect(await vault.balanceOf(otherUserAddress)).to.eq(toFixedPtAmt("100").mul("1000000"));
+        await expect(() => redeemVaultNotes(vault, bal, deployer)).to.changeTokenBalances(
+          vault,
+          [deployer],
+          [bal * -1n],
+        );
+        expect(await vault.balanceOf(otherUserAddress)).to.eq(toFixedPtAmt("100") * 1000000n);
       });
 
       it("should return redemption amounts", async function () {
-        const redemptionAmts = await vault.callStatic.redeem(bal);
+        const redemptionAmts = await vault.computeRedemptionAmts(bal);
         expect(redemptionAmts.length).to.eq(3);
-        expect(redemptionAmts[0].token).to.eq(collateralToken.address);
+        expect(redemptionAmts[0].token).to.eq(collateralToken.target);
         expect(redemptionAmts[0].amount).to.eq(toFixedPtAmt("5"));
-        expect(redemptionAmts[1].token).to.eq(reserveTranches[0].address);
+        expect(redemptionAmts[1].token).to.eq(reserveTranches[0].target);
         expect(redemptionAmts[1].amount).to.eq(toFixedPtAmt("10"));
-        expect(redemptionAmts[2].token).to.eq(rolloverInTranches[1].address);
+        expect(redemptionAmts[2].token).to.eq(rolloverInTranches[1].target);
         expect(redemptionAmts[2].amount).to.eq(toFixedPtAmt("40"));
       });
     });
-
-    describe("when fee > 0", function () {
-      beforeEach(async function () {
-        await collateralToken.approve(vault.address, toFixedPtAmt("100"));
-        await vault.deposit(toFixedPtAmt("100"));
-
-        await collateralToken.transfer(otherUserAddress, toFixedPtAmt("100"));
-        await collateralToken.connect(otherUser).approve(vault.address, toFixedPtAmt("100"));
-        await vault.connect(otherUser).deposit(toFixedPtAmt("100"));
-
-        await vault.deploy();
-        await collateralToken.transfer(vault.address, toFixedPtAmt("20"));
-
-        bal = toFixedPtAmt("50").mul("1000000");
-
-        await feePolicy.computeVaultBurnFeePerc.returns(toPercFixedPtAmt("0.1"));
-      });
-
-      it("should transfer assets", async function () {
-        await expect(() => vault.redeem(bal)).to.changeTokenBalances(
-          collateralToken,
-          [deployer, vault],
-          [toFixedPtAmt("4.5"), toFixedPtAmt("-4.5")],
-        );
-      });
-
-      it("should transfer assets", async function () {
-        await expect(() => vault.redeem(bal)).to.changeTokenBalances(
-          reserveTranches[0],
-          [deployer, vault],
-          [toFixedPtAmt("9"), toFixedPtAmt("-9")],
-        );
-      });
-
-      it("should transfer assets", async function () {
-        await expect(() => vault.redeem(bal)).to.changeTokenBalances(
-          rolloverInTranches[1],
-          [deployer, vault],
-          [toFixedPtAmt("36"), toFixedPtAmt("-36")],
-        );
-      });
-
-      it("should update vault", async function () {
-        await checkVaultAssetComposition(
-          vault,
-          [collateralToken, reserveTranches[0], rolloverInTranches[1]],
-          [toFixedPtAmt("20"), toFixedPtAmt("40"), toFixedPtAmt("160")],
-        );
-        await vault.redeem(bal);
-        await checkVaultAssetComposition(
-          vault,
-          [collateralToken, reserveTranches[0], rolloverInTranches[1]],
-          [toFixedPtAmt("15.5"), toFixedPtAmt("31"), toFixedPtAmt("124")],
-        );
-      });
-
-      it("should burn users notes", async function () {
-        await expect(() => vault.redeem(bal)).to.changeTokenBalances(vault, [deployer], [bal.mul("-1")]);
-        expect(await vault.balanceOf(otherUserAddress)).to.eq(toFixedPtAmt("100").mul("1000000"));
-      });
-
-      it("should return redemption amounts", async function () {
-        const redemptionAmts = await vault.callStatic.redeem(bal);
-        expect(redemptionAmts.length).to.eq(3);
-        expect(redemptionAmts[0].token).to.eq(collateralToken.address);
-        expect(redemptionAmts[0].amount).to.eq(toFixedPtAmt("4.5"));
-        expect(redemptionAmts[1].token).to.eq(reserveTranches[0].address);
-        expect(redemptionAmts[1].amount).to.eq(toFixedPtAmt("9"));
-        expect(redemptionAmts[2].token).to.eq(rolloverInTranches[1].address);
-        expect(redemptionAmts[2].amount).to.eq(toFixedPtAmt("36"));
-      });
-    });
-  });
-
-  describe("#recoverAndRedeem", function () {
-    let bal: BigNumber;
-    beforeEach(async function () {
-      await collateralToken.approve(vault.address, toFixedPtAmt("100"));
-      await vault.deposit(toFixedPtAmt("100"));
-
-      await collateralToken.transfer(otherUserAddress, toFixedPtAmt("100"));
-      await collateralToken.connect(otherUser).approve(vault.address, toFixedPtAmt("100"));
-      await vault.connect(otherUser).deposit(toFixedPtAmt("100"));
-
-      await vault.deploy();
-      await collateralToken.transfer(vault.address, toFixedPtAmt("20"));
-
-      await advancePerpQueueUpToBondMaturity(perp, await bondAt(await perp.callStatic.getDepositBond()));
-      bal = toFixedPtAmt("50").mul("1000000");
-    });
-
-    it("should transfer assets", async function () {
-      await expect(() => vault.recoverAndRedeem(bal)).to.changeTokenBalances(
-        collateralToken,
-        [deployer, vault],
-        [toFixedPtAmt("55"), toFixedPtAmt("145")],
-      );
-    });
-
-    it("should transfer assets", async function () {
-      await expect(() => vault.recoverAndRedeem(bal)).to.changeTokenBalances(
-        reserveTranches[0],
-        [deployer, vault],
-        [toFixedPtAmt("0"), toFixedPtAmt("-40")],
-      );
-    });
-
-    it("should transfer assets", async function () {
-      await expect(() => vault.recoverAndRedeem(bal)).to.changeTokenBalances(
-        rolloverInTranches[1],
-        [deployer, vault],
-        [toFixedPtAmt("0"), toFixedPtAmt("-160")],
-      );
-    });
-
-    it("should update vault", async function () {
-      await checkVaultAssetComposition(
-        vault,
-        [collateralToken, reserveTranches[0], rolloverInTranches[1]],
-        [toFixedPtAmt("20"), toFixedPtAmt("40"), toFixedPtAmt("160")],
-      );
-      await vault.recoverAndRedeem(bal);
-      await checkVaultAssetComposition(vault, [collateralToken], [toFixedPtAmt("165")]);
-    });
-
-    it("should burn users notes", async function () {
-      await expect(() => vault.recoverAndRedeem(bal)).to.changeTokenBalances(vault, [deployer], [bal.mul("-1")]);
-      expect(await vault.balanceOf(otherUserAddress)).to.eq(toFixedPtAmt("100").mul("1000000"));
-    });
-
-    it("should return redemption amounts", async function () {
-      await perp.updateState();
-      const redemptionAmts = await vault.callStatic.recoverAndRedeem(bal);
-      expect(redemptionAmts.length).to.eq(1);
-      expect(redemptionAmts[0].token).to.eq(collateralToken.address);
-      expect(redemptionAmts[0].amount).to.eq(toFixedPtAmt("55"));
-    });
   });
 });
diff --git a/spot-contracts/test/rollover-vault/RolloverVault_recover.ts b/spot-contracts/test/rollover-vault/RolloverVault_recover.ts
index e3d97785..877d16b5 100644
--- a/spot-contracts/test/rollover-vault/RolloverVault_recover.ts
+++ b/spot-contracts/test/rollover-vault/RolloverVault_recover.ts
@@ -1,8 +1,6 @@
-import { expect, use } from "chai";
+import { expect } from "chai";
 import { network, ethers, upgrades } from "hardhat";
 import { Contract, Signer } from "ethers";
-import { smock } from "@defi-wonderland/smock";
-
 import {
   setupCollateralToken,
   mintCollteralToken,
@@ -12,29 +10,30 @@ import {
   bondAt,
   getTranches,
   toFixedPtAmt,
+  toPercFixedPtAmt,
   getDepositBond,
   advancePerpQueue,
   advancePerpQueueUpToBondMaturity,
   advancePerpQueueToBondMaturity,
   advancePerpQueueToRollover,
-  checkReserveComposition,
-  checkVaultAssetComposition,
+  checkPerpComposition,
+  checkVaultComposition,
+  DMock,
 } from "../helpers";
-use(smock.matchers);
 
 let vault: Contract;
 let perp: Contract;
 let bondFactory: Contract;
 let collateralToken: Contract;
 let issuer: Contract;
-let feePolicy: Contract;
+let balancer: Contract;
 let deployer: Signer;
 let reserveTranches: Contract[][] = [];
 let rolloverInBond: Contract;
 
 describe("RolloverVault", function () {
   beforeEach(async function () {
-    await network.provider.send("hardhat_reset");
+    await network.provider.request({ method: "hardhat_reset" });
 
     const accounts = await ethers.getSigners();
     deployer = accounts[0];
@@ -45,23 +44,24 @@ describe("RolloverVault", function () {
     const BondIssuer = await ethers.getContractFactory("BondIssuer");
     issuer = await upgrades.deployProxy(
       BondIssuer.connect(deployer),
-      [bondFactory.address, collateralToken.address, 4800, [200, 800], 1200, 0],
+      [bondFactory.target, collateralToken.target, 4800, [200, 800], 1200, 0],
       {
         initializer: "init(address,address,uint256,uint256[],uint256,uint256)",
       },
     );
 
-    const FeePolicy = await ethers.getContractFactory("FeePolicy");
-    feePolicy = await smock.fake(FeePolicy);
-    await feePolicy.computePerpRolloverFeePerc.returns("0");
-    await feePolicy.decimals.returns(8);
+    balancer = new DMock(await ethers.getContractFactory("Balancer"));
+    await balancer.deploy();
+    await balancer.mockMethod("decimals()", [8]);
+    await balancer.mockMethod("computeDeviationRatio(uint256,uint256,uint256)", [toPercFixedPtAmt("1")]);
+    await balancer.mockMethod("computePerpRolloverFeePerc(uint256)", [0n]);
 
     const PerpetualTranche = await ethers.getContractFactory("PerpetualTranche");
     perp = await upgrades.deployProxy(
       PerpetualTranche.connect(deployer),
-      ["PerpetualTranche", "PERP", collateralToken.address, issuer.address, feePolicy.address],
+      ["PerpetualTranche", "PERP", collateralToken.target, issuer.target],
       {
-        initializer: "init(string,string,address,address,address)",
+        initializer: "init(string,string,address,address)",
       },
     );
 
@@ -70,8 +70,9 @@ describe("RolloverVault", function () {
 
     const RolloverVault = await ethers.getContractFactory("RolloverVault");
     vault = await upgrades.deployProxy(RolloverVault.connect(deployer));
-    await vault.init("RolloverVault", "VSHARE", perp.address, feePolicy.address);
-    await perp.updateVault(vault.address);
+    await vault.init("RolloverVault", "VSHARE", perp.target);
+    await vault.updateBalancer(balancer.target);
+    await perp.updateVault(await deployer.getAddress());
 
     reserveTranches = [];
     for (let i = 0; i < 4; i++) {
@@ -79,30 +80,33 @@ describe("RolloverVault", function () {
       const tranches = await getTranches(bond);
       await depositIntoBond(bond, toFixedPtAmt("1000"), deployer);
 
-      await tranches[0].approve(perp.address, toFixedPtAmt("200"));
-      await perp.deposit(tranches[0].address, toFixedPtAmt("200"));
+      await tranches[0].approve(perp.target, toFixedPtAmt("200"));
+      await perp.deposit(tranches[0].target, toFixedPtAmt("200"));
 
       reserveTranches.push(tranches[0]);
       await advancePerpQueue(perp, 1200);
     }
 
-    await checkReserveComposition(
+    await checkPerpComposition(
       perp,
       [collateralToken, ...reserveTranches.slice(-3)],
       [toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("200")],
     );
 
-    rolloverInBond = await bondAt(await perp.callStatic.getDepositBond());
+    rolloverInBond = await bondAt(await perp.depositBond());
 
     await mintCollteralToken(collateralToken, toFixedPtAmt("100000"), deployer);
-    await collateralToken.approve(vault.address, toFixedPtAmt("1"));
+    await collateralToken.approve(vault.target, toFixedPtAmt("1"));
 
-    await checkVaultAssetComposition(vault, [collateralToken], ["0"]);
+    await checkVaultComposition(vault, [collateralToken], ["0"]);
     expect(await vault.assetCount()).to.eq(1);
+
+    await perp.updateBalancer(balancer.target);
+    await perp.updateVault(vault.target);
   });
 
   afterEach(async function () {
-    await network.provider.send("hardhat_reset");
+    await network.provider.request({ method: "hardhat_reset" });
   });
 
   describe("#recover()", function () {
@@ -118,13 +122,13 @@ describe("RolloverVault", function () {
       let currentBondIn: Contract, currentTranchesIn: Contract[];
       beforeEach(async function () {
         await advancePerpQueueToBondMaturity(perp, rolloverInBond);
-        currentBondIn = await bondAt(await perp.callStatic.getDepositBond());
+        currentBondIn = await bondAt(await perp.depositBond());
         currentTranchesIn = await getTranches(currentBondIn);
 
-        await collateralToken.transfer(vault.address, toFixedPtAmt("10"));
+        await collateralToken.transfer(vault.target, toFixedPtAmt("10"));
 
         await vault.deploy();
-        await checkVaultAssetComposition(
+        await checkVaultComposition(
           vault,
           [collateralToken, currentTranchesIn[1]],
           [toFixedPtAmt("2"), toFixedPtAmt("8")],
@@ -134,7 +138,7 @@ describe("RolloverVault", function () {
       describe("when its not mature", function () {
         it("should be a no-op", async function () {
           await expect(vault["recover()"]()).not.to.be.reverted;
-          await checkVaultAssetComposition(
+          await checkVaultComposition(
             vault,
             [collateralToken, currentTranchesIn[1]],
             [toFixedPtAmt("2"), toFixedPtAmt("8")],
@@ -149,12 +153,12 @@ describe("RolloverVault", function () {
         it("should recover", async function () {
           await expect(vault["recover()"]()).not.to.be.reverted;
           expect(await vault.assetCount()).to.eq(1);
-          await checkVaultAssetComposition(vault, [collateralToken], [toFixedPtAmt("10")]);
+          await checkVaultComposition(vault, [collateralToken], [toFixedPtAmt("10")]);
         });
         it("should sync assets", async function () {
           const tx = vault["recover()"]();
-          await expect(tx).to.emit(vault, "AssetSynced").withArgs(collateralToken.address, toFixedPtAmt("10"));
-          await expect(tx).to.emit(vault, "AssetSynced").withArgs(currentTranchesIn[1].address, "0");
+          await expect(tx).to.emit(vault, "AssetSynced").withArgs(collateralToken.target, toFixedPtAmt("10"));
+          await expect(tx).to.emit(vault, "AssetSynced").withArgs(currentTranchesIn[1].target, "0");
         });
       });
     });
@@ -163,13 +167,13 @@ describe("RolloverVault", function () {
       let currentBondIn: Contract, currentTranchesIn: Contract[], newBondIn: Contract, newTranchesIn: Contract[];
       beforeEach(async function () {
         await advancePerpQueueToBondMaturity(perp, rolloverInBond);
-        currentBondIn = await bondAt(await perp.callStatic.getDepositBond());
+        currentBondIn = await bondAt(await perp.depositBond());
         currentTranchesIn = await getTranches(currentBondIn);
 
-        await collateralToken.transfer(vault.address, toFixedPtAmt("10"));
+        await collateralToken.transfer(vault.target, toFixedPtAmt("10"));
         await vault.deploy();
 
-        await checkVaultAssetComposition(
+        await checkVaultComposition(
           vault,
           [collateralToken, currentTranchesIn[1]],
           [toFixedPtAmt("2"), toFixedPtAmt("8")],
@@ -180,7 +184,7 @@ describe("RolloverVault", function () {
       describe("when no redemption", function () {
         it("should be a no-op", async function () {
           await expect(vault["recover()"]()).not.to.be.reverted;
-          await checkVaultAssetComposition(
+          await checkVaultComposition(
             vault,
             [collateralToken, currentTranchesIn[1]],
             [toFixedPtAmt("2"), toFixedPtAmt("8")],
@@ -196,30 +200,30 @@ describe("RolloverVault", function () {
         it("should recover", async function () {
           await expect(vault["recover()"]()).not.to.be.reverted;
           expect(await vault.assetCount()).to.eq(1);
-          await checkVaultAssetComposition(vault, [collateralToken], [toFixedPtAmt("10")]);
+          await checkVaultComposition(vault, [collateralToken], [toFixedPtAmt("10")]);
         });
         it("should sync assets", async function () {
           const tx = vault["recover()"]();
-          await expect(tx).to.emit(vault, "AssetSynced").withArgs(collateralToken.address, toFixedPtAmt("10"));
-          await expect(tx).to.emit(vault, "AssetSynced").withArgs(currentTranchesIn[1].address, "0");
+          await expect(tx).to.emit(vault, "AssetSynced").withArgs(collateralToken.target, toFixedPtAmt("10"));
+          await expect(tx).to.emit(vault, "AssetSynced").withArgs(currentTranchesIn[1].target, "0");
         });
       });
 
       describe("when immature redemption", function () {
         beforeEach(async function () {
           await depositIntoBond(currentBondIn, toFixedPtAmt("1000"), deployer);
-          await currentTranchesIn[0].transfer(vault.address, toFixedPtAmt("100"));
+          await currentTranchesIn[0].transfer(vault.target, toFixedPtAmt("100"));
 
           await advancePerpQueueToRollover(perp, currentBondIn);
 
-          newBondIn = await bondAt(await perp.callStatic.getDepositBond());
+          newBondIn = await bondAt(await perp.depositBond());
           newTranchesIn = await getTranches(newBondIn);
 
-          await collateralToken.transfer(vault.address, toFixedPtAmt("9998"));
+          await collateralToken.transfer(vault.target, toFixedPtAmt("9998"));
           await vault.deploy();
 
           expect(await vault.assetCount()).to.eq(3);
-          await checkVaultAssetComposition(
+          await checkVaultComposition(
             vault,
             [collateralToken, currentTranchesIn[0], newTranchesIn[1]],
             [toFixedPtAmt("6808"), toFixedPtAmt("100"), toFixedPtAmt("3200")],
@@ -228,12 +232,12 @@ describe("RolloverVault", function () {
 
         describe("without reminder", function () {
           beforeEach(async function () {
-            await currentTranchesIn[1].transfer(vault.address, toFixedPtAmt("400"));
+            await currentTranchesIn[1].transfer(vault.target, toFixedPtAmt("400"));
           });
           it("should recover", async function () {
             await expect(vault["recover()"]()).not.to.be.reverted;
             expect(await vault.assetCount()).to.eq(2);
-            await checkVaultAssetComposition(
+            await checkVaultComposition(
               vault,
               [collateralToken, newTranchesIn[1]],
               [toFixedPtAmt("7308"), toFixedPtAmt("3200")],
@@ -241,20 +245,20 @@ describe("RolloverVault", function () {
           });
           it("should sync assets", async function () {
             const tx = vault["recover()"]();
-            await expect(tx).to.emit(vault, "AssetSynced").withArgs(collateralToken.address, toFixedPtAmt("7308"));
-            await expect(tx).to.emit(vault, "AssetSynced").withArgs(newTranchesIn[1].address, toFixedPtAmt("3200"));
-            await expect(tx).to.emit(vault, "AssetSynced").withArgs(currentTranchesIn[0].address, toFixedPtAmt("0"));
+            await expect(tx).to.emit(vault, "AssetSynced").withArgs(collateralToken.target, toFixedPtAmt("7308"));
+            await expect(tx).to.emit(vault, "AssetSynced").withArgs(newTranchesIn[1].target, toFixedPtAmt("3200"));
+            await expect(tx).to.emit(vault, "AssetSynced").withArgs(currentTranchesIn[0].target, toFixedPtAmt("0"));
           });
         });
 
         describe("with reminder", function () {
           beforeEach(async function () {
-            await currentTranchesIn[1].transfer(vault.address, toFixedPtAmt("100"));
+            await currentTranchesIn[1].transfer(vault.target, toFixedPtAmt("100"));
           });
           it("should recover", async function () {
             await expect(vault["recover()"]()).not.to.be.reverted;
             expect(await vault.assetCount()).to.eq(3);
-            await checkVaultAssetComposition(
+            await checkVaultComposition(
               vault,
               [collateralToken, currentTranchesIn[0], newTranchesIn[1]],
               [toFixedPtAmt("6933"), toFixedPtAmt("75"), toFixedPtAmt("3200")],
@@ -262,9 +266,9 @@ describe("RolloverVault", function () {
           });
           it("should sync assets", async function () {
             const tx = vault["recover()"]();
-            await expect(tx).to.emit(vault, "AssetSynced").withArgs(collateralToken.address, toFixedPtAmt("6933"));
-            await expect(tx).to.emit(vault, "AssetSynced").withArgs(currentTranchesIn[0].address, toFixedPtAmt("75"));
-            await expect(tx).to.emit(vault, "AssetSynced").withArgs(newTranchesIn[1].address, toFixedPtAmt("3200"));
+            await expect(tx).to.emit(vault, "AssetSynced").withArgs(collateralToken.target, toFixedPtAmt("6933"));
+            await expect(tx).to.emit(vault, "AssetSynced").withArgs(currentTranchesIn[0].target, toFixedPtAmt("75"));
+            await expect(tx).to.emit(vault, "AssetSynced").withArgs(newTranchesIn[1].target, toFixedPtAmt("3200"));
           });
         });
       });
@@ -275,7 +279,7 @@ describe("RolloverVault", function () {
     describe("when no asset is deployed", function () {
       it("should revert", async function () {
         await vault["recover()"]();
-        await expect(vault["recover(address)"](collateralToken.address)).to.be.revertedWithCustomError(
+        await expect(vault["recover(address)"](collateralToken.target)).to.be.revertedWithCustomError(
           vault,
           "UnexpectedAsset",
         );
@@ -287,13 +291,13 @@ describe("RolloverVault", function () {
       let currentBondIn: Contract, currentTranchesIn: Contract[];
       beforeEach(async function () {
         await advancePerpQueueToBondMaturity(perp, rolloverInBond);
-        currentBondIn = await bondAt(await perp.callStatic.getDepositBond());
+        currentBondIn = await bondAt(await perp.depositBond());
         currentTranchesIn = await getTranches(currentBondIn);
 
-        await collateralToken.transfer(vault.address, toFixedPtAmt("10"));
+        await collateralToken.transfer(vault.target, toFixedPtAmt("10"));
 
         await vault.deploy();
-        await checkVaultAssetComposition(
+        await checkVaultComposition(
           vault,
           [collateralToken, currentTranchesIn[1]],
           [toFixedPtAmt("2"), toFixedPtAmt("8")],
@@ -303,7 +307,7 @@ describe("RolloverVault", function () {
 
       describe("when address is not valid", function () {
         it("should be reverted", async function () {
-          await expect(vault["recover(address)"](collateralToken.address)).to.be.revertedWithCustomError(
+          await expect(vault["recover(address)"](collateralToken.target)).to.be.revertedWithCustomError(
             vault,
             "UnexpectedAsset",
           );
@@ -313,14 +317,14 @@ describe("RolloverVault", function () {
       describe("when belongs to a malicious tranche", function () {
         it("should be reverted", async function () {
           const maliciousBond = await createBondWithFactory(bondFactory, collateralToken, [1, 999], 100000000000);
-          await collateralToken.approve(maliciousBond.address, toFixedPtAmt("1"));
+          await collateralToken.approve(maliciousBond.target, toFixedPtAmt("1"));
           await maliciousBond.deposit(toFixedPtAmt("1"));
           const maliciousTranches = await getTranches(maliciousBond);
           await maliciousTranches[1].transfer(
-            vault.address,
+            vault.target,
             maliciousTranches[1].balanceOf(await deployer.getAddress()),
           );
-          await expect(vault["recover(address)"](maliciousTranches[1].address)).to.be.revertedWithCustomError(
+          await expect(vault["recover(address)"](maliciousTranches[1].target)).to.be.revertedWithCustomError(
             vault,
             "UnexpectedAsset",
           );
@@ -329,8 +333,8 @@ describe("RolloverVault", function () {
 
       describe("when its not mature", function () {
         it("should be a no-op", async function () {
-          await expect(vault["recover(address)"](currentTranchesIn[1].address)).not.to.be.reverted;
-          await checkVaultAssetComposition(
+          await expect(vault["recover(address)"](currentTranchesIn[1].target)).not.to.be.reverted;
+          await checkVaultComposition(
             vault,
             [collateralToken, currentTranchesIn[1]],
             [toFixedPtAmt("2"), toFixedPtAmt("8")],
@@ -344,14 +348,14 @@ describe("RolloverVault", function () {
           await advancePerpQueueUpToBondMaturity(perp, currentBondIn);
         });
         it("should recover", async function () {
-          await expect(vault["recover(address)"](currentTranchesIn[1].address)).not.to.be.reverted;
+          await expect(vault["recover(address)"](currentTranchesIn[1].target)).not.to.be.reverted;
           expect(await vault.assetCount()).to.eq(1);
-          await checkVaultAssetComposition(vault, [collateralToken], [toFixedPtAmt("10")]);
+          await checkVaultComposition(vault, [collateralToken], [toFixedPtAmt("10")]);
         });
         it("should sync assets", async function () {
-          const tx = vault["recover(address)"](currentTranchesIn[1].address);
-          await expect(tx).to.emit(vault, "AssetSynced").withArgs(collateralToken.address, toFixedPtAmt("10"));
-          await expect(tx).to.emit(vault, "AssetSynced").withArgs(currentTranchesIn[1].address, "0");
+          const tx = vault["recover(address)"](currentTranchesIn[1].target);
+          await expect(tx).to.emit(vault, "AssetSynced").withArgs(collateralToken.target, toFixedPtAmt("10"));
+          await expect(tx).to.emit(vault, "AssetSynced").withArgs(currentTranchesIn[1].target, "0");
         });
       });
     });
@@ -360,13 +364,13 @@ describe("RolloverVault", function () {
       let currentBondIn: Contract, currentTranchesIn: Contract[], newBondIn: Contract, newTranchesIn: Contract[];
       beforeEach(async function () {
         await advancePerpQueueToBondMaturity(perp, rolloverInBond);
-        currentBondIn = await bondAt(await perp.callStatic.getDepositBond());
+        currentBondIn = await bondAt(await perp.depositBond());
         currentTranchesIn = await getTranches(currentBondIn);
 
-        await collateralToken.transfer(vault.address, toFixedPtAmt("10"));
+        await collateralToken.transfer(vault.target, toFixedPtAmt("10"));
         await vault.deploy();
 
-        await checkVaultAssetComposition(
+        await checkVaultComposition(
           vault,
           [collateralToken, currentTranchesIn[1]],
           [toFixedPtAmt("2"), toFixedPtAmt("8")],
@@ -376,8 +380,8 @@ describe("RolloverVault", function () {
 
       describe("when no redemption", function () {
         it("should be a no-op", async function () {
-          await expect(vault["recover(address)"](currentTranchesIn[1].address)).not.to.be.reverted;
-          await checkVaultAssetComposition(
+          await expect(vault["recover(address)"](currentTranchesIn[1].target)).not.to.be.reverted;
+          await checkVaultComposition(
             vault,
             [collateralToken, currentTranchesIn[1]],
             [toFixedPtAmt("2"), toFixedPtAmt("8")],
@@ -391,14 +395,14 @@ describe("RolloverVault", function () {
           await advancePerpQueueToBondMaturity(perp, currentBondIn);
         });
         it("should recover", async function () {
-          await expect(vault["recover(address)"](currentTranchesIn[1].address)).not.to.be.reverted;
-          await checkVaultAssetComposition(vault, [collateralToken], [toFixedPtAmt("10")]);
+          await expect(vault["recover(address)"](currentTranchesIn[1].target)).not.to.be.reverted;
+          await checkVaultComposition(vault, [collateralToken], [toFixedPtAmt("10")]);
           expect(await vault.assetCount()).to.eq(1);
         });
         it("should sync assets", async function () {
-          const tx = vault["recover(address)"](currentTranchesIn[1].address);
-          await expect(tx).to.emit(vault, "AssetSynced").withArgs(collateralToken.address, toFixedPtAmt("10"));
-          await expect(tx).to.emit(vault, "AssetSynced").withArgs(currentTranchesIn[1].address, "0");
+          const tx = vault["recover(address)"](currentTranchesIn[1].target);
+          await expect(tx).to.emit(vault, "AssetSynced").withArgs(collateralToken.target, toFixedPtAmt("10"));
+          await expect(tx).to.emit(vault, "AssetSynced").withArgs(currentTranchesIn[1].target, "0");
         });
       });
 
@@ -406,14 +410,14 @@ describe("RolloverVault", function () {
         beforeEach(async function () {
           await advancePerpQueueToRollover(perp, currentBondIn);
 
-          newBondIn = await bondAt(await perp.callStatic.getDepositBond());
+          newBondIn = await bondAt(await perp.depositBond());
           newTranchesIn = await getTranches(newBondIn);
 
-          await collateralToken.transfer(vault.address, toFixedPtAmt("9998"));
+          await collateralToken.transfer(vault.target, toFixedPtAmt("9998"));
           await vault.deploy();
 
           expect(await vault.assetCount()).to.eq(2);
-          await checkVaultAssetComposition(
+          await checkVaultComposition(
             vault,
             [collateralToken, newTranchesIn[1]],
             [toFixedPtAmt("6808"), toFixedPtAmt("3200")],
@@ -423,31 +427,31 @@ describe("RolloverVault", function () {
         describe("without reminder", function () {
           beforeEach(async function () {
             await depositIntoBond(newBondIn, toFixedPtAmt("4000"), deployer);
-            await newTranchesIn[0].transfer(vault.address, toFixedPtAmt("800"));
+            await newTranchesIn[0].transfer(vault.target, toFixedPtAmt("800"));
           });
           it("should recover", async function () {
-            await expect(vault["recover(address)"](newTranchesIn[1].address)).not.to.be.reverted;
+            await expect(vault["recover(address)"](newTranchesIn[1].target)).not.to.be.reverted;
             expect(await vault.assetCount()).to.eq(1);
-            await checkVaultAssetComposition(vault, [collateralToken], [toFixedPtAmt("10808")]);
+            await checkVaultComposition(vault, [collateralToken], [toFixedPtAmt("10808")]);
           });
           it("should sync assets", async function () {
-            const tx = vault["recover(address)"](newTranchesIn[1].address);
-            await expect(tx).to.emit(vault, "AssetSynced").withArgs(collateralToken.address, toFixedPtAmt("10808"));
-            await expect(tx).to.emit(vault, "AssetSynced").withArgs(newTranchesIn[0].address, "0");
-            await expect(tx).to.emit(vault, "AssetSynced").withArgs(newTranchesIn[1].address, "0");
+            const tx = vault["recover(address)"](newTranchesIn[1].target);
+            await expect(tx).to.emit(vault, "AssetSynced").withArgs(collateralToken.target, toFixedPtAmt("10808"));
+            await expect(tx).to.emit(vault, "AssetSynced").withArgs(newTranchesIn[0].target, "0");
+            await expect(tx).to.emit(vault, "AssetSynced").withArgs(newTranchesIn[1].target, "0");
           });
         });
 
         describe("with reminder", function () {
           beforeEach(async function () {
             await depositIntoBond(newBondIn, toFixedPtAmt("1000"), deployer);
-            await newTranchesIn[0].transfer(vault.address, toFixedPtAmt("200"));
+            await newTranchesIn[0].transfer(vault.target, toFixedPtAmt("200"));
           });
 
           it("should recover", async function () {
-            await expect(vault["recover(address)"](newTranchesIn[1].address)).not.to.be.reverted;
+            await expect(vault["recover(address)"](newTranchesIn[1].target)).not.to.be.reverted;
             expect(await vault.assetCount()).to.eq(2);
-            await checkVaultAssetComposition(
+            await checkVaultComposition(
               vault,
               [collateralToken, newTranchesIn[1]],
               [toFixedPtAmt("7808"), toFixedPtAmt("2400")],
@@ -455,23 +459,23 @@ describe("RolloverVault", function () {
           });
 
           it("should sync assets", async function () {
-            const tx = vault["recover(address)"](newTranchesIn[1].address);
-            await expect(tx).to.emit(vault, "AssetSynced").withArgs(collateralToken.address, toFixedPtAmt("7808"));
-            await expect(tx).to.emit(vault, "AssetSynced").withArgs(newTranchesIn[0].address, toFixedPtAmt("0"));
-            await expect(tx).to.emit(vault, "AssetSynced").withArgs(newTranchesIn[1].address, toFixedPtAmt("2400"));
+            const tx = vault["recover(address)"](newTranchesIn[1].target);
+            await expect(tx).to.emit(vault, "AssetSynced").withArgs(collateralToken.target, toFixedPtAmt("7808"));
+            await expect(tx).to.emit(vault, "AssetSynced").withArgs(newTranchesIn[0].target, toFixedPtAmt("0"));
+            await expect(tx).to.emit(vault, "AssetSynced").withArgs(newTranchesIn[1].target, toFixedPtAmt("2400"));
           });
         });
 
         describe("with dust reminder", function () {
           beforeEach(async function () {
             await depositIntoBond(newBondIn, toFixedPtAmt("1000"), deployer);
-            await newTranchesIn[0].transfer(vault.address, "200000");
+            await newTranchesIn[0].transfer(vault.target, "200000");
           });
 
           it("should recover", async function () {
-            await expect(vault["recover(address)"](newTranchesIn[1].address)).not.to.be.reverted;
+            await expect(vault["recover(address)"](newTranchesIn[1].target)).not.to.be.reverted;
             expect(await vault.assetCount()).to.eq(2);
-            await checkVaultAssetComposition(
+            await checkVaultComposition(
               vault,
               [collateralToken, newTranchesIn[1]],
               [toFixedPtAmt("6808.000000000001"), toFixedPtAmt("3199.9999999999992")],
@@ -479,31 +483,31 @@ describe("RolloverVault", function () {
           });
 
           it("should sync assets", async function () {
-            const tx = vault["recover(address)"](newTranchesIn[1].address);
+            const tx = vault["recover(address)"](newTranchesIn[1].target);
             await expect(tx)
               .to.emit(vault, "AssetSynced")
-              .withArgs(collateralToken.address, toFixedPtAmt("6808.000000000001"));
-            await expect(tx).to.emit(vault, "AssetSynced").withArgs(newTranchesIn[0].address, toFixedPtAmt("0"));
+              .withArgs(collateralToken.target, toFixedPtAmt("6808.000000000001"));
+            await expect(tx).to.emit(vault, "AssetSynced").withArgs(newTranchesIn[0].target, toFixedPtAmt("0"));
             await expect(tx)
               .to.emit(vault, "AssetSynced")
-              .withArgs(newTranchesIn[1].address, toFixedPtAmt("3199.9999999999992"));
+              .withArgs(newTranchesIn[1].target, toFixedPtAmt("3199.9999999999992"));
           });
 
           it("should not recover dust when triggered again", async function () {
             await depositIntoBond(newBondIn, toFixedPtAmt("10000"), deployer);
-            await newTranchesIn[0].transfer(vault.address, toFixedPtAmt("799.999999999999"));
-            await vault["recover(address)"](newTranchesIn[1].address);
-            const tx = vault["recover(address)"](newTranchesIn[1].address);
+            await newTranchesIn[0].transfer(vault.target, toFixedPtAmt("799.999999999999"));
+            await vault["recover(address)"](newTranchesIn[1].target);
+            const tx = vault["recover(address)"](newTranchesIn[1].target);
             await tx;
-            await checkVaultAssetComposition(
+            await checkVaultComposition(
               vault,
               [collateralToken, newTranchesIn[1]],
               [toFixedPtAmt("10807.999999999996"), "3200000"],
             );
             await expect(tx)
               .to.emit(vault, "AssetSynced")
-              .withArgs(collateralToken.address, toFixedPtAmt("10807.999999999996"));
-            await expect(tx).to.emit(vault, "AssetSynced").withArgs(newTranchesIn[1].address, "3200000");
+              .withArgs(collateralToken.target, toFixedPtAmt("10807.999999999996"));
+            await expect(tx).to.emit(vault, "AssetSynced").withArgs(newTranchesIn[1].target, "3200000");
           });
         });
       });
@@ -512,13 +516,13 @@ describe("RolloverVault", function () {
     describe("recovering perp", function () {
       let currentBondIn: Contract, currentTranchesIn: Contract[];
       beforeEach(async function () {
-        currentBondIn = await bondAt(await perp.callStatic.getDepositBond());
+        currentBondIn = await bondAt(await perp.depositBond());
         currentTranchesIn = await getTranches(currentBondIn);
 
-        await collateralToken.transfer(vault.address, toFixedPtAmt("125"));
+        await collateralToken.transfer(vault.target, toFixedPtAmt("125"));
         await vault.deploy();
 
-        await checkVaultAssetComposition(
+        await checkVaultComposition(
           vault,
           [collateralToken, currentTranchesIn[1]],
           [toFixedPtAmt("25"), toFixedPtAmt("100")],
@@ -528,8 +532,8 @@ describe("RolloverVault", function () {
 
       describe("when vault has no perps", function () {
         it("should be a no-op", async function () {
-          await expect(vault["recover(address)"](perp.address)).not.to.be.reverted;
-          await checkVaultAssetComposition(
+          await expect(vault["recover(address)"](perp.target)).not.to.be.reverted;
+          await checkVaultComposition(
             vault,
             [collateralToken, currentTranchesIn[1]],
             [toFixedPtAmt("25"), toFixedPtAmt("100")],
@@ -540,11 +544,11 @@ describe("RolloverVault", function () {
 
       describe("when vault has perps", function () {
         beforeEach(async function () {
-          await perp.transfer(vault.address, toFixedPtAmt("100"));
+          await perp.transfer(vault.target, toFixedPtAmt("100"));
         });
         it("should recover", async function () {
-          await expect(vault["recover(address)"](perp.address)).not.to.be.reverted;
-          await checkVaultAssetComposition(
+          await expect(vault["recover(address)"](perp.target)).not.to.be.reverted;
+          await checkVaultComposition(
             vault,
             [collateralToken, currentTranchesIn[1], ...reserveTranches.slice(-3)],
             [toFixedPtAmt("62.5"), toFixedPtAmt("87.5"), toFixedPtAmt("25"), toFixedPtAmt("25"), toFixedPtAmt("25")],
@@ -552,13 +556,13 @@ describe("RolloverVault", function () {
           expect(await vault.assetCount()).to.eq(5);
         });
         it("should sync assets", async function () {
-          const tx = vault["recover(address)"](perp.address);
-          await expect(tx).to.emit(vault, "AssetSynced").withArgs(collateralToken.address, toFixedPtAmt("62.5"));
-          await expect(tx).to.emit(vault, "AssetSynced").withArgs(currentTranchesIn[1].address, toFixedPtAmt("87.5"));
-          await expect(tx).to.emit(vault, "AssetSynced").withArgs(currentTranchesIn[0].address, "0");
-          await expect(tx).to.emit(vault, "AssetSynced").withArgs(reserveTranches[1].address, toFixedPtAmt("25"));
-          await expect(tx).to.emit(vault, "AssetSynced").withArgs(reserveTranches[2].address, toFixedPtAmt("25"));
-          await expect(tx).to.emit(vault, "AssetSynced").withArgs(reserveTranches[3].address, toFixedPtAmt("25"));
+          const tx = vault["recover(address)"](perp.target);
+          await expect(tx).to.emit(vault, "AssetSynced").withArgs(collateralToken.target, toFixedPtAmt("62.5"));
+          await expect(tx).to.emit(vault, "AssetSynced").withArgs(currentTranchesIn[1].target, toFixedPtAmt("87.5"));
+          await expect(tx).to.emit(vault, "AssetSynced").withArgs(currentTranchesIn[0].target, "0");
+          await expect(tx).to.emit(vault, "AssetSynced").withArgs(reserveTranches[1].target, toFixedPtAmt("25"));
+          await expect(tx).to.emit(vault, "AssetSynced").withArgs(reserveTranches[2].target, toFixedPtAmt("25"));
+          await expect(tx).to.emit(vault, "AssetSynced").withArgs(reserveTranches[3].target, toFixedPtAmt("25"));
         });
       });
     });
@@ -568,13 +572,13 @@ describe("RolloverVault", function () {
     let currentBondIn: Contract, currentTranchesIn: Contract[], newBondIn: Contract, newTranchesIn: Contract[];
     beforeEach(async function () {
       await advancePerpQueueToBondMaturity(perp, rolloverInBond);
-      currentBondIn = await bondAt(await perp.callStatic.getDepositBond());
+      currentBondIn = await bondAt(await perp.depositBond());
       currentTranchesIn = await getTranches(currentBondIn);
 
-      await collateralToken.transfer(vault.address, toFixedPtAmt("10"));
+      await collateralToken.transfer(vault.target, toFixedPtAmt("10"));
       await vault.deploy();
 
-      await checkVaultAssetComposition(
+      await checkVaultComposition(
         vault,
         [collateralToken, currentTranchesIn[1]],
         [toFixedPtAmt("2"), toFixedPtAmt("8")],
@@ -583,28 +587,24 @@ describe("RolloverVault", function () {
 
       await advancePerpQueueToBondMaturity(perp, currentBondIn);
 
-      newBondIn = await bondAt(await perp.callStatic.getDepositBond());
+      newBondIn = await bondAt(await perp.depositBond());
       newTranchesIn = await getTranches(newBondIn);
     });
 
     it("should recover", async function () {
       await expect(vault.recoverAndRedeploy()).not.to.be.reverted;
       expect(await vault.assetCount()).to.eq(2);
-      await checkVaultAssetComposition(
-        vault,
-        [collateralToken, newTranchesIn[1]],
-        [toFixedPtAmt("2"), toFixedPtAmt("8")],
-      );
+      await checkVaultComposition(vault, [collateralToken, newTranchesIn[1]], [toFixedPtAmt("2"), toFixedPtAmt("8")]);
     });
 
     it("should sync assets", async function () {
       const tx = vault.recoverAndRedeploy();
-      await expect(tx).to.emit(vault, "AssetSynced").withArgs(collateralToken.address, toFixedPtAmt("10"));
-      await expect(tx).to.emit(vault, "AssetSynced").withArgs(currentTranchesIn[1].address, "0");
-      await expect(tx).to.emit(vault, "AssetSynced").withArgs(newTranchesIn[0].address, toFixedPtAmt("2"));
-      await expect(tx).to.emit(vault, "AssetSynced").withArgs(newTranchesIn[1].address, toFixedPtAmt("8"));
-      await expect(tx).to.emit(vault, "AssetSynced").withArgs(newTranchesIn[0].address, "0");
-      await expect(tx).to.emit(vault, "AssetSynced").withArgs(collateralToken.address, toFixedPtAmt("2"));
+      await expect(tx).to.emit(vault, "AssetSynced").withArgs(collateralToken.target, toFixedPtAmt("10"));
+      await expect(tx).to.emit(vault, "AssetSynced").withArgs(currentTranchesIn[1].target, "0");
+      await expect(tx).to.emit(vault, "AssetSynced").withArgs(newTranchesIn[0].target, toFixedPtAmt("2"));
+      await expect(tx).to.emit(vault, "AssetSynced").withArgs(newTranchesIn[1].target, toFixedPtAmt("8"));
+      await expect(tx).to.emit(vault, "AssetSynced").withArgs(newTranchesIn[0].target, "0");
+      await expect(tx).to.emit(vault, "AssetSynced").withArgs(collateralToken.target, toFixedPtAmt("2"));
     });
   });
 });
diff --git a/spot-contracts/test/rollover-vault/RolloverVault_swap.ts b/spot-contracts/test/rollover-vault/RolloverVault_swap.ts
index e2eb17b7..2b92104d 100644
--- a/spot-contracts/test/rollover-vault/RolloverVault_swap.ts
+++ b/spot-contracts/test/rollover-vault/RolloverVault_swap.ts
@@ -1,8 +1,6 @@
-import { expect, use } from "chai";
+import { expect } from "chai";
 import { network, ethers, upgrades } from "hardhat";
-import { Contract, Signer, constants, Transaction } from "ethers";
-import { smock } from "@defi-wonderland/smock";
-
+import { Contract, Signer, Transaction } from "ethers";
 import {
   setupCollateralToken,
   mintCollteralToken,
@@ -15,11 +13,11 @@ import {
   getDepositBond,
   advancePerpQueue,
   advancePerpQueueToBondMaturity,
-  checkReserveComposition,
-  checkVaultAssetComposition,
+  checkPerpComposition,
+  checkVaultComposition,
   rebase,
+  DMock,
 } from "../helpers";
-use(smock.matchers);
 
 let vault: Contract;
 let perp: Contract;
@@ -27,7 +25,7 @@ let bondFactory: Contract;
 let collateralToken: Contract;
 let rebaseOracle: Contract;
 let issuer: Contract;
-let feePolicy: Contract;
+let balancer: Contract;
 let deployer: Signer;
 let reserveTranches: Contract[][] = [];
 let remainingJuniorTranches: Contract[][] = [];
@@ -36,7 +34,7 @@ let currentTranchesIn: Contract[];
 
 describe("RolloverVault", function () {
   beforeEach(async function () {
-    await network.provider.send("hardhat_reset");
+    await network.provider.request({ method: "hardhat_reset" });
 
     const accounts = await ethers.getSigners();
     deployer = accounts[0];
@@ -47,25 +45,24 @@ describe("RolloverVault", function () {
     const BondIssuer = await ethers.getContractFactory("BondIssuer");
     issuer = await upgrades.deployProxy(
       BondIssuer.connect(deployer),
-      [bondFactory.address, collateralToken.address, 4800, [200, 800], 1200, 0],
+      [bondFactory.target, collateralToken.target, 4800, [200, 800], 1200, 0],
       {
         initializer: "init(address,address,uint256,uint256[],uint256,uint256)",
       },
     );
 
-    const FeePolicy = await ethers.getContractFactory("FeePolicy");
-    feePolicy = await smock.fake(FeePolicy);
-    await feePolicy.decimals.returns(8);
-    await feePolicy.computePerpMintFeePerc.returns(0);
-    await feePolicy.computePerpBurnFeePerc.returns(0);
-    await feePolicy.computePerpRolloverFeePerc.returns(0);
+    balancer = new DMock(await ethers.getContractFactory("Balancer"));
+    await balancer.deploy();
+    await balancer.mockMethod("decimals()", [8]);
+    await balancer.mockMethod("computeDeviationRatio(uint256,uint256,uint256)", [toPercFixedPtAmt("1")]);
+    await balancer.mockMethod("computePerpRolloverFeePerc(uint256)", [0n]);
 
     const PerpetualTranche = await ethers.getContractFactory("PerpetualTranche");
     perp = await upgrades.deployProxy(
       PerpetualTranche.connect(deployer),
-      ["PerpetualTranche", "PERP", collateralToken.address, issuer.address, feePolicy.address],
+      ["PerpetualTranche", "PERP", collateralToken.target, issuer.target],
       {
-        initializer: "init(string,string,address,address,address)",
+        initializer: "init(string,string,address,address)",
       },
     );
     await perp.updateTolerableTrancheMaturity(1200, 4800);
@@ -73,9 +70,10 @@ describe("RolloverVault", function () {
 
     const RolloverVault = await ethers.getContractFactory("RolloverVault");
     vault = await upgrades.deployProxy(RolloverVault.connect(deployer));
-    await collateralToken.approve(vault.address, toFixedPtAmt("1"));
-    await vault.init("RolloverVault", "VSHARE", perp.address, feePolicy.address);
-    await perp.updateVault(vault.address);
+    await collateralToken.approve(vault.target, toFixedPtAmt("1"));
+    await vault.init("RolloverVault", "VSHARE", perp.target);
+    await vault.updateBalancer(balancer.target);
+    await perp.updateVault(await deployer.getAddress());
 
     reserveTranches = [];
     remainingJuniorTranches = [];
@@ -84,423 +82,213 @@ describe("RolloverVault", function () {
       const tranches = await getTranches(bond);
       await depositIntoBond(bond, toFixedPtAmt("1000"), deployer);
 
-      await tranches[0].approve(perp.address, toFixedPtAmt("200"));
-      await perp.deposit(tranches[0].address, toFixedPtAmt("200"));
+      await tranches[0].approve(perp.target, toFixedPtAmt("200"));
+      await perp.deposit(tranches[0].target, toFixedPtAmt("200"));
 
       reserveTranches.push(tranches[0]);
       remainingJuniorTranches.push(tranches[1]);
       await advancePerpQueue(perp, 1200);
     }
 
-    await checkReserveComposition(
+    await perp.updateVault(vault.target);
+    await perp.updateBalancer(balancer.target);
+
+    await checkPerpComposition(
       perp,
       [collateralToken, ...reserveTranches.slice(-3)],
       [toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("200")],
     );
-    await checkVaultAssetComposition(vault, [collateralToken], [0]);
+    await checkVaultComposition(vault, [collateralToken], [0]);
     expect(await vault.assetCount()).to.eq(1);
 
     await mintCollteralToken(collateralToken, toFixedPtAmt("100000"), deployer);
-    currentBondIn = await bondAt(await perp.callStatic.getDepositBond());
+    currentBondIn = await bondAt(await perp.depositBond());
     currentTranchesIn = await getTranches(currentBondIn);
-    await collateralToken.transfer(vault.address, toFixedPtAmt("1000"));
+    await collateralToken.transfer(vault.target, toFixedPtAmt("1000"));
     await vault.deploy();
-    await collateralToken.transfer(vault.address, toFixedPtAmt("1000"));
+    await collateralToken.transfer(vault.target, toFixedPtAmt("1000"));
 
-    await checkVaultAssetComposition(
+    await checkVaultComposition(
       vault,
       [collateralToken, currentTranchesIn[1]],
       [toFixedPtAmt("1200"), toFixedPtAmt("800")],
     );
     expect(await vault.assetCount()).to.eq(2);
 
-    await collateralToken.approve(vault.address, toFixedPtAmt("1000"));
-    await perp.approve(vault.address, toFixedPtAmt("1000"));
+    await collateralToken.approve(vault.target, toFixedPtAmt("1000"));
+    await perp.approve(vault.target, toFixedPtAmt("1000"));
+
+    await vault.updateBalancer(await deployer.getAddress());
   });
 
   afterEach(async function () {
-    await network.provider.send("hardhat_reset");
+    await network.provider.request({ method: "hardhat_reset" });
   });
 
   describe("#swapUnderlyingForPerps", function () {
-    describe("when fee is zero", function () {
-      beforeEach(async function () {
-        await feePolicy.computePerpMintFeePerc.returns(0);
-        await feePolicy.computeUnderlyingToPerpVaultSwapFeePerc.returns(0);
-      });
-
-      describe("when perp price is 1", function () {
-        it("should compute swap amount", async function () {
-          const s = await vault.callStatic.computeUnderlyingToPerpSwapAmt(toFixedPtAmt("100"));
-          expect(s[0]).to.eq(toFixedPtAmt("100"));
-          expect(s[1]).to.eq(0);
-          expect(s[2].perpTVL).to.eq(toFixedPtAmt("800"));
-          expect(s[2].vaultTVL).to.eq(toFixedPtAmt("2000"));
-          expect(s[2].seniorTR).to.eq("200");
-        });
-
-        it("should update vault after swap", async function () {
-          await checkVaultAssetComposition(
-            vault,
-            [collateralToken, currentTranchesIn[1]],
-            [toFixedPtAmt("1200"), toFixedPtAmt("800")],
-          );
-
-          await vault.swapUnderlyingForPerps(toFixedPtAmt("100"));
-
-          await checkVaultAssetComposition(
-            vault,
-            [collateralToken, currentTranchesIn[1]],
-            [toFixedPtAmt("800"), toFixedPtAmt("1200")],
-          );
-        });
-      });
-
-      describe("when perp price > 1", function () {
-        beforeEach(async function () {
-          await collateralToken.transfer(perp.address, toFixedPtAmt("800"));
-        });
-
-        it("should compute swap amount", async function () {
-          const s = await vault.callStatic.computeUnderlyingToPerpSwapAmt(toFixedPtAmt("100"));
-          expect(s[0]).to.eq(toFixedPtAmt("50"));
-          expect(s[1]).to.eq(0);
-          expect(s[2].perpTVL).to.eq(toFixedPtAmt("1600"));
-          expect(s[2].vaultTVL).to.eq(toFixedPtAmt("2000"));
-          expect(s[2].seniorTR).to.eq("200");
-        });
-
-        it("should update vault after swap", async function () {
-          await checkVaultAssetComposition(
-            vault,
-            [collateralToken, currentTranchesIn[1]],
-            [toFixedPtAmt("1200"), toFixedPtAmt("800")],
-          );
-
-          await vault.swapUnderlyingForPerps(toFixedPtAmt("100"));
-
-          await checkVaultAssetComposition(
-            vault,
-            [collateralToken, currentTranchesIn[1]],
-            [toFixedPtAmt("800"), toFixedPtAmt("1200")],
-          );
-        });
-      });
-
-      describe("when perp price < 1", function () {
-        beforeEach(async function () {
-          await rebase(collateralToken, rebaseOracle, -0.9);
-        });
-        it("should compute swap amount", async function () {
-          const s = await vault.callStatic.computeUnderlyingToPerpSwapAmt(toFixedPtAmt("100"));
-          expect(s[0]).to.eq(toFixedPtAmt("200"));
-          expect(s[1]).to.eq(0);
-          expect(s[2].perpTVL).to.eq(toFixedPtAmt("400"));
-          expect(s[2].vaultTVL).to.eq(toFixedPtAmt("120"));
-          expect(s[2].seniorTR).to.eq("200");
-        });
-        it("should update vault after swap", async function () {
-          await checkVaultAssetComposition(
-            vault,
-            [collateralToken, currentTranchesIn[1]],
-            [toFixedPtAmt("120"), toFixedPtAmt("800")],
-          );
-
-          await vault.swapUnderlyingForPerps(toFixedPtAmt("100"));
-
-          await checkVaultAssetComposition(
-            vault,
-            [collateralToken, currentTranchesIn[1]],
-            [toFixedPtAmt("120"), toFixedPtAmt("1600")],
-          );
-        });
-      });
-
-      describe("when perp price is 1 but deposit bond has rebased down", function () {
-        beforeEach(async function () {
-          await rebase(collateralToken, rebaseOracle, -0.1);
-        });
-
-        it("should compute swap amount", async function () {
-          const s = await vault.callStatic.computeUnderlyingToPerpSwapAmt(toFixedPtAmt("100"));
-          expect(s[0]).to.eq(toFixedPtAmt("100"));
-          expect(s[1]).to.eq(0);
-          expect(s[2].perpTVL).to.eq(toFixedPtAmt("800"));
-          expect(s[2].vaultTVL).to.eq(toFixedPtAmt("1780"));
-          expect(s[2].seniorTR).to.eq("200");
-        });
-
-        it("should update vault after swap", async function () {
-          await checkVaultAssetComposition(
-            vault,
-            [collateralToken, currentTranchesIn[1]],
-            [toFixedPtAmt("1080"), toFixedPtAmt("800")],
-          );
-
-          await vault.swapUnderlyingForPerps(toFixedPtAmt("100"));
-
-          await checkVaultAssetComposition(
-            vault,
-            [collateralToken, currentTranchesIn[1]],
-            [toFixedPtAmt("730"), toFixedPtAmt("1200")],
-          );
-        });
-      });
-
-      describe("when perp price is 1 but deposit bond has rebased up", function () {
-        beforeEach(async function () {
-          await rebase(collateralToken, rebaseOracle, 0.1);
-        });
-
-        it("should compute swap amount", async function () {
-          const s = await vault.callStatic.computeUnderlyingToPerpSwapAmt(toFixedPtAmt("100"));
-          expect(s[0]).to.eq(toFixedPtAmt("100"));
-          expect(s[1]).to.eq(0);
-          expect(s[2].perpTVL).to.eq(toFixedPtAmt("800"));
-          expect(s[2].vaultTVL).to.eq(toFixedPtAmt("2220"));
-          expect(s[2].seniorTR).to.eq("200");
-        });
-
-        it("should update vault after swap", async function () {
-          await checkVaultAssetComposition(
-            vault,
-            [collateralToken, currentTranchesIn[1]],
-            [toFixedPtAmt("1320"), toFixedPtAmt("800")],
-          );
-
-          await vault.swapUnderlyingForPerps(toFixedPtAmt("100"));
-
-          await checkVaultAssetComposition(
-            vault,
-            [collateralToken, currentTranchesIn[1]],
-            [toFixedPtAmt("870"), toFixedPtAmt("1200")],
-          );
-        });
+    describe("when perp price is 1", function () {
+      it("should compute swap amount", async function () {
+        const s = await vault.computeUnderlyingToPerpSwapAmt(toFixedPtAmt("100"));
+        expect(s).to.eq(toFixedPtAmt("100"));
+      });
+
+      it("should update vault after swap", async function () {
+        await checkVaultComposition(
+          vault,
+          [collateralToken, currentTranchesIn[1]],
+          [toFixedPtAmt("1200"), toFixedPtAmt("800")],
+        );
+
+        await vault.swapUnderlyingForPerps(toFixedPtAmt("100"));
+
+        await checkVaultComposition(
+          vault,
+          [collateralToken, currentTranchesIn[1]],
+          [toFixedPtAmt("800"), toFixedPtAmt("1200")],
+        );
       });
     });
 
-    describe("when fee is not zero", function () {
+    describe("when perp price > 1", function () {
       beforeEach(async function () {
-        await feePolicy.computePerpMintFeePerc.returns(toPercFixedPtAmt("0.05"));
-        await feePolicy.computeUnderlyingToPerpVaultSwapFeePerc.returns(toPercFixedPtAmt("0.1"));
+        await collateralToken.transfer(perp.target, toFixedPtAmt("800"));
       });
 
       it("should compute swap amount", async function () {
-        const s = await vault.callStatic.computeUnderlyingToPerpSwapAmt(toFixedPtAmt("100"));
-        expect(s[0]).to.eq(toFixedPtAmt("85"));
-        expect(s[1]).to.eq(toFixedPtAmt("5"));
-        expect(s[2].perpTVL).to.eq(toFixedPtAmt("800"));
-        expect(s[2].vaultTVL).to.eq(toFixedPtAmt("2000"));
-        expect(s[2].seniorTR).to.eq("200");
+        const s = await vault.computeUnderlyingToPerpSwapAmt(toFixedPtAmt("100"));
+        expect(s).to.eq(toFixedPtAmt("50"));
       });
-    });
 
-    describe("when swap amount is zero", function () {
-      it("should be reverted", async function () {
-        await expect(vault.swapUnderlyingForPerps(0)).to.be.revertedWithCustomError(vault, "UnacceptableSwap");
-      });
-    });
+      it("should update vault after swap", async function () {
+        await checkVaultComposition(
+          vault,
+          [collateralToken, currentTranchesIn[1]],
+          [toFixedPtAmt("1200"), toFixedPtAmt("800")],
+        );
 
-    describe("when absolute liquidity is too low", function () {
-      beforeEach(async function () {
-        await vault.updateMinUnderlyingBal(toFixedPtAmt("1000"));
-        await vault.updateMinUnderlyingPerc(0);
-      });
-      it("should be reverted", async function () {
-        await expect(vault.swapUnderlyingForPerps(toFixedPtAmt("50"))).to.be.revertedWithCustomError(
+        await vault.swapUnderlyingForPerps(toFixedPtAmt("100"));
+
+        await checkVaultComposition(
           vault,
-          "InsufficientLiquidity",
+          [collateralToken, currentTranchesIn[1]],
+          [toFixedPtAmt("800"), toFixedPtAmt("1200")],
         );
-        await expect(vault.swapUnderlyingForPerps(toFixedPtAmt("1"))).not.to.be.reverted;
       });
     });
 
-    describe("when percentage of liquidity is too low", function () {
+    describe("when perp price < 1", function () {
       beforeEach(async function () {
-        await vault.updateMinUnderlyingBal(0);
-        await vault.updateMinUnderlyingPerc(toPercFixedPtAmt("0.40"));
+        await rebase(collateralToken, rebaseOracle, -0.9);
       });
-      it("should be reverted", async function () {
-        await expect(vault.swapUnderlyingForPerps(toFixedPtAmt("100"))).to.be.revertedWithCustomError(
+      it("should compute swap amount", async function () {
+        const s = await vault.computeUnderlyingToPerpSwapAmt(toFixedPtAmt("100"));
+        expect(s).to.eq(toFixedPtAmt("200"));
+      });
+      it("should update vault after swap", async function () {
+        await checkVaultComposition(
           vault,
-          "InsufficientLiquidity",
+          [collateralToken, currentTranchesIn[1]],
+          [toFixedPtAmt("120"), toFixedPtAmt("800")],
         );
-        await expect(vault.swapUnderlyingForPerps(toFixedPtAmt("99"))).not.to.be.reverted;
-      });
-    });
 
-    describe("when fee is 100%", function () {
-      it("should be reverted", async function () {
-        await feePolicy.computePerpMintFeePerc.returns(0);
-        await feePolicy.computeUnderlyingToPerpVaultSwapFeePerc.returns(toPercFixedPtAmt("1"));
-        await expect(vault.swapUnderlyingForPerps(toFixedPtAmt("100"))).to.be.revertedWithCustomError(
+        await vault.swapUnderlyingForPerps(toFixedPtAmt("100"));
+
+        await checkVaultComposition(
           vault,
-          "UnacceptableSwap",
+          [collateralToken, currentTranchesIn[1]],
+          [toFixedPtAmt("120"), toFixedPtAmt("1600")],
         );
       });
     });
 
-    describe("when fee is greater than 100%", function () {
-      it("should be reverted", async function () {
-        await feePolicy.computePerpMintFeePerc.returns(toPercFixedPtAmt("0.05"));
-        await feePolicy.computeUnderlyingToPerpVaultSwapFeePerc.returns(toPercFixedPtAmt("1"));
-        await expect(vault.swapUnderlyingForPerps(toFixedPtAmt("100"))).to.be.reverted;
-      });
-    });
-
-    describe("on successful swap with zero fees", function () {
-      let txFn: Promise<Transaction>;
+    describe("when perp price is 1 but deposit bond has rebased down", function () {
       beforeEach(async function () {
-        await feePolicy.computePerpMintFeePerc.returns(0);
-        await feePolicy.computeUnderlyingToPerpVaultSwapFeePerc.returns(0);
-        txFn = () => vault.swapUnderlyingForPerps(toFixedPtAmt("100"));
-      });
-
-      it("should mint perps for swap and leave none left over", async function () {
-        expect(await perp.totalSupply()).to.eq(toFixedPtAmt("800"));
-        await expect(txFn())
-          .to.emit(perp, "Transfer")
-          .withArgs(constants.AddressZero, vault.address, toFixedPtAmt("100"));
-        expect(await perp.totalSupply()).to.eq(toFixedPtAmt("900"));
-        expect(await perp.balanceOf(vault.address)).to.eq(0);
+        await rebase(collateralToken, rebaseOracle, -0.1);
       });
 
-      it("should return the perp amt", async function () {
-        expect(await vault.callStatic.swapUnderlyingForPerps(toFixedPtAmt("100"))).to.eq(toFixedPtAmt("100"));
-      });
-
-      it("should transfer underlying from the user", async function () {
-        await expect(txFn).to.changeTokenBalances(collateralToken, [deployer], [toFixedPtAmt("-100")]);
-      });
-
-      it("should transfer back perps to the user", async function () {
-        await expect(txFn).to.changeTokenBalances(perp, [deployer], [toFixedPtAmt("100")]);
+      it("should compute swap amount", async function () {
+        const s = await vault.computeUnderlyingToPerpSwapAmt(toFixedPtAmt("100"));
+        expect(s).to.eq(toFixedPtAmt("100"));
       });
 
-      it("should update the vault assets", async function () {
-        await checkReserveComposition(
-          perp,
-          [collateralToken, ...reserveTranches.slice(-3), currentTranchesIn[0]],
-          [0, toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("200")],
-        );
-
-        await checkVaultAssetComposition(
+      it("should update vault after swap", async function () {
+        await checkVaultComposition(
           vault,
           [collateralToken, currentTranchesIn[1]],
-          [toFixedPtAmt("1200"), toFixedPtAmt("800")],
+          [toFixedPtAmt("1080"), toFixedPtAmt("800")],
         );
 
-        await txFn();
+        await vault.swapUnderlyingForPerps(toFixedPtAmt("100"));
 
-        await checkReserveComposition(
-          perp,
-          [collateralToken, ...reserveTranches.slice(-3), currentTranchesIn[0]],
-          [0, toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("300")],
-        );
-
-        await checkVaultAssetComposition(
+        await checkVaultComposition(
           vault,
           [collateralToken, currentTranchesIn[1]],
-          [toFixedPtAmt("800"), toFixedPtAmt("1200")],
+          [toFixedPtAmt("730"), toFixedPtAmt("1200")],
         );
       });
-
-      it("should update the vault tvl", async function () {
-        expect(await vault.callStatic.getTVL()).to.eq(toFixedPtAmt("2000"));
-        await txFn();
-        expect(await vault.callStatic.getTVL()).to.eq(toFixedPtAmt("2000"));
-      });
     });
 
-    describe("on successful swap with zero perp fees", function () {
-      let txFn: Promise<Transaction>;
+    describe("when perp price is 1 but deposit bond has rebased up", function () {
       beforeEach(async function () {
-        await feePolicy.computePerpMintFeePerc.returns(0);
-        await feePolicy.computeUnderlyingToPerpVaultSwapFeePerc.returns(toPercFixedPtAmt("0.1"));
-        txFn = () => vault.swapUnderlyingForPerps(toFixedPtAmt("100"));
-      });
-
-      it("should mint perps for swap and leave none left over", async function () {
-        expect(await perp.totalSupply()).to.eq(toFixedPtAmt("800"));
-        await expect(txFn())
-          .to.emit(perp, "Transfer")
-          .withArgs(constants.AddressZero, vault.address, toFixedPtAmt("90"));
-        expect(await perp.totalSupply()).to.eq(toFixedPtAmt("890"));
-        expect(await perp.balanceOf(vault.address)).to.eq(0);
-      });
-
-      it("should return the perp amt", async function () {
-        expect(await vault.callStatic.swapUnderlyingForPerps(toFixedPtAmt("100"))).to.eq(toFixedPtAmt("90"));
-      });
-
-      it("should transfer underlying from the user", async function () {
-        await expect(txFn).to.changeTokenBalances(collateralToken, [deployer], [toFixedPtAmt("-100")]);
+        await rebase(collateralToken, rebaseOracle, 0.1);
       });
 
-      it("should transfer back perps to the user", async function () {
-        await expect(txFn).to.changeTokenBalances(perp, [deployer], [toFixedPtAmt("90")]);
+      it("should compute swap amount", async function () {
+        const s = await vault.computeUnderlyingToPerpSwapAmt(toFixedPtAmt("100"));
+        expect(s).to.eq(toFixedPtAmt("100"));
       });
 
-      it("should update the vault assets", async function () {
-        await checkReserveComposition(
-          perp,
-          [collateralToken, ...reserveTranches.slice(-3), currentTranchesIn[0]],
-          [0, toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("200")],
-        );
-
-        await checkVaultAssetComposition(
+      it("should update vault after swap", async function () {
+        await checkVaultComposition(
           vault,
           [collateralToken, currentTranchesIn[1]],
-          [toFixedPtAmt("1200"), toFixedPtAmt("800")],
+          [toFixedPtAmt("1320"), toFixedPtAmt("800")],
         );
 
-        await txFn();
-
-        await checkReserveComposition(
-          perp,
-          [collateralToken, ...reserveTranches.slice(-3), currentTranchesIn[0]],
-          [0, toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("290")],
-        );
+        await vault.swapUnderlyingForPerps(toFixedPtAmt("100"));
 
-        await checkVaultAssetComposition(
+        await checkVaultComposition(
           vault,
           [collateralToken, currentTranchesIn[1]],
-          [toFixedPtAmt("850"), toFixedPtAmt("1160")],
+          [toFixedPtAmt("870"), toFixedPtAmt("1200")],
         );
       });
+    });
 
-      it("should update the vault tvl", async function () {
-        expect(await vault.callStatic.getTVL()).to.eq(toFixedPtAmt("2000"));
-        await txFn();
-        expect(await vault.callStatic.getTVL()).to.eq(toFixedPtAmt("2010"));
+    describe("when swap amount is zero", function () {
+      it("should be reverted", async function () {
+        await expect(vault.swapUnderlyingForPerps(0)).to.be.revertedWithCustomError(vault, "UnacceptableSwap");
+      });
+    });
+
+    describe("when absolute liquidity is too low", function () {
+      beforeEach(async function () {
+        await vault.updateMinUnderlyingBal(toFixedPtAmt("1000"));
+      });
+      it("should be reverted", async function () {
+        await expect(vault.swapUnderlyingForPerps(toFixedPtAmt("50"))).to.be.revertedWithCustomError(
+          vault,
+          "InsufficientLiquidity",
+        );
+        await expect(vault.swapUnderlyingForPerps(toFixedPtAmt("1"))).not.to.be.reverted;
       });
     });
 
     describe("on successful swap", function () {
       let txFn: Promise<Transaction>;
       beforeEach(async function () {
-        await feePolicy.computePerpMintFeePerc.returns(toPercFixedPtAmt("0.05"));
-        await feePolicy.computeUnderlyingToPerpVaultSwapFeePerc.returns(toPercFixedPtAmt("0.1"));
         txFn = () => vault.swapUnderlyingForPerps(toFixedPtAmt("100"));
       });
 
       it("should mint perps for swap and leave none left over", async function () {
         expect(await perp.totalSupply()).to.eq(toFixedPtAmt("800"));
-        await expect(txFn())
-          .to.emit(perp, "Transfer")
-          .withArgs(constants.AddressZero, vault.address, toFixedPtAmt("90"));
-        expect(await perp.totalSupply()).to.eq(toFixedPtAmt("885"));
-        expect(await perp.balanceOf(vault.address)).to.eq(0);
-      });
-
-      it("should burn perps as fee", async function () {
-        await expect(txFn())
-          .to.emit(perp, "Transfer")
-          .withArgs(vault.address, constants.AddressZero, toFixedPtAmt("5"));
+        await expect(txFn()).to.emit(perp, "Transfer").withArgs(ethers.ZeroAddress, vault.target, toFixedPtAmt("100"));
+        expect(await perp.totalSupply()).to.eq(toFixedPtAmt("900"));
+        expect(await perp.balanceOf(vault.target)).to.eq(0);
       });
 
       it("should return the perp amt", async function () {
-        expect(await vault.callStatic.swapUnderlyingForPerps(toFixedPtAmt("100"))).to.eq(toFixedPtAmt("85"));
+        expect(await vault.swapUnderlyingForPerps.staticCall(toFixedPtAmt("100"))).to.eq(toFixedPtAmt("100"));
       });
 
       it("should transfer underlying from the user", async function () {
@@ -508,17 +296,17 @@ describe("RolloverVault", function () {
       });
 
       it("should transfer back perps to the user", async function () {
-        await expect(txFn).to.changeTokenBalances(perp, [deployer], [toFixedPtAmt("85")]);
+        await expect(txFn).to.changeTokenBalances(perp, [deployer], [toFixedPtAmt("100")]);
       });
 
       it("should update the vault assets", async function () {
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, ...reserveTranches.slice(-3), currentTranchesIn[0]],
           [0, toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("200")],
         );
 
-        await checkVaultAssetComposition(
+        await checkVaultComposition(
           vault,
           [collateralToken, currentTranchesIn[1]],
           [toFixedPtAmt("1200"), toFixedPtAmt("800")],
@@ -526,31 +314,29 @@ describe("RolloverVault", function () {
 
         await txFn();
 
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, ...reserveTranches.slice(-3), currentTranchesIn[0]],
-          [0, toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("290")],
+          [0, toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("300")],
         );
 
-        await checkVaultAssetComposition(
+        await checkVaultComposition(
           vault,
           [collateralToken, currentTranchesIn[1]],
-          [toFixedPtAmt("850"), toFixedPtAmt("1160")],
+          [toFixedPtAmt("800"), toFixedPtAmt("1200")],
         );
       });
 
       it("should update the vault tvl", async function () {
-        expect(await vault.callStatic.getTVL()).to.eq(toFixedPtAmt("2000"));
+        expect(await vault.getTVL()).to.eq(toFixedPtAmt("2000"));
         await txFn();
-        expect(await vault.callStatic.getTVL()).to.eq(toFixedPtAmt("2010"));
+        expect(await vault.getTVL()).to.eq(toFixedPtAmt("2000"));
       });
     });
 
     describe("on successful swap with imperfect rounding", function () {
       let txFn: Promise<Transaction>;
       beforeEach(async function () {
-        await feePolicy.computePerpMintFeePerc.returns(toPercFixedPtAmt("0.1"));
-        await feePolicy.computeUnderlyingToPerpVaultSwapFeePerc.returns(toPercFixedPtAmt("0.1"));
         txFn = () => vault.swapUnderlyingForPerps(toFixedPtAmt("100.999999999999999999"));
       });
 
@@ -558,20 +344,14 @@ describe("RolloverVault", function () {
         expect(await perp.totalSupply()).to.eq(toFixedPtAmt("800"));
         await expect(txFn())
           .to.emit(perp, "Transfer")
-          .withArgs(constants.AddressZero, vault.address, toFixedPtAmt("90.899999999999999999"));
-        expect(await perp.totalSupply()).to.eq(toFixedPtAmt("880.799999999999999999"));
-        expect(await perp.balanceOf(vault.address)).to.eq(0);
-      });
-
-      it("should burn perps as fee", async function () {
-        await expect(txFn())
-          .to.emit(perp, "Transfer")
-          .withArgs(vault.address, constants.AddressZero, toFixedPtAmt("10.1"));
+          .withArgs(ethers.ZeroAddress, vault.target, toFixedPtAmt("100.999999999999999999"));
+        expect(await perp.totalSupply()).to.eq(toFixedPtAmt("900.999999999999999999"));
+        expect(await perp.balanceOf(vault.target)).to.eq(0);
       });
 
       it("should return the perp amt", async function () {
-        expect(await vault.callStatic.swapUnderlyingForPerps(toFixedPtAmt("100.999999999999999999"))).to.eq(
-          toFixedPtAmt("80.799999999999999999"),
+        expect(await vault.swapUnderlyingForPerps.staticCall(toFixedPtAmt("100.999999999999999999"))).to.eq(
+          toFixedPtAmt("100.999999999999999999"),
         );
       });
 
@@ -584,17 +364,17 @@ describe("RolloverVault", function () {
       });
 
       it("should transfer back perps to the user", async function () {
-        await expect(txFn).to.changeTokenBalances(perp, [deployer], [toFixedPtAmt("80.799999999999999999")]);
+        await expect(txFn).to.changeTokenBalances(perp, [deployer], [toFixedPtAmt("100.999999999999999999")]);
       });
 
       it("should update the vault assets", async function () {
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, ...reserveTranches.slice(-3), currentTranchesIn[0]],
           [0, toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("200")],
         );
 
-        await checkVaultAssetComposition(
+        await checkVaultComposition(
           vault,
           [collateralToken, currentTranchesIn[1]],
           [toFixedPtAmt("1200"), toFixedPtAmt("800")],
@@ -602,23 +382,23 @@ describe("RolloverVault", function () {
 
         await txFn();
 
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, ...reserveTranches.slice(-3), currentTranchesIn[0]],
-          [0, toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("290.899999999999999999")],
+          [0, toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("300.999999999999999999")],
         );
 
-        await checkVaultAssetComposition(
+        await checkVaultComposition(
           vault,
           [collateralToken, currentTranchesIn[1]],
-          [toFixedPtAmt("846.500000000000000004"), toFixedPtAmt("1163.599999999999999996")],
+          [toFixedPtAmt("796.000000000000000004"), toFixedPtAmt("1203.999999999999999996")],
         );
       });
 
       it("should update the vault tvl", async function () {
-        expect(await vault.callStatic.getTVL()).to.eq(toFixedPtAmt("2000"));
+        expect(await vault.getTVL()).to.eq(toFixedPtAmt("2000"));
         await txFn();
-        expect(await vault.callStatic.getTVL()).to.eq(toFixedPtAmt("2010.10"));
+        expect(await vault.getTVL()).to.eq(toFixedPtAmt("2000"));
       });
     });
 
@@ -626,28 +406,18 @@ describe("RolloverVault", function () {
       let txFn: Promise<Transaction>;
       beforeEach(async function () {
         await advancePerpQueueToBondMaturity(perp, await getDepositBond(perp));
-        await feePolicy.computePerpMintFeePerc.returns(toPercFixedPtAmt("0.05"));
-        await feePolicy.computeUnderlyingToPerpVaultSwapFeePerc.returns(toPercFixedPtAmt("0.1"));
         txFn = () => vault.swapUnderlyingForPerps(toFixedPtAmt("100"));
       });
 
       it("should mint perps for swap and leave none left over", async function () {
         expect(await perp.totalSupply()).to.eq(toFixedPtAmt("800"));
-        await expect(txFn())
-          .to.emit(perp, "Transfer")
-          .withArgs(constants.AddressZero, vault.address, toFixedPtAmt("90"));
-        expect(await perp.totalSupply()).to.eq(toFixedPtAmt("885"));
-        expect(await perp.balanceOf(vault.address)).to.eq(0);
-      });
-
-      it("should burn perps as fee", async function () {
-        await expect(txFn())
-          .to.emit(perp, "Transfer")
-          .withArgs(vault.address, constants.AddressZero, toFixedPtAmt("5"));
+        await expect(txFn()).to.emit(perp, "Transfer").withArgs(ethers.ZeroAddress, vault.target, toFixedPtAmt("100"));
+        expect(await perp.totalSupply()).to.eq(toFixedPtAmt("900"));
+        expect(await perp.balanceOf(vault.target)).to.eq(0);
       });
 
       it("should return the perp amt", async function () {
-        expect(await vault.callStatic.swapUnderlyingForPerps(toFixedPtAmt("100"))).to.eq(toFixedPtAmt("85"));
+        expect(await vault.swapUnderlyingForPerps.staticCall(toFixedPtAmt("100"))).to.eq(toFixedPtAmt("100"));
       });
 
       it("should transfer underlying from the user", async function () {
@@ -655,15 +425,15 @@ describe("RolloverVault", function () {
       });
 
       it("should transfer back perps to the user", async function () {
-        await expect(txFn).to.changeTokenBalances(perp, [deployer], [toFixedPtAmt("85")]);
+        await expect(txFn).to.changeTokenBalances(perp, [deployer], [toFixedPtAmt("100")]);
       });
 
       it("should update the vault assets", async function () {
-        const depositBond = await bondAt(perp.callStatic.getDepositBond());
+        const depositBond = await bondAt(await perp.depositBond());
         const depositTranches = await getTranches(depositBond);
-        await checkReserveComposition(perp, [collateralToken], [toFixedPtAmt("800")]);
+        await checkPerpComposition(perp, [collateralToken], [toFixedPtAmt("800")]);
 
-        await checkVaultAssetComposition(
+        await checkVaultComposition(
           vault,
           [collateralToken, currentTranchesIn[1]],
           [toFixedPtAmt("1200"), toFixedPtAmt("800")],
@@ -671,134 +441,76 @@ describe("RolloverVault", function () {
 
         await txFn();
 
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, depositTranches[0]],
-          [toFixedPtAmt("800"), toFixedPtAmt("90")],
+          [toFixedPtAmt("800"), toFixedPtAmt("100")],
         );
 
-        await checkVaultAssetComposition(
+        await checkVaultComposition(
           vault,
           [collateralToken, currentTranchesIn[1], depositTranches[1]],
-          [toFixedPtAmt("850"), toFixedPtAmt("800"), toFixedPtAmt("360")],
+          [toFixedPtAmt("800"), toFixedPtAmt("800"), toFixedPtAmt("400")],
         );
       });
 
       it("should update the vault tvl", async function () {
-        expect(await vault.callStatic.getTVL()).to.eq(toFixedPtAmt("2000"));
+        expect(await vault.getTVL()).to.eq(toFixedPtAmt("2000"));
         await txFn();
-        expect(await vault.callStatic.getTVL()).to.eq(toFixedPtAmt("2010"));
+        expect(await vault.getTVL()).to.eq(toFixedPtAmt("2000"));
       });
     });
   });
 
   describe("#swapPerpsForUnderlying", function () {
-    describe("when fee is zero", function () {
-      beforeEach(async function () {
-        await feePolicy.computePerpBurnFeePerc.returns(0);
-        await feePolicy.computePerpToUnderlyingVaultSwapFeePerc.returns(0);
-      });
-
-      describe("when perp price is 1", function () {
-        it("should compute swap amount", async function () {
-          const s = await vault.callStatic.computePerpToUnderlyingSwapAmt(toFixedPtAmt("100"));
-          expect(s[0]).to.eq(toFixedPtAmt("100"));
-          expect(s[1]).to.eq(0);
-          expect(s[2].perpTVL).to.eq(toFixedPtAmt("800"));
-          expect(s[2].vaultTVL).to.eq(toFixedPtAmt("2000"));
-          expect(s[2].seniorTR).to.eq("200");
-        });
-      });
-
-      describe("when perp price > 1", function () {
-        beforeEach(async function () {
-          await collateralToken.transfer(perp.address, toFixedPtAmt("800"));
-        });
-        it("should compute swap amount", async function () {
-          const s = await vault.callStatic.computePerpToUnderlyingSwapAmt(toFixedPtAmt("100"));
-          expect(s[0]).to.eq(toFixedPtAmt("200"));
-          expect(s[1]).to.eq(0);
-          expect(s[2].perpTVL).to.eq(toFixedPtAmt("1600"));
-          expect(s[2].vaultTVL).to.eq(toFixedPtAmt("2000"));
-          expect(s[2].seniorTR).to.eq("200");
-        });
-      });
-
-      describe("when perp price < 1", function () {
-        beforeEach(async function () {
-          await rebase(collateralToken, rebaseOracle, -0.9);
-        });
-        it("should compute swap amount", async function () {
-          const s = await vault.callStatic.computePerpToUnderlyingSwapAmt(toFixedPtAmt("100"));
-          expect(s[0]).to.eq(toFixedPtAmt("50"));
-          expect(s[1]).to.eq(0);
-          expect(s[2].perpTVL).to.eq(toFixedPtAmt("400"));
-          expect(s[2].vaultTVL).to.eq(toFixedPtAmt("120"));
-          expect(s[2].seniorTR).to.eq("200");
-        });
+    describe("when perp price is 1", function () {
+      it("should compute swap amount", async function () {
+        const s = await vault.computePerpToUnderlyingSwapAmt.staticCall(toFixedPtAmt("100"));
+        expect(s).to.eq(toFixedPtAmt("100"));
       });
     });
 
-    describe("when fee is not zero", function () {
+    describe("when perp price > 1", function () {
       beforeEach(async function () {
-        await feePolicy.computePerpBurnFeePerc.returns(toPercFixedPtAmt("0.05"));
-        await feePolicy.computePerpToUnderlyingVaultSwapFeePerc.returns(toPercFixedPtAmt("0.15"));
+        await collateralToken.transfer(perp.target, toFixedPtAmt("800"));
       });
-
       it("should compute swap amount", async function () {
-        const s = await vault.callStatic.computePerpToUnderlyingSwapAmt(toFixedPtAmt("100"));
-        expect(s[0]).to.eq(toFixedPtAmt("80"));
-        expect(s[1]).to.eq(toFixedPtAmt("5"));
-        expect(s[2].perpTVL).to.eq(toFixedPtAmt("800"));
-        expect(s[2].vaultTVL).to.eq(toFixedPtAmt("2000"));
-        expect(s[2].seniorTR).to.eq("200");
+        const s = await vault.computePerpToUnderlyingSwapAmt.staticCall(toFixedPtAmt("100"));
+        expect(s).to.eq(toFixedPtAmt("200"));
       });
     });
 
-    describe("when swap amount is zero", function () {
-      it("should be reverted", async function () {
-        await expect(vault.swapPerpsForUnderlying(0)).to.be.revertedWithCustomError(vault, "UnacceptableSwap");
+    describe("when perp price < 1", function () {
+      beforeEach(async function () {
+        await rebase(collateralToken, rebaseOracle, -0.9);
       });
-    });
-
-    describe("when fee is 100%", function () {
-      it("should be reverted", async function () {
-        await feePolicy.computePerpBurnFeePerc.returns(0);
-        await feePolicy.computePerpToUnderlyingVaultSwapFeePerc.returns(toPercFixedPtAmt("1"));
-        await expect(vault.swapPerpsForUnderlying(toFixedPtAmt("100"))).to.be.revertedWithCustomError(
-          vault,
-          "UnacceptableSwap",
-        );
+      it("should compute swap amount", async function () {
+        const s = await vault.computePerpToUnderlyingSwapAmt.staticCall(toFixedPtAmt("100"));
+        expect(s).to.eq(toFixedPtAmt("50"));
       });
     });
 
-    describe("when fee is greater than 100%", function () {
+    describe("when swap amount is zero", function () {
       it("should be reverted", async function () {
-        await feePolicy.computePerpBurnFeePerc.returns(toPercFixedPtAmt("0.05"));
-        await feePolicy.computePerpToUnderlyingVaultSwapFeePerc.returns(toPercFixedPtAmt("1"));
-        await expect(vault.swapPerpsForUnderlying(toFixedPtAmt("100"))).to.be.reverted;
+        await expect(vault.swapPerpsForUnderlying(0)).to.be.revertedWithCustomError(vault, "UnacceptableSwap");
       });
     });
 
-    describe("on successful swap with zero fees", function () {
+    describe("on successful swap", function () {
       let txFn: Promise<Transaction>;
       beforeEach(async function () {
-        await feePolicy.computePerpBurnFeePerc.returns(0);
-        await feePolicy.computePerpToUnderlyingVaultSwapFeePerc.returns(0);
         txFn = () => vault.swapPerpsForUnderlying(toFixedPtAmt("100"));
       });
 
       it("should redeem perps for swap and leave none left over", async function () {
         expect(await perp.totalSupply()).to.eq(toFixedPtAmt("800"));
-        await expect(txFn())
-          .to.emit(perp, "Transfer")
-          .withArgs(vault.address, constants.AddressZero, toFixedPtAmt("100"));
+        await expect(txFn()).to.emit(perp, "Transfer").withArgs(vault.target, ethers.ZeroAddress, toFixedPtAmt("100"));
         expect(await perp.totalSupply()).to.eq(toFixedPtAmt("700"));
-        expect(await perp.balanceOf(vault.address)).to.eq(0);
+        expect(await perp.balanceOf(vault.target)).to.eq(0);
       });
 
       it("should return the underlying amt", async function () {
-        expect(await vault.callStatic.swapPerpsForUnderlying(toFixedPtAmt("100"))).to.eq(toFixedPtAmt("100"));
+        expect(await vault.swapPerpsForUnderlying.staticCall(toFixedPtAmt("100"))).to.eq(toFixedPtAmt("100"));
       });
 
       it("should transfer perps from the user", async function () {
@@ -810,13 +522,13 @@ describe("RolloverVault", function () {
       });
 
       it("should update the vault assets", async function () {
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, ...reserveTranches.slice(-3), currentTranchesIn[0]],
           [0, toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("200")],
         );
 
-        await checkVaultAssetComposition(
+        await checkVaultComposition(
           vault,
           [collateralToken, currentTranchesIn[1]],
           [toFixedPtAmt("1200"), toFixedPtAmt("800")],
@@ -824,13 +536,13 @@ describe("RolloverVault", function () {
 
         await txFn();
 
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, ...reserveTranches.slice(-3), currentTranchesIn[0]],
           [0, toFixedPtAmt("175"), toFixedPtAmt("175"), toFixedPtAmt("175"), toFixedPtAmt("175")],
         );
 
-        await checkVaultAssetComposition(
+        await checkVaultComposition(
           vault,
           [collateralToken, currentTranchesIn[1], ...reserveTranches.slice(-3)],
           [toFixedPtAmt("1225"), toFixedPtAmt("700"), toFixedPtAmt("25"), toFixedPtAmt("25"), toFixedPtAmt("25")],
@@ -838,164 +550,15 @@ describe("RolloverVault", function () {
       });
 
       it("should update the vault tvl", async function () {
-        expect(await vault.callStatic.getTVL()).to.eq(toFixedPtAmt("2000"));
+        expect(await vault.getTVL()).to.eq(toFixedPtAmt("2000"));
         await txFn();
-        expect(await vault.callStatic.getTVL()).to.eq(toFixedPtAmt("2000"));
-      });
-    });
-
-    describe("on successful swap with zero perp fees", function () {
-      let txFn: Promise<Transaction>;
-      beforeEach(async function () {
-        await feePolicy.computePerpBurnFeePerc.returns(0);
-        await feePolicy.computePerpToUnderlyingVaultSwapFeePerc.returns(toPercFixedPtAmt("0.1"));
-        txFn = () => vault.swapPerpsForUnderlying(toFixedPtAmt("100"));
-      });
-
-      it("should redeem perps for swap and leave none left over", async function () {
-        expect(await perp.totalSupply()).to.eq(toFixedPtAmt("800"));
-        await expect(txFn())
-          .to.emit(perp, "Transfer")
-          .withArgs(vault.address, constants.AddressZero, toFixedPtAmt("100"));
-        expect(await perp.totalSupply()).to.eq(toFixedPtAmt("700"));
-        expect(await perp.balanceOf(vault.address)).to.eq(0);
-      });
-
-      it("should return the underlying amt", async function () {
-        expect(await vault.callStatic.swapPerpsForUnderlying(toFixedPtAmt("100"))).to.eq(toFixedPtAmt("90"));
-      });
-
-      it("should transfer perps from the user", async function () {
-        await expect(txFn).to.changeTokenBalances(perp, [deployer], [toFixedPtAmt("-100")]);
-      });
-
-      it("should transfer back underlying to the user", async function () {
-        await expect(txFn).to.changeTokenBalances(collateralToken, [deployer], [toFixedPtAmt("90")]);
-      });
-
-      it("should update the vault assets", async function () {
-        await checkReserveComposition(
-          perp,
-          [collateralToken, ...reserveTranches.slice(-3), currentTranchesIn[0]],
-          [0, toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("200")],
-        );
-
-        await checkVaultAssetComposition(
-          vault,
-          [collateralToken, currentTranchesIn[1]],
-          [toFixedPtAmt("1200"), toFixedPtAmt("800")],
-        );
-
-        await txFn();
-
-        await checkReserveComposition(
-          perp,
-          [collateralToken, ...reserveTranches.slice(-3), currentTranchesIn[0]],
-          [0, toFixedPtAmt("175"), toFixedPtAmt("175"), toFixedPtAmt("175"), toFixedPtAmt("175")],
-        );
-
-        await checkVaultAssetComposition(
-          vault,
-          [collateralToken, currentTranchesIn[1], ...reserveTranches.slice(-3)],
-          [toFixedPtAmt("1235"), toFixedPtAmt("700"), toFixedPtAmt("25"), toFixedPtAmt("25"), toFixedPtAmt("25")],
-        );
-      });
-
-      it("should update the vault tvl", async function () {
-        expect(await vault.callStatic.getTVL()).to.eq(toFixedPtAmt("2000"));
-        await txFn();
-        expect(await vault.callStatic.getTVL()).to.eq(toFixedPtAmt("2010"));
-      });
-    });
-
-    describe("on successful swap", function () {
-      let txFn: Promise<Transaction>;
-      beforeEach(async function () {
-        await feePolicy.computePerpBurnFeePerc.returns(toPercFixedPtAmt("0.1"));
-        await feePolicy.computePerpToUnderlyingVaultSwapFeePerc.returns(toPercFixedPtAmt("0.15"));
-        txFn = () => vault.swapPerpsForUnderlying(toFixedPtAmt("100"));
-      });
-
-      it("should redeem perps for swap and leave none left over", async function () {
-        expect(await perp.totalSupply()).to.eq(toFixedPtAmt("800"));
-        await expect(txFn())
-          .to.emit(perp, "Transfer")
-          .withArgs(vault.address, constants.AddressZero, toFixedPtAmt("90"));
-        expect(await perp.totalSupply()).to.eq(toFixedPtAmt("700"));
-        expect(await perp.balanceOf(vault.address)).to.eq(0);
-      });
-
-      it("should burn perps as fee", async function () {
-        await expect(txFn())
-          .to.emit(perp, "Transfer")
-          .withArgs(vault.address, constants.AddressZero, toFixedPtAmt("10"));
-      });
-
-      it("should return the underlying amt", async function () {
-        expect(await vault.callStatic.swapPerpsForUnderlying(toFixedPtAmt("100"))).to.eq(toFixedPtAmt("75"));
-      });
-
-      it("should transfer perps from the user", async function () {
-        await expect(txFn).to.changeTokenBalances(perp, [deployer], [toFixedPtAmt("-100")]);
-      });
-
-      it("should transfer back underlying to the user", async function () {
-        await expect(txFn).to.changeTokenBalances(collateralToken, [deployer], [toFixedPtAmt("75")]);
-      });
-
-      it("should update the vault assets", async function () {
-        await checkReserveComposition(
-          perp,
-          [collateralToken, ...reserveTranches.slice(-3), currentTranchesIn[0]],
-          [0, toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("200")],
-        );
-
-        await checkVaultAssetComposition(
-          vault,
-          [collateralToken, currentTranchesIn[1]],
-          [toFixedPtAmt("1200"), toFixedPtAmt("800")],
-        );
-
-        await txFn();
-
-        await checkReserveComposition(
-          perp,
-          [collateralToken, ...reserveTranches.slice(-3), currentTranchesIn[0]],
-          [
-            0,
-            toFixedPtAmt("177.215189873417721519"),
-            toFixedPtAmt("177.215189873417721519"),
-            toFixedPtAmt("177.215189873417721519"),
-            toFixedPtAmt("177.215189873417721519"),
-          ],
-        );
-
-        await checkVaultAssetComposition(
-          vault,
-          [collateralToken, currentTranchesIn[1], ...reserveTranches.slice(-3), currentTranchesIn[0]],
-          [
-            toFixedPtAmt("1238.924050632911392"),
-            toFixedPtAmt("708.8607594936708864"),
-            toFixedPtAmt("22.784810126582278481"),
-            toFixedPtAmt("22.784810126582278481"),
-            toFixedPtAmt("22.784810126582278481"),
-            toFixedPtAmt("0.000000000000000081"),
-          ],
-        );
-      });
-
-      it("should update the vault tvl", async function () {
-        expect(await vault.callStatic.getTVL()).to.eq(toFixedPtAmt("2000"));
-        await txFn();
-        expect(await vault.callStatic.getTVL()).to.eq(toFixedPtAmt("2016.139240506329113843"));
+        expect(await vault.getTVL()).to.eq(toFixedPtAmt("2000"));
       });
     });
 
     describe("on successful swap with imperfect rounding", function () {
       let txFn: Promise<Transaction>;
       beforeEach(async function () {
-        await feePolicy.computePerpBurnFeePerc.returns(toPercFixedPtAmt("0.1"));
-        await feePolicy.computePerpToUnderlyingVaultSwapFeePerc.returns(toPercFixedPtAmt("0.1"));
         txFn = () => vault.swapPerpsForUnderlying(toFixedPtAmt("100.999999999999999999"));
       });
 
@@ -1003,20 +566,14 @@ describe("RolloverVault", function () {
         expect(await perp.totalSupply()).to.eq(toFixedPtAmt("800"));
         await expect(txFn())
           .to.emit(perp, "Transfer")
-          .withArgs(vault.address, constants.AddressZero, toFixedPtAmt("90.899999999999999999"));
+          .withArgs(vault.target, ethers.ZeroAddress, toFixedPtAmt("100.999999999999999999"));
         expect(await perp.totalSupply()).to.eq(toFixedPtAmt("699.000000000000000001"));
-        expect(await perp.balanceOf(vault.address)).to.eq(0);
-      });
-
-      it("should burn perps as fee", async function () {
-        await expect(txFn())
-          .to.emit(perp, "Transfer")
-          .withArgs(vault.address, constants.AddressZero, toFixedPtAmt("10.1"));
+        expect(await perp.balanceOf(vault.target)).to.eq(0);
       });
 
       it("should return the underlying amt", async function () {
-        expect(await vault.callStatic.swapPerpsForUnderlying(toFixedPtAmt("100.999999999999999999"))).to.eq(
-          toFixedPtAmt("80.799999999999999999"),
+        expect(await vault.swapPerpsForUnderlying.staticCall(toFixedPtAmt("100.999999999999999999"))).to.eq(
+          toFixedPtAmt("100.999999999999999999"),
         );
       });
 
@@ -1025,17 +582,21 @@ describe("RolloverVault", function () {
       });
 
       it("should transfer back underlying to the user", async function () {
-        await expect(txFn).to.changeTokenBalances(collateralToken, [deployer], [toFixedPtAmt("80.799999999999999999")]);
+        await expect(txFn).to.changeTokenBalances(
+          collateralToken,
+          [deployer],
+          [toFixedPtAmt("100.999999999999999999")],
+        );
       });
 
       it("should update the vault assets", async function () {
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, ...reserveTranches.slice(-3), currentTranchesIn[0]],
           [0, toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("200")],
         );
 
-        await checkVaultAssetComposition(
+        await checkVaultComposition(
           vault,
           [collateralToken, currentTranchesIn[1]],
           [toFixedPtAmt("1200"), toFixedPtAmt("800")],
@@ -1043,67 +604,58 @@ describe("RolloverVault", function () {
 
         await txFn();
 
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, ...reserveTranches.slice(-3), currentTranchesIn[0]],
           [
             0,
-            toFixedPtAmt("176.984428408659323966"),
-            toFixedPtAmt("176.984428408659323966"),
-            toFixedPtAmt("176.984428408659323966"),
-            toFixedPtAmt("176.984428408659323966"),
+            toFixedPtAmt("174.750000000000000001"),
+            toFixedPtAmt("174.750000000000000001"),
+            toFixedPtAmt("174.750000000000000001"),
+            toFixedPtAmt("174.750000000000000001"),
           ],
         );
 
-        await checkVaultAssetComposition(
+        await checkVaultComposition(
           vault,
           [collateralToken, currentTranchesIn[1], ...reserveTranches.slice(-3), currentTranchesIn[0]],
           [
-            toFixedPtAmt("1234.277857956703380001"),
-            toFixedPtAmt("707.937713634637296000"),
-            toFixedPtAmt("23.015571591340676034"),
-            toFixedPtAmt("23.015571591340676034"),
-            toFixedPtAmt("23.015571591340676034"),
-            toFixedPtAmt("0.000000000000000034"),
+            toFixedPtAmt("1225.249999999999999001"),
+            toFixedPtAmt("699.0000000000000008"),
+            toFixedPtAmt("25.249999999999999999"),
+            toFixedPtAmt("25.249999999999999999"),
+            toFixedPtAmt("25.249999999999999999"),
+            toFixedPtAmt("0.000000000000000199"),
           ],
         );
       });
 
       it("should update the vault tvl", async function () {
-        expect(await vault.callStatic.getTVL()).to.eq(toFixedPtAmt("2000"));
+        expect(await vault.getTVL()).to.eq(toFixedPtAmt("2000"));
         await txFn();
-        expect(await vault.callStatic.getTVL()).to.eq(toFixedPtAmt("2011.262286365362704103"));
+        // NOTE: the computed tvl goes down slightly because dust assets aren't counted
+        expect(await vault.getTVL()).to.eq(toFixedPtAmt("1999.999999999999999798"));
       });
     });
 
     describe("on successful swap with some the juniors in the vault", function () {
       let txFn: Promise<Transaction>;
       beforeEach(async function () {
-        await feePolicy.computePerpBurnFeePerc.returns(toPercFixedPtAmt("0.1"));
-        await feePolicy.computePerpToUnderlyingVaultSwapFeePerc.returns(toPercFixedPtAmt("0.15"));
-        remainingJuniorTranches[1].transfer(vault.address, toFixedPtAmt("100"));
-        remainingJuniorTranches[2].transfer(vault.address, toFixedPtAmt("100"));
-        remainingJuniorTranches[3].transfer(vault.address, toFixedPtAmt("100"));
+        remainingJuniorTranches[1].transfer(vault.target, toFixedPtAmt("100"));
+        remainingJuniorTranches[2].transfer(vault.target, toFixedPtAmt("100"));
+        remainingJuniorTranches[3].transfer(vault.target, toFixedPtAmt("100"));
         txFn = () => vault.swapPerpsForUnderlying(toFixedPtAmt("200"));
       });
 
       it("should redeem perps for swap and leave none left over", async function () {
         expect(await perp.totalSupply()).to.eq(toFixedPtAmt("800"));
-        await expect(txFn())
-          .to.emit(perp, "Transfer")
-          .withArgs(vault.address, constants.AddressZero, toFixedPtAmt("180"));
+        await expect(txFn()).to.emit(perp, "Transfer").withArgs(vault.target, ethers.ZeroAddress, toFixedPtAmt("200"));
         expect(await perp.totalSupply()).to.eq(toFixedPtAmt("600"));
-        expect(await perp.balanceOf(vault.address)).to.eq(0);
-      });
-
-      it("should burn perps as fee", async function () {
-        await expect(txFn())
-          .to.emit(perp, "Transfer")
-          .withArgs(vault.address, constants.AddressZero, toFixedPtAmt("20"));
+        expect(await perp.balanceOf(vault.target)).to.eq(0);
       });
 
       it("should return the underlying amt", async function () {
-        expect(await vault.callStatic.swapPerpsForUnderlying(toFixedPtAmt("200"))).to.eq(toFixedPtAmt("150"));
+        expect(await vault.swapPerpsForUnderlying.staticCall(toFixedPtAmt("200"))).to.eq(toFixedPtAmt("200"));
       });
 
       it("should transfer perps from the user", async function () {
@@ -1111,17 +663,17 @@ describe("RolloverVault", function () {
       });
 
       it("should transfer back underlying to the user", async function () {
-        await expect(txFn).to.changeTokenBalances(collateralToken, [deployer], [toFixedPtAmt("150")]);
+        await expect(txFn).to.changeTokenBalances(collateralToken, [deployer], [toFixedPtAmt("200")]);
       });
 
       it("should update the vault assets", async function () {
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, ...reserveTranches.slice(-3), currentTranchesIn[0]],
           [0, toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("200")],
         );
 
-        await checkVaultAssetComposition(
+        await checkVaultComposition(
           vault,
           [collateralToken, currentTranchesIn[1]],
           [toFixedPtAmt("1200"), toFixedPtAmt("800")],
@@ -1129,69 +681,51 @@ describe("RolloverVault", function () {
 
         await txFn();
 
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, ...reserveTranches.slice(-3), currentTranchesIn[0]],
-          [
-            0,
-            toFixedPtAmt("153.846153846153846154"),
-            toFixedPtAmt("153.846153846153846154"),
-            toFixedPtAmt("153.846153846153846154"),
-            toFixedPtAmt("153.846153846153846154"),
-          ],
+          [0, toFixedPtAmt("150"), toFixedPtAmt("150"), toFixedPtAmt("150"), toFixedPtAmt("150")],
         );
 
-        await checkVaultAssetComposition(
+        await checkVaultComposition(
           vault,
-          [collateralToken, currentTranchesIn[1], ...reserveTranches.slice(-3), currentTranchesIn[0]],
+          [collateralToken, currentTranchesIn[1], ...reserveTranches.slice(-3)],
           [
-            toFixedPtAmt("1655.769230769230769000"),
-            toFixedPtAmt("615.384615384615384800"),
-            toFixedPtAmt("21.153846153846153846"),
-            toFixedPtAmt("21.153846153846153846"),
-            toFixedPtAmt("21.153846153846153846"),
+            toFixedPtAmt("1625"),
+            toFixedPtAmt("600"),
+            toFixedPtAmt("25"),
+            toFixedPtAmt("25"),
+            toFixedPtAmt("25"),
             toFixedPtAmt("0.000000000000000046"),
           ],
         );
       });
 
       it("should update the vault tvl", async function () {
-        expect(await vault.callStatic.getTVL()).to.eq(toFixedPtAmt("2000"));
+        expect(await vault.getTVL()).to.eq(toFixedPtAmt("2000"));
         await txFn();
-        expect(await vault.callStatic.getTVL()).to.eq(toFixedPtAmt("2334.615384615384615338"));
+        expect(await vault.getTVL()).to.eq(toFixedPtAmt("2300")); // +300 transferred in
       });
     });
 
     describe("on successful swap with all the juniors in the vault", function () {
       let txFn: Promise<Transaction>;
       beforeEach(async function () {
-        await feePolicy.computePerpBurnFeePerc.returns(toPercFixedPtAmt("0.1"));
-        await feePolicy.computePerpToUnderlyingVaultSwapFeePerc.returns(toPercFixedPtAmt("0.15"));
-
-        remainingJuniorTranches[1].transfer(vault.address, toFixedPtAmt("800"));
-        remainingJuniorTranches[2].transfer(vault.address, toFixedPtAmt("800"));
-        remainingJuniorTranches[3].transfer(vault.address, toFixedPtAmt("800"));
-
+        remainingJuniorTranches[1].transfer(vault.target, toFixedPtAmt("800"));
+        remainingJuniorTranches[2].transfer(vault.target, toFixedPtAmt("800"));
+        remainingJuniorTranches[3].transfer(vault.target, toFixedPtAmt("800"));
         txFn = () => vault.swapPerpsForUnderlying(toFixedPtAmt("200"));
       });
 
       it("should redeem perps for swap and leave none left over", async function () {
         expect(await perp.totalSupply()).to.eq(toFixedPtAmt("800"));
-        await expect(txFn())
-          .to.emit(perp, "Transfer")
-          .withArgs(vault.address, constants.AddressZero, toFixedPtAmt("180"));
+        await expect(txFn()).to.emit(perp, "Transfer").withArgs(vault.target, ethers.ZeroAddress, toFixedPtAmt("200"));
         expect(await perp.totalSupply()).to.eq(toFixedPtAmt("600"));
-        expect(await perp.balanceOf(vault.address)).to.eq(0);
-      });
-
-      it("should burn perps as fee", async function () {
-        await expect(txFn())
-          .to.emit(perp, "Transfer")
-          .withArgs(vault.address, constants.AddressZero, toFixedPtAmt("20"));
+        expect(await perp.balanceOf(vault.target)).to.eq(0);
       });
 
       it("should return the underlying amt", async function () {
-        expect(await vault.callStatic.swapPerpsForUnderlying(toFixedPtAmt("200"))).to.eq(toFixedPtAmt("150"));
+        expect(await vault.swapPerpsForUnderlying.staticCall(toFixedPtAmt("200"))).to.eq(toFixedPtAmt("200"));
       });
 
       it("should transfer perps from the user", async function () {
@@ -1199,17 +733,17 @@ describe("RolloverVault", function () {
       });
 
       it("should transfer back underlying to the user", async function () {
-        await expect(txFn).to.changeTokenBalances(collateralToken, [deployer], [toFixedPtAmt("150")]);
+        await expect(txFn).to.changeTokenBalances(collateralToken, [deployer], [toFixedPtAmt("200")]);
       });
 
       it("should update the vault assets", async function () {
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, ...reserveTranches.slice(-3), currentTranchesIn[0]],
           [0, toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("200"), toFixedPtAmt("200")],
         );
 
-        await checkVaultAssetComposition(
+        await checkVaultComposition(
           vault,
           [collateralToken, currentTranchesIn[1]],
           [toFixedPtAmt("1200"), toFixedPtAmt("800")],
@@ -1217,19 +751,13 @@ describe("RolloverVault", function () {
 
         await txFn();
 
-        await checkReserveComposition(
+        await checkPerpComposition(
           perp,
           [collateralToken, ...reserveTranches.slice(-3), currentTranchesIn[0]],
-          [
-            0,
-            toFixedPtAmt("153.846153846153846154"),
-            toFixedPtAmt("153.846153846153846154"),
-            toFixedPtAmt("153.846153846153846154"),
-            toFixedPtAmt("153.846153846153846154"),
-          ],
+          [0, toFixedPtAmt("150"), toFixedPtAmt("150"), toFixedPtAmt("150"), toFixedPtAmt("150")],
         );
 
-        await checkVaultAssetComposition(
+        await checkVaultComposition(
           vault,
           [
             collateralToken,
@@ -1237,27 +765,15 @@ describe("RolloverVault", function () {
             remainingJuniorTranches[1],
             remainingJuniorTranches[2],
             remainingJuniorTranches[3],
-            ...reserveTranches.slice(-3),
-            currentTranchesIn[0],
-          ],
-          [
-            toFixedPtAmt("1973.076923076923076"),
-            toFixedPtAmt("615.3846153846153848"),
-            toFixedPtAmt("615.3846153846153848"),
-            toFixedPtAmt("615.3846153846153848"),
-            toFixedPtAmt("615.3846153846153848"),
-            toFixedPtAmt("0.000000000000000046"),
-            toFixedPtAmt("0.000000000000000046"),
-            toFixedPtAmt("0.000000000000000046"),
-            toFixedPtAmt("0.000000000000000046"),
           ],
+          [toFixedPtAmt("2000"), toFixedPtAmt("600"), toFixedPtAmt("600"), toFixedPtAmt("600"), toFixedPtAmt("600")],
         );
       });
 
       it("should update the vault tvl", async function () {
-        expect(await vault.callStatic.getTVL()).to.eq(toFixedPtAmt("2000")); // + 2400 transferred in
+        expect(await vault.getTVL()).to.eq(toFixedPtAmt("2000")); // + 2400 transferred in
         await txFn();
-        expect(await vault.callStatic.getTVL()).to.eq(toFixedPtAmt("4434.6153846153846152"));
+        expect(await vault.getTVL()).to.eq(toFixedPtAmt("4400"));
       });
     });
   });
diff --git a/yarn.lock b/yarn.lock
index b576ca51..821ae70a 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -12,24 +12,30 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@adraffy/ens-normalize@npm:1.10.1":
+  version: 1.10.1
+  resolution: "@adraffy/ens-normalize@npm:1.10.1"
+  checksum: 0836f394ea256972ec19a0b5e78cb7f5bcdfd48d8a32c7478afc94dd53ae44c04d1aa2303d7f3077b4f3ac2323b1f557ab9188e8059978748fdcd83e04a80dcc
+  languageName: node
+  linkType: hard
+
 "@ampleforthorg/spot-contracts@workspace:spot-contracts":
   version: 0.0.0-use.local
   resolution: "@ampleforthorg/spot-contracts@workspace:spot-contracts"
   dependencies:
-    "@defi-wonderland/smock": ^2.3.4
     "@ethersproject/abi": ^5.6.4
     "@ethersproject/abstract-provider": ^5.7.0
     "@ethersproject/abstract-signer": ^5.7.0
     "@ethersproject/bytes": ^5.6.1
     "@ethersproject/providers": ^5.6.8
-    "@nomicfoundation/hardhat-chai-matchers": ^1.0.6
-    "@nomicfoundation/hardhat-verify": ^1.1.0
-    "@nomiclabs/hardhat-ethers": ^2.2.1
-    "@nomiclabs/hardhat-waffle": ^2.0.3
-    "@openzeppelin/contracts-upgradeable": ^4.7.3
-    "@openzeppelin/hardhat-upgrades": ^1.19.0
+    "@nomicfoundation/hardhat-chai-matchers": latest
+    "@nomicfoundation/hardhat-ethers": ^3.0.0
+    "@nomicfoundation/hardhat-verify": latest
+    "@nomiclabs/hardhat-waffle": ^2.0.6
+    "@openzeppelin/contracts-upgradeable": 4.7.3
+    "@openzeppelin/hardhat-upgrades": ^3.0.4
     "@openzeppelin/upgrades-core": latest
-    "@typechain/ethers-v5": ^10.1.0
+    "@typechain/ethers-v6": ^0.5.1
     "@typechain/hardhat": ^6.1.2
     "@types/chai": ^4.3.1
     "@types/mocha": ^9.1.1
@@ -49,11 +55,12 @@ __metadata:
     eslint-plugin-prettier: ^4.2.1
     eslint-plugin-promise: ^6.0.0
     eslint-plugin-unused-imports: ^3.0.0
-    ethereum-waffle: ^3.4.4
-    ethers: ^5.6.9
-    ganache-cli: ^6.12.2
-    hardhat: ^2.19.4
-    hardhat-gas-reporter: ^1.0.9
+    ethereum-waffle: latest
+    ethers: ^6.6.0
+    ethers-v5: "npm:ethers@^5.7.0"
+    ganache-cli: latest
+    hardhat: ^2.22.1
+    hardhat-gas-reporter: latest
     lodash: ^4.17.21
     prettier: ^2.7.1
     prettier-plugin-solidity: ^1.0.0-dev.23
@@ -156,52 +163,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@chainsafe/as-sha256@npm:^0.3.1":
-  version: 0.3.1
-  resolution: "@chainsafe/as-sha256@npm:0.3.1"
-  checksum: 58ea733be1657b0e31dbf48b0dba862da0833df34a81c1460c7352f04ce90874f70003cbf34d0afb9e5e53a33ee2d63a261a8b12462be85b2ba0a6f7f13d6150
-  languageName: node
-  linkType: hard
-
-"@chainsafe/persistent-merkle-tree@npm:^0.4.2":
-  version: 0.4.2
-  resolution: "@chainsafe/persistent-merkle-tree@npm:0.4.2"
-  dependencies:
-    "@chainsafe/as-sha256": ^0.3.1
-  checksum: f9cfcb2132a243992709715dbd28186ab48c7c0c696f29d30857693cca5526bf753974a505ef68ffd5623bbdbcaa10f9083f4dd40bf99eb6408e451cc26a1a9e
-  languageName: node
-  linkType: hard
-
-"@chainsafe/persistent-merkle-tree@npm:^0.5.0":
-  version: 0.5.0
-  resolution: "@chainsafe/persistent-merkle-tree@npm:0.5.0"
-  dependencies:
-    "@chainsafe/as-sha256": ^0.3.1
-  checksum: 2c67203da776c79cd3a6132e2d672fe132393b2e63dc71604e3134acc8c0ec25cc5e431051545939ea0f7c5ff2066fb806b9e5cab974ca085d046226a1671f7d
-  languageName: node
-  linkType: hard
-
-"@chainsafe/ssz@npm:^0.10.0":
-  version: 0.10.2
-  resolution: "@chainsafe/ssz@npm:0.10.2"
-  dependencies:
-    "@chainsafe/as-sha256": ^0.3.1
-    "@chainsafe/persistent-merkle-tree": ^0.5.0
-  checksum: 6bb70cf741d0a19dd0b28b3f6f067b96fa39f556e2eefa6ac745b21db9c3b3a8393dc3cca8ff4a6ce065ed71ddc3fb1b2b390a92004b9d01067c26e2558e5503
-  languageName: node
-  linkType: hard
-
-"@chainsafe/ssz@npm:^0.9.2":
-  version: 0.9.4
-  resolution: "@chainsafe/ssz@npm:0.9.4"
-  dependencies:
-    "@chainsafe/as-sha256": ^0.3.1
-    "@chainsafe/persistent-merkle-tree": ^0.4.2
-    case: ^1.6.3
-  checksum: c6eaedeae9e5618b3c666ff4507a27647f665a8dcf17d5ca86da4ed4788c5a93868f256d0005467d184fdf35ec03f323517ec2e55ec42492d769540a2ec396bc
-  languageName: node
-  linkType: hard
-
 "@cspotcode/source-map-support@npm:^0.8.0":
   version: 0.8.1
   resolution: "@cspotcode/source-map-support@npm:0.8.1"
@@ -211,49 +172,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@defi-wonderland/smock@npm:^2.3.4":
-  version: 2.3.5
-  resolution: "@defi-wonderland/smock@npm:2.3.5"
-  dependencies:
-    "@nomicfoundation/ethereumjs-evm": ^1.0.0-rc.3
-    "@nomicfoundation/ethereumjs-util": ^8.0.0-rc.3
-    "@nomicfoundation/ethereumjs-vm": ^6.0.0-rc.3
-    diff: ^5.0.0
-    lodash.isequal: ^4.5.0
-    lodash.isequalwith: ^4.4.0
-    rxjs: ^7.2.0
-    semver: ^7.3.5
-  peerDependencies:
-    "@ethersproject/abi": ^5
-    "@ethersproject/abstract-provider": ^5
-    "@ethersproject/abstract-signer": ^5
-    "@nomiclabs/hardhat-ethers": ^2
-    ethers: ^5
-    hardhat: ^2
-  checksum: b3c408fb43cd7b02bf6f3b3a392758944ee4d4ad9d92a5bcb595b2bdf7ebe702d052b8631afba0b408e80185b1db22d655dc63feba82365f5f1f6786eb98d859
-  languageName: node
-  linkType: hard
-
-"@ensdomains/ens@npm:^0.4.4":
-  version: 0.4.5
-  resolution: "@ensdomains/ens@npm:0.4.5"
-  dependencies:
-    bluebird: ^3.5.2
-    eth-ens-namehash: ^2.0.8
-    solc: ^0.4.20
-    testrpc: 0.0.1
-    web3-utils: ^1.0.0-beta.31
-  checksum: 3b4f6e34f3376f1b3cc60927d53d5951c4da0a9ff0f8856aaedba5a73bceccb7c08632bf6709b3bb9e43d6e83223d23928f574fc62dec12b2b1a692bcd3d45c6
-  languageName: node
-  linkType: hard
-
-"@ensdomains/resolver@npm:^0.2.4":
-  version: 0.2.4
-  resolution: "@ensdomains/resolver@npm:0.2.4"
-  checksum: 3827a3430cc8935a0839dac9dafcfa6011c6f71af229ff91cbc6cdcbaa35d20c6dbb1a8a901cdb00e66428578ce1675bd6fe6901778b5d0d828321fbec9e0f7f
-  languageName: node
-  linkType: hard
-
 "@eslint-community/eslint-utils@npm:^4.2.0":
   version: 4.4.0
   resolution: "@eslint-community/eslint-utils@npm:4.4.0"
@@ -296,66 +214,130 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@ethereum-waffle/chai@npm:^3.4.4":
-  version: 3.4.4
-  resolution: "@ethereum-waffle/chai@npm:3.4.4"
+"@ethereum-waffle/chai@npm:4.0.10":
+  version: 4.0.10
+  resolution: "@ethereum-waffle/chai@npm:4.0.10"
   dependencies:
-    "@ethereum-waffle/provider": ^3.4.4
-    ethers: ^5.5.2
-  checksum: b2b9b6b839c3f6b4abf8489fe50549e6fda07bd81ae8e4250b20d9a76ce4a729ef47c741364387b1d2dbc7fac14b46a5d6dcc4d404344b9cce5f9698ff012251
+    "@ethereum-waffle/provider": 4.0.5
+    debug: ^4.3.4
+    json-bigint: ^1.0.0
+  peerDependencies:
+    ethers: "*"
+  checksum: 11a2fa51224e98ee4cbf346a731be68b17b3c172e68391b25fc0027545d7477dbeca916bbd10be0fa9de612eaed6115a0578f9d3e312e9fe95af2b7791fd0981
   languageName: node
   linkType: hard
 
-"@ethereum-waffle/compiler@npm:^3.4.4":
-  version: 3.4.4
-  resolution: "@ethereum-waffle/compiler@npm:3.4.4"
+"@ethereum-waffle/compiler@npm:4.0.3":
+  version: 4.0.3
+  resolution: "@ethereum-waffle/compiler@npm:4.0.3"
   dependencies:
     "@resolver-engine/imports": ^0.3.3
     "@resolver-engine/imports-fs": ^0.3.3
-    "@typechain/ethers-v5": ^2.0.0
+    "@typechain/ethers-v5": ^10.0.0
     "@types/mkdirp": ^0.5.2
-    "@types/node-fetch": ^2.5.5
-    ethers: ^5.0.1
+    "@types/node-fetch": ^2.6.1
     mkdirp: ^0.5.1
-    node-fetch: ^2.6.1
-    solc: ^0.6.3
-    ts-generator: ^0.1.1
-    typechain: ^3.0.0
-  checksum: ebffca732969253934c1e8cca6cc1f12d6294f848d44e6595af81460bc3230bc69096d0965b9deb2c7eecd472a1d536d8cbe993f95bfc76fbbe2114ddbabff70
+    node-fetch: ^2.6.7
+  peerDependencies:
+    ethers: "*"
+    solc: "*"
+    typechain: ^8.0.0
+  checksum: ec7839b0f79a40a77fa05bb6941e00b2b3b1e0aa5514a617400c988b302bbbc5e9373b25ba52c7319bb00b83923dce42011384883c7a234c52f8c44eb5b571fc
   languageName: node
   linkType: hard
 
-"@ethereum-waffle/ens@npm:^3.4.4":
-  version: 3.4.4
-  resolution: "@ethereum-waffle/ens@npm:3.4.4"
-  dependencies:
+"@ethereum-waffle/ens@npm:4.0.3":
+  version: 4.0.3
+  resolution: "@ethereum-waffle/ens@npm:4.0.3"
+  peerDependencies:
     "@ensdomains/ens": ^0.4.4
     "@ensdomains/resolver": ^0.2.4
-    ethers: ^5.5.2
-  checksum: 71d93c09ef3ab89a46f05b9e2a06e129e2109d160c3a819e4bf3b4414fc4707e7fc646c87c1d82f9ba769dc1ac3c6f4934fd72499654fcfc9db4abf46c21d118
+    ethers: "*"
+  checksum: 84435c3dda78c416b332c481cfa9322f5bf06168d5887607d320cb30f20283ccde52eabd18adb5791485125d44d99ff7b5f84bd7bbdb1fde86465abb40a81966
+  languageName: node
+  linkType: hard
+
+"@ethereum-waffle/mock-contract@npm:4.0.4":
+  version: 4.0.4
+  resolution: "@ethereum-waffle/mock-contract@npm:4.0.4"
+  peerDependencies:
+    ethers: "*"
+  checksum: 45bea2ba4615a0bb81692c3d647ad39c2c37fcf250b577aeb6c5aad03fd4d0912d8d9ef5de638ab276ece1eb9ca1d09d23ed297d96da683fe34e0b01ba631da9
+  languageName: node
+  linkType: hard
+
+"@ethereum-waffle/provider@npm:4.0.5":
+  version: 4.0.5
+  resolution: "@ethereum-waffle/provider@npm:4.0.5"
+  dependencies:
+    "@ethereum-waffle/ens": 4.0.3
+    "@ganache/ethereum-options": 0.1.4
+    debug: ^4.3.4
+    ganache: 7.4.3
+  peerDependencies:
+    ethers: "*"
+  checksum: b1282ea28cbfba05343cc101bceab3f72fdd9ed391f7c7e0f252aead81aec46b6a0ab7d7ca8504e080e306d6554c21e5420765965d92ed5b303a12543dc85cf4
+  languageName: node
+  linkType: hard
+
+"@ethereumjs/block@npm:^3.5.0, @ethereumjs/block@npm:^3.6.0, @ethereumjs/block@npm:^3.6.2":
+  version: 3.6.3
+  resolution: "@ethereumjs/block@npm:3.6.3"
+  dependencies:
+    "@ethereumjs/common": ^2.6.5
+    "@ethereumjs/tx": ^3.5.2
+    ethereumjs-util: ^7.1.5
+    merkle-patricia-tree: ^4.2.4
+  checksum: d08c78134d15bc09c08b9a355ab736faa0f6b04ab87d2962e60df9c8bf977ebc68fe10aec6ca50bc2486532f489d7968fb5046defcd839b3b5ce28ca9dbce40f
+  languageName: node
+  linkType: hard
+
+"@ethereumjs/blockchain@npm:^5.5.0":
+  version: 5.5.3
+  resolution: "@ethereumjs/blockchain@npm:5.5.3"
+  dependencies:
+    "@ethereumjs/block": ^3.6.2
+    "@ethereumjs/common": ^2.6.4
+    "@ethereumjs/ethash": ^1.1.0
+    debug: ^4.3.3
+    ethereumjs-util: ^7.1.5
+    level-mem: ^5.0.1
+    lru-cache: ^5.1.1
+    semaphore-async-await: ^1.5.1
+  checksum: eeefb4735ac06e6fe5ec5457eb9ac7aa26ced8651093d05067aee264f23704d79eacb1b2742e0651b73d2528aa8a9a40f3cc9e479f1837253c2dbb784a7a8e59
+  languageName: node
+  linkType: hard
+
+"@ethereumjs/common@npm:2.6.0":
+  version: 2.6.0
+  resolution: "@ethereumjs/common@npm:2.6.0"
+  dependencies:
+    crc-32: ^1.2.0
+    ethereumjs-util: ^7.1.3
+  checksum: f1e775f0d3963011f84cd6f6de985b342064331c8fd41bc81a6497abe959078704bf4febd8c59a3fc51c3527b1261441436d55d032f85f0453ff1af4a8dbccb3
   languageName: node
   linkType: hard
 
-"@ethereum-waffle/mock-contract@npm:^3.4.4":
-  version: 3.4.4
-  resolution: "@ethereum-waffle/mock-contract@npm:3.4.4"
+"@ethereumjs/common@npm:^2.6.0, @ethereumjs/common@npm:^2.6.4, @ethereumjs/common@npm:^2.6.5":
+  version: 2.6.5
+  resolution: "@ethereumjs/common@npm:2.6.5"
   dependencies:
-    "@ethersproject/abi": ^5.5.0
-    ethers: ^5.5.2
-  checksum: 6e5c62b342e424cd1937f2f7eb424056ad143b238320880f378c0db61c6d694617f968687321a2f030d546aa5b4dde42681cbb419589d7f87452c82844a4488b
+    crc-32: ^1.2.0
+    ethereumjs-util: ^7.1.5
+  checksum: 0143386f267ef01b7a8bb1847596f964ad58643c084e5fd8e3a0271a7bf8428605dbf38cbb92c84f6622080ad095abeb765f178c02d86ec52abf9e8a4c0e4ecf
   languageName: node
   linkType: hard
 
-"@ethereum-waffle/provider@npm:^3.4.4":
-  version: 3.4.4
-  resolution: "@ethereum-waffle/provider@npm:3.4.4"
+"@ethereumjs/ethash@npm:^1.1.0":
+  version: 1.1.0
+  resolution: "@ethereumjs/ethash@npm:1.1.0"
   dependencies:
-    "@ethereum-waffle/ens": ^3.4.4
-    ethers: ^5.5.2
-    ganache-core: ^2.13.2
-    patch-package: ^6.2.2
-    postinstall-postinstall: ^2.1.0
-  checksum: 9e251d7b0198c22e337b18368e3893de766a821e818702dbef0e0d603bad550c6e3a29676cff11272bc82762833586ee9659593d957ec8759a8cc93c2b0f3d00
+    "@ethereumjs/block": ^3.5.0
+    "@types/levelup": ^4.3.0
+    buffer-xor: ^2.0.1
+    ethereumjs-util: ^7.1.1
+    miller-rabin: ^4.0.0
+  checksum: 152bc0850eeb0f2507383ca005418697b0a6a4487b120d7b3fadae4cb3b4781403c96c01f0c47149031431e518fb174c284ff38806b457f86f00c500eb213df3
   languageName: node
   linkType: hard
 
@@ -368,6 +350,26 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@ethereumjs/tx@npm:3.4.0":
+  version: 3.4.0
+  resolution: "@ethereumjs/tx@npm:3.4.0"
+  dependencies:
+    "@ethereumjs/common": ^2.6.0
+    ethereumjs-util: ^7.1.3
+  checksum: 381cbb872edb0ae83a56bf5d5657ac4f594f43ca0956b6577fb762840033081252345d67151d4feafde3f97caaab9a9826348780553c05d5a8ca2984259ad555
+  languageName: node
+  linkType: hard
+
+"@ethereumjs/tx@npm:^3.4.0, @ethereumjs/tx@npm:^3.5.2":
+  version: 3.5.2
+  resolution: "@ethereumjs/tx@npm:3.5.2"
+  dependencies:
+    "@ethereumjs/common": ^2.6.4
+    ethereumjs-util: ^7.1.5
+  checksum: a34a7228a623b40300484d15875b9f31f0a612cfeab64a845f6866cf0bfe439519e9455ac6396149f29bc527cf0ee277ace082ae013a1075dcbf7193220a0146
+  languageName: node
+  linkType: hard
+
 "@ethereumjs/util@npm:^8.1.0":
   version: 8.1.0
   resolution: "@ethereumjs/util@npm:8.1.0"
@@ -379,24 +381,27 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@ethersproject/abi@npm:5.0.0-beta.153":
-  version: 5.0.0-beta.153
-  resolution: "@ethersproject/abi@npm:5.0.0-beta.153"
+"@ethereumjs/vm@npm:5.6.0":
+  version: 5.6.0
+  resolution: "@ethereumjs/vm@npm:5.6.0"
   dependencies:
-    "@ethersproject/address": ">=5.0.0-beta.128"
-    "@ethersproject/bignumber": ">=5.0.0-beta.130"
-    "@ethersproject/bytes": ">=5.0.0-beta.129"
-    "@ethersproject/constants": ">=5.0.0-beta.128"
-    "@ethersproject/hash": ">=5.0.0-beta.128"
-    "@ethersproject/keccak256": ">=5.0.0-beta.127"
-    "@ethersproject/logger": ">=5.0.0-beta.129"
-    "@ethersproject/properties": ">=5.0.0-beta.131"
-    "@ethersproject/strings": ">=5.0.0-beta.130"
-  checksum: 9f5c3c986a47c2bcc066e0ea1d8190be4358de6722d0eb75eaaacbc1f7610169691cc369085aa390bd88c731c6e539f309cb81face594feffac9336e369444c5
+    "@ethereumjs/block": ^3.6.0
+    "@ethereumjs/blockchain": ^5.5.0
+    "@ethereumjs/common": ^2.6.0
+    "@ethereumjs/tx": ^3.4.0
+    async-eventemitter: ^0.2.4
+    core-js-pure: ^3.0.1
+    debug: ^2.2.0
+    ethereumjs-util: ^7.1.3
+    functional-red-black-tree: ^1.0.1
+    mcl-wasm: ^0.7.1
+    merkle-patricia-tree: ^4.2.2
+    rustbn.js: ~0.2.0
+  checksum: 67f803f7dc851aeed9996cdab6751dc3f7565146ff8a24982526d33a07c173e84dd449b2fbb9202a479c7446b628105af41465b75c1f9143e1e68cf573fed4c3
   languageName: node
   linkType: hard
 
-"@ethersproject/abi@npm:5.7.0, @ethersproject/abi@npm:^5.0.9, @ethersproject/abi@npm:^5.1.2, @ethersproject/abi@npm:^5.5.0, @ethersproject/abi@npm:^5.6.3, @ethersproject/abi@npm:^5.6.4, @ethersproject/abi@npm:^5.7.0":
+"@ethersproject/abi@npm:5.7.0, @ethersproject/abi@npm:^5.0.9, @ethersproject/abi@npm:^5.1.2, @ethersproject/abi@npm:^5.6.4, @ethersproject/abi@npm:^5.7.0":
   version: 5.7.0
   resolution: "@ethersproject/abi@npm:5.7.0"
   dependencies:
@@ -441,7 +446,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@ethersproject/address@npm:5.7.0, @ethersproject/address@npm:>=5.0.0-beta.128, @ethersproject/address@npm:^5.0.2, @ethersproject/address@npm:^5.7.0":
+"@ethersproject/address@npm:5.7.0, @ethersproject/address@npm:^5.0.2, @ethersproject/address@npm:^5.7.0":
   version: 5.7.0
   resolution: "@ethersproject/address@npm:5.7.0"
   dependencies:
@@ -473,7 +478,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@ethersproject/bignumber@npm:5.7.0, @ethersproject/bignumber@npm:>=5.0.0-beta.130, @ethersproject/bignumber@npm:^5.7.0":
+"@ethersproject/bignumber@npm:5.7.0, @ethersproject/bignumber@npm:^5.7.0":
   version: 5.7.0
   resolution: "@ethersproject/bignumber@npm:5.7.0"
   dependencies:
@@ -484,7 +489,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@ethersproject/bytes@npm:5.7.0, @ethersproject/bytes@npm:>=5.0.0-beta.129, @ethersproject/bytes@npm:^5.6.1, @ethersproject/bytes@npm:^5.7.0":
+"@ethersproject/bytes@npm:5.7.0, @ethersproject/bytes@npm:^5.6.1, @ethersproject/bytes@npm:^5.7.0":
   version: 5.7.0
   resolution: "@ethersproject/bytes@npm:5.7.0"
   dependencies:
@@ -493,7 +498,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@ethersproject/constants@npm:5.7.0, @ethersproject/constants@npm:>=5.0.0-beta.128, @ethersproject/constants@npm:^5.7.0":
+"@ethersproject/constants@npm:5.7.0, @ethersproject/constants@npm:^5.7.0":
   version: 5.7.0
   resolution: "@ethersproject/constants@npm:5.7.0"
   dependencies:
@@ -520,7 +525,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@ethersproject/hash@npm:5.7.0, @ethersproject/hash@npm:>=5.0.0-beta.128, @ethersproject/hash@npm:^5.7.0":
+"@ethersproject/hash@npm:5.7.0, @ethersproject/hash@npm:^5.7.0":
   version: 5.7.0
   resolution: "@ethersproject/hash@npm:5.7.0"
   dependencies:
@@ -578,7 +583,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@ethersproject/keccak256@npm:5.7.0, @ethersproject/keccak256@npm:>=5.0.0-beta.127, @ethersproject/keccak256@npm:^5.7.0":
+"@ethersproject/keccak256@npm:5.7.0, @ethersproject/keccak256@npm:^5.7.0":
   version: 5.7.0
   resolution: "@ethersproject/keccak256@npm:5.7.0"
   dependencies:
@@ -588,7 +593,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@ethersproject/logger@npm:5.7.0, @ethersproject/logger@npm:>=5.0.0-beta.129, @ethersproject/logger@npm:^5.7.0":
+"@ethersproject/logger@npm:5.7.0, @ethersproject/logger@npm:^5.7.0":
   version: 5.7.0
   resolution: "@ethersproject/logger@npm:5.7.0"
   checksum: 075ab2f605f1fd0813f2e39c3308f77b44a67732b36e712d9bc085f22a84aac4da4f71b39bee50fe78da3e1c812673fadc41180c9970fe5e486e91ea17befe0d
@@ -614,7 +619,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@ethersproject/properties@npm:5.7.0, @ethersproject/properties@npm:>=5.0.0-beta.131, @ethersproject/properties@npm:^5.7.0":
+"@ethersproject/properties@npm:5.7.0, @ethersproject/properties@npm:^5.7.0":
   version: 5.7.0
   resolution: "@ethersproject/properties@npm:5.7.0"
   dependencies:
@@ -623,7 +628,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@ethersproject/providers@npm:5.7.2, @ethersproject/providers@npm:^5.6.8, @ethersproject/providers@npm:^5.7.1, @ethersproject/providers@npm:^5.7.2":
+"@ethersproject/providers@npm:5.7.2, @ethersproject/providers@npm:^5.6.8":
   version: 5.7.2
   resolution: "@ethersproject/providers@npm:5.7.2"
   dependencies:
@@ -710,7 +715,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@ethersproject/strings@npm:5.7.0, @ethersproject/strings@npm:>=5.0.0-beta.130, @ethersproject/strings@npm:^5.7.0":
+"@ethersproject/strings@npm:5.7.0, @ethersproject/strings@npm:^5.7.0":
   version: 5.7.0
   resolution: "@ethersproject/strings@npm:5.7.0"
   dependencies:
@@ -721,7 +726,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@ethersproject/transactions@npm:5.7.0, @ethersproject/transactions@npm:^5.0.0-beta.135, @ethersproject/transactions@npm:^5.7.0":
+"@ethersproject/transactions@npm:5.7.0, @ethersproject/transactions@npm:^5.7.0":
   version: 5.7.0
   resolution: "@ethersproject/transactions@npm:5.7.0"
   dependencies:
@@ -805,6 +810,82 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@ganache/ethereum-address@npm:0.1.4":
+  version: 0.1.4
+  resolution: "@ganache/ethereum-address@npm:0.1.4"
+  dependencies:
+    "@ganache/utils": 0.1.4
+  checksum: 0e07102c67aa2c25233e30f8ca359cbd012ad0e0b9580b8e6aff6f87dd46daee89bbc60d9518f2204f36f943e7bd5d20e571646c85e6a68a98784c3ede2ccec0
+  languageName: node
+  linkType: hard
+
+"@ganache/ethereum-options@npm:0.1.4":
+  version: 0.1.4
+  resolution: "@ganache/ethereum-options@npm:0.1.4"
+  dependencies:
+    "@ganache/ethereum-address": 0.1.4
+    "@ganache/ethereum-utils": 0.1.4
+    "@ganache/options": 0.1.4
+    "@ganache/utils": 0.1.4
+    bip39: 3.0.4
+    seedrandom: 3.0.5
+  checksum: 597b32502654ce9f3fec02fdf308f1e6b2c657b5e25c6d4219d71ecbea94e45faa4135c6d4e25cacf1faac1509f2b7546f3d8bbdba1e9121975d820999d3aa76
+  languageName: node
+  linkType: hard
+
+"@ganache/ethereum-utils@npm:0.1.4":
+  version: 0.1.4
+  resolution: "@ganache/ethereum-utils@npm:0.1.4"
+  dependencies:
+    "@ethereumjs/common": 2.6.0
+    "@ethereumjs/tx": 3.4.0
+    "@ethereumjs/vm": 5.6.0
+    "@ganache/ethereum-address": 0.1.4
+    "@ganache/rlp": 0.1.4
+    "@ganache/utils": 0.1.4
+    emittery: 0.10.0
+    ethereumjs-abi: 0.6.8
+    ethereumjs-util: 7.1.3
+  checksum: 74bc7b7fb62e9dc2f114f6f428c465d9365c0bb84c85144d34935d24a2893c5471c8cae263ae4bea51f1335803b6b1771f57c25a276e9c0539a08a90c3289bca
+  languageName: node
+  linkType: hard
+
+"@ganache/options@npm:0.1.4":
+  version: 0.1.4
+  resolution: "@ganache/options@npm:0.1.4"
+  dependencies:
+    "@ganache/utils": 0.1.4
+    bip39: 3.0.4
+    seedrandom: 3.0.5
+  checksum: 4f1cda646f5599b18a0eeaf27286499c78c3e2e0eb2541db756c27f2ca16e58539c9db99aab8441e593f9fe586269940d800900f63312fcb10231ab95ebdc3dc
+  languageName: node
+  linkType: hard
+
+"@ganache/rlp@npm:0.1.4":
+  version: 0.1.4
+  resolution: "@ganache/rlp@npm:0.1.4"
+  dependencies:
+    "@ganache/utils": 0.1.4
+    rlp: 2.2.6
+  checksum: 425c5d4a0a36b834cfac005d05679b3df970a6d8d953f385a5f9bd003a326ba23c1bce06095729879136699b70389d7f2627f939f712ed8897c96e542766771f
+  languageName: node
+  linkType: hard
+
+"@ganache/utils@npm:0.1.4":
+  version: 0.1.4
+  resolution: "@ganache/utils@npm:0.1.4"
+  dependencies:
+    "@trufflesuite/bigint-buffer": 1.1.9
+    emittery: 0.10.0
+    keccak: 3.0.1
+    seedrandom: 3.0.5
+  dependenciesMeta:
+    "@trufflesuite/bigint-buffer":
+      optional: true
+  checksum: c81b7380d56292a44e9cdb0e581d815b9510fb1be87661fe135e2d3611b495f1cd01aa4b91e287bfc28d08d1b4b4210f7b54e32ea28e054faa006cf232fb3dcc
+  languageName: node
+  linkType: hard
+
 "@graphprotocol/graph-cli@npm:^0.21.1":
   version: 0.21.3
   resolution: "@graphprotocol/graph-cli@npm:0.21.3"
@@ -936,24 +1017,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@ljharb/resumer@npm:~0.0.1":
-  version: 0.0.1
-  resolution: "@ljharb/resumer@npm:0.0.1"
-  dependencies:
-    "@ljharb/through": ^2.3.9
-  checksum: 1cff0a485cb857933d2921cb05a349f8fe894fa2bb6b31a347010ecccc4a2b369e43ebe5383a32a60ee6c9572d2c83fcab383eb01727e1507bf29c59f312dae6
-  languageName: node
-  linkType: hard
-
-"@ljharb/through@npm:^2.3.9, @ljharb/through@npm:~2.3.9":
-  version: 2.3.12
-  resolution: "@ljharb/through@npm:2.3.12"
-  dependencies:
-    call-bind: ^1.0.5
-  checksum: d5a78568cd3025c03264a9f9c61b30511d27cb9611fae7575cb1339a1baa1a263b6af03e28505b821324f3c6285086ee5add612b8b0155d1f253ed5159cd3f56
-  languageName: node
-  linkType: hard
-
 "@metamask/eth-sig-util@npm:^4.0.0":
   version: 4.0.1
   resolution: "@metamask/eth-sig-util@npm:4.0.1"
@@ -967,6 +1030,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@noble/curves@npm:1.2.0":
+  version: 1.2.0
+  resolution: "@noble/curves@npm:1.2.0"
+  dependencies:
+    "@noble/hashes": 1.3.2
+  checksum: bb798d7a66d8e43789e93bc3c2ddff91a1e19fdb79a99b86cd98f1e5eff0ee2024a2672902c2576ef3577b6f282f3b5c778bebd55761ddbb30e36bf275e83dd0
+  languageName: node
+  linkType: hard
+
 "@noble/curves@npm:1.3.0, @noble/curves@npm:~1.3.0":
   version: 1.3.0
   resolution: "@noble/curves@npm:1.3.0"
@@ -983,6 +1055,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@noble/hashes@npm:1.3.2":
+  version: 1.3.2
+  resolution: "@noble/hashes@npm:1.3.2"
+  checksum: fe23536b436539d13f90e4b9be843cc63b1b17666a07634a2b1259dded6f490be3d050249e6af98076ea8f2ea0d56f578773c2197f2aa0eeaa5fba5bc18ba474
+  languageName: node
+  linkType: hard
+
 "@noble/hashes@npm:1.3.3, @noble/hashes@npm:~1.3.2":
   version: 1.3.3
   resolution: "@noble/hashes@npm:1.3.3"
@@ -1024,341 +1103,188 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@nomicfoundation/ethereumjs-block@npm:4.2.2":
-  version: 4.2.2
-  resolution: "@nomicfoundation/ethereumjs-block@npm:4.2.2"
-  dependencies:
-    "@nomicfoundation/ethereumjs-common": 3.1.2
-    "@nomicfoundation/ethereumjs-rlp": 4.0.3
-    "@nomicfoundation/ethereumjs-trie": 5.0.5
-    "@nomicfoundation/ethereumjs-tx": 4.1.2
-    "@nomicfoundation/ethereumjs-util": 8.0.6
-    ethereum-cryptography: 0.1.3
-  checksum: 174a251d9c4e0bb9c1a7a6e77c52f1b2b4708d8135dba55c1025776248258ce905e4383a79da0ce7ac4e67e03b6c56351ca634a771b5eae976ed97498fc163f9
+"@nomicfoundation/edr-darwin-arm64@npm:0.3.2":
+  version: 0.3.2
+  resolution: "@nomicfoundation/edr-darwin-arm64@npm:0.3.2"
+  conditions: os=darwin & cpu=arm64
   languageName: node
   linkType: hard
 
-"@nomicfoundation/ethereumjs-block@npm:5.0.2":
-  version: 5.0.2
-  resolution: "@nomicfoundation/ethereumjs-block@npm:5.0.2"
-  dependencies:
-    "@nomicfoundation/ethereumjs-common": 4.0.2
-    "@nomicfoundation/ethereumjs-rlp": 5.0.2
-    "@nomicfoundation/ethereumjs-trie": 6.0.2
-    "@nomicfoundation/ethereumjs-tx": 5.0.2
-    "@nomicfoundation/ethereumjs-util": 9.0.2
-    ethereum-cryptography: 0.1.3
-    ethers: ^5.7.1
-  checksum: 7ff744f44a01f1c059ca7812a1cfc8089f87aa506af6cb39c78331dca71b32993cbd6fa05ad03f8c4f4fab73bb998a927af69e0d8ff01ae192ee5931606e09f5
+"@nomicfoundation/edr-darwin-x64@npm:0.3.2":
+  version: 0.3.2
+  resolution: "@nomicfoundation/edr-darwin-x64@npm:0.3.2"
+  conditions: os=darwin & cpu=x64
   languageName: node
   linkType: hard
 
-"@nomicfoundation/ethereumjs-blockchain@npm:6.2.2":
-  version: 6.2.2
-  resolution: "@nomicfoundation/ethereumjs-blockchain@npm:6.2.2"
-  dependencies:
-    "@nomicfoundation/ethereumjs-block": 4.2.2
-    "@nomicfoundation/ethereumjs-common": 3.1.2
-    "@nomicfoundation/ethereumjs-ethash": 2.0.5
-    "@nomicfoundation/ethereumjs-rlp": 4.0.3
-    "@nomicfoundation/ethereumjs-trie": 5.0.5
-    "@nomicfoundation/ethereumjs-util": 8.0.6
-    abstract-level: ^1.0.3
-    debug: ^4.3.3
-    ethereum-cryptography: 0.1.3
-    level: ^8.0.0
-    lru-cache: ^5.1.1
-    memory-level: ^1.0.0
-  checksum: 5933600bf005ec3e33f6fdd0b3582b80ed7eac8fa776fc86f21de8a6ac3614e3262c48ad3737015c19558165aecd7b13a8056e96afd61511d0605411e0264871
+"@nomicfoundation/edr-linux-arm64-gnu@npm:0.3.2":
+  version: 0.3.2
+  resolution: "@nomicfoundation/edr-linux-arm64-gnu@npm:0.3.2"
+  conditions: os=linux & cpu=arm64 & libc=glibc
   languageName: node
   linkType: hard
 
-"@nomicfoundation/ethereumjs-blockchain@npm:7.0.2":
-  version: 7.0.2
-  resolution: "@nomicfoundation/ethereumjs-blockchain@npm:7.0.2"
-  dependencies:
-    "@nomicfoundation/ethereumjs-block": 5.0.2
-    "@nomicfoundation/ethereumjs-common": 4.0.2
-    "@nomicfoundation/ethereumjs-ethash": 3.0.2
-    "@nomicfoundation/ethereumjs-rlp": 5.0.2
-    "@nomicfoundation/ethereumjs-trie": 6.0.2
-    "@nomicfoundation/ethereumjs-tx": 5.0.2
-    "@nomicfoundation/ethereumjs-util": 9.0.2
-    abstract-level: ^1.0.3
-    debug: ^4.3.3
-    ethereum-cryptography: 0.1.3
-    level: ^8.0.0
-    lru-cache: ^5.1.1
-    memory-level: ^1.0.0
-  checksum: b7e440dcd73e32aa72d13bfd28cb472773c9c60ea808a884131bf7eb3f42286ad594a0864215f599332d800f3fe1f772fff4b138d2dcaa8f41e4d8389bff33e7
+"@nomicfoundation/edr-linux-arm64-musl@npm:0.3.2":
+  version: 0.3.2
+  resolution: "@nomicfoundation/edr-linux-arm64-musl@npm:0.3.2"
+  conditions: os=linux & cpu=arm64 & libc=musl
   languageName: node
   linkType: hard
 
-"@nomicfoundation/ethereumjs-common@npm:3.1.2":
-  version: 3.1.2
-  resolution: "@nomicfoundation/ethereumjs-common@npm:3.1.2"
-  dependencies:
-    "@nomicfoundation/ethereumjs-util": 8.0.6
-    crc-32: ^1.2.0
-  checksum: b886e47bb4da26b42bf9e905c5f073db62d2ad1b740d50898012580b501868839fcf08430debe3fca927b4d73e01628c1b0b2e84401feb551245dacfac045404
+"@nomicfoundation/edr-linux-x64-gnu@npm:0.3.2":
+  version: 0.3.2
+  resolution: "@nomicfoundation/edr-linux-x64-gnu@npm:0.3.2"
+  conditions: os=linux & cpu=x64 & libc=glibc
   languageName: node
   linkType: hard
 
-"@nomicfoundation/ethereumjs-common@npm:4.0.2":
-  version: 4.0.2
-  resolution: "@nomicfoundation/ethereumjs-common@npm:4.0.2"
-  dependencies:
-    "@nomicfoundation/ethereumjs-util": 9.0.2
-    crc-32: ^1.2.0
-  checksum: f0d84704d6254d374299c19884312bd5666974b4b6f342d3f10bc76e549de78d20e45a53d25fbdc146268a52335497127e4f069126da7c60ac933a158e704887
+"@nomicfoundation/edr-linux-x64-musl@npm:0.3.2":
+  version: 0.3.2
+  resolution: "@nomicfoundation/edr-linux-x64-musl@npm:0.3.2"
+  conditions: os=linux & cpu=x64 & libc=musl
   languageName: node
   linkType: hard
 
-"@nomicfoundation/ethereumjs-ethash@npm:2.0.5":
-  version: 2.0.5
-  resolution: "@nomicfoundation/ethereumjs-ethash@npm:2.0.5"
-  dependencies:
-    "@nomicfoundation/ethereumjs-block": 4.2.2
-    "@nomicfoundation/ethereumjs-rlp": 4.0.3
-    "@nomicfoundation/ethereumjs-util": 8.0.6
-    abstract-level: ^1.0.3
-    bigint-crypto-utils: ^3.0.23
-    ethereum-cryptography: 0.1.3
-  checksum: 0b03c8771602cfa64c9d35e5686326d0bfecb7dc0874cd9ff737cae0ec401396187d8499c103b8858fed5b9bd930e132b8fd09d19b3f0649df36d7d0fdf4d27c
+"@nomicfoundation/edr-win32-arm64-msvc@npm:0.3.2":
+  version: 0.3.2
+  resolution: "@nomicfoundation/edr-win32-arm64-msvc@npm:0.3.2"
+  conditions: os=win32 & cpu=arm64
   languageName: node
   linkType: hard
 
-"@nomicfoundation/ethereumjs-ethash@npm:3.0.2":
-  version: 3.0.2
-  resolution: "@nomicfoundation/ethereumjs-ethash@npm:3.0.2"
-  dependencies:
-    "@nomicfoundation/ethereumjs-block": 5.0.2
-    "@nomicfoundation/ethereumjs-rlp": 5.0.2
-    "@nomicfoundation/ethereumjs-util": 9.0.2
-    abstract-level: ^1.0.3
-    bigint-crypto-utils: ^3.0.23
-    ethereum-cryptography: 0.1.3
-  checksum: e4011e4019dd9b92f7eeebfc1e6c9a9685c52d8fd0ee4f28f03e50048a23b600c714490827f59fdce497b3afb503b3fd2ebf6815ff307e9949c3efeff1403278
+"@nomicfoundation/edr-win32-ia32-msvc@npm:0.3.2":
+  version: 0.3.2
+  resolution: "@nomicfoundation/edr-win32-ia32-msvc@npm:0.3.2"
+  conditions: os=win32 & cpu=ia32
   languageName: node
   linkType: hard
 
-"@nomicfoundation/ethereumjs-evm@npm:1.3.2, @nomicfoundation/ethereumjs-evm@npm:^1.0.0-rc.3":
-  version: 1.3.2
-  resolution: "@nomicfoundation/ethereumjs-evm@npm:1.3.2"
-  dependencies:
-    "@nomicfoundation/ethereumjs-common": 3.1.2
-    "@nomicfoundation/ethereumjs-util": 8.0.6
-    "@types/async-eventemitter": ^0.2.1
-    async-eventemitter: ^0.2.4
-    debug: ^4.3.3
-    ethereum-cryptography: 0.1.3
-    mcl-wasm: ^0.7.1
-    rustbn.js: ~0.2.0
-  checksum: 4a051f36968574ffbee5d3c401ebf1c81899b69a0692c372fced67691fe18f26741f26d1781e79dfa52136af888e561d80de4fd7dd59000d640c51bd8b130023
+"@nomicfoundation/edr-win32-x64-msvc@npm:0.3.2":
+  version: 0.3.2
+  resolution: "@nomicfoundation/edr-win32-x64-msvc@npm:0.3.2"
+  conditions: os=win32 & cpu=x64
   languageName: node
   linkType: hard
 
-"@nomicfoundation/ethereumjs-evm@npm:2.0.2":
-  version: 2.0.2
-  resolution: "@nomicfoundation/ethereumjs-evm@npm:2.0.2"
-  dependencies:
-    "@ethersproject/providers": ^5.7.1
-    "@nomicfoundation/ethereumjs-common": 4.0.2
-    "@nomicfoundation/ethereumjs-tx": 5.0.2
-    "@nomicfoundation/ethereumjs-util": 9.0.2
-    debug: ^4.3.3
-    ethereum-cryptography: 0.1.3
-    mcl-wasm: ^0.7.1
-    rustbn.js: ~0.2.0
-  checksum: a23cf570836ddc147606b02df568069de946108e640f902358fef67e589f6b371d856056ee44299d9b4e3497f8ae25faa45e6b18fefd90e9b222dc6a761d85f0
+"@nomicfoundation/edr@npm:^0.3.1":
+  version: 0.3.2
+  resolution: "@nomicfoundation/edr@npm:0.3.2"
+  dependencies:
+    "@nomicfoundation/edr-darwin-arm64": 0.3.2
+    "@nomicfoundation/edr-darwin-x64": 0.3.2
+    "@nomicfoundation/edr-linux-arm64-gnu": 0.3.2
+    "@nomicfoundation/edr-linux-arm64-musl": 0.3.2
+    "@nomicfoundation/edr-linux-x64-gnu": 0.3.2
+    "@nomicfoundation/edr-linux-x64-musl": 0.3.2
+    "@nomicfoundation/edr-win32-arm64-msvc": 0.3.2
+    "@nomicfoundation/edr-win32-ia32-msvc": 0.3.2
+    "@nomicfoundation/edr-win32-x64-msvc": 0.3.2
+  dependenciesMeta:
+    "@nomicfoundation/edr-darwin-arm64":
+      optional: true
+    "@nomicfoundation/edr-darwin-x64":
+      optional: true
+    "@nomicfoundation/edr-linux-arm64-gnu":
+      optional: true
+    "@nomicfoundation/edr-linux-arm64-musl":
+      optional: true
+    "@nomicfoundation/edr-linux-x64-gnu":
+      optional: true
+    "@nomicfoundation/edr-linux-x64-musl":
+      optional: true
+    "@nomicfoundation/edr-win32-arm64-msvc":
+      optional: true
+    "@nomicfoundation/edr-win32-ia32-msvc":
+      optional: true
+    "@nomicfoundation/edr-win32-x64-msvc":
+      optional: true
+  checksum: 92700c041b6f6f21f7c252abc2c90aa4fdd5c7488d22ae9f9407d224774ea5000b6b498363abf760d7f8293609d1aeea9b6b066eeb6c3335d3a01572fcbe04ed
   languageName: node
   linkType: hard
 
-"@nomicfoundation/ethereumjs-rlp@npm:4.0.3":
-  version: 4.0.3
-  resolution: "@nomicfoundation/ethereumjs-rlp@npm:4.0.3"
-  bin:
-    rlp: bin/rlp
-  checksum: 14fc83701dd52323fae705786549ab07482ace315de69a586bb948b6f21ec529794cef8248af0b5c7e8f8b05fbadfbe222754b305841fa2189bfbc8f1eb064a2
+"@nomicfoundation/ethereumjs-common@npm:4.0.4":
+  version: 4.0.4
+  resolution: "@nomicfoundation/ethereumjs-common@npm:4.0.4"
+  dependencies:
+    "@nomicfoundation/ethereumjs-util": 9.0.4
+  checksum: ce3f6e4ae15b976efdb7ccda27e19aadb62b5ffee209f9503e68b4fd8633715d4d697c0cc10ccd35f5e4e977edd05100d0f214e28880ec64fff77341dc34fcdf
   languageName: node
   linkType: hard
 
-"@nomicfoundation/ethereumjs-rlp@npm:5.0.2":
-  version: 5.0.2
-  resolution: "@nomicfoundation/ethereumjs-rlp@npm:5.0.2"
+"@nomicfoundation/ethereumjs-rlp@npm:5.0.4":
+  version: 5.0.4
+  resolution: "@nomicfoundation/ethereumjs-rlp@npm:5.0.4"
   bin:
-    rlp: bin/rlp
-  checksum: a74434cadefca9aa8754607cc1ad7bb4bbea4ee61c6214918e60a5bbee83206850346eb64e39fd1fe97f854c7ec0163e01148c0c881dda23881938f0645a0ef2
+    rlp: bin/rlp.cjs
+  checksum: ee2c2e5776c73801dc5ed636f4988b599b4563c2d0037da542ea57eb237c69dd1ac555f6bcb5e06f70515b6459779ba0d68252a6e105132b4659ab4bf62919b0
   languageName: node
   linkType: hard
 
-"@nomicfoundation/ethereumjs-statemanager@npm:1.0.5":
-  version: 1.0.5
-  resolution: "@nomicfoundation/ethereumjs-statemanager@npm:1.0.5"
+"@nomicfoundation/ethereumjs-tx@npm:5.0.4":
+  version: 5.0.4
+  resolution: "@nomicfoundation/ethereumjs-tx@npm:5.0.4"
   dependencies:
-    "@nomicfoundation/ethereumjs-common": 3.1.2
-    "@nomicfoundation/ethereumjs-rlp": 4.0.3
-    "@nomicfoundation/ethereumjs-trie": 5.0.5
-    "@nomicfoundation/ethereumjs-util": 8.0.6
-    debug: ^4.3.3
+    "@nomicfoundation/ethereumjs-common": 4.0.4
+    "@nomicfoundation/ethereumjs-rlp": 5.0.4
+    "@nomicfoundation/ethereumjs-util": 9.0.4
     ethereum-cryptography: 0.1.3
-    functional-red-black-tree: ^1.0.1
-  checksum: 0f88743900b2211deb5d2393bf111ef63411ce533387a6d06c48cc9ac1f4fc38f968cdecc4712ebdafdebc3c4c2ce6bd1abd82989f4f4f515d3f571981d38f9f
+  peerDependencies:
+    c-kzg: ^2.1.2
+  peerDependenciesMeta:
+    c-kzg:
+      optional: true
+  checksum: 0f1c87716682ccbcf4d92ffc6cf8ab557e658b90319d82be3219a091a736859f8803c73c98e4863682e3e86d264751c472d33ff6d3c3daf4e75b5f01d0af8fa3
   languageName: node
   linkType: hard
 
-"@nomicfoundation/ethereumjs-statemanager@npm:2.0.2":
-  version: 2.0.2
-  resolution: "@nomicfoundation/ethereumjs-statemanager@npm:2.0.2"
+"@nomicfoundation/ethereumjs-util@npm:9.0.4":
+  version: 9.0.4
+  resolution: "@nomicfoundation/ethereumjs-util@npm:9.0.4"
   dependencies:
-    "@nomicfoundation/ethereumjs-common": 4.0.2
-    "@nomicfoundation/ethereumjs-rlp": 5.0.2
-    debug: ^4.3.3
+    "@nomicfoundation/ethereumjs-rlp": 5.0.4
     ethereum-cryptography: 0.1.3
-    ethers: ^5.7.1
-    js-sdsl: ^4.1.4
-  checksum: 3ab6578e252e53609afd98d8ba42a99f182dcf80252f23ed9a5e0471023ffb2502130f85fc47fa7c94cd149f9be799ed9a0942ca52a143405be9267f4ad94e64
+  peerDependencies:
+    c-kzg: ^2.1.2
+  peerDependenciesMeta:
+    c-kzg:
+      optional: true
+  checksum: 754439f72b11cad2d8986707ad020077dcc763c4055f73e2668a0b4cadb22aa4407faa9b3c587d9eb5b97ac337afbe037eb642bc1d5a16197284f83db3462cbe
   languageName: node
   linkType: hard
 
-"@nomicfoundation/ethereumjs-trie@npm:5.0.5":
-  version: 5.0.5
-  resolution: "@nomicfoundation/ethereumjs-trie@npm:5.0.5"
+"@nomicfoundation/hardhat-chai-matchers@npm:latest":
+  version: 2.0.6
+  resolution: "@nomicfoundation/hardhat-chai-matchers@npm:2.0.6"
   dependencies:
-    "@nomicfoundation/ethereumjs-rlp": 4.0.3
-    "@nomicfoundation/ethereumjs-util": 8.0.6
-    ethereum-cryptography: 0.1.3
-    readable-stream: ^3.6.0
-  checksum: bed56b55093275166c40d0aa097b32d348b3795cbfdc3797d48d136a578161431e70f30bcf453b74b52f77b897d79b61a3fb9d1abd10187c0cb7f25e40dea9c5
+    "@types/chai-as-promised": ^7.1.3
+    chai-as-promised: ^7.1.1
+    deep-eql: ^4.0.1
+    ordinal: ^1.0.3
+  peerDependencies:
+    "@nomicfoundation/hardhat-ethers": ^3.0.0
+    chai: ^4.2.0
+    ethers: ^6.1.0
+    hardhat: ^2.9.4
+  checksum: 050bf0cf2f33b480bc93912330929649b0e08a0f9405bbadda66239bfeedaee7f2cfc7e34ed03540cb381b41925fc9dd4ec9a36088ccfa8d7461259d8c78003d
   languageName: node
   linkType: hard
 
-"@nomicfoundation/ethereumjs-trie@npm:6.0.2":
-  version: 6.0.2
-  resolution: "@nomicfoundation/ethereumjs-trie@npm:6.0.2"
+"@nomicfoundation/hardhat-ethers@npm:^3.0.0":
+  version: 3.0.5
+  resolution: "@nomicfoundation/hardhat-ethers@npm:3.0.5"
   dependencies:
-    "@nomicfoundation/ethereumjs-rlp": 5.0.2
-    "@nomicfoundation/ethereumjs-util": 9.0.2
-    "@types/readable-stream": ^2.3.13
-    ethereum-cryptography: 0.1.3
-    readable-stream: ^3.6.0
-  checksum: d4da918d333851b9f2cce7dbd25ab5753e0accd43d562d98fd991b168b6a08d1794528f0ade40fe5617c84900378376fe6256cdbe52c8d66bf4c53293bbc7c40
+    debug: ^4.1.1
+    lodash.isequal: ^4.5.0
+  peerDependencies:
+    ethers: ^6.1.0
+    hardhat: ^2.0.0
+  checksum: 34b092dfec68f8d8673c96af717660327edc814bc5c9cdb5bc1f82d5bde2b18bc9b9d3499a632784a3d4f2505ac174217e55d31b546b7eaa77a5bb30b3c80bb4
   languageName: node
   linkType: hard
 
-"@nomicfoundation/ethereumjs-tx@npm:4.1.2":
-  version: 4.1.2
-  resolution: "@nomicfoundation/ethereumjs-tx@npm:4.1.2"
-  dependencies:
-    "@nomicfoundation/ethereumjs-common": 3.1.2
-    "@nomicfoundation/ethereumjs-rlp": 4.0.3
-    "@nomicfoundation/ethereumjs-util": 8.0.6
-    ethereum-cryptography: 0.1.3
-  checksum: 209622bdc56e5f1267e5d2de69ed18388b141edc568f739f0ed865aecfe96e07c381aab779ed0adacefeae4da5be64fa1110a02e481e9a7c343bf0d53f4fd1b9
-  languageName: node
-  linkType: hard
-
-"@nomicfoundation/ethereumjs-tx@npm:5.0.2":
-  version: 5.0.2
-  resolution: "@nomicfoundation/ethereumjs-tx@npm:5.0.2"
-  dependencies:
-    "@chainsafe/ssz": ^0.9.2
-    "@ethersproject/providers": ^5.7.2
-    "@nomicfoundation/ethereumjs-common": 4.0.2
-    "@nomicfoundation/ethereumjs-rlp": 5.0.2
-    "@nomicfoundation/ethereumjs-util": 9.0.2
-    ethereum-cryptography: 0.1.3
-  checksum: 0bbcea75786b2ccb559afe2ecc9866fb4566a9f157b6ffba4f50960d14f4b3da2e86e273f6fadda9b860e67cfcabf589970fb951b328cb5f900a585cd21842a2
-  languageName: node
-  linkType: hard
-
-"@nomicfoundation/ethereumjs-util@npm:8.0.6, @nomicfoundation/ethereumjs-util@npm:^8.0.0-rc.3":
-  version: 8.0.6
-  resolution: "@nomicfoundation/ethereumjs-util@npm:8.0.6"
-  dependencies:
-    "@nomicfoundation/ethereumjs-rlp": 4.0.3
-    ethereum-cryptography: 0.1.3
-  checksum: 7a51c2069702750d94bf6bc5afd4a26c50321fe42504339d5275b60974941451eb41232f8a08c307797bcd498f20a3b27074351a76abdfc36a5e74473a7eda01
-  languageName: node
-  linkType: hard
-
-"@nomicfoundation/ethereumjs-util@npm:9.0.2":
-  version: 9.0.2
-  resolution: "@nomicfoundation/ethereumjs-util@npm:9.0.2"
-  dependencies:
-    "@chainsafe/ssz": ^0.10.0
-    "@nomicfoundation/ethereumjs-rlp": 5.0.2
-    ethereum-cryptography: 0.1.3
-  checksum: 3a08f7b88079ef9f53b43da9bdcb8195498fd3d3911c2feee2571f4d1204656053f058b2f650471c86f7d2d0ba2f814768c7cfb0f266eede41c848356afc4900
-  languageName: node
-  linkType: hard
-
-"@nomicfoundation/ethereumjs-vm@npm:7.0.2":
-  version: 7.0.2
-  resolution: "@nomicfoundation/ethereumjs-vm@npm:7.0.2"
-  dependencies:
-    "@nomicfoundation/ethereumjs-block": 5.0.2
-    "@nomicfoundation/ethereumjs-blockchain": 7.0.2
-    "@nomicfoundation/ethereumjs-common": 4.0.2
-    "@nomicfoundation/ethereumjs-evm": 2.0.2
-    "@nomicfoundation/ethereumjs-rlp": 5.0.2
-    "@nomicfoundation/ethereumjs-statemanager": 2.0.2
-    "@nomicfoundation/ethereumjs-trie": 6.0.2
-    "@nomicfoundation/ethereumjs-tx": 5.0.2
-    "@nomicfoundation/ethereumjs-util": 9.0.2
-    debug: ^4.3.3
-    ethereum-cryptography: 0.1.3
-    mcl-wasm: ^0.7.1
-    rustbn.js: ~0.2.0
-  checksum: 1c25ba4d0644cadb8a2b0241a4bb02e578bfd7f70e3492b855c2ab5c120cb159cb8f7486f84dc1597884bd1697feedbfb5feb66e91352afb51f3694fd8e4a043
-  languageName: node
-  linkType: hard
-
-"@nomicfoundation/ethereumjs-vm@npm:^6.0.0-rc.3":
-  version: 6.4.2
-  resolution: "@nomicfoundation/ethereumjs-vm@npm:6.4.2"
-  dependencies:
-    "@nomicfoundation/ethereumjs-block": 4.2.2
-    "@nomicfoundation/ethereumjs-blockchain": 6.2.2
-    "@nomicfoundation/ethereumjs-common": 3.1.2
-    "@nomicfoundation/ethereumjs-evm": 1.3.2
-    "@nomicfoundation/ethereumjs-rlp": 4.0.3
-    "@nomicfoundation/ethereumjs-statemanager": 1.0.5
-    "@nomicfoundation/ethereumjs-trie": 5.0.5
-    "@nomicfoundation/ethereumjs-tx": 4.1.2
-    "@nomicfoundation/ethereumjs-util": 8.0.6
-    "@types/async-eventemitter": ^0.2.1
-    async-eventemitter: ^0.2.4
-    debug: ^4.3.3
-    ethereum-cryptography: 0.1.3
-    functional-red-black-tree: ^1.0.1
-    mcl-wasm: ^0.7.1
-    rustbn.js: ~0.2.0
-  checksum: 9138b8cce872a51fe2e378942c52fc6c54d8126ff094ba6bb78cbb630cafa20d7fbaa2b08bdcf7cad6de78e19ce68493ddbcc2e02acb7c803b866dc121274ea7
-  languageName: node
-  linkType: hard
-
-"@nomicfoundation/hardhat-chai-matchers@npm:^1.0.6":
-  version: 1.0.6
-  resolution: "@nomicfoundation/hardhat-chai-matchers@npm:1.0.6"
-  dependencies:
-    "@ethersproject/abi": ^5.1.2
-    "@types/chai-as-promised": ^7.1.3
-    chai-as-promised: ^7.1.1
-    deep-eql: ^4.0.1
-    ordinal: ^1.0.3
-  peerDependencies:
-    "@nomiclabs/hardhat-ethers": ^2.0.0
-    chai: ^4.2.0
-    ethers: ^5.0.0
-    hardhat: ^2.9.4
-  checksum: c388e5ed9068f2ba7c227737ab7312dd03405d5fab195247b061f2fa52e700fbd0fb65359c2d4f2086f2905bfca642c19a9122d034533edd936f89aea65ac7f2
-  languageName: node
-  linkType: hard
-
-"@nomicfoundation/hardhat-verify@npm:^1.1.0":
-  version: 1.1.1
-  resolution: "@nomicfoundation/hardhat-verify@npm:1.1.1"
+"@nomicfoundation/hardhat-verify@npm:latest":
+  version: 2.0.4
+  resolution: "@nomicfoundation/hardhat-verify@npm:2.0.4"
   dependencies:
     "@ethersproject/abi": ^5.1.2
     "@ethersproject/address": ^5.0.2
@@ -1371,7 +1297,7 @@ __metadata:
     undici: ^5.14.0
   peerDependencies:
     hardhat: ^2.0.4
-  checksum: 2d83d32d6833f23fb62c30c68c9a2ab3956098030edcf459e69639960f059c72572d203bcf92f191c69c9cb0fbbf011a1113bacde1e3cbb28d5e812334f04f32
+  checksum: 249c73404e5ed71cd9d8fb4d4736804f4f358866985e6e59641ed9047cdb2f6aa19e407f690bf38a6dca35350e7dba168911c2810a6d670f0838f2865df718e8
   languageName: node
   linkType: hard
 
@@ -1484,17 +1410,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@nomiclabs/hardhat-ethers@npm:^2.2.1":
-  version: 2.2.3
-  resolution: "@nomiclabs/hardhat-ethers@npm:2.2.3"
-  peerDependencies:
-    ethers: ^5.0.0
-    hardhat: ^2.0.0
-  checksum: 72321317e55eb510306e04c42353c5f7ceb42d086fc76cc740120da6e1635b7ad5bbf23a8d6b02bd590754adcf646618933111624085ab249b1ff3482e773226
-  languageName: node
-  linkType: hard
-
-"@nomiclabs/hardhat-waffle@npm:^2.0.3":
+"@nomiclabs/hardhat-waffle@npm:^2.0.6":
   version: 2.0.6
   resolution: "@nomiclabs/hardhat-waffle@npm:2.0.6"
   peerDependencies:
@@ -1529,14 +1445,27 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@openzeppelin/contracts-upgradeable@npm:^4.7.3":
-  version: 4.9.5
-  resolution: "@openzeppelin/contracts-upgradeable@npm:4.9.5"
-  checksum: d5d9bad93fe2a88a8336060901d45f185ebfe1fed9844b1fe50e8641d946588c6e69a5a8f1694f0bd073c913b4b9a5c34316acfc17d8f75228adecbcb635ea62
+"@openzeppelin/contracts-upgradeable@npm:4.7.3":
+  version: 4.7.3
+  resolution: "@openzeppelin/contracts-upgradeable@npm:4.7.3"
+  checksum: c9ffb40cb847a975d440204fc6a811f43af960050242f707332b984d29bd16dc242ffa0935de61867aeb9e0357fadedb16b09b276deda5e9775582face831021
+  languageName: node
+  linkType: hard
+
+"@openzeppelin/defender-admin-client@npm:^1.52.0":
+  version: 1.54.1
+  resolution: "@openzeppelin/defender-admin-client@npm:1.54.1"
+  dependencies:
+    "@openzeppelin/defender-base-client": 1.54.1
+    axios: ^1.4.0
+    ethers: ^5.7.2
+    lodash: ^4.17.19
+    node-fetch: ^2.6.0
+  checksum: c247b38c9fdedc55d01d59b7db7fbe212b1ff5177950a0626010b8df3e298e3cf52e0d46d06cadc95c418f570547864c3d652e42804f4c845b3790de581e3d19
   languageName: node
   linkType: hard
 
-"@openzeppelin/defender-base-client@npm:^1.46.0":
+"@openzeppelin/defender-base-client@npm:1.54.1, @openzeppelin/defender-base-client@npm:^1.52.0":
   version: 1.54.1
   resolution: "@openzeppelin/defender-base-client@npm:1.54.1"
   dependencies:
@@ -1549,44 +1478,75 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@openzeppelin/hardhat-upgrades@npm:^1.19.0":
-  version: 1.28.0
-  resolution: "@openzeppelin/hardhat-upgrades@npm:1.28.0"
+"@openzeppelin/defender-sdk-base-client@npm:^1.10.0, @openzeppelin/defender-sdk-base-client@npm:^1.9.0":
+  version: 1.10.0
+  resolution: "@openzeppelin/defender-sdk-base-client@npm:1.10.0"
+  dependencies:
+    amazon-cognito-identity-js: ^6.3.6
+    async-retry: ^1.3.3
+  checksum: c9a8050461512ef6f2a49e006c09d80dd4d80e13e5aafd0ca812b1c37f57855f9dc8e76d5f1fc426d12903e2add294b433c5d48288f487d30a181508b02c82ab
+  languageName: node
+  linkType: hard
+
+"@openzeppelin/defender-sdk-deploy-client@npm:^1.9.0":
+  version: 1.10.0
+  resolution: "@openzeppelin/defender-sdk-deploy-client@npm:1.10.0"
+  dependencies:
+    "@ethersproject/abi": ^5.7.0
+    "@openzeppelin/defender-sdk-base-client": ^1.10.0
+    axios: ^1.6.7
+    lodash: ^4.17.21
+  checksum: 70c38ccbe0cc78d329cd25985cd641218d06714c310957454f370337c68753d169c07e6d9922c262e9c71ce897c245ef358aee27b6eda7e3c2921d691c5a0554
+  languageName: node
+  linkType: hard
+
+"@openzeppelin/hardhat-upgrades@npm:^3.0.4":
+  version: 3.0.4
+  resolution: "@openzeppelin/hardhat-upgrades@npm:3.0.4"
   dependencies:
-    "@openzeppelin/defender-base-client": ^1.46.0
-    "@openzeppelin/platform-deploy-client": ^0.8.0
-    "@openzeppelin/upgrades-core": ^1.27.0
+    "@openzeppelin/defender-admin-client": ^1.52.0
+    "@openzeppelin/defender-base-client": ^1.52.0
+    "@openzeppelin/defender-sdk-base-client": ^1.9.0
+    "@openzeppelin/defender-sdk-deploy-client": ^1.9.0
+    "@openzeppelin/upgrades-core": ^1.32.0
     chalk: ^4.1.0
     debug: ^4.1.1
+    ethereumjs-util: ^7.1.5
     proper-lockfile: ^4.1.1
+    undici: ^5.28.2
   peerDependencies:
-    "@nomiclabs/hardhat-ethers": ^2.0.0
-    "@nomiclabs/hardhat-etherscan": ^3.1.0
-    ethers: ^5.0.5
+    "@nomicfoundation/hardhat-ethers": ^3.0.0
+    "@nomicfoundation/hardhat-verify": ^2.0.0
+    ethers: ^6.6.0
     hardhat: ^2.0.2
   peerDependenciesMeta:
-    "@nomiclabs/harhdat-etherscan":
+    "@nomicfoundation/hardhat-verify":
       optional: true
   bin:
     migrate-oz-cli-project: dist/scripts/migrate-oz-cli-project.js
-  checksum: b37a5eb7c3a5c1fb4ae6754f5fe1d6e93eb6bc143861f57babf5c7d66706ee3e44ca7d57db17ce2ec6c7014f09c269d506f62b3b116897407fdb0d1ff68f4925
+  checksum: 97ca7a91665eb60a989c0ab7d58a832769a4340a3575b74cfc8d99b188f4309d9c35324f63acb1eca6b018eba342a835f6f0aefeee67360d236af8dabc121bda
   languageName: node
   linkType: hard
 
-"@openzeppelin/platform-deploy-client@npm:^0.8.0":
-  version: 0.8.0
-  resolution: "@openzeppelin/platform-deploy-client@npm:0.8.0"
+"@openzeppelin/upgrades-core@npm:^1.32.0":
+  version: 1.32.5
+  resolution: "@openzeppelin/upgrades-core@npm:1.32.5"
   dependencies:
-    "@ethersproject/abi": ^5.6.3
-    "@openzeppelin/defender-base-client": ^1.46.0
-    axios: ^0.21.2
-    lodash: ^4.17.19
-    node-fetch: ^2.6.0
-  checksum: 0ce050e185a812c366ceef7dcfce526815babab9396275d9724f324a548ddfdca92ea9913ce61356dcd8c014fc495890c8e21afab4a197e0e14e761c698cce68
+    cbor: ^9.0.0
+    chalk: ^4.1.0
+    compare-versions: ^6.0.0
+    debug: ^4.1.1
+    ethereumjs-util: ^7.0.3
+    minimist: ^1.2.7
+    proper-lockfile: ^4.1.1
+    solidity-ast: ^0.4.51
+  bin:
+    openzeppelin-upgrades-core: dist/cli/cli.js
+  checksum: dd5daf48a2884e48ac1f80b0ecb0c0289f77cbc422556680e3bb9d031607739442017355684ed4cfb1175718f64fa4c67da3d19e83abd8558f0133e6423e8cec
   languageName: node
   linkType: hard
 
-"@openzeppelin/upgrades-core@npm:^1.27.0, @openzeppelin/upgrades-core@npm:latest":
+"@openzeppelin/upgrades-core@npm:latest":
   version: 1.32.4
   resolution: "@openzeppelin/upgrades-core@npm:1.32.4"
   dependencies:
@@ -1860,20 +1820,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@sindresorhus/is@npm:^0.14.0":
-  version: 0.14.0
-  resolution: "@sindresorhus/is@npm:0.14.0"
-  checksum: 971e0441dd44ba3909b467219a5e242da0fc584048db5324cfb8048148fa8dcc9d44d71e3948972c4f6121d24e5da402ef191420d1266a95f713bb6d6e59c98a
-  languageName: node
-  linkType: hard
-
-"@sindresorhus/is@npm:^4.0.0":
-  version: 4.6.0
-  resolution: "@sindresorhus/is@npm:4.6.0"
-  checksum: 83839f13da2c29d55c97abc3bc2c55b250d33a0447554997a85c539e058e57b8da092da396e252b11ec24a0279a0bed1f537fa26302209327060643e327f81d2
-  languageName: node
-  linkType: hard
-
 "@smithy/types@npm:^2.9.1":
   version: 2.9.1
   resolution: "@smithy/types@npm:2.9.1"
@@ -1915,21 +1861,23 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@szmarczak/http-timer@npm:^1.1.2":
-  version: 1.1.2
-  resolution: "@szmarczak/http-timer@npm:1.1.2"
+"@trufflesuite/bigint-buffer@npm:1.1.10":
+  version: 1.1.10
+  resolution: "@trufflesuite/bigint-buffer@npm:1.1.10"
   dependencies:
-    defer-to-connect: ^1.0.1
-  checksum: 4d9158061c5f397c57b4988cde33a163244e4f02df16364f103971957a32886beb104d6180902cbe8b38cb940e234d9f98a4e486200deca621923f62f50a06fe
+    node-gyp: latest
+    node-gyp-build: 4.4.0
+  checksum: e1dc5e4fbf348a55e660c0055267021eb04cbbdb7f6b0ee983ad32cd4aae1200be448a2ca3963c7d19c7c936d42f66c1ff8b5e4e2332cb1a9e3f870ff818dce4
   languageName: node
   linkType: hard
 
-"@szmarczak/http-timer@npm:^4.0.5":
-  version: 4.0.6
-  resolution: "@szmarczak/http-timer@npm:4.0.6"
+"@trufflesuite/bigint-buffer@npm:1.1.9":
+  version: 1.1.9
+  resolution: "@trufflesuite/bigint-buffer@npm:1.1.9"
   dependencies:
-    defer-to-connect: ^2.0.0
-  checksum: c29df3bcec6fc3bdec2b17981d89d9c9fc9bd7d0c9bcfe92821dc533f4440bc890ccde79971838b4ceed1921d456973c4180d7175ee1d0023ad0562240a58d95
+    node-gyp: latest
+    node-gyp-build: 4.3.0
+  checksum: 627dcff2cae7afe31432646232518363869e89b300f90f88ca68d903d0bdc79119975a5bc338223c03c1a4484cfac6d9cf4413ef20933a69eee48dd925519165
   languageName: node
   linkType: hard
 
@@ -1961,7 +1909,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@typechain/ethers-v5@npm:^10.1.0":
+"@typechain/ethers-v5@npm:^10.0.0":
   version: 10.2.1
   resolution: "@typechain/ethers-v5@npm:10.2.1"
   dependencies:
@@ -1977,15 +1925,17 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@typechain/ethers-v5@npm:^2.0.0":
-  version: 2.0.0
-  resolution: "@typechain/ethers-v5@npm:2.0.0"
+"@typechain/ethers-v6@npm:^0.5.1":
+  version: 0.5.1
+  resolution: "@typechain/ethers-v6@npm:0.5.1"
   dependencies:
-    ethers: ^5.0.2
+    lodash: ^4.17.15
+    ts-essentials: ^7.0.1
   peerDependencies:
-    ethers: ^5.0.0
-    typechain: ^3.0.0
-  checksum: 785430547f11de358c4018338f6f72aac113ece70d743aad410fff4eacbc3b4876d2e0d3389e1a56123afcf156f5c044ee72275342e45218448c23fe93d23915
+    ethers: 6.x
+    typechain: ^8.3.2
+    typescript: ">=4.7.0"
+  checksum: 44e7970ce95eeb1a02019f8a53bbe30dcb87664e1df15fe436ae48eea1bf91ca72b5b230eac1bdf9cbe9b55bc488b54c6273e6f77155eaeff885fb34cfcd1108
   languageName: node
   linkType: hard
 
@@ -2005,16 +1955,14 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@types/async-eventemitter@npm:^0.2.1":
-  version: 0.2.4
-  resolution: "@types/async-eventemitter@npm:0.2.4"
-  dependencies:
-    "@types/events": "*"
-  checksum: cee62e258cf02a45688a3f6f517b623270a9c2779dfd2f53b52e0efbcb0282d7078c3ce1fafb2af257aefdb892acc09ba51d93647930885414ec719437430bf7
+"@types/abstract-leveldown@npm:*":
+  version: 7.2.5
+  resolution: "@types/abstract-leveldown@npm:7.2.5"
+  checksum: 3a99b13c81a53a62b42bea9cff326880de3146b4eeff528b039be69a268515b3120a6c12142e96646fcb0a03c463f298998581e86d9ddb29fbea3612f40edb2b
   languageName: node
   linkType: hard
 
-"@types/bn.js@npm:^4.11.3, @types/bn.js@npm:^4.11.5":
+"@types/bn.js@npm:^4.11.3":
   version: 4.11.6
   resolution: "@types/bn.js@npm:4.11.6"
   dependencies:
@@ -2032,18 +1980,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@types/cacheable-request@npm:^6.0.1":
-  version: 6.0.3
-  resolution: "@types/cacheable-request@npm:6.0.3"
-  dependencies:
-    "@types/http-cache-semantics": "*"
-    "@types/keyv": ^3.1.4
-    "@types/node": "*"
-    "@types/responselike": ^1.0.0
-  checksum: d9b26403fe65ce6b0cb3720b7030104c352bcb37e4fac2a7089a25a97de59c355fa08940658751f2f347a8512aa9d18fdb66ab3ade835975b2f454f2d5befbd9
-  languageName: node
-  linkType: hard
-
 "@types/chai-as-promised@npm:^7.1.3":
   version: 7.1.8
   resolution: "@types/chai-as-promised@npm:7.1.8"
@@ -2085,13 +2021,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@types/events@npm:*":
-  version: 3.0.3
-  resolution: "@types/events@npm:3.0.3"
-  checksum: 50af9312fab001fd6bd4bb3ff65830f940877e6778de140a92481a0d9bf5f4853d44ec758a8800ef60e0598ac43ed1b5688116a3c65906ae54e989278d6c7c82
-  languageName: node
-  linkType: hard
-
 "@types/form-data@npm:0.0.33":
   version: 0.0.33
   resolution: "@types/form-data@npm:0.0.33"
@@ -2111,13 +2040,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@types/http-cache-semantics@npm:*":
-  version: 4.0.4
-  resolution: "@types/http-cache-semantics@npm:4.0.4"
-  checksum: 7f4dd832e618bc1e271be49717d7b4066d77c2d4eed5b81198eb987e532bb3e1c7e02f45d77918185bad936f884b700c10cebe06305f50400f382ab75055f9e8
-  languageName: node
-  linkType: hard
-
 "@types/json-schema@npm:^7.0.3, @types/json-schema@npm:^7.0.9":
   version: 7.0.15
   resolution: "@types/json-schema@npm:7.0.15"
@@ -2132,12 +2054,21 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@types/keyv@npm:^3.1.1, @types/keyv@npm:^3.1.4":
-  version: 3.1.4
-  resolution: "@types/keyv@npm:3.1.4"
+"@types/level-errors@npm:*":
+  version: 3.0.2
+  resolution: "@types/level-errors@npm:3.0.2"
+  checksum: 3d9b801f6499f795b60ac723c1b3f93ca105f20ed26966eeb606c804b10c65984c3233fb99914644d75a3223f80f220eca74fda316640a85a5b3d7572cd86925
+  languageName: node
+  linkType: hard
+
+"@types/levelup@npm:^4.3.0":
+  version: 4.3.3
+  resolution: "@types/levelup@npm:4.3.3"
   dependencies:
+    "@types/abstract-leveldown": "*"
+    "@types/level-errors": "*"
     "@types/node": "*"
-  checksum: e009a2bfb50e90ca9b7c6e8f648f8464067271fd99116f881073fa6fa76dc8d0133181dd65e6614d5fb1220d671d67b0124aef7d97dc02d7e342ab143a47779d
+  checksum: 04969bb805035960b8d6650e8f76893be7ba70267bb7012f6f00d67a0cf096ada552355629791b3f5925e9cdb6912d3fe08892c33c3c583e8fd02099b573bdd7
   languageName: node
   linkType: hard
 
@@ -2148,7 +2079,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@types/lru-cache@npm:^5.1.0":
+"@types/lru-cache@npm:5.1.1, @types/lru-cache@npm:^5.1.0":
   version: 5.1.1
   resolution: "@types/lru-cache@npm:5.1.1"
   checksum: e1d6c0085f61b16ec5b3073ec76ad1be4844ea036561c3f145fc19f71f084b58a6eb600b14128aa95809d057d28f1d147c910186ae51219f58366ffd2ff2e118
@@ -2185,7 +2116,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@types/node-fetch@npm:^2.5.5":
+"@types/node-fetch@npm:^2.6.1":
   version: 2.6.11
   resolution: "@types/node-fetch@npm:2.6.11"
   dependencies:
@@ -2204,6 +2135,20 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@types/node@npm:11.11.6":
+  version: 11.11.6
+  resolution: "@types/node@npm:11.11.6"
+  checksum: 075f1c011cf568e49701419acbcb55c24906b3bb5a34d9412a3b88f228a7a78401a5ad4d3e1cd6855c99aaea5ef96e37fc86ca097e50f06da92cf822befc1fff
+  languageName: node
+  linkType: hard
+
+"@types/node@npm:18.15.13":
+  version: 18.15.13
+  resolution: "@types/node@npm:18.15.13"
+  checksum: 79cc5a2b5f98e8973061a4260a781425efd39161a0e117a69cd089603964816c1a14025e1387b4590c8e82d05133b7b4154fa53a7dffb3877890a66145e76515
+  languageName: node
+  linkType: hard
+
 "@types/node@npm:^10.0.3":
   version: 10.17.60
   resolution: "@types/node@npm:10.17.60"
@@ -2211,7 +2156,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@types/node@npm:^12.12.54, @types/node@npm:^12.12.6":
+"@types/node@npm:^12.12.54":
   version: 12.20.55
   resolution: "@types/node@npm:12.20.55"
   checksum: e4f86785f4092706e0d3b0edff8dca5a13b45627e4b36700acd8dfe6ad53db71928c8dee914d4276c7fd3b6ccd829aa919811c9eb708a2c8e4c6eb3701178c37
@@ -2264,34 +2209,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@types/readable-stream@npm:^2.3.13":
-  version: 2.3.15
-  resolution: "@types/readable-stream@npm:2.3.15"
-  dependencies:
-    "@types/node": "*"
-    safe-buffer: ~5.1.1
-  checksum: ec36f525cad09b6c65a1dafcb5ad99b9e2ed824ec49b7aa23180ac427e5d35b8a0706193ecd79ab4253a283ad485ba03d5917a98daaaa144f0ea34f4823e9d82
-  languageName: node
-  linkType: hard
-
-"@types/resolve@npm:^0.0.8":
-  version: 0.0.8
-  resolution: "@types/resolve@npm:0.0.8"
-  dependencies:
-    "@types/node": "*"
-  checksum: f241bb773ab14b14500623ac3b57c52006ce32b20426b6d8bf2fe5fdc0344f42c77ac0f94ff57b443ae1d320a1a86c62b4e47239f0321699404402fbeb24bad6
-  languageName: node
-  linkType: hard
-
-"@types/responselike@npm:^1.0.0":
-  version: 1.0.3
-  resolution: "@types/responselike@npm:1.0.3"
-  dependencies:
-    "@types/node": "*"
-  checksum: 6ac4b35723429b11b117e813c7acc42c3af8b5554caaf1fc750404c1ae59f9b7376bc69b9e9e194a5a97357a597c2228b7173d317320f0360d617b6425212f58
-  languageName: node
-  linkType: hard
-
 "@types/secp256k1@npm:^4.0.1":
   version: 4.0.6
   resolution: "@types/secp256k1@npm:4.0.6"
@@ -2301,6 +2218,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"@types/seedrandom@npm:3.0.1":
+  version: 3.0.1
+  resolution: "@types/seedrandom@npm:3.0.1"
+  checksum: d9755452f224a4f5072a1d8738da6c9de3039fc59a2a449b1f658e51087be7b48ada49bcabc8b0f16633c095f55598c32fcd072c448858422a2f6a0566569e4c
+  languageName: node
+  linkType: hard
+
 "@types/semver@npm:^7.3.12":
   version: 7.5.6
   resolution: "@types/semver@npm:7.5.6"
@@ -2538,13 +2462,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"@yarnpkg/lockfile@npm:^1.1.0":
-  version: 1.1.0
-  resolution: "@yarnpkg/lockfile@npm:1.1.0"
-  checksum: 05b881b4866a3546861fee756e6d3812776ea47fa6eb7098f983d6d0eefa02e12b66c3fff931574120f196286a7ad4879ce02743c8bb2be36c6a576c7852083a
-  languageName: node
-  linkType: hard
-
 "JSONStream@npm:1.3.2":
   version: 1.3.2
   resolution: "JSONStream@npm:1.3.2"
@@ -2599,64 +2516,43 @@ __metadata:
   languageName: node
   linkType: hard
 
-"abstract-level@npm:^1.0.0, abstract-level@npm:^1.0.2, abstract-level@npm:^1.0.3, abstract-level@npm:^1.0.4":
-  version: 1.0.4
-  resolution: "abstract-level@npm:1.0.4"
-  dependencies:
-    buffer: ^6.0.3
-    catering: ^2.1.0
-    is-buffer: ^2.0.5
-    level-supports: ^4.0.0
-    level-transcoder: ^1.0.1
-    module-error: ^1.0.1
-    queue-microtask: ^1.2.3
-  checksum: 5b70d08926f5234c3c23ffca848542af4def780dc96d6ca35a81659af80e6439c46f5106bd14a5ea37465173d7dcc8294317048b0194fdf6480103edc4aa9e63
-  languageName: node
-  linkType: hard
-
-"abstract-leveldown@npm:3.0.0":
-  version: 3.0.0
-  resolution: "abstract-leveldown@npm:3.0.0"
-  dependencies:
-    xtend: ~4.0.0
-  checksum: 1d3e65fc2288fd17955df3b0887fdd3d4fa7fcd816062014f872ea12a1e86e886151cbdc36abd2f243a810b7999252eaa30adf636ffe1be3103493ab37277e49
-  languageName: node
-  linkType: hard
-
-"abstract-leveldown@npm:^2.4.1, abstract-leveldown@npm:~2.7.1":
-  version: 2.7.2
-  resolution: "abstract-leveldown@npm:2.7.2"
+"abstract-leveldown@npm:^6.2.1":
+  version: 6.3.0
+  resolution: "abstract-leveldown@npm:6.3.0"
   dependencies:
+    buffer: ^5.5.0
+    immediate: ^3.2.3
+    level-concat-iterator: ~2.0.0
+    level-supports: ~1.0.0
     xtend: ~4.0.0
-  checksum: 97c45a05d8b5d24edf3855c1f9a19f919c4a189e387929745289a53116c80638339a7d4e50ad76d0ad2900166adaeaf2e0350dcdcd453e783cd8f04fd9bea17a
+  checksum: 121a8509d8c6a540e656c2a69e5b8d853d4df71072011afefc868b98076991bb00120550e90643de9dc18889c675f62413409eeb4c8c204663124c7d215e4ec3
   languageName: node
   linkType: hard
 
-"abstract-leveldown@npm:^5.0.0, abstract-leveldown@npm:~5.0.0":
-  version: 5.0.0
-  resolution: "abstract-leveldown@npm:5.0.0"
+"abstract-leveldown@npm:^7.2.0":
+  version: 7.2.0
+  resolution: "abstract-leveldown@npm:7.2.0"
   dependencies:
-    xtend: ~4.0.0
-  checksum: d55d03cc7fad011d5fea30d26504b1a76123ec8edd3623d21f80ce0561c610b7ed1e00eb037c14746ec2b7ad8638586024f11d4a1476beee2c470c8cf27e3586
+    buffer: ^6.0.3
+    catering: ^2.0.0
+    is-buffer: ^2.0.5
+    level-concat-iterator: ^3.0.0
+    level-supports: ^2.0.1
+    queue-microtask: ^1.2.3
+  checksum: d558111f2d123da95ac80b8ba3b9b0a5bc8cd87296e64b05dca693f5f4839aa0e2fc97bad56a101766f499824e2962611750f8a76bbac4a5db35801968fbbe02
   languageName: node
   linkType: hard
 
-"abstract-leveldown@npm:~2.6.0":
-  version: 2.6.3
-  resolution: "abstract-leveldown@npm:2.6.3"
+"abstract-leveldown@npm:~6.2.1":
+  version: 6.2.3
+  resolution: "abstract-leveldown@npm:6.2.3"
   dependencies:
+    buffer: ^5.5.0
+    immediate: ^3.2.3
+    level-concat-iterator: ~2.0.0
+    level-supports: ~1.0.0
     xtend: ~4.0.0
-  checksum: 87b18580467c303c34c305620e2c3227010f64187d6b1cd60c2d1b9adc058b0c4de716e111e9493aaad0080cb7836601032c5084990cd713f86b6a78f1fab791
-  languageName: node
-  linkType: hard
-
-"accepts@npm:~1.3.8":
-  version: 1.3.8
-  resolution: "accepts@npm:1.3.8"
-  dependencies:
-    mime-types: ~2.1.34
-    negotiator: 0.6.3
-  checksum: 50c43d32e7b50285ebe84b613ee4a3aa426715a7d131b65b786e2ead0fd76b6b60091b9916d3478a75f11f162628a2139991b6c03ab3f1d9ab7c86075dc8eab4
+  checksum: 00202b2eb7955dd7bc04f3e44d225e60160cedb8f96fe6ae0e6dca9c356d57071f001ece8ae1d53f48095c4c036d92b3440f2bc7666730610ddea030f9fbde4a
   languageName: node
   linkType: hard
 
@@ -2715,10 +2611,10 @@ __metadata:
   languageName: node
   linkType: hard
 
-"aes-js@npm:^3.1.1":
-  version: 3.1.2
-  resolution: "aes-js@npm:3.1.2"
-  checksum: 062154d50b1e433cc8c3b8ca7879f3a6375d5e79c2a507b2b6c4ec920b4cd851bf2afa7f65c98761a9da89c0ab618cbe6529e8e9a1c71f93290b53128fb8f712
+"aes-js@npm:4.0.0-beta.5":
+  version: 4.0.0-beta.5
+  resolution: "aes-js@npm:4.0.0-beta.5"
+  checksum: cc2ea969d77df939c32057f7e361b6530aa6cb93cb10617a17a45cd164e6d761002f031ff6330af3e67e58b1f0a3a8fd0b63a720afd591a653b02f649470e15b
   languageName: node
   linkType: hard
 
@@ -2787,6 +2683,19 @@ __metadata:
   languageName: node
   linkType: hard
 
+"amazon-cognito-identity-js@npm:^6.3.6":
+  version: 6.3.12
+  resolution: "amazon-cognito-identity-js@npm:6.3.12"
+  dependencies:
+    "@aws-crypto/sha256-js": 1.2.2
+    buffer: 4.9.2
+    fast-base64-decode: ^1.0.0
+    isomorphic-unfetch: ^3.0.0
+    js-cookie: ^2.2.1
+  checksum: d3ccf7e4b2d6b9428d92af5820b7c348f332acc39c5f130c7eaeaf0f05ee9bf52264f866f71b784ec62c53368d60c3ac339c58213594062d826b435b46014323
+  languageName: node
+  linkType: hard
+
 "amdefine@npm:>=0.0.4":
   version: 1.0.1
   resolution: "amdefine@npm:1.0.1"
@@ -2833,13 +2742,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"ansi-regex@npm:^2.0.0":
-  version: 2.1.1
-  resolution: "ansi-regex@npm:2.1.1"
-  checksum: 190abd03e4ff86794f338a31795d262c1dfe8c91f7e01d04f13f646f1dcb16c5800818f886047876f1272f065570ab86b24b99089f8b68a0e11ff19aed4ca8f1
-  languageName: node
-  linkType: hard
-
 "ansi-regex@npm:^3.0.0":
   version: 3.0.1
   resolution: "ansi-regex@npm:3.0.1"
@@ -2868,13 +2770,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"ansi-styles@npm:^2.2.1":
-  version: 2.2.1
-  resolution: "ansi-styles@npm:2.2.1"
-  checksum: ebc0e00381f2a29000d1dac8466a640ce11943cef3bda3cd0020dc042e31e1058ab59bf6169cd794a54c3a7338a61ebc404b7c91e004092dd20e028c432c9c2c
-  languageName: node
-  linkType: hard
-
 "ansi-styles@npm:^3.2.0, ansi-styles@npm:^3.2.1":
   version: 3.2.1
   resolution: "ansi-styles@npm:3.2.1"
@@ -2982,45 +2877,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"arr-diff@npm:^4.0.0":
-  version: 4.0.0
-  resolution: "arr-diff@npm:4.0.0"
-  checksum: ea7c8834842ad3869297f7915689bef3494fd5b102ac678c13ffccab672d3d1f35802b79e90c4cfec2f424af3392e44112d1ccf65da34562ed75e049597276a0
-  languageName: node
-  linkType: hard
-
-"arr-flatten@npm:^1.1.0":
-  version: 1.1.0
-  resolution: "arr-flatten@npm:1.1.0"
-  checksum: 963fe12564fca2f72c055f3f6c206b9e031f7c433a0c66ca9858b484821f248c5b1e5d53c8e4989d80d764cd776cf6d9b160ad05f47bdc63022bfd63b5455e22
-  languageName: node
-  linkType: hard
-
-"arr-union@npm:^3.1.0":
-  version: 3.1.0
-  resolution: "arr-union@npm:3.1.0"
-  checksum: b5b0408c6eb7591143c394f3be082fee690ddd21f0fdde0a0a01106799e847f67fcae1b7e56b0a0c173290e29c6aca9562e82b300708a268bc8f88f3d6613cb9
-  languageName: node
-  linkType: hard
-
-"array-back@npm:^1.0.3, array-back@npm:^1.0.4":
-  version: 1.0.4
-  resolution: "array-back@npm:1.0.4"
-  dependencies:
-    typical: ^2.6.0
-  checksum: 37a8be4cd4920b3d07bdbef40dae83bb37948f5d49601da98a6e48ba5496e9a0008e7f3f2184bcf4d3501bd371a048c9bdca7dc3cc5c3d5b1eb189bbba7b55db
-  languageName: node
-  linkType: hard
-
-"array-back@npm:^2.0.0":
-  version: 2.0.0
-  resolution: "array-back@npm:2.0.0"
-  dependencies:
-    typical: ^2.6.1
-  checksum: ab36ab3504b25116b47541fb0ac78ff13d1e991f33d98c361edd3aada3ed818a900b619bd67b195dd4e41b9256c27e8cdd6a69ece507e482f1207d07670ed6bd
-  languageName: node
-  linkType: hard
-
 "array-back@npm:^3.0.1, array-back@npm:^3.1.0":
   version: 3.1.0
   resolution: "array-back@npm:3.1.0"
@@ -3045,13 +2901,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"array-flatten@npm:1.1.1":
-  version: 1.1.1
-  resolution: "array-flatten@npm:1.1.1"
-  checksum: a9925bf3512d9dce202112965de90c222cd59a4fbfce68a0951d25d965cf44642931f40aac72309c41f12df19afa010ecadceb07cfff9ccc1621e99d89ab5f3b
-  languageName: node
-  linkType: hard
-
 "array-includes@npm:^3.1.7":
   version: 3.1.7
   resolution: "array-includes@npm:3.1.7"
@@ -3079,13 +2928,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"array-unique@npm:^0.3.2":
-  version: 0.3.2
-  resolution: "array-unique@npm:0.3.2"
-  checksum: da344b89cfa6b0a5c221f965c21638bfb76b57b45184a01135382186924f55973cd9b171d4dad6bf606c6d9d36b0d721d091afdc9791535ead97ccbe78f8a888
-  languageName: node
-  linkType: hard
-
 "array.prototype.filter@npm:^1.0.3":
   version: 1.0.3
   resolution: "array.prototype.filter@npm:1.0.3"
@@ -3149,22 +2991,9 @@ __metadata:
   languageName: node
   linkType: hard
 
-"array.prototype.reduce@npm:^1.0.6":
-  version: 1.0.6
-  resolution: "array.prototype.reduce@npm:1.0.6"
-  dependencies:
-    call-bind: ^1.0.2
-    define-properties: ^1.2.0
-    es-abstract: ^1.22.1
-    es-array-method-boxes-properly: ^1.0.0
-    is-string: ^1.0.7
-  checksum: c709c3f5caa2aac4fb10e0c6c1982cca50328a2a48658d53b1da8ee3a78069ad67cdac21296d6285521aa3a932a8178c0e192b5fc831fae2977b69a5a8a64ad7
-  languageName: node
-  linkType: hard
-
-"arraybuffer.prototype.slice@npm:^1.0.2":
-  version: 1.0.3
-  resolution: "arraybuffer.prototype.slice@npm:1.0.3"
+"arraybuffer.prototype.slice@npm:^1.0.2":
+  version: 1.0.3
+  resolution: "arraybuffer.prototype.slice@npm:1.0.3"
   dependencies:
     array-buffer-byte-length: ^1.0.1
     call-bind: ^1.0.5
@@ -3185,18 +3014,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"asn1.js@npm:^5.2.0":
-  version: 5.4.1
-  resolution: "asn1.js@npm:5.4.1"
-  dependencies:
-    bn.js: ^4.0.0
-    inherits: ^2.0.1
-    minimalistic-assert: ^1.0.0
-    safer-buffer: ^2.1.0
-  checksum: 3786a101ac6f304bd4e9a7df79549a7561950a13d4bcaec0c7790d44c80d147c1a94ba3d4e663673406064642a40b23fcd6c82a9952468e386c1a1376d747f9a
-  languageName: node
-  linkType: hard
-
 "asn1@npm:~0.2.3":
   version: 0.2.6
   resolution: "asn1@npm:0.2.6"
@@ -3237,13 +3054,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"assign-symbols@npm:^1.0.0":
-  version: 1.0.0
-  resolution: "assign-symbols@npm:1.0.0"
-  checksum: c0eb895911d05b6b2d245154f70461c5e42c107457972e5ebba38d48967870dee53bcdf6c7047990586daa80fab8dab3cc6300800fbd47b454247fdedd859a2c
-  languageName: node
-  linkType: hard
-
 "ast-parents@npm:^0.0.1":
   version: 0.0.1
   resolution: "ast-parents@npm:0.0.1"
@@ -3265,7 +3075,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"async-eventemitter@npm:^0.2.2, async-eventemitter@npm:^0.2.4":
+"async-eventemitter@npm:^0.2.4":
   version: 0.2.4
   resolution: "async-eventemitter@npm:0.2.4"
   dependencies:
@@ -3274,13 +3084,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"async-limiter@npm:~1.0.0":
-  version: 1.0.1
-  resolution: "async-limiter@npm:1.0.1"
-  checksum: 2b849695b465d93ad44c116220dee29a5aeb63adac16c1088983c339b0de57d76e82533e8e364a93a9f997f28bbfc6a92948cefc120652bd07f3b59f8d75cf2b
-  languageName: node
-  linkType: hard
-
 "async-retry@npm:^1.3.3":
   version: 1.3.3
   resolution: "async-retry@npm:1.3.3"
@@ -3290,23 +3093,14 @@ __metadata:
   languageName: node
   linkType: hard
 
-"async@npm:1.x, async@npm:^1.4.2":
+"async@npm:1.x":
   version: 1.5.2
   resolution: "async@npm:1.5.2"
   checksum: fe5d6214d8f15bd51eee5ae8ec5079b228b86d2d595f47b16369dec2e11b3ff75a567bb5f70d12d79006665fbbb7ee0a7ec0e388524eefd454ecbe651c124ebd
   languageName: node
   linkType: hard
 
-"async@npm:2.6.2":
-  version: 2.6.2
-  resolution: "async@npm:2.6.2"
-  dependencies:
-    lodash: ^4.17.11
-  checksum: e5e90a3bcc4d9bf964bfc6b77d63b8f5bee8c14e9a51c3317dbcace44d5b6b1fe01cd4fd347449704a107da7fcd25e1382ee8545957b2702782ae720605cf7a4
-  languageName: node
-  linkType: hard
-
-"async@npm:^2.0.1, async@npm:^2.1.2, async@npm:^2.4.0, async@npm:^2.5.0, async@npm:^2.6.1":
+"async@npm:^2.4.0":
   version: 2.6.4
   resolution: "async@npm:2.6.4"
   dependencies:
@@ -3329,15 +3123,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"atob@npm:^2.1.2":
-  version: 2.1.2
-  resolution: "atob@npm:2.1.2"
-  bin:
-    atob: bin/atob.js
-  checksum: dfeeeb70090c5ebea7be4b9f787f866686c645d9f39a0d184c817252d0cf08455ed25267d79c03254d3be1f03ac399992a792edcd5ffb9c91e097ab5ef42833a
-  languageName: node
-  linkType: hard
-
 "available-typed-arrays@npm:^1.0.5, available-typed-arrays@npm:^1.0.6":
   version: 1.0.6
   resolution: "available-typed-arrays@npm:1.0.6"
@@ -3359,7 +3144,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"axios@npm:^0.21.2, axios@npm:^0.21.4":
+"axios@npm:^0.21.4":
   version: 0.21.4
   resolution: "axios@npm:0.21.4"
   dependencies:
@@ -3368,7 +3153,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"axios@npm:^1.4.0, axios@npm:^1.5.1":
+"axios@npm:^1.4.0, axios@npm:^1.5.1, axios@npm:^1.6.7":
   version: 1.6.7
   resolution: "axios@npm:1.6.7"
   dependencies:
@@ -3379,644 +3164,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"babel-code-frame@npm:^6.26.0":
-  version: 6.26.0
-  resolution: "babel-code-frame@npm:6.26.0"
-  dependencies:
-    chalk: ^1.1.3
-    esutils: ^2.0.2
-    js-tokens: ^3.0.2
-  checksum: 9410c3d5a921eb02fa409675d1a758e493323a49e7b9dddb7a2a24d47e61d39ab1129dd29f9175836eac9ce8b1d4c0a0718fcdc57ce0b865b529fd250dbab313
-  languageName: node
-  linkType: hard
-
-"babel-core@npm:^6.0.14, babel-core@npm:^6.26.0":
-  version: 6.26.3
-  resolution: "babel-core@npm:6.26.3"
-  dependencies:
-    babel-code-frame: ^6.26.0
-    babel-generator: ^6.26.0
-    babel-helpers: ^6.24.1
-    babel-messages: ^6.23.0
-    babel-register: ^6.26.0
-    babel-runtime: ^6.26.0
-    babel-template: ^6.26.0
-    babel-traverse: ^6.26.0
-    babel-types: ^6.26.0
-    babylon: ^6.18.0
-    convert-source-map: ^1.5.1
-    debug: ^2.6.9
-    json5: ^0.5.1
-    lodash: ^4.17.4
-    minimatch: ^3.0.4
-    path-is-absolute: ^1.0.1
-    private: ^0.1.8
-    slash: ^1.0.0
-    source-map: ^0.5.7
-  checksum: 3d6a37e5c69ea7f7d66c2a261cbd7219197f2f938700e6ebbabb6d84a03f2bf86691ffa066866dcb49ba6c4bd702d347c9e0e147660847d709705cf43c964752
-  languageName: node
-  linkType: hard
-
-"babel-generator@npm:^6.26.0":
-  version: 6.26.1
-  resolution: "babel-generator@npm:6.26.1"
-  dependencies:
-    babel-messages: ^6.23.0
-    babel-runtime: ^6.26.0
-    babel-types: ^6.26.0
-    detect-indent: ^4.0.0
-    jsesc: ^1.3.0
-    lodash: ^4.17.4
-    source-map: ^0.5.7
-    trim-right: ^1.0.1
-  checksum: 5397f4d4d1243e7157e3336be96c10fcb1f29f73bf2d9842229c71764d9a6431397d249483a38c4d8b1581459e67be4df6f32d26b1666f02d0f5bfc2c2f25193
-  languageName: node
-  linkType: hard
-
-"babel-helper-builder-binary-assignment-operator-visitor@npm:^6.24.1":
-  version: 6.24.1
-  resolution: "babel-helper-builder-binary-assignment-operator-visitor@npm:6.24.1"
-  dependencies:
-    babel-helper-explode-assignable-expression: ^6.24.1
-    babel-runtime: ^6.22.0
-    babel-types: ^6.24.1
-  checksum: 6ef49597837d042980e78284df014972daac7f1f1f2635d978bb2d13990304322f5135f27b8f2d6eb8c4c2459b496ec76e21544e26afbb5dec88f53089e17476
-  languageName: node
-  linkType: hard
-
-"babel-helper-call-delegate@npm:^6.24.1":
-  version: 6.24.1
-  resolution: "babel-helper-call-delegate@npm:6.24.1"
-  dependencies:
-    babel-helper-hoist-variables: ^6.24.1
-    babel-runtime: ^6.22.0
-    babel-traverse: ^6.24.1
-    babel-types: ^6.24.1
-  checksum: b6277d6e48c10cf416632f6dfbac77bdf6ba8ec4ac2f6359a77d6b731dae941c2a3ec7f35e1eba78aad2a7e0838197731d1ef75af529055096c4cb7d96432c88
-  languageName: node
-  linkType: hard
-
-"babel-helper-define-map@npm:^6.24.1":
-  version: 6.26.0
-  resolution: "babel-helper-define-map@npm:6.26.0"
-  dependencies:
-    babel-helper-function-name: ^6.24.1
-    babel-runtime: ^6.26.0
-    babel-types: ^6.26.0
-    lodash: ^4.17.4
-  checksum: 08e201eb009a7dbd020232fb7468ac772ebb8cfd33ec9a41113a54f4c90fd1e3474497783d635b8f87d797706323ca0c1758c516a630b0c95277112fc2fe4f13
-  languageName: node
-  linkType: hard
-
-"babel-helper-explode-assignable-expression@npm:^6.24.1":
-  version: 6.24.1
-  resolution: "babel-helper-explode-assignable-expression@npm:6.24.1"
-  dependencies:
-    babel-runtime: ^6.22.0
-    babel-traverse: ^6.24.1
-    babel-types: ^6.24.1
-  checksum: 1bafdb51ce3dd95cf25d712d24a0c3c2ae02ff58118c77462f14ede4d8161aaee42c5c759c3d3a3344a5851b8b0f8d16b395713413b8194e1c3264fc5b12b754
-  languageName: node
-  linkType: hard
-
-"babel-helper-function-name@npm:^6.24.1":
-  version: 6.24.1
-  resolution: "babel-helper-function-name@npm:6.24.1"
-  dependencies:
-    babel-helper-get-function-arity: ^6.24.1
-    babel-runtime: ^6.22.0
-    babel-template: ^6.24.1
-    babel-traverse: ^6.24.1
-    babel-types: ^6.24.1
-  checksum: d651db9e0b29e135877e90e7858405750a684220d22a6f7c78bb163305a1b322cc1c8bea1bc617625c34d92d0927fdbaa49ee46822e2f86b524eced4c88c7ff0
-  languageName: node
-  linkType: hard
-
-"babel-helper-get-function-arity@npm:^6.24.1":
-  version: 6.24.1
-  resolution: "babel-helper-get-function-arity@npm:6.24.1"
-  dependencies:
-    babel-runtime: ^6.22.0
-    babel-types: ^6.24.1
-  checksum: 37e344d6c5c00b67a3b378490a5d7ba924bab1c2ccd6ecf1b7da96ca679be12d75fbec6279366ae9772e482fb06a7b48293954dd79cbeba9b947e2db67252fbd
-  languageName: node
-  linkType: hard
-
-"babel-helper-hoist-variables@npm:^6.24.1":
-  version: 6.24.1
-  resolution: "babel-helper-hoist-variables@npm:6.24.1"
-  dependencies:
-    babel-runtime: ^6.22.0
-    babel-types: ^6.24.1
-  checksum: 6af1c165d5f0ad192df07daa194d13de77572bd914d2fc9a270d56b93b2705d98eebabf412b1211505535af131fbe95886fcfad8b3a07b4d501c24b9cb8e57fe
-  languageName: node
-  linkType: hard
-
-"babel-helper-optimise-call-expression@npm:^6.24.1":
-  version: 6.24.1
-  resolution: "babel-helper-optimise-call-expression@npm:6.24.1"
-  dependencies:
-    babel-runtime: ^6.22.0
-    babel-types: ^6.24.1
-  checksum: 16e6aba819b473dbf013391f759497df9f57bc7060bc4e5f7f6b60fb03670eb1dec65dd2227601d58f151e9d647e1f676a12466f5e6674379978820fa02c0fbb
-  languageName: node
-  linkType: hard
-
-"babel-helper-regex@npm:^6.24.1":
-  version: 6.26.0
-  resolution: "babel-helper-regex@npm:6.26.0"
-  dependencies:
-    babel-runtime: ^6.26.0
-    babel-types: ^6.26.0
-    lodash: ^4.17.4
-  checksum: ab949a4c90ab255abaafd9ec11a4a6dc77dba360875af2bb0822b699c058858773792c1e969c425c396837f61009f30c9ee5ba4b9a8ca87b0779ae1622f89fb3
-  languageName: node
-  linkType: hard
-
-"babel-helper-remap-async-to-generator@npm:^6.24.1":
-  version: 6.24.1
-  resolution: "babel-helper-remap-async-to-generator@npm:6.24.1"
-  dependencies:
-    babel-helper-function-name: ^6.24.1
-    babel-runtime: ^6.22.0
-    babel-template: ^6.24.1
-    babel-traverse: ^6.24.1
-    babel-types: ^6.24.1
-  checksum: f330943104b61e7f9248d222bd5fe5d3238904ee20643b76197571e14a724723d64a8096b292a60f64788f0efe30176882c376eeebde00657925678e304324f0
-  languageName: node
-  linkType: hard
-
-"babel-helper-replace-supers@npm:^6.24.1":
-  version: 6.24.1
-  resolution: "babel-helper-replace-supers@npm:6.24.1"
-  dependencies:
-    babel-helper-optimise-call-expression: ^6.24.1
-    babel-messages: ^6.23.0
-    babel-runtime: ^6.22.0
-    babel-template: ^6.24.1
-    babel-traverse: ^6.24.1
-    babel-types: ^6.24.1
-  checksum: ca1d216c5c6afc6af2ef55ea16777ba99e108780ea25da61d93edb09fd85f5e96c756306e2a21e737c3b0c7a16c99762b62a0e5f529d3865b14029fef7351cba
-  languageName: node
-  linkType: hard
-
-"babel-helpers@npm:^6.24.1":
-  version: 6.24.1
-  resolution: "babel-helpers@npm:6.24.1"
-  dependencies:
-    babel-runtime: ^6.22.0
-    babel-template: ^6.24.1
-  checksum: 751c6010e18648eebae422adfea5f3b5eff70d592d693bfe0f53346227d74b38e6cd2553c4c18de1e64faac585de490eccbd3ab86ba0885bdac42ed4478bc6b0
-  languageName: node
-  linkType: hard
-
-"babel-messages@npm:^6.23.0":
-  version: 6.23.0
-  resolution: "babel-messages@npm:6.23.0"
-  dependencies:
-    babel-runtime: ^6.22.0
-  checksum: c8075c17587a33869e1a5bd0a5b73bbe395b68188362dacd5418debbc7c8fd784bcd3295e81ee7e410dc2c2655755add6af03698c522209f6a68334c15e6d6ca
-  languageName: node
-  linkType: hard
-
-"babel-plugin-check-es2015-constants@npm:^6.22.0":
-  version: 6.22.0
-  resolution: "babel-plugin-check-es2015-constants@npm:6.22.0"
-  dependencies:
-    babel-runtime: ^6.22.0
-  checksum: 39168cb4ff078911726bfaf9d111d1e18f3e99d8b6f6101d343249b28346c3869e415c97fe7e857e7f34b913f8a052634b2b9dcfb4c0272e5f64ed22df69c735
-  languageName: node
-  linkType: hard
-
-"babel-plugin-syntax-async-functions@npm:^6.8.0":
-  version: 6.13.0
-  resolution: "babel-plugin-syntax-async-functions@npm:6.13.0"
-  checksum: e982d9756869fa83eb6a4502490a90b0d31e8a41e2ee582045934f022ac8ff5fa6a3386366976fab3a391d5a7ab8ea5f9da623f35ed8ab328b8ab6d9b2feb1d3
-  languageName: node
-  linkType: hard
-
-"babel-plugin-syntax-exponentiation-operator@npm:^6.8.0":
-  version: 6.13.0
-  resolution: "babel-plugin-syntax-exponentiation-operator@npm:6.13.0"
-  checksum: cbcb3aeae7005240325f72d55c3c90575033123e8a1ddfa6bf9eac4ee7e246c2a23f5b5ab1144879590d947a3ed1d88838169d125e5d7c4f53678526482b020e
-  languageName: node
-  linkType: hard
-
-"babel-plugin-syntax-trailing-function-commas@npm:^6.22.0":
-  version: 6.22.0
-  resolution: "babel-plugin-syntax-trailing-function-commas@npm:6.22.0"
-  checksum: d8b9039ded835bb128e8e14eeeb6e0ac2a876b85250924bdc3a8dc2a6984d3bfade4de04d40fb15ea04a86d561ac280ae0d7306d7d4ef7a8c52c43b6a23909c6
-  languageName: node
-  linkType: hard
-
-"babel-plugin-transform-async-to-generator@npm:^6.22.0":
-  version: 6.24.1
-  resolution: "babel-plugin-transform-async-to-generator@npm:6.24.1"
-  dependencies:
-    babel-helper-remap-async-to-generator: ^6.24.1
-    babel-plugin-syntax-async-functions: ^6.8.0
-    babel-runtime: ^6.22.0
-  checksum: ffe8b4b2ed6db1f413ede385bd1a36f39e02a64ed79ce02779440049af75215c98f8debdc70eb01430bfd889f792682b0136576fe966f7f9e1b30e2a54695a8d
-  languageName: node
-  linkType: hard
-
-"babel-plugin-transform-es2015-arrow-functions@npm:^6.22.0":
-  version: 6.22.0
-  resolution: "babel-plugin-transform-es2015-arrow-functions@npm:6.22.0"
-  dependencies:
-    babel-runtime: ^6.22.0
-  checksum: 746e2be0fed20771c07f0984ba79ef0bab37d6e98434267ec96cef57272014fe53a180bfb9047bf69ed149d367a2c97baad54d6057531cd037684f371aab2333
-  languageName: node
-  linkType: hard
-
-"babel-plugin-transform-es2015-block-scoped-functions@npm:^6.22.0":
-  version: 6.22.0
-  resolution: "babel-plugin-transform-es2015-block-scoped-functions@npm:6.22.0"
-  dependencies:
-    babel-runtime: ^6.22.0
-  checksum: f251611f723d94b4068d2a873a2783e019bd81bd7144cfdbcfc31ef166f4d82fa2f1efba64342ba2630dab93a2b12284067725c0aa08315712419a2bc3b92a75
-  languageName: node
-  linkType: hard
-
-"babel-plugin-transform-es2015-block-scoping@npm:^6.23.0":
-  version: 6.26.0
-  resolution: "babel-plugin-transform-es2015-block-scoping@npm:6.26.0"
-  dependencies:
-    babel-runtime: ^6.26.0
-    babel-template: ^6.26.0
-    babel-traverse: ^6.26.0
-    babel-types: ^6.26.0
-    lodash: ^4.17.4
-  checksum: 5e4dee33bf4aab0ce7751a9ae845c25d3bf03944ffdfc8d784e1de2123a3eec19657dd59274c9969461757f5e2ab75c517e978bafe5309a821a41e278ad38a63
-  languageName: node
-  linkType: hard
-
-"babel-plugin-transform-es2015-classes@npm:^6.23.0":
-  version: 6.24.1
-  resolution: "babel-plugin-transform-es2015-classes@npm:6.24.1"
-  dependencies:
-    babel-helper-define-map: ^6.24.1
-    babel-helper-function-name: ^6.24.1
-    babel-helper-optimise-call-expression: ^6.24.1
-    babel-helper-replace-supers: ^6.24.1
-    babel-messages: ^6.23.0
-    babel-runtime: ^6.22.0
-    babel-template: ^6.24.1
-    babel-traverse: ^6.24.1
-    babel-types: ^6.24.1
-  checksum: 999392b47a83cf9297e49fbde00bc9b15fb6d71bc041f7b3d621ac45361486ec4b66f55c47f98dca6c398ceaa8bfc9f3c21257854822c4523e7475a92e6c000a
-  languageName: node
-  linkType: hard
-
-"babel-plugin-transform-es2015-computed-properties@npm:^6.22.0":
-  version: 6.24.1
-  resolution: "babel-plugin-transform-es2015-computed-properties@npm:6.24.1"
-  dependencies:
-    babel-runtime: ^6.22.0
-    babel-template: ^6.24.1
-  checksum: 34e466bfd4b021aa3861db66cf10a9093fa6a4fcedbc8c82a55f6ca1fcbd212a9967f2df6c5f9e9a20046fa43c8967633a476f2bbc15cb8d3769cbba948a5c16
-  languageName: node
-  linkType: hard
-
-"babel-plugin-transform-es2015-destructuring@npm:^6.23.0":
-  version: 6.23.0
-  resolution: "babel-plugin-transform-es2015-destructuring@npm:6.23.0"
-  dependencies:
-    babel-runtime: ^6.22.0
-  checksum: 1343d27f09846e6e1e48da7b83d0d4f2d5571559c468ad8ad4c3715b8ff3e21b2d553e90ad420dc6840de260b7f3b9f9c057606d527e3d838a52a3a7c5fffdbe
-  languageName: node
-  linkType: hard
-
-"babel-plugin-transform-es2015-duplicate-keys@npm:^6.22.0":
-  version: 6.24.1
-  resolution: "babel-plugin-transform-es2015-duplicate-keys@npm:6.24.1"
-  dependencies:
-    babel-runtime: ^6.22.0
-    babel-types: ^6.24.1
-  checksum: 756a7a13517c3e80c8312137b9872b9bc32fbfbb905e9f1e45bf321e2b464d0e6a6e6deca22c61b62377225bd8136b73580897cccb394995d6e00bc8ce882ba4
-  languageName: node
-  linkType: hard
-
-"babel-plugin-transform-es2015-for-of@npm:^6.23.0":
-  version: 6.23.0
-  resolution: "babel-plugin-transform-es2015-for-of@npm:6.23.0"
-  dependencies:
-    babel-runtime: ^6.22.0
-  checksum: 0124e320c32b25de84ddaba951a6f0ad031fa5019de54de32bd317d2a97b3f967026008f32e8c88728330c1cce7c4f1d0ecb15007020d50bd5ca1438a882e205
-  languageName: node
-  linkType: hard
-
-"babel-plugin-transform-es2015-function-name@npm:^6.22.0":
-  version: 6.24.1
-  resolution: "babel-plugin-transform-es2015-function-name@npm:6.24.1"
-  dependencies:
-    babel-helper-function-name: ^6.24.1
-    babel-runtime: ^6.22.0
-    babel-types: ^6.24.1
-  checksum: 629ecd824d53ec973a3ef85e74d9fd8c710203084ca2f7ac833879ddfa3b83a28f0270fe2ee5f3b8c078bb4b3e4b843173a646a7cd4abc49e8c1c563d31fb711
-  languageName: node
-  linkType: hard
-
-"babel-plugin-transform-es2015-literals@npm:^6.22.0":
-  version: 6.22.0
-  resolution: "babel-plugin-transform-es2015-literals@npm:6.22.0"
-  dependencies:
-    babel-runtime: ^6.22.0
-  checksum: 40e270580a0236990f2555f5dc7ae24b4db9f4709ca455ed1a6724b0078592482274be7448579b14122bd06481641a38e7b2e48d0b49b8c81c88e154a26865b4
-  languageName: node
-  linkType: hard
-
-"babel-plugin-transform-es2015-modules-amd@npm:^6.22.0, babel-plugin-transform-es2015-modules-amd@npm:^6.24.1":
-  version: 6.24.1
-  resolution: "babel-plugin-transform-es2015-modules-amd@npm:6.24.1"
-  dependencies:
-    babel-plugin-transform-es2015-modules-commonjs: ^6.24.1
-    babel-runtime: ^6.22.0
-    babel-template: ^6.24.1
-  checksum: 084c7a1ef3bd0b2b9f4851b27cfb65f8ea1408349af05b4d88f994c23844a0754abfa4799bbc5f3f0ec94232b3a54a2e46d7f1dff1bdd40fa66a46f645197dfa
-  languageName: node
-  linkType: hard
-
-"babel-plugin-transform-es2015-modules-commonjs@npm:^6.23.0, babel-plugin-transform-es2015-modules-commonjs@npm:^6.24.1":
-  version: 6.26.2
-  resolution: "babel-plugin-transform-es2015-modules-commonjs@npm:6.26.2"
-  dependencies:
-    babel-plugin-transform-strict-mode: ^6.24.1
-    babel-runtime: ^6.26.0
-    babel-template: ^6.26.0
-    babel-types: ^6.26.0
-  checksum: 9cd93a84037855c1879bcc100229bee25b44c4805a9a9f040e8927f772c4732fa17a0706c81ea0db77b357dd9baf84388eec03ceb36597932c48fe32fb3d4171
-  languageName: node
-  linkType: hard
-
-"babel-plugin-transform-es2015-modules-systemjs@npm:^6.23.0":
-  version: 6.24.1
-  resolution: "babel-plugin-transform-es2015-modules-systemjs@npm:6.24.1"
-  dependencies:
-    babel-helper-hoist-variables: ^6.24.1
-    babel-runtime: ^6.22.0
-    babel-template: ^6.24.1
-  checksum: b34877e201d7b4d293d87c04962a3575fe7727a9593e99ce3a7f8deea3da8883a08bd87a6a12927083ac26f47f6944a31cdbfe3d6eb4d18dd884cb2d304ee943
-  languageName: node
-  linkType: hard
-
-"babel-plugin-transform-es2015-modules-umd@npm:^6.23.0":
-  version: 6.24.1
-  resolution: "babel-plugin-transform-es2015-modules-umd@npm:6.24.1"
-  dependencies:
-    babel-plugin-transform-es2015-modules-amd: ^6.24.1
-    babel-runtime: ^6.22.0
-    babel-template: ^6.24.1
-  checksum: 735857b9f2ad0c41ceda31a1594fe2a063025f4428f9e243885a437b5bd415aca445a5e8495ff34b7120617735b1c3a2158033f0be23f1f5a90e655fff742a01
-  languageName: node
-  linkType: hard
-
-"babel-plugin-transform-es2015-object-super@npm:^6.22.0":
-  version: 6.24.1
-  resolution: "babel-plugin-transform-es2015-object-super@npm:6.24.1"
-  dependencies:
-    babel-helper-replace-supers: ^6.24.1
-    babel-runtime: ^6.22.0
-  checksum: 97b2968f699ac94cb55f4f1e7ea53dc9e4264ec99cab826f40f181da9f6db5980cd8b4985f05c7b6f1e19fbc31681e6e63894dfc5ecf4b3a673d736c4ef0f9db
-  languageName: node
-  linkType: hard
-
-"babel-plugin-transform-es2015-parameters@npm:^6.23.0":
-  version: 6.24.1
-  resolution: "babel-plugin-transform-es2015-parameters@npm:6.24.1"
-  dependencies:
-    babel-helper-call-delegate: ^6.24.1
-    babel-helper-get-function-arity: ^6.24.1
-    babel-runtime: ^6.22.0
-    babel-template: ^6.24.1
-    babel-traverse: ^6.24.1
-    babel-types: ^6.24.1
-  checksum: bb6c047dc10499be8ccebdffac22c77f14aee5d3106da8f2e96c801d2746403c809d8c6922e8ebd2eb31d8827b4bb2321ba43378fcdc9dca206417bb345c4f93
-  languageName: node
-  linkType: hard
-
-"babel-plugin-transform-es2015-shorthand-properties@npm:^6.22.0":
-  version: 6.24.1
-  resolution: "babel-plugin-transform-es2015-shorthand-properties@npm:6.24.1"
-  dependencies:
-    babel-runtime: ^6.22.0
-    babel-types: ^6.24.1
-  checksum: 9302c5de158a28432e932501a783560094c624c3659f4e0a472b6b2e9d6e8ab2634f82ef74d3e75363d46ccff6aad119267dbc34f67464c70625e24a651ad9e5
-  languageName: node
-  linkType: hard
-
-"babel-plugin-transform-es2015-spread@npm:^6.22.0":
-  version: 6.22.0
-  resolution: "babel-plugin-transform-es2015-spread@npm:6.22.0"
-  dependencies:
-    babel-runtime: ^6.22.0
-  checksum: 8694a8a7802d905503194ab81c155354b36d39fc819ad2148f83146518dd37d2c6926c8568712f5aa890169afc9353fd4bcc49397959c6dc9da3480b449c0ae9
-  languageName: node
-  linkType: hard
-
-"babel-plugin-transform-es2015-sticky-regex@npm:^6.22.0":
-  version: 6.24.1
-  resolution: "babel-plugin-transform-es2015-sticky-regex@npm:6.24.1"
-  dependencies:
-    babel-helper-regex: ^6.24.1
-    babel-runtime: ^6.22.0
-    babel-types: ^6.24.1
-  checksum: d9c45401caf0d74779a1170e886976d4c865b7de2e90dfffc7557481b9e73b6e37e9f1028aa07b813896c4df88f4d7e89968249a74547c7875e6c499c90c801d
-  languageName: node
-  linkType: hard
-
-"babel-plugin-transform-es2015-template-literals@npm:^6.22.0":
-  version: 6.22.0
-  resolution: "babel-plugin-transform-es2015-template-literals@npm:6.22.0"
-  dependencies:
-    babel-runtime: ^6.22.0
-  checksum: 4fad2b7b383a2e784858ee7bf837419ee8ff9602afe218e1472f8c33a0c008f01d06f23ff2f2322fb23e1ed17e37237a818575fe88ecc5417d85331973b0ea4d
-  languageName: node
-  linkType: hard
-
-"babel-plugin-transform-es2015-typeof-symbol@npm:^6.23.0":
-  version: 6.23.0
-  resolution: "babel-plugin-transform-es2015-typeof-symbol@npm:6.23.0"
-  dependencies:
-    babel-runtime: ^6.22.0
-  checksum: 68a1609c6abcddf5f138c56bafcd9fad7c6b3b404fe40910148ab70eb21d6c7807a343a64eb81ce45daf4b70c384c528c55fad45e0d581e4b09efa4d574a6a1b
-  languageName: node
-  linkType: hard
-
-"babel-plugin-transform-es2015-unicode-regex@npm:^6.22.0":
-  version: 6.24.1
-  resolution: "babel-plugin-transform-es2015-unicode-regex@npm:6.24.1"
-  dependencies:
-    babel-helper-regex: ^6.24.1
-    babel-runtime: ^6.22.0
-    regexpu-core: ^2.0.0
-  checksum: 739ddb02e5f77904f83ea45323c9a636e3aed34b2a49c7c68208b5f2834eecb6b655e772f870f16a7aaf09ac8219f754ad69d61741d088f5b681d13cda69265d
-  languageName: node
-  linkType: hard
-
-"babel-plugin-transform-exponentiation-operator@npm:^6.22.0":
-  version: 6.24.1
-  resolution: "babel-plugin-transform-exponentiation-operator@npm:6.24.1"
-  dependencies:
-    babel-helper-builder-binary-assignment-operator-visitor: ^6.24.1
-    babel-plugin-syntax-exponentiation-operator: ^6.8.0
-    babel-runtime: ^6.22.0
-  checksum: 533ad53ba2cd6ff3c0f751563e1beea429c620038dc2efeeb8348ab4752ebcc95d1521857abfd08047400f1921b2d4df5e0cd266e65ddbe4c3edc58b9ad6fd3c
-  languageName: node
-  linkType: hard
-
-"babel-plugin-transform-regenerator@npm:^6.22.0":
-  version: 6.26.0
-  resolution: "babel-plugin-transform-regenerator@npm:6.26.0"
-  dependencies:
-    regenerator-transform: ^0.10.0
-  checksum: 41a51d8f692bf4a5cbd705fa70f3cb6abebae66d9ba3dccfb5921da262f8c30f630e1fe9f7b132e29b96fe0d99385a801f6aa204278c5bd0af4284f7f93a665a
-  languageName: node
-  linkType: hard
-
-"babel-plugin-transform-strict-mode@npm:^6.24.1":
-  version: 6.24.1
-  resolution: "babel-plugin-transform-strict-mode@npm:6.24.1"
-  dependencies:
-    babel-runtime: ^6.22.0
-    babel-types: ^6.24.1
-  checksum: 32d70ce9d8c8918a6a840e46df03dfe1e265eb9b25df5a800fedb5065ef1b4b5f24d7c62d92fca0e374db8b0b9b6f84e68edd02ad21883d48f608583ec29f638
-  languageName: node
-  linkType: hard
-
-"babel-preset-env@npm:^1.7.0":
-  version: 1.7.0
-  resolution: "babel-preset-env@npm:1.7.0"
-  dependencies:
-    babel-plugin-check-es2015-constants: ^6.22.0
-    babel-plugin-syntax-trailing-function-commas: ^6.22.0
-    babel-plugin-transform-async-to-generator: ^6.22.0
-    babel-plugin-transform-es2015-arrow-functions: ^6.22.0
-    babel-plugin-transform-es2015-block-scoped-functions: ^6.22.0
-    babel-plugin-transform-es2015-block-scoping: ^6.23.0
-    babel-plugin-transform-es2015-classes: ^6.23.0
-    babel-plugin-transform-es2015-computed-properties: ^6.22.0
-    babel-plugin-transform-es2015-destructuring: ^6.23.0
-    babel-plugin-transform-es2015-duplicate-keys: ^6.22.0
-    babel-plugin-transform-es2015-for-of: ^6.23.0
-    babel-plugin-transform-es2015-function-name: ^6.22.0
-    babel-plugin-transform-es2015-literals: ^6.22.0
-    babel-plugin-transform-es2015-modules-amd: ^6.22.0
-    babel-plugin-transform-es2015-modules-commonjs: ^6.23.0
-    babel-plugin-transform-es2015-modules-systemjs: ^6.23.0
-    babel-plugin-transform-es2015-modules-umd: ^6.23.0
-    babel-plugin-transform-es2015-object-super: ^6.22.0
-    babel-plugin-transform-es2015-parameters: ^6.23.0
-    babel-plugin-transform-es2015-shorthand-properties: ^6.22.0
-    babel-plugin-transform-es2015-spread: ^6.22.0
-    babel-plugin-transform-es2015-sticky-regex: ^6.22.0
-    babel-plugin-transform-es2015-template-literals: ^6.22.0
-    babel-plugin-transform-es2015-typeof-symbol: ^6.23.0
-    babel-plugin-transform-es2015-unicode-regex: ^6.22.0
-    babel-plugin-transform-exponentiation-operator: ^6.22.0
-    babel-plugin-transform-regenerator: ^6.22.0
-    browserslist: ^3.2.6
-    invariant: ^2.2.2
-    semver: ^5.3.0
-  checksum: 6e459a6c76086a2a377707680148b94c3d0aba425b039b427ca01171ebada7f5db5d336b309548462f6ba015e13176a4724f912875c15084d4aa88d77020d185
-  languageName: node
-  linkType: hard
-
-"babel-register@npm:^6.26.0":
-  version: 6.26.0
-  resolution: "babel-register@npm:6.26.0"
-  dependencies:
-    babel-core: ^6.26.0
-    babel-runtime: ^6.26.0
-    core-js: ^2.5.0
-    home-or-tmp: ^2.0.0
-    lodash: ^4.17.4
-    mkdirp: ^0.5.1
-    source-map-support: ^0.4.15
-  checksum: 75d5fe060e4850dbdbd5f56db2928cd0b6b6c93a65ba5f2a991465af4dc3f4adf46d575138f228b2169b1e25e3b4a7cdd16515a355fea41b873321bf56467583
-  languageName: node
-  linkType: hard
-
-"babel-runtime@npm:^6.18.0, babel-runtime@npm:^6.22.0, babel-runtime@npm:^6.26.0":
-  version: 6.26.0
-  resolution: "babel-runtime@npm:6.26.0"
-  dependencies:
-    core-js: ^2.4.0
-    regenerator-runtime: ^0.11.0
-  checksum: 8aeade94665e67a73c1ccc10f6fd42ba0c689b980032b70929de7a6d9a12eb87ef51902733f8fefede35afea7a5c3ef7e916a64d503446c1eedc9e3284bd3d50
-  languageName: node
-  linkType: hard
-
-"babel-template@npm:^6.24.1, babel-template@npm:^6.26.0":
-  version: 6.26.0
-  resolution: "babel-template@npm:6.26.0"
-  dependencies:
-    babel-runtime: ^6.26.0
-    babel-traverse: ^6.26.0
-    babel-types: ^6.26.0
-    babylon: ^6.18.0
-    lodash: ^4.17.4
-  checksum: 028dd57380f09b5641b74874a19073c53c4fb3f1696e849575aae18f8c80eaf21db75209057db862f3b893ce2cd9b795d539efa591b58f4a0fb011df0a56fbed
-  languageName: node
-  linkType: hard
-
-"babel-traverse@npm:^6.24.1, babel-traverse@npm:^6.26.0":
-  version: 6.26.0
-  resolution: "babel-traverse@npm:6.26.0"
-  dependencies:
-    babel-code-frame: ^6.26.0
-    babel-messages: ^6.23.0
-    babel-runtime: ^6.26.0
-    babel-types: ^6.26.0
-    babylon: ^6.18.0
-    debug: ^2.6.8
-    globals: ^9.18.0
-    invariant: ^2.2.2
-    lodash: ^4.17.4
-  checksum: fca037588d2791ae0409f1b7aa56075b798699cccc53ea04d82dd1c0f97b9e7ab17065f7dd3ecd69101d7874c9c8fd5e0f88fa53abbae1fe94e37e6b81ebcb8d
-  languageName: node
-  linkType: hard
-
-"babel-types@npm:^6.19.0, babel-types@npm:^6.24.1, babel-types@npm:^6.26.0":
-  version: 6.26.0
-  resolution: "babel-types@npm:6.26.0"
-  dependencies:
-    babel-runtime: ^6.26.0
-    esutils: ^2.0.2
-    lodash: ^4.17.4
-    to-fast-properties: ^1.0.3
-  checksum: d16b0fa86e9b0e4c2623be81d0a35679faff24dd2e43cde4ca58baf49f3e39415a011a889e6c2259ff09e1228e4c3a3db6449a62de59e80152fe1ce7398fde76
-  languageName: node
-  linkType: hard
-
-"babelify@npm:^7.3.0":
-  version: 7.3.0
-  resolution: "babelify@npm:7.3.0"
-  dependencies:
-    babel-core: ^6.0.14
-    object-assign: ^4.0.0
-  checksum: 4e169606ed0f2ff6f886d2367c72243d36b3b354490ccc916b913f6b4afd14102c91f771d71d485857feb134581dd48702f25431e19b5c7035f474f9898c3c2e
-  languageName: node
-  linkType: hard
-
-"babylon@npm:^6.18.0":
-  version: 6.18.0
-  resolution: "babylon@npm:6.18.0"
-  bin:
-    babylon: ./bin/babylon.js
-  checksum: 0777ae0c735ce1cbfc856d627589ed9aae212b84fb0c03c368b55e6c5d3507841780052808d0ad46e18a2ba516e93d55eeed8cd967f3b2938822dfeccfb2a16d
-  languageName: node
-  linkType: hard
-
-"backoff@npm:^2.5.0":
-  version: 2.5.0
-  resolution: "backoff@npm:2.5.0"
-  dependencies:
-    precond: 0.2
-  checksum: ccdcf2a26acd9379d0d4f09e3fb3b7ee34dee94f07ab74d1e38b38f89a3675d9f3cbebb142d9c61c655f4c9eb63f1d6ec28cebeb3dc9215efd8fe7cef92725b9
-  languageName: node
-  linkType: hard
-
 "balanced-match@npm:^1.0.0":
   version: 1.0.2
   resolution: "balanced-match@npm:1.0.2"
@@ -4024,7 +3171,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"base-x@npm:^3.0.2, base-x@npm:^3.0.8":
+"base-x@npm:^3.0.2":
   version: 3.0.9
   resolution: "base-x@npm:3.0.9"
   dependencies:
@@ -4040,21 +3187,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"base@npm:^0.11.1":
-  version: 0.11.2
-  resolution: "base@npm:0.11.2"
-  dependencies:
-    cache-base: ^1.0.1
-    class-utils: ^0.3.5
-    component-emitter: ^1.2.1
-    define-property: ^1.0.0
-    isobject: ^3.0.1
-    mixin-deep: ^1.2.0
-    pascalcase: ^0.1.1
-  checksum: a4a146b912e27eea8f66d09cb0c9eab666f32ce27859a7dfd50f38cd069a2557b39f16dba1bc2aecb3b44bf096738dd207b7970d99b0318423285ab1b1994edd
-  languageName: node
-  linkType: hard
-
 "bcrypt-pbkdf@npm:^1.0.0":
   version: 1.0.2
   resolution: "bcrypt-pbkdf@npm:1.0.2"
@@ -4071,13 +3203,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"bigint-crypto-utils@npm:^3.0.23":
-  version: 3.3.0
-  resolution: "bigint-crypto-utils@npm:3.3.0"
-  checksum: 9598ce57b23f776c8936d44114c9f051e62b5fa654915b664784cbcbacc5aa0485f4479571c51ff58008abb1210c0d6a234853742f07cf84bda890f2a1e01000
-  languageName: node
-  linkType: hard
-
 "bignumber.js@npm:^9.0.0":
   version: 9.1.2
   resolution: "bignumber.js@npm:9.1.2"
@@ -4103,16 +3228,15 @@ __metadata:
   languageName: node
   linkType: hard
 
-"bip39@npm:2.5.0":
-  version: 2.5.0
-  resolution: "bip39@npm:2.5.0"
+"bip39@npm:3.0.4":
+  version: 3.0.4
+  resolution: "bip39@npm:3.0.4"
   dependencies:
+    "@types/node": 11.11.6
     create-hash: ^1.1.0
     pbkdf2: ^3.0.9
     randombytes: ^2.0.1
-    safe-buffer: ^5.0.1
-    unorm: ^1.3.3
-  checksum: 26e83583c43a8430afea1c385328b447005c74ddaf997cd8d3e416057f4968360b08ebf7de32374d605295c3abdd7ddd448d8078a2aa3d951735f4499c23875b
+  checksum: 79ce1600a03d1ba5053bdd4e6323f9463ec340764c7e52918b6c6b9dca81221940f2d9a65656447f108f9bc2c8d9ae8df319cca83bbd1dad63f53ef2768d9bae
   languageName: node
   linkType: hard
 
@@ -4142,13 +3266,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"bluebird@npm:^3.5.0, bluebird@npm:^3.5.2":
-  version: 3.7.2
-  resolution: "bluebird@npm:3.7.2"
-  checksum: 869417503c722e7dc54ca46715f70e15f4d9c602a423a02c825570862d12935be59ed9c7ba34a9b31f186c017c23cac6b54e35446f8353059c101da73eac22ef
-  languageName: node
-  linkType: hard
-
 "bn.js@npm:4.11.6":
   version: 4.11.6
   resolution: "bn.js@npm:4.11.6"
@@ -4156,60 +3273,20 @@ __metadata:
   languageName: node
   linkType: hard
 
-"bn.js@npm:^4.0.0, bn.js@npm:^4.1.0, bn.js@npm:^4.10.0, bn.js@npm:^4.11.0, bn.js@npm:^4.11.6, bn.js@npm:^4.11.8, bn.js@npm:^4.11.9, bn.js@npm:^4.8.0":
+"bn.js@npm:^4.0.0, bn.js@npm:^4.11.0, bn.js@npm:^4.11.1, bn.js@npm:^4.11.8, bn.js@npm:^4.11.9":
   version: 4.12.0
   resolution: "bn.js@npm:4.12.0"
   checksum: 39afb4f15f4ea537b55eaf1446c896af28ac948fdcf47171961475724d1bb65118cca49fa6e3d67706e4790955ec0e74de584e45c8f1ef89f46c812bee5b5a12
   languageName: node
   linkType: hard
 
-"bn.js@npm:^5.0.0, bn.js@npm:^5.1.2, bn.js@npm:^5.2.0, bn.js@npm:^5.2.1":
+"bn.js@npm:^5.1.2, bn.js@npm:^5.2.0, bn.js@npm:^5.2.1":
   version: 5.2.1
   resolution: "bn.js@npm:5.2.1"
   checksum: 3dd8c8d38055fedfa95c1d5fc3c99f8dd547b36287b37768db0abab3c239711f88ff58d18d155dd8ad902b0b0cee973747b7ae20ea12a09473272b0201c9edd3
   languageName: node
   linkType: hard
 
-"body-parser@npm:1.20.1":
-  version: 1.20.1
-  resolution: "body-parser@npm:1.20.1"
-  dependencies:
-    bytes: 3.1.2
-    content-type: ~1.0.4
-    debug: 2.6.9
-    depd: 2.0.0
-    destroy: 1.2.0
-    http-errors: 2.0.0
-    iconv-lite: 0.4.24
-    on-finished: 2.4.1
-    qs: 6.11.0
-    raw-body: 2.5.1
-    type-is: ~1.6.18
-    unpipe: 1.0.0
-  checksum: f1050dbac3bede6a78f0b87947a8d548ce43f91ccc718a50dd774f3c81f2d8b04693e52acf62659fad23101827dd318da1fb1363444ff9a8482b886a3e4a5266
-  languageName: node
-  linkType: hard
-
-"body-parser@npm:^1.16.0":
-  version: 1.20.2
-  resolution: "body-parser@npm:1.20.2"
-  dependencies:
-    bytes: 3.1.2
-    content-type: ~1.0.5
-    debug: 2.6.9
-    depd: 2.0.0
-    destroy: 1.2.0
-    http-errors: 2.0.0
-    iconv-lite: 0.4.24
-    on-finished: 2.4.1
-    qs: 6.11.0
-    raw-body: 2.5.2
-    type-is: ~1.6.18
-    unpipe: 1.0.0
-  checksum: 14d37ec638ab5c93f6099ecaed7f28f890d222c650c69306872e00b9efa081ff6c596cd9afb9930656aae4d6c4e1c17537bea12bb73c87a217cb3cfea8896737
-  languageName: node
-  linkType: hard
-
 "boxen@npm:^5.1.2":
   version: 5.1.2
   resolution: "boxen@npm:5.1.2"
@@ -4245,24 +3322,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"braces@npm:^2.3.1":
-  version: 2.3.2
-  resolution: "braces@npm:2.3.2"
-  dependencies:
-    arr-flatten: ^1.1.0
-    array-unique: ^0.3.2
-    extend-shallow: ^2.0.1
-    fill-range: ^4.0.0
-    isobject: ^3.0.1
-    repeat-element: ^1.1.2
-    snapdragon: ^0.8.1
-    snapdragon-node: ^2.0.1
-    split-string: ^3.0.2
-    to-regex: ^3.0.1
-  checksum: e30dcb6aaf4a31c8df17d848aa283a65699782f75ad61ae93ec25c9729c66cf58e66f0000a9fec84e4add1135bb7da40f7cb9601b36bebcfa9ca58e8d5c07de0
-  languageName: node
-  linkType: hard
-
 "braces@npm:^3.0.2, braces@npm:~3.0.2":
   version: 3.0.2
   resolution: "braces@npm:3.0.2"
@@ -4279,18 +3338,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"browser-level@npm:^1.0.1":
-  version: 1.0.1
-  resolution: "browser-level@npm:1.0.1"
-  dependencies:
-    abstract-level: ^1.0.2
-    catering: ^2.1.1
-    module-error: ^1.0.2
-    run-parallel-limit: ^1.1.0
-  checksum: 67fbc77ce832940bfa25073eccff279f512ad56f545deb996a5b23b02316f5e76f4a79d381acc27eda983f5c9a2566aaf9c97e4fdd0748288c4407307537a29b
-  languageName: node
-  linkType: hard
-
 "browser-readablestream-to-it@npm:^1.0.0, browser-readablestream-to-it@npm:^1.0.1, browser-readablestream-to-it@npm:^1.0.3":
   version: 1.0.3
   resolution: "browser-readablestream-to-it@npm:1.0.3"
@@ -4305,7 +3352,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"browserify-aes@npm:^1.0.0, browserify-aes@npm:^1.0.4, browserify-aes@npm:^1.2.0":
+"browserify-aes@npm:^1.2.0":
   version: 1.2.0
   resolution: "browserify-aes@npm:1.2.0"
   dependencies:
@@ -4319,68 +3366,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"browserify-cipher@npm:^1.0.0":
-  version: 1.0.1
-  resolution: "browserify-cipher@npm:1.0.1"
-  dependencies:
-    browserify-aes: ^1.0.4
-    browserify-des: ^1.0.0
-    evp_bytestokey: ^1.0.0
-  checksum: 2d8500acf1ee535e6bebe808f7a20e4c3a9e2ed1a6885fff1facbfd201ac013ef030422bec65ca9ece8ffe82b03ca580421463f9c45af6c8415fd629f4118c13
-  languageName: node
-  linkType: hard
-
-"browserify-des@npm:^1.0.0":
-  version: 1.0.2
-  resolution: "browserify-des@npm:1.0.2"
-  dependencies:
-    cipher-base: ^1.0.1
-    des.js: ^1.0.0
-    inherits: ^2.0.1
-    safe-buffer: ^5.1.2
-  checksum: b15a3e358a1d78a3b62ddc06c845d02afde6fc826dab23f1b9c016e643e7b1fda41de628d2110b712f6a44fb10cbc1800bc6872a03ddd363fb50768e010395b7
-  languageName: node
-  linkType: hard
-
-"browserify-rsa@npm:^4.0.0, browserify-rsa@npm:^4.1.0":
-  version: 4.1.0
-  resolution: "browserify-rsa@npm:4.1.0"
-  dependencies:
-    bn.js: ^5.0.0
-    randombytes: ^2.0.1
-  checksum: 155f0c135873efc85620571a33d884aa8810e40176125ad424ec9d85016ff105a07f6231650914a760cca66f29af0494087947b7be34880dd4599a0cd3c38e54
-  languageName: node
-  linkType: hard
-
-"browserify-sign@npm:^4.0.0":
-  version: 4.2.2
-  resolution: "browserify-sign@npm:4.2.2"
-  dependencies:
-    bn.js: ^5.2.1
-    browserify-rsa: ^4.1.0
-    create-hash: ^1.2.0
-    create-hmac: ^1.1.7
-    elliptic: ^6.5.4
-    inherits: ^2.0.4
-    parse-asn1: ^5.1.6
-    readable-stream: ^3.6.2
-    safe-buffer: ^5.2.1
-  checksum: b622730c0fc183328c3a1c9fdaaaa5118821ed6822b266fa6b0375db7e20061ebec87301d61931d79b9da9a96ada1cab317fce3c68f233e5e93ed02dbb35544c
-  languageName: node
-  linkType: hard
-
-"browserslist@npm:^3.2.6":
-  version: 3.2.8
-  resolution: "browserslist@npm:3.2.8"
-  dependencies:
-    caniuse-lite: ^1.0.30000844
-    electron-to-chromium: ^1.3.47
-  bin:
-    browserslist: ./cli.js
-  checksum: 74d9ab1089a3813f54a7c4f9f6612faa6256799c8e42c7e00e4aae626c17f199049a01707a525a05b1673cd1493936583e51aad295e25249166e7e8fbd0273ba
-  languageName: node
-  linkType: hard
-
 "bs58@npm:^4.0.0":
   version: 4.0.1
   resolution: "bs58@npm:4.0.1"
@@ -4432,13 +3417,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"buffer-to-arraybuffer@npm:^0.0.5":
-  version: 0.0.5
-  resolution: "buffer-to-arraybuffer@npm:0.0.5"
-  checksum: b2e6493a6679e03d0e0e146b4258b9a6d92649d528d8fc4a74423b77f0d4f9398c9f965f3378d1683a91738054bae2761196cfe233f41ab3695126cb58cb25f9
-  languageName: node
-  linkType: hard
-
 "buffer-xor@npm:^1.0.3":
   version: 1.0.3
   resolution: "buffer-xor@npm:1.0.3"
@@ -4466,7 +3444,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"buffer@npm:^5.0.5, buffer@npm:^5.2.1, buffer@npm:^5.5.0, buffer@npm:^5.6.0":
+"buffer@npm:^5.5.0, buffer@npm:^5.6.0":
   version: 5.7.1
   resolution: "buffer@npm:5.7.1"
   dependencies:
@@ -4486,13 +3464,13 @@ __metadata:
   languageName: node
   linkType: hard
 
-"bufferutil@npm:^4.0.1":
-  version: 4.0.8
-  resolution: "bufferutil@npm:4.0.8"
+"bufferutil@npm:4.0.5":
+  version: 4.0.5
+  resolution: "bufferutil@npm:4.0.5"
   dependencies:
     node-gyp: latest
     node-gyp-build: ^4.3.0
-  checksum: 7e9a46f1867dca72fda350966eb468eca77f4d623407b0650913fadf73d5750d883147d6e5e21c56f9d3b0bdc35d5474e80a600b9f31ec781315b4d2469ef087
+  checksum: 37d5bef7cb38d29f9377b8891ff8a57f53ae6057313d77a8aa2a7417df37a72f16987100796cb2f1e1862f3eb80057705f3c052615ec076a0dcc7aa6c83b68c9
   languageName: node
   linkType: hard
 
@@ -4512,25 +3490,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"bytewise-core@npm:^1.2.2":
-  version: 1.2.3
-  resolution: "bytewise-core@npm:1.2.3"
-  dependencies:
-    typewise-core: ^1.2
-  checksum: e0d28fb7ff5bb6fd9320eef31c6b37e98da3b9a24d9893e2c17e0ee544457e0c76c2d3fc642c99d82daa0f18dcd49e7dce8dcc338711200e9ced79107cb78e8e
-  languageName: node
-  linkType: hard
-
-"bytewise@npm:~1.1.0":
-  version: 1.1.0
-  resolution: "bytewise@npm:1.1.0"
-  dependencies:
-    bytewise-core: ^1.2.2
-    typewise: ^1.0.3
-  checksum: 20d7387ecf8c29adc4740e626fb02eaa27f34ae4c5ca881657d403e792730c0625ba4fed824462b3ddb7d3ebe41b7abbfe24f1cd3bf07cecc5a631f154d2d8d2
-  languageName: node
-  linkType: hard
-
 "cacache@npm:^18.0.0":
   version: 18.0.2
   resolution: "cacache@npm:18.0.2"
@@ -4551,71 +3510,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"cache-base@npm:^1.0.1":
-  version: 1.0.1
-  resolution: "cache-base@npm:1.0.1"
-  dependencies:
-    collection-visit: ^1.0.0
-    component-emitter: ^1.2.1
-    get-value: ^2.0.6
-    has-value: ^1.0.0
-    isobject: ^3.0.1
-    set-value: ^2.0.0
-    to-object-path: ^0.3.0
-    union-value: ^1.0.0
-    unset-value: ^1.0.0
-  checksum: 9114b8654fe2366eedc390bad0bcf534e2f01b239a888894e2928cb58cdc1e6ea23a73c6f3450dcfd2058aa73a8a981e723cd1e7c670c047bf11afdc65880107
-  languageName: node
-  linkType: hard
-
-"cacheable-lookup@npm:^5.0.3":
-  version: 5.0.4
-  resolution: "cacheable-lookup@npm:5.0.4"
-  checksum: 763e02cf9196bc9afccacd8c418d942fc2677f22261969a4c2c2e760fa44a2351a81557bd908291c3921fe9beb10b976ba8fa50c5ca837c5a0dd945f16468f2d
-  languageName: node
-  linkType: hard
-
-"cacheable-request@npm:^6.0.0":
-  version: 6.1.0
-  resolution: "cacheable-request@npm:6.1.0"
-  dependencies:
-    clone-response: ^1.0.2
-    get-stream: ^5.1.0
-    http-cache-semantics: ^4.0.0
-    keyv: ^3.0.0
-    lowercase-keys: ^2.0.0
-    normalize-url: ^4.1.0
-    responselike: ^1.0.2
-  checksum: b510b237b18d17e89942e9ee2d2a077cb38db03f12167fd100932dfa8fc963424bfae0bfa1598df4ae16c944a5484e43e03df8f32105b04395ee9495e9e4e9f1
-  languageName: node
-  linkType: hard
-
-"cacheable-request@npm:^7.0.2":
-  version: 7.0.4
-  resolution: "cacheable-request@npm:7.0.4"
-  dependencies:
-    clone-response: ^1.0.2
-    get-stream: ^5.1.0
-    http-cache-semantics: ^4.0.0
-    keyv: ^4.0.0
-    lowercase-keys: ^2.0.0
-    normalize-url: ^6.0.1
-    responselike: ^2.0.0
-  checksum: 0de9df773fd4e7dd9bd118959878f8f2163867e2e1ab3575ffbecbe6e75e80513dd0c68ba30005e5e5a7b377cc6162bbc00ab1db019bb4e9cb3c2f3f7a6f1ee4
-  languageName: node
-  linkType: hard
-
-"cachedown@npm:1.0.0":
-  version: 1.0.0
-  resolution: "cachedown@npm:1.0.0"
-  dependencies:
-    abstract-leveldown: ^2.4.1
-    lru-cache: ^3.2.0
-  checksum: ffd229839ca7efbfa14e35321fb8df444421e192bdf7be16048a303d2a24f3ed86cbe6c7a8cca91761423e4c53c3ed1098d337bbb9d3448801d4792172b4ab3e
-  languageName: node
-  linkType: hard
-
-"call-bind@npm:^1.0.0, call-bind@npm:^1.0.2, call-bind@npm:^1.0.5, call-bind@npm:~1.0.2":
+"call-bind@npm:^1.0.0, call-bind@npm:^1.0.2, call-bind@npm:^1.0.5":
   version: 1.0.5
   resolution: "call-bind@npm:1.0.5"
   dependencies:
@@ -4633,13 +3528,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"camelcase@npm:^3.0.0":
-  version: 3.0.0
-  resolution: "camelcase@npm:3.0.0"
-  checksum: ae4fe1c17c8442a3a345a6b7d2393f028ab7a7601af0c352ad15d1ab97ca75112e19e29c942b2a214898e160194829b68923bce30e018d62149c6d84187f1673
-  languageName: node
-  linkType: hard
-
 "camelcase@npm:^5.0.0":
   version: 5.3.1
   resolution: "camelcase@npm:5.3.1"
@@ -4654,20 +3542,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"caniuse-lite@npm:^1.0.30000844":
-  version: 1.0.30001584
-  resolution: "caniuse-lite@npm:1.0.30001584"
-  checksum: de7018759561795ef31864b0d1584735eef267033d4e9b5f046b976756e06c43e85afd46705c5d63c63e3c36484c26794c259b9748eefffa582750b4ad0822ce
-  languageName: node
-  linkType: hard
-
-"case@npm:^1.6.3":
-  version: 1.6.3
-  resolution: "case@npm:1.6.3"
-  checksum: febe73278f910b0d28aab7efd6f51c235f9aa9e296148edb56dfb83fd58faa88308c30ce9a0122b6e53e0362c44f4407105bd5ef89c46860fc2b184e540fd68d
-  languageName: node
-  linkType: hard
-
 "caseless@npm:^0.12.0, caseless@npm:~0.12.0":
   version: 0.12.0
   resolution: "caseless@npm:0.12.0"
@@ -4675,7 +3549,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"catering@npm:^2.1.0, catering@npm:^2.1.1":
+"catering@npm:^2.0.0, catering@npm:^2.1.0":
   version: 2.1.1
   resolution: "catering@npm:2.1.1"
   checksum: 205daefa69c935b0c19f3d8f2e0a520dd69aebe9bda55902958003f7c9cff8f967dfb90071b421bd6eb618576f657a89d2bc0986872c9bc04bbd66655e9d4bd6
@@ -4735,20 +3609,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"chalk@npm:^1.1.3":
-  version: 1.1.3
-  resolution: "chalk@npm:1.1.3"
-  dependencies:
-    ansi-styles: ^2.2.1
-    escape-string-regexp: ^1.0.2
-    has-ansi: ^2.0.0
-    strip-ansi: ^3.0.0
-    supports-color: ^2.0.0
-  checksum: 9d2ea6b98fc2b7878829eec223abcf404622db6c48396a9b9257f6d0ead2acf18231ae368d6a664a83f272b0679158da12e97b5229f794939e555cc574478acd
-  languageName: node
-  linkType: hard
-
-"chalk@npm:^2.1.0, chalk@npm:^2.4.1, chalk@npm:^2.4.2":
+"chalk@npm:^2.1.0, chalk@npm:^2.4.2":
   version: 2.4.2
   resolution: "chalk@npm:2.4.2"
   dependencies:
@@ -4802,15 +3663,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"checkpoint-store@npm:^1.1.0":
-  version: 1.1.0
-  resolution: "checkpoint-store@npm:1.1.0"
-  dependencies:
-    functional-red-black-tree: ^1.0.1
-  checksum: 94e921ccb222c7970615e8b2bcd956dbd52f15a1c397af0447dbdef8ecd32ffe342e394d39e55f2912278a460f3736de777b5b57a5baf229c0a6bd04d2465511
-  languageName: node
-  linkType: hard
-
 "chokidar@npm:3.5.3, chokidar@npm:^3.0.2, chokidar@npm:^3.4.0":
   version: 3.5.3
   resolution: "chokidar@npm:3.5.3"
@@ -4830,7 +3682,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"chownr@npm:^1.0.1, chownr@npm:^1.1.4":
+"chownr@npm:^1.0.1":
   version: 1.1.4
   resolution: "chownr@npm:1.1.4"
   checksum: 115648f8eb38bac5e41c3857f3e663f9c39ed6480d1349977c4d96c95a47266fcacc5a5aabf3cb6c481e22d72f41992827db47301851766c4fd77ac21a4f081d
@@ -4851,19 +3703,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"cids@npm:^0.7.1":
-  version: 0.7.5
-  resolution: "cids@npm:0.7.5"
-  dependencies:
-    buffer: ^5.5.0
-    class-is: ^1.1.0
-    multibase: ~0.6.0
-    multicodec: ^1.0.0
-    multihashes: ~0.4.15
-  checksum: 54aa031bef76b08a2c934237696a4af2cfc8afb5d2727cb39ab69f6ac142ef312b9a0c6070dc2b4be0a43076d8961339d8bf85287773c647b3d1d25ce203f325
-  languageName: node
-  linkType: hard
-
 "cipher-base@npm:^1.0.0, cipher-base@npm:^1.0.1, cipher-base@npm:^1.0.3":
   version: 1.0.4
   resolution: "cipher-base@npm:1.0.4"
@@ -4874,39 +3713,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"class-is@npm:^1.1.0":
-  version: 1.1.0
-  resolution: "class-is@npm:1.1.0"
-  checksum: 49024de3b264fc501a38dd59d8668f1a2b4973fa6fcef6b83d80fe6fe99a2000a8fbea5b50d4607169c65014843c9f6b41a4f8473df806c1b4787b4d47521880
-  languageName: node
-  linkType: hard
-
-"class-utils@npm:^0.3.5":
-  version: 0.3.6
-  resolution: "class-utils@npm:0.3.6"
-  dependencies:
-    arr-union: ^3.1.0
-    define-property: ^0.2.5
-    isobject: ^3.0.0
-    static-extend: ^0.1.1
-  checksum: be108900801e639e50f96a7e4bfa8867c753a7750a7603879f3981f8b0a89cba657497a2d5f40cd4ea557ff15d535a100818bb486baf6e26fe5d7872e75f1078
-  languageName: node
-  linkType: hard
-
-"classic-level@npm:^1.2.0":
-  version: 1.4.1
-  resolution: "classic-level@npm:1.4.1"
-  dependencies:
-    abstract-level: ^1.0.2
-    catering: ^2.1.0
-    module-error: ^1.0.1
-    napi-macros: ^2.2.2
-    node-gyp: latest
-    node-gyp-build: ^4.3.0
-  checksum: 62e7e07297fcd656941eb88f92b91df0046ebb2b34987e98ec870cb736f096e212ef109a25541deba2f30866b9d5df550594ed04948614815dd5964933da50a9
-  languageName: node
-  linkType: hard
-
 "clean-stack@npm:^2.0.0":
   version: 2.2.0
   resolution: "clean-stack@npm:2.2.0"
@@ -4958,17 +3764,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"cliui@npm:^3.2.0":
-  version: 3.2.0
-  resolution: "cliui@npm:3.2.0"
-  dependencies:
-    string-width: ^1.0.1
-    strip-ansi: ^3.0.1
-    wrap-ansi: ^2.0.0
-  checksum: c68d1dbc3e347bfe79ed19cc7f48007d5edd6cd8438342e32073e0b4e311e3c44e1f4f19221462bc6590de56c2df520e427533a9dde95dee25710bec322746ad
-  languageName: node
-  linkType: hard
-
 "cliui@npm:^5.0.0":
   version: 5.0.0
   resolution: "cliui@npm:5.0.0"
@@ -4991,22 +3786,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"clone-response@npm:^1.0.2":
-  version: 1.0.3
-  resolution: "clone-response@npm:1.0.3"
-  dependencies:
-    mimic-response: ^1.0.0
-  checksum: 4e671cac39b11c60aa8ba0a450657194a5d6504df51bca3fac5b3bd0145c4f8e8464898f87c8406b83232e3bc5cca555f51c1f9c8ac023969ebfbf7f6bdabb2e
-  languageName: node
-  linkType: hard
-
-"clone@npm:2.1.2, clone@npm:^2.0.0":
-  version: 2.1.2
-  resolution: "clone@npm:2.1.2"
-  checksum: aaf106e9bc025b21333e2f4c12da539b568db4925c0501a1bf4070836c9e848c892fa22c35548ce0d1132b08bbbfa17a00144fe58fccdab6fa900fec4250f67d
-  languageName: node
-  linkType: hard
-
 "clone@npm:^1.0.2":
   version: 1.0.4
   resolution: "clone@npm:1.0.4"
@@ -5014,23 +3793,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"code-point-at@npm:^1.0.0":
-  version: 1.1.0
-  resolution: "code-point-at@npm:1.1.0"
-  checksum: 17d5666611f9b16d64fdf48176d9b7fb1c7d1c1607a189f7e600040a11a6616982876af148230336adb7d8fe728a559f743a4e29db3747e3b1a32fa7f4529681
-  languageName: node
-  linkType: hard
-
-"collection-visit@npm:^1.0.0":
-  version: 1.0.0
-  resolution: "collection-visit@npm:1.0.0"
-  dependencies:
-    map-visit: ^1.0.0
-    object-visit: ^1.0.0
-  checksum: 15d9658fe6eb23594728346adad5433b86bb7a04fd51bbab337755158722f9313a5376ef479de5b35fbc54140764d0d39de89c339f5d25b959ed221466981da9
-  languageName: node
-  linkType: hard
-
 "color-convert@npm:^1.9.0":
   version: 1.9.3
   resolution: "color-convert@npm:1.9.3"
@@ -5086,19 +3848,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"command-line-args@npm:^4.0.7":
-  version: 4.0.7
-  resolution: "command-line-args@npm:4.0.7"
-  dependencies:
-    array-back: ^2.0.0
-    find-replace: ^1.0.3
-    typical: ^2.6.1
-  bin:
-    command-line-args: bin/cli.js
-  checksum: 618109143fbca741048d54a5d31a2a5e166fbda318ed1419c1ca66877ce92ed80d6768a52a2e6392eb751f16ca7755d4014ced6f5f858a68d0cbe793bab6e3ee
-  languageName: node
-  linkType: hard
-
 "command-line-args@npm:^5.1.1":
   version: 5.2.1
   resolution: "command-line-args@npm:5.2.1"
@@ -5144,6 +3893,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"commander@npm:^8.1.0":
+  version: 8.3.0
+  resolution: "commander@npm:8.3.0"
+  checksum: 0f82321821fc27b83bd409510bb9deeebcfa799ff0bf5d102128b500b7af22872c0c92cb6a0ebc5a4cf19c6b550fba9cedfa7329d18c6442a625f851377bacf0
+  languageName: node
+  linkType: hard
+
 "compare-versions@npm:^6.0.0":
   version: 6.1.0
   resolution: "compare-versions@npm:6.1.0"
@@ -5151,13 +3907,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"component-emitter@npm:^1.2.1":
-  version: 1.3.1
-  resolution: "component-emitter@npm:1.3.1"
-  checksum: 94550aa462c7bd5a61c1bc480e28554aa306066930152d1b1844a0dd3845d4e5db7e261ddec62ae184913b3e59b55a2ad84093b9d3596a8f17c341514d6c483d
-  languageName: node
-  linkType: hard
-
 "concat-map@npm:0.0.1":
   version: 0.0.1
   resolution: "concat-map@npm:0.0.1"
@@ -5165,7 +3914,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"concat-stream@npm:^1.5.1, concat-stream@npm:^1.6.0, concat-stream@npm:^1.6.2, concat-stream@npm:~1.6.2":
+"concat-stream@npm:^1.6.0, concat-stream@npm:^1.6.2, concat-stream@npm:~1.6.2":
   version: 1.6.2
   resolution: "concat-stream@npm:1.6.2"
   dependencies:
@@ -5177,54 +3926,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"content-disposition@npm:0.5.4":
-  version: 0.5.4
-  resolution: "content-disposition@npm:0.5.4"
-  dependencies:
-    safe-buffer: 5.2.1
-  checksum: afb9d545e296a5171d7574fcad634b2fdf698875f4006a9dd04a3e1333880c5c0c98d47b560d01216fb6505a54a2ba6a843ee3a02ec86d7e911e8315255f56c3
-  languageName: node
-  linkType: hard
-
-"content-hash@npm:^2.5.2":
-  version: 2.5.2
-  resolution: "content-hash@npm:2.5.2"
-  dependencies:
-    cids: ^0.7.1
-    multicodec: ^0.5.5
-    multihashes: ^0.4.15
-  checksum: 31869e4d137b59d02003df0c0f0ad080744d878ed12a57f7d20b2cfd526d59d6317e9f52fa6e49cba59df7f9ab49ceb96d6a832685b85bae442e0c906f7193be
-  languageName: node
-  linkType: hard
-
-"content-type@npm:~1.0.4, content-type@npm:~1.0.5":
-  version: 1.0.5
-  resolution: "content-type@npm:1.0.5"
-  checksum: 566271e0a251642254cde0f845f9dd4f9856e52d988f4eb0d0dcffbb7a1f8ec98de7a5215fc628f3bce30fe2fb6fd2bc064b562d721658c59b544e2d34ea2766
-  languageName: node
-  linkType: hard
-
-"convert-source-map@npm:^1.5.1":
-  version: 1.9.0
-  resolution: "convert-source-map@npm:1.9.0"
-  checksum: dc55a1f28ddd0e9485ef13565f8f756b342f9a46c4ae18b843fe3c30c675d058d6a4823eff86d472f187b176f0adf51ea7b69ea38be34be4a63cbbf91b0593c8
-  languageName: node
-  linkType: hard
-
-"cookie-signature@npm:1.0.6":
-  version: 1.0.6
-  resolution: "cookie-signature@npm:1.0.6"
-  checksum: f4e1b0a98a27a0e6e66fd7ea4e4e9d8e038f624058371bf4499cfcd8f3980be9a121486995202ba3fca74fbed93a407d6d54d43a43f96fd28d0bd7a06761591a
-  languageName: node
-  linkType: hard
-
-"cookie@npm:0.5.0":
-  version: 0.5.0
-  resolution: "cookie@npm:0.5.0"
-  checksum: 1f4bd2ca5765f8c9689a7e8954183f5332139eb72b6ff783d8947032ec1fdf43109852c178e21a953a30c0dd42257828185be01b49d1eb1a67fd054ca588a180
-  languageName: node
-  linkType: hard
-
 "cookie@npm:^0.4.1":
   version: 0.4.2
   resolution: "cookie@npm:0.4.2"
@@ -5232,20 +3933,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"cookiejar@npm:^2.1.1":
-  version: 2.1.4
-  resolution: "cookiejar@npm:2.1.4"
-  checksum: c4442111963077dc0e5672359956d6556a195d31cbb35b528356ce5f184922b99ac48245ac05ed86cf993f7df157c56da10ab3efdadfed79778a0d9b1b092d5b
-  languageName: node
-  linkType: hard
-
-"copy-descriptor@npm:^0.1.0":
-  version: 0.1.1
-  resolution: "copy-descriptor@npm:0.1.1"
-  checksum: d4b7b57b14f1d256bb9aa0b479241048afd7f5bcf22035fc7b94e8af757adeae247ea23c1a774fe44869fd5694efba4a969b88d966766c5245fdee59837fe45b
-  languageName: node
-  linkType: hard
-
 "core-js-pure@npm:^3.0.1":
   version: 3.35.1
   resolution: "core-js-pure@npm:3.35.1"
@@ -5253,13 +3940,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"core-js@npm:^2.4.0, core-js@npm:^2.5.0":
-  version: 2.6.12
-  resolution: "core-js@npm:2.6.12"
-  checksum: 44fa9934a85f8c78d61e0c8b7b22436330471ffe59ec5076fe7f324d6e8cf7f824b14b1c81ca73608b13bdb0fef035bd820989bf059767ad6fa13123bb8bd016
-  languageName: node
-  linkType: hard
-
 "core-util-is@npm:1.0.2":
   version: 1.0.2
   resolution: "core-util-is@npm:1.0.2"
@@ -5274,16 +3954,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"cors@npm:^2.8.1":
-  version: 2.8.5
-  resolution: "cors@npm:2.8.5"
-  dependencies:
-    object-assign: ^4
-    vary: ^1
-  checksum: ced838404ccd184f61ab4fdc5847035b681c90db7ac17e428f3d81d69e2989d2b680cc254da0e2554f5ed4f8a341820a1ce3d1c16b499f6e2f47a1b9b07b5006
-  languageName: node
-  linkType: hard
-
 "cosmiconfig@npm:6.0.0":
   version: 6.0.0
   resolution: "cosmiconfig@npm:6.0.0"
@@ -5323,16 +3993,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"create-ecdh@npm:^4.0.0":
-  version: 4.0.4
-  resolution: "create-ecdh@npm:4.0.4"
-  dependencies:
-    bn.js: ^4.1.0
-    elliptic: ^6.5.3
-  checksum: 0dd7fca9711d09e152375b79acf1e3f306d1a25ba87b8ff14c2fd8e68b83aafe0a7dd6c4e540c9ffbdd227a5fa1ad9b81eca1f233c38bb47770597ba247e614b
-  languageName: node
-  linkType: hard
-
 "create-hash@npm:^1.1.0, create-hash@npm:^1.1.2, create-hash@npm:^1.2.0":
   version: 1.2.0
   resolution: "create-hash@npm:1.2.0"
@@ -5346,7 +4006,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"create-hmac@npm:^1.1.0, create-hmac@npm:^1.1.4, create-hmac@npm:^1.1.7":
+"create-hmac@npm:^1.1.4, create-hmac@npm:^1.1.7":
   version: 1.1.7
   resolution: "create-hmac@npm:1.1.7"
   dependencies:
@@ -5367,16 +4027,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"cross-fetch@npm:^2.1.0, cross-fetch@npm:^2.1.1":
-  version: 2.2.6
-  resolution: "cross-fetch@npm:2.2.6"
-  dependencies:
-    node-fetch: ^2.6.7
-    whatwg-fetch: ^2.0.4
-  checksum: df9c6728b314ff96022dca468a3d2a05b4546cd318d82a7e1f1445e7160472d39029bccbe5f20d319b8ba3793930592b0b956244aef6a87a133fbcfed85fc8ca
-  languageName: node
-  linkType: hard
-
 "cross-spawn@npm:^6.0.0, cross-spawn@npm:^6.0.5":
   version: 6.0.5
   resolution: "cross-spawn@npm:6.0.5"
@@ -5408,35 +4058,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"crypto-browserify@npm:3.12.0":
-  version: 3.12.0
-  resolution: "crypto-browserify@npm:3.12.0"
-  dependencies:
-    browserify-cipher: ^1.0.0
-    browserify-sign: ^4.0.0
-    create-ecdh: ^4.0.0
-    create-hash: ^1.1.0
-    create-hmac: ^1.1.0
-    diffie-hellman: ^5.0.0
-    inherits: ^2.0.1
-    pbkdf2: ^3.0.3
-    public-encrypt: ^4.0.0
-    randombytes: ^2.0.0
-    randomfill: ^1.0.3
-  checksum: c1609af82605474262f3eaa07daa0b2140026bd264ab316d4bf1170272570dbe02f0c49e29407fe0d3634f96c507c27a19a6765fb856fed854a625f9d15618e2
-  languageName: node
-  linkType: hard
-
-"d@npm:1, d@npm:^1.0.1":
-  version: 1.0.1
-  resolution: "d@npm:1.0.1"
-  dependencies:
-    es5-ext: ^0.10.50
-    type: ^1.0.1
-  checksum: 49ca0639c7b822db670de93d4fbce44b4aa072cd848c76292c9978a8cd0fff1028763020ff4b0f147bd77bfe29b4c7f82e0f71ade76b2a06100543cdfd948d19
-  languageName: node
-  linkType: hard
-
 "dashdash@npm:^1.12.0":
   version: 1.14.1
   resolution: "dashdash@npm:1.14.1"
@@ -5453,24 +4074,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"debug@npm:2.6.9, debug@npm:^2.2.0, debug@npm:^2.3.3, debug@npm:^2.6.8, debug@npm:^2.6.9":
-  version: 2.6.9
-  resolution: "debug@npm:2.6.9"
-  dependencies:
-    ms: 2.0.0
-  checksum: d2f51589ca66df60bf36e1fa6e4386b318c3f1e06772280eea5b1ae9fd3d05e9c2b7fd8a7d862457d00853c75b00451aa2d7459b924629ee385287a650f58fe6
-  languageName: node
-  linkType: hard
-
-"debug@npm:3.2.6":
-  version: 3.2.6
-  resolution: "debug@npm:3.2.6"
-  dependencies:
-    ms: ^2.1.1
-  checksum: 07bc8b3a13ef3cfa6c06baf7871dfb174c291e5f85dbf566f086620c16b9c1a0e93bb8f1935ebbd07a683249e7e30286f2966e2ef461e8fd17b1b60732062d6b
-  languageName: node
-  linkType: hard
-
 "debug@npm:4, debug@npm:4.3.4, debug@npm:^4.0.1, debug@npm:^4.1.1, debug@npm:^4.3.1, debug@npm:^4.3.2, debug@npm:^4.3.3, debug@npm:^4.3.4":
   version: 4.3.4
   resolution: "debug@npm:4.3.4"
@@ -5483,6 +4086,15 @@ __metadata:
   languageName: node
   linkType: hard
 
+"debug@npm:^2.2.0":
+  version: 2.6.9
+  resolution: "debug@npm:2.6.9"
+  dependencies:
+    ms: 2.0.0
+  checksum: d2f51589ca66df60bf36e1fa6e4386b318c3f1e06772280eea5b1ae9fd3d05e9c2b7fd8a7d862457d00853c75b00451aa2d7459b924629ee385287a650f58fe6
+  languageName: node
+  linkType: hard
+
 "debug@npm:^3.1.0, debug@npm:^3.2.6, debug@npm:^3.2.7":
   version: 3.2.7
   resolution: "debug@npm:3.2.7"
@@ -5492,7 +4104,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"decamelize@npm:^1.1.1, decamelize@npm:^1.2.0":
+"decamelize@npm:^1.2.0":
   version: 1.2.0
   resolution: "decamelize@npm:1.2.0"
   checksum: ad8c51a7e7e0720c70ec2eeb1163b66da03e7616d7b98c9ef43cce2416395e84c1e9548dd94f5f6ffecfee9f8b94251fc57121a8b021f2ff2469b2bae247b8aa
@@ -5506,31 +4118,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"decode-uri-component@npm:^0.2.0":
-  version: 0.2.2
-  resolution: "decode-uri-component@npm:0.2.2"
-  checksum: 95476a7d28f267292ce745eac3524a9079058bbb35767b76e3ee87d42e34cd0275d2eb19d9d08c3e167f97556e8a2872747f5e65cbebcac8b0c98d83e285f139
-  languageName: node
-  linkType: hard
-
-"decompress-response@npm:^3.3.0":
-  version: 3.3.0
-  resolution: "decompress-response@npm:3.3.0"
-  dependencies:
-    mimic-response: ^1.0.0
-  checksum: 952552ac3bd7de2fc18015086b09468645c9638d98a551305e485230ada278c039c91116e946d07894b39ee53c0f0d5b6473f25a224029344354513b412d7380
-  languageName: node
-  linkType: hard
-
-"decompress-response@npm:^6.0.0":
-  version: 6.0.0
-  resolution: "decompress-response@npm:6.0.0"
-  dependencies:
-    mimic-response: ^3.1.0
-  checksum: d377cf47e02d805e283866c3f50d3d21578b779731e8c5072d6ce8c13cc31493db1c2f6784da9d1d5250822120cefa44f1deab112d5981015f2e17444b763812
-  languageName: node
-  linkType: hard
-
 "deep-eql@npm:^4.0.1, deep-eql@npm:^4.1.3":
   version: 4.1.3
   resolution: "deep-eql@npm:4.1.3"
@@ -5540,20 +4127,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"deep-equal@npm:~1.1.1":
-  version: 1.1.2
-  resolution: "deep-equal@npm:1.1.2"
-  dependencies:
-    is-arguments: ^1.1.1
-    is-date-object: ^1.0.5
-    is-regex: ^1.1.4
-    object-is: ^1.1.5
-    object-keys: ^1.1.1
-    regexp.prototype.flags: ^1.5.1
-  checksum: 2d50f27fff785fb272cdef038ee5365ee5a30ab1aab053976e6a6add44cc60abd99b38179a46a01ac52c5e54ebb220e8f1a3a1954da20678b79c46ef4d97c9db
-  languageName: node
-  linkType: hard
-
 "deep-extend@npm:~0.6.0":
   version: 0.6.0
   resolution: "deep-extend@npm:0.6.0"
@@ -5577,36 +4150,13 @@ __metadata:
   languageName: node
   linkType: hard
 
-"defer-to-connect@npm:^1.0.1":
-  version: 1.1.3
-  resolution: "defer-to-connect@npm:1.1.3"
-  checksum: 9491b301dcfa04956f989481ba7a43c2231044206269eb4ab64a52d6639ee15b1252262a789eb4239fb46ab63e44d4e408641bae8e0793d640aee55398cb3930
-  languageName: node
-  linkType: hard
-
-"defer-to-connect@npm:^2.0.0":
-  version: 2.0.1
-  resolution: "defer-to-connect@npm:2.0.1"
-  checksum: 8a9b50d2f25446c0bfefb55a48e90afd58f85b21bcf78e9207cd7b804354f6409032a1705c2491686e202e64fc05f147aa5aa45f9aa82627563f045937f5791b
-  languageName: node
-  linkType: hard
-
-"deferred-leveldown@npm:~1.2.1":
-  version: 1.2.2
-  resolution: "deferred-leveldown@npm:1.2.2"
-  dependencies:
-    abstract-leveldown: ~2.6.0
-  checksum: ad3a26d20dc80c702c85c4795cbb52ef25d8e500728c98098b468c499ca745051e6cc03bd12be97ff38c43466a7895879db76ffb761a75b0f009829d990a0ea9
-  languageName: node
-  linkType: hard
-
-"deferred-leveldown@npm:~4.0.0":
-  version: 4.0.2
-  resolution: "deferred-leveldown@npm:4.0.2"
+"deferred-leveldown@npm:~5.3.0":
+  version: 5.3.0
+  resolution: "deferred-leveldown@npm:5.3.0"
   dependencies:
-    abstract-leveldown: ~5.0.0
+    abstract-leveldown: ~6.2.1
     inherits: ^2.0.3
-  checksum: 6b3649bbb7a2617e08eecdddb516d0bde215bd376a37089df203ad78627f59c424c785afbcbfd3e53488d4f9e5d27d9d126d5645b7da53e8760cc34df2d2f13e
+  checksum: 5631e153528bb9de1aa60d59a5065d1a519374c5e4c1d486f2190dba4008dcf5c2ee8dd7f2f81396fc4d5a6bb6e7d0055e3dfe68afe00da02adaa3bf329addf7
   languageName: node
   linkType: hard
 
@@ -5632,41 +4182,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"define-property@npm:^0.2.5":
-  version: 0.2.5
-  resolution: "define-property@npm:0.2.5"
-  dependencies:
-    is-descriptor: ^0.1.0
-  checksum: 85af107072b04973b13f9e4128ab74ddfda48ec7ad2e54b193c0ffb57067c4ce5b7786a7b4ae1f24bd03e87c5d18766b094571810b314d7540f86d4354dbd394
-  languageName: node
-  linkType: hard
-
-"define-property@npm:^1.0.0":
-  version: 1.0.0
-  resolution: "define-property@npm:1.0.0"
-  dependencies:
-    is-descriptor: ^1.0.0
-  checksum: 5fbed11dace44dd22914035ba9ae83ad06008532ca814d7936a53a09e897838acdad5b108dd0688cc8d2a7cf0681acbe00ee4136cf36743f680d10517379350a
-  languageName: node
-  linkType: hard
-
-"define-property@npm:^2.0.2":
-  version: 2.0.2
-  resolution: "define-property@npm:2.0.2"
-  dependencies:
-    is-descriptor: ^1.0.2
-    isobject: ^3.0.1
-  checksum: 3217ed53fc9eed06ba8da6f4d33e28c68a82e2f2a8ab4d562c4920d8169a166fe7271453675e6c69301466f36a65d7f47edf0cf7f474b9aa52a5ead9c1b13c99
-  languageName: node
-  linkType: hard
-
-"defined@npm:~1.0.1":
-  version: 1.0.1
-  resolution: "defined@npm:1.0.1"
-  checksum: b1a852300bdb57f297289b55eafdd0c517afaa3ec8190e78fce91b9d8d0c0369d4505ecbdacfd3d98372e664f4a267d9bd793938d4a8c76209c9d9516fbe2101
-  languageName: node
-  linkType: hard
-
 "delay@npm:^5.0.0":
   version: 5.0.0
   resolution: "delay@npm:5.0.0"
@@ -5688,32 +4203,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"des.js@npm:^1.0.0":
-  version: 1.1.0
-  resolution: "des.js@npm:1.1.0"
-  dependencies:
-    inherits: ^2.0.1
-    minimalistic-assert: ^1.0.0
-  checksum: 0e9c1584b70d31e20f20a613fc9ef60fbc6a147dfec9e448a168794a4b97ac04d8dc47ea008f1fa93b0f8aaf7c1ead632a5e59ce1913a6079d2d244c9f5ebe33
-  languageName: node
-  linkType: hard
-
-"destroy@npm:1.2.0":
-  version: 1.2.0
-  resolution: "destroy@npm:1.2.0"
-  checksum: 0acb300b7478a08b92d810ab229d5afe0d2f4399272045ab22affa0d99dbaf12637659411530a6fcd597a9bdac718fc94373a61a95b4651bbc7b83684a565e38
-  languageName: node
-  linkType: hard
-
-"detect-indent@npm:^4.0.0":
-  version: 4.0.0
-  resolution: "detect-indent@npm:4.0.0"
-  dependencies:
-    repeating: ^2.0.0
-  checksum: 328f273915c1610899bc7d4784ce874413d0a698346364cd3ee5d79afba1c5cf4dbc97b85a801e20f4d903c0598bd5096af32b800dfb8696b81464ccb3dfda2c
-  languageName: node
-  linkType: hard
-
 "detect-port@npm:^1.3.0":
   version: 1.5.1
   resolution: "detect-port@npm:1.5.1"
@@ -5741,24 +4230,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"diff@npm:^5.0.0":
-  version: 5.1.0
-  resolution: "diff@npm:5.1.0"
-  checksum: c7bf0df7c9bfbe1cf8a678fd1b2137c4fb11be117a67bc18a0e03ae75105e8533dbfb1cda6b46beb3586ef5aed22143ef9d70713977d5fb1f9114e21455fba90
-  languageName: node
-  linkType: hard
-
-"diffie-hellman@npm:^5.0.0":
-  version: 5.0.3
-  resolution: "diffie-hellman@npm:5.0.3"
-  dependencies:
-    bn.js: ^4.1.0
-    miller-rabin: ^4.0.0
-    randombytes: ^2.0.0
-  checksum: 0e620f322170c41076e70181dd1c24e23b08b47dbb92a22a644f3b89b6d3834b0f8ee19e37916164e5eb1ee26d2aa836d6129f92723995267250a0b541811065
-  languageName: node
-  linkType: hard
-
 "difflib@npm:^0.2.4":
   version: 0.2.4
   resolution: "difflib@npm:0.2.4"
@@ -5838,13 +4309,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"dom-walk@npm:^0.1.0":
-  version: 0.1.2
-  resolution: "dom-walk@npm:0.1.2"
-  checksum: 19eb0ce9c6de39d5e231530685248545d9cd2bd97b2cb3486e0bfc0f2a393a9addddfd5557463a932b52fdfcf68ad2a619020cd2c74a5fe46fbecaa8e80872f3
-  languageName: node
-  linkType: hard
-
 "dotenv@npm:^16.0.1":
   version: 16.4.1
   resolution: "dotenv@npm:16.4.1"
@@ -5852,24 +4316,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"dotignore@npm:~0.1.2":
-  version: 0.1.2
-  resolution: "dotignore@npm:0.1.2"
-  dependencies:
-    minimatch: ^3.0.4
-  bin:
-    ignored: bin/ignored
-  checksum: 06bab15e2a2400c6f823a0edbcd73661180f6245a4041a3fe3b9fde4b22ae74b896604df4520a877093f05c656bd080087376c9f605bccdea847664c59910f37
-  languageName: node
-  linkType: hard
-
-"duplexer3@npm:^0.1.4":
-  version: 0.1.5
-  resolution: "duplexer3@npm:0.1.5"
-  checksum: e677cb4c48f031ca728601d6a20bf6aed4c629d69ef9643cb89c67583d673c4ec9317cc6427501f38bd8c368d3a18f173987cc02bd99d8cf8fe3d94259a22a20
-  languageName: node
-  linkType: hard
-
 "eastasianwidth@npm:^0.2.0":
   version: 0.2.0
   resolution: "eastasianwidth@npm:0.2.0"
@@ -5887,13 +4333,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"ee-first@npm:1.1.1":
-  version: 1.1.1
-  resolution: "ee-first@npm:1.1.1"
-  checksum: 1b4cac778d64ce3b582a7e26b218afe07e207a0f9bfe13cc7395a6d307849cfe361e65033c3251e00c27dd060cab43014c2d6b2647676135e18b77d2d05b3f4f
-  languageName: node
-  linkType: hard
-
 "ejs@npm:^2.6.1":
   version: 2.7.4
   resolution: "ejs@npm:2.7.4"
@@ -5910,14 +4349,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"electron-to-chromium@npm:^1.3.47":
-  version: 1.4.656
-  resolution: "electron-to-chromium@npm:1.4.656"
-  checksum: b9e00c81e74ee307141a216ef971efeff8784232a9eaa9074a65687b631029725f8f4ddeefd98c43287339cdadb6c7aba92c01806122f9cae813a95735fcd432
-  languageName: node
-  linkType: hard
-
-"elliptic@npm:6.5.4, elliptic@npm:^6.4.0, elliptic@npm:^6.5.2, elliptic@npm:^6.5.3, elliptic@npm:^6.5.4":
+"elliptic@npm:6.5.4, elliptic@npm:^6.5.2, elliptic@npm:^6.5.4":
   version: 6.5.4
   resolution: "elliptic@npm:6.5.4"
   dependencies:
@@ -5932,6 +4364,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"emittery@npm:0.10.0":
+  version: 0.10.0
+  resolution: "emittery@npm:0.10.0"
+  checksum: 2616a802df51e3f412b9b33f1b43161f7bc96037142cada6ecdbf35ddef1368e30d4f8e47fddc10b0753ccf91d3483b20ebca535b4b1e47526440e13150e2bc7
+  languageName: node
+  linkType: hard
+
 "emoji-regex@npm:^7.0.1":
   version: 7.0.3
   resolution: "emoji-regex@npm:7.0.3"
@@ -5953,27 +4392,19 @@ __metadata:
   languageName: node
   linkType: hard
 
-"encodeurl@npm:~1.0.2":
-  version: 1.0.2
-  resolution: "encodeurl@npm:1.0.2"
-  checksum: e50e3d508cdd9c4565ba72d2012e65038e5d71bdc9198cb125beb6237b5b1ade6c0d343998da9e170fb2eae52c1bed37d4d6d98a46ea423a0cddbed5ac3f780c
-  languageName: node
-  linkType: hard
-
-"encoding-down@npm:5.0.4, encoding-down@npm:~5.0.0":
-  version: 5.0.4
-  resolution: "encoding-down@npm:5.0.4"
+"encoding-down@npm:^6.3.0":
+  version: 6.3.0
+  resolution: "encoding-down@npm:6.3.0"
   dependencies:
-    abstract-leveldown: ^5.0.0
+    abstract-leveldown: ^6.2.1
     inherits: ^2.0.3
     level-codec: ^9.0.0
     level-errors: ^2.0.0
-    xtend: ^4.0.1
-  checksum: b8d9d4b058622c11e33d8ec0fb6432194925e109ed8e44e93555406496e8b77b294c8c338dd5ed9ab8d7bc50250a48bb93f9af62ecee3ce8d82f4ef78b2ca880
+  checksum: 74043e6d9061a470614ff61d708c849259ab32932a428fd5ddfb0878719804f56a52f59b31cccd95fddc2e636c0fd22dc3e02481fb98d5bf1bdbbbc44ca09bdc
   languageName: node
   linkType: hard
 
-"encoding@npm:^0.1.11, encoding@npm:^0.1.13":
+"encoding@npm:^0.1.13":
   version: 0.1.13
   resolution: "encoding@npm:0.1.13"
   dependencies:
@@ -6042,7 +4473,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"error-ex@npm:^1.2.0, error-ex@npm:^1.3.1":
+"error-ex@npm:^1.3.1":
   version: 1.3.2
   resolution: "error-ex@npm:1.3.2"
   dependencies:
@@ -6143,28 +4574,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"es5-ext@npm:^0.10.35, es5-ext@npm:^0.10.50":
-  version: 0.10.62
-  resolution: "es5-ext@npm:0.10.62"
-  dependencies:
-    es6-iterator: ^2.0.3
-    es6-symbol: ^3.1.3
-    next-tick: ^1.1.0
-  checksum: 25f42f6068cfc6e393cf670bc5bba249132c5f5ec2dd0ed6e200e6274aca2fed8e9aec8a31c76031744c78ca283c57f0b41c7e737804c6328c7b8d3fbcba7983
-  languageName: node
-  linkType: hard
-
-"es6-iterator@npm:^2.0.3":
-  version: 2.0.3
-  resolution: "es6-iterator@npm:2.0.3"
-  dependencies:
-    d: 1
-    es5-ext: ^0.10.35
-    es6-symbol: ^3.1.1
-  checksum: 6e48b1c2d962c21dee604b3d9f0bc3889f11ed5a8b33689155a2065d20e3107e2a69cc63a71bd125aeee3a589182f8bbcb5c8a05b6a8f38fa4205671b6d09697
-  languageName: node
-  linkType: hard
-
 "es6-promise@npm:^4.0.3":
   version: 4.2.8
   resolution: "es6-promise@npm:4.2.8"
@@ -6181,16 +4590,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"es6-symbol@npm:^3.1.1, es6-symbol@npm:^3.1.3":
-  version: 3.1.3
-  resolution: "es6-symbol@npm:3.1.3"
-  dependencies:
-    d: ^1.0.1
-    ext: ^1.1.2
-  checksum: cd49722c2a70f011eb02143ef1c8c70658d2660dead6641e160b94619f408b9cf66425515787ffe338affdf0285ad54f4eae30ea5bd510e33f8659ec53bcaa70
-  languageName: node
-  linkType: hard
-
 "escalade@npm:^3.1.1":
   version: 3.1.1
   resolution: "escalade@npm:3.1.1"
@@ -6198,13 +4597,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"escape-html@npm:~1.0.3":
-  version: 1.0.3
-  resolution: "escape-html@npm:1.0.3"
-  checksum: 6213ca9ae00d0ab8bccb6d8d4e0a98e76237b2410302cf7df70aaa6591d509a2a37ce8998008cbecae8fc8ffaadf3fb0229535e6a145f3ce0b211d060decbb24
-  languageName: node
-  linkType: hard
-
 "escape-string-regexp@npm:4.0.0, escape-string-regexp@npm:^4.0.0":
   version: 4.0.0
   resolution: "escape-string-regexp@npm:4.0.0"
@@ -6212,7 +4604,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"escape-string-regexp@npm:^1.0.2, escape-string-regexp@npm:^1.0.5":
+"escape-string-regexp@npm:^1.0.5":
   version: 1.0.5
   resolution: "escape-string-regexp@npm:1.0.5"
   checksum: 6092fda75c63b110c706b6a9bfde8a612ad595b628f0bd2147eea1d3406723020810e591effc7db1da91d80a71a737a313567c5abb3813e8d9c71f4aa595b410
@@ -6682,189 +5074,35 @@ __metadata:
   linkType: hard
 
 "esutils@npm:^2.0.2":
-  version: 2.0.3
-  resolution: "esutils@npm:2.0.3"
-  checksum: 22b5b08f74737379a840b8ed2036a5fb35826c709ab000683b092d9054e5c2a82c27818f12604bfc2a9a76b90b6834ef081edbc1c7ae30d1627012e067c6ec87
-  languageName: node
-  linkType: hard
-
-"etag@npm:~1.8.1":
-  version: 1.8.1
-  resolution: "etag@npm:1.8.1"
-  checksum: 571aeb3dbe0f2bbd4e4fadbdb44f325fc75335cd5f6f6b6a091e6a06a9f25ed5392f0863c5442acb0646787446e816f13cbfc6edce5b07658541dff573cab1ff
-  languageName: node
-  linkType: hard
-
-"eth-block-tracker@npm:^3.0.0":
-  version: 3.0.1
-  resolution: "eth-block-tracker@npm:3.0.1"
-  dependencies:
-    eth-query: ^2.1.0
-    ethereumjs-tx: ^1.3.3
-    ethereumjs-util: ^5.1.3
-    ethjs-util: ^0.1.3
-    json-rpc-engine: ^3.6.0
-    pify: ^2.3.0
-    tape: ^4.6.3
-  checksum: b68dda7a60e2c15fa7097f31277ebfce08852de83229c2c65879a5482db28610bc85248cfe6578971ad2357552d5ce6124fb0c2a29d18fd30c70f092beeda3b8
-  languageName: node
-  linkType: hard
-
-"eth-ens-namehash@npm:2.0.8, eth-ens-namehash@npm:^2.0.8":
-  version: 2.0.8
-  resolution: "eth-ens-namehash@npm:2.0.8"
-  dependencies:
-    idna-uts46-hx: ^2.3.1
-    js-sha3: ^0.5.7
-  checksum: 40ce4aeedaa4e7eb4485c8d8857457ecc46a4652396981d21b7e3a5f922d5beff63c71cb4b283c935293e530eba50b329d9248be3c433949c6bc40c850c202a3
-  languageName: node
-  linkType: hard
-
-"eth-gas-reporter@npm:^0.2.25":
-  version: 0.2.27
-  resolution: "eth-gas-reporter@npm:0.2.27"
-  dependencies:
-    "@solidity-parser/parser": ^0.14.0
-    axios: ^1.5.1
-    cli-table3: ^0.5.0
-    colors: 1.4.0
-    ethereum-cryptography: ^1.0.3
-    ethers: ^5.7.2
-    fs-readdir-recursive: ^1.1.0
-    lodash: ^4.17.14
-    markdown-table: ^1.1.3
-    mocha: ^10.2.0
-    req-cwd: ^2.0.0
-    sha1: ^1.1.1
-    sync-request: ^6.0.0
-  peerDependencies:
-    "@codechecks/client": ^0.1.0
-  peerDependenciesMeta:
-    "@codechecks/client":
-      optional: true
-  checksum: 9a26a4936693de6dbe633a9e6f9d69eb93c9d45c61ecbc20702a72f15ade424785e29ae8e62ea3a2afc49ea22a4777a71914dc8da1b8587e9d47d085a3246784
-  languageName: node
-  linkType: hard
-
-"eth-json-rpc-infura@npm:^3.1.0":
-  version: 3.2.1
-  resolution: "eth-json-rpc-infura@npm:3.2.1"
-  dependencies:
-    cross-fetch: ^2.1.1
-    eth-json-rpc-middleware: ^1.5.0
-    json-rpc-engine: ^3.4.0
-    json-rpc-error: ^2.0.0
-  checksum: 393e825986c0eedb9a1bb771b84e5b7c4037d8f870ab92cdba9dbaa52b5c7d5755ed02fd80d2a07b5db7a3af2c0b30d37756eb39cd7d2ae39173c6c2ea138e7d
-  languageName: node
-  linkType: hard
-
-"eth-json-rpc-middleware@npm:^1.5.0":
-  version: 1.6.0
-  resolution: "eth-json-rpc-middleware@npm:1.6.0"
-  dependencies:
-    async: ^2.5.0
-    eth-query: ^2.1.2
-    eth-tx-summary: ^3.1.2
-    ethereumjs-block: ^1.6.0
-    ethereumjs-tx: ^1.3.3
-    ethereumjs-util: ^5.1.2
-    ethereumjs-vm: ^2.1.0
-    fetch-ponyfill: ^4.0.0
-    json-rpc-engine: ^3.6.0
-    json-rpc-error: ^2.0.0
-    json-stable-stringify: ^1.0.1
-    promise-to-callback: ^1.0.0
-    tape: ^4.6.3
-  checksum: 0f6c146bdb277b3be9eef68f7424e1709a57f58330a3ae076153313be60f5026a5eee0de16d1ee6e41515e76cb1d38ef590948dd55d4b3ab1b3659af61337922
-  languageName: node
-  linkType: hard
-
-"eth-lib@npm:0.2.8":
-  version: 0.2.8
-  resolution: "eth-lib@npm:0.2.8"
-  dependencies:
-    bn.js: ^4.11.6
-    elliptic: ^6.4.0
-    xhr-request-promise: ^0.1.2
-  checksum: be7efb0b08a78e20d12d2892363ecbbc557a367573ac82fc26a549a77a1b13c7747e6eadbb88026634828fcf9278884b555035787b575b1cab5e6958faad0fad
-  languageName: node
-  linkType: hard
-
-"eth-lib@npm:^0.1.26":
-  version: 0.1.29
-  resolution: "eth-lib@npm:0.1.29"
-  dependencies:
-    bn.js: ^4.11.6
-    elliptic: ^6.4.0
-    nano-json-stream-parser: ^0.1.2
-    servify: ^0.1.12
-    ws: ^3.0.0
-    xhr-request-promise: ^0.1.2
-  checksum: d1494fc0af372d46d1c9e7506cfbfa81b9073d98081cf4cbe518932f88bee40cf46a764590f1f8aba03d4a534fa2b1cd794fa2a4f235f656d82b8ab185b5cb9d
-  languageName: node
-  linkType: hard
-
-"eth-query@npm:^2.0.2, eth-query@npm:^2.1.0, eth-query@npm:^2.1.2":
-  version: 2.1.2
-  resolution: "eth-query@npm:2.1.2"
-  dependencies:
-    json-rpc-random-id: ^1.0.0
-    xtend: ^4.0.1
-  checksum: 83daa0e28452c54722aec78cd24d036bad5b6e7c08035d98e10d4bea11f71662f12cab63ebd8a848d4df46ad316503d54ecccb41c9244d2ea8b29364b0a20201
-  languageName: node
-  linkType: hard
-
-"eth-sig-util@npm:3.0.0":
-  version: 3.0.0
-  resolution: "eth-sig-util@npm:3.0.0"
-  dependencies:
-    buffer: ^5.2.1
-    elliptic: ^6.4.0
-    ethereumjs-abi: 0.6.5
-    ethereumjs-util: ^5.1.1
-    tweetnacl: ^1.0.0
-    tweetnacl-util: ^0.15.0
-  checksum: fbe44efb7909737b070e1e1d8c7096da3bdbd1356de242fc3458849e042e39c83a4e2dd1cbce0dc21ff3e5eca1843981751428bc160dcf3a6fcca2f1e8161be4
-  languageName: node
-  linkType: hard
-
-"eth-sig-util@npm:^1.4.2":
-  version: 1.4.2
-  resolution: "eth-sig-util@npm:1.4.2"
-  dependencies:
-    ethereumjs-abi: "git+https://github.com/ethereumjs/ethereumjs-abi.git"
-    ethereumjs-util: ^5.1.1
-  checksum: 578f5c571c1bb0a86dc1bd4a5b56b8073b37823496d7afa74d772cf91ae6860f91bafcbee931be39a3d13f0c195df9f026a27fce350605ad5d15901a5a4ea94a
-  languageName: node
-  linkType: hard
-
-"eth-tx-summary@npm:^3.1.2":
-  version: 3.2.4
-  resolution: "eth-tx-summary@npm:3.2.4"
-  dependencies:
-    async: ^2.1.2
-    clone: ^2.0.0
-    concat-stream: ^1.5.1
-    end-of-stream: ^1.1.0
-    eth-query: ^2.0.2
-    ethereumjs-block: ^1.4.1
-    ethereumjs-tx: ^1.1.1
-    ethereumjs-util: ^5.0.1
-    ethereumjs-vm: ^2.6.0
-    through2: ^2.0.3
-  checksum: 7df8b91bc2bd3f6941e2a5b3230cad5c5523ca3750190cd06af07983feba1bb4af893f226f01072958b00aa626869846894bcb1bfaa451d9c8f7f5b8cdf5ce0a
+  version: 2.0.3
+  resolution: "esutils@npm:2.0.3"
+  checksum: 22b5b08f74737379a840b8ed2036a5fb35826c709ab000683b092d9054e5c2a82c27818f12604bfc2a9a76b90b6834ef081edbc1c7ae30d1627012e067c6ec87
   languageName: node
   linkType: hard
 
-"ethashjs@npm:~0.0.7":
-  version: 0.0.8
-  resolution: "ethashjs@npm:0.0.8"
+"eth-gas-reporter@npm:^0.2.25":
+  version: 0.2.27
+  resolution: "eth-gas-reporter@npm:0.2.27"
   dependencies:
-    async: ^2.1.2
-    buffer-xor: ^2.0.1
-    ethereumjs-util: ^7.0.2
-    miller-rabin: ^4.0.0
-  checksum: d9b6b47d32cbe017848ce5d8aec86eb6416300c6f52a68029bf6fc8fcf5429a45c14f2033d514435acd02047af16f6f804056e81587b30ed677039ac678b15f8
+    "@solidity-parser/parser": ^0.14.0
+    axios: ^1.5.1
+    cli-table3: ^0.5.0
+    colors: 1.4.0
+    ethereum-cryptography: ^1.0.3
+    ethers: ^5.7.2
+    fs-readdir-recursive: ^1.1.0
+    lodash: ^4.17.14
+    markdown-table: ^1.1.3
+    mocha: ^10.2.0
+    req-cwd: ^2.0.0
+    sha1: ^1.1.1
+    sync-request: ^6.0.0
+  peerDependencies:
+    "@codechecks/client": ^0.1.0
+  peerDependenciesMeta:
+    "@codechecks/client":
+      optional: true
+  checksum: 9a26a4936693de6dbe633a9e6f9d69eb93c9d45c61ecbc20702a72f15ade424785e29ae8e62ea3a2afc49ea22a4777a71914dc8da1b8587e9d47d085a3246784
   languageName: node
   linkType: hard
 
@@ -6877,20 +5115,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"ethereum-common@npm:0.2.0":
-  version: 0.2.0
-  resolution: "ethereum-common@npm:0.2.0"
-  checksum: 5e80af27482530ac700676502cd4c02a7248c064999d01dced302f5f40a180c86f57caaab347dbd12482c2869539d321c8c0039db9e3dfb1411e6ad3d57b2547
-  languageName: node
-  linkType: hard
-
-"ethereum-common@npm:^0.0.18":
-  version: 0.0.18
-  resolution: "ethereum-common@npm:0.0.18"
-  checksum: 2244126199604abc17508ca249c6f8a66a2ed02e9c97115f234e311f42e2d67aedff08128569fa3dfb8a2d09e1c194eace39a1ce61bfeb2338b6d3f2ac324ee8
-  languageName: node
-  linkType: hard
-
 "ethereum-cryptography@npm:0.1.3, ethereum-cryptography@npm:^0.1.3":
   version: 0.1.3
   resolution: "ethereum-cryptography@npm:0.1.3"
@@ -6938,38 +5162,21 @@ __metadata:
   languageName: node
   linkType: hard
 
-"ethereum-waffle@npm:^3.4.4":
-  version: 3.4.4
-  resolution: "ethereum-waffle@npm:3.4.4"
+"ethereum-waffle@npm:latest":
+  version: 4.0.10
+  resolution: "ethereum-waffle@npm:4.0.10"
   dependencies:
-    "@ethereum-waffle/chai": ^3.4.4
-    "@ethereum-waffle/compiler": ^3.4.4
-    "@ethereum-waffle/mock-contract": ^3.4.4
-    "@ethereum-waffle/provider": ^3.4.4
-    ethers: ^5.0.1
+    "@ethereum-waffle/chai": 4.0.10
+    "@ethereum-waffle/compiler": 4.0.3
+    "@ethereum-waffle/mock-contract": 4.0.4
+    "@ethereum-waffle/provider": 4.0.5
+    solc: 0.8.15
+    typechain: ^8.0.0
+  peerDependencies:
+    ethers: "*"
   bin:
     waffle: bin/waffle
-  checksum: 5a181b52f66f1b3c89ed1b68ef44cbd9acd4d743262de9edbe1fd57b0925576dd62c3436b1e65434d5ac03ab16da0df283972cd9aae726de0b8b9cdd7876b917
-  languageName: node
-  linkType: hard
-
-"ethereumjs-abi@git+https://github.com/ethereumjs/ethereumjs-abi.git":
-  version: 0.6.8
-  resolution: "ethereumjs-abi@https://github.com/ethereumjs/ethereumjs-abi.git#commit=ee3994657fa7a427238e6ba92a84d0b529bbcde0"
-  dependencies:
-    bn.js: ^4.11.8
-    ethereumjs-util: ^6.0.0
-  checksum: ae074be0bb012857ab5d3ae644d1163b908a48dd724b7d2567cfde309dc72222d460438f2411936a70dc949dc604ce1ef7118f7273bd525815579143c907e336
-  languageName: node
-  linkType: hard
-
-"ethereumjs-abi@npm:0.6.5":
-  version: 0.6.5
-  resolution: "ethereumjs-abi@npm:0.6.5"
-  dependencies:
-    bn.js: ^4.10.0
-    ethereumjs-util: ^4.3.0
-  checksum: 3abdc79dc60614d30b1cefb5e6bfbdab3ca8252b4e742330544103f86d6e49a55921d9b8822a0a47fee3efd9dd2493ec93448b1869d82479a4c71a44001e8337
+  checksum: 680df4f5cf61f2f64b740d7724323e0872b1b1462e7ee2f1de6a1c9732155b28c4ac25c669ba557f72e1bb20204f81696a1fd543aece03654d71a9d9ebe1fc53
   languageName: node
   linkType: hard
 
@@ -6983,107 +5190,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"ethereumjs-account@npm:3.0.0, ethereumjs-account@npm:^3.0.0":
-  version: 3.0.0
-  resolution: "ethereumjs-account@npm:3.0.0"
-  dependencies:
-    ethereumjs-util: ^6.0.0
-    rlp: ^2.2.1
-    safe-buffer: ^5.1.1
-  checksum: 64dbe026d29aca12c79596cf4085fb27e209988f11b7d5bf3a1f2aadaaa517d90d722680c8b525144c26a2d9cd8494aa26ac088fa80b358cc3e28024f7ddbe81
-  languageName: node
-  linkType: hard
-
-"ethereumjs-account@npm:^2.0.3":
-  version: 2.0.5
-  resolution: "ethereumjs-account@npm:2.0.5"
-  dependencies:
-    ethereumjs-util: ^5.0.0
-    rlp: ^2.0.0
-    safe-buffer: ^5.1.1
-  checksum: 2e4546b8b0213168eebd3a5296da904b6f55470e39b4c742d252748927d2b268f8d6374b0178c1d5b7188646f97dae74a7ac1c7485fe96ea557c152b52223f18
-  languageName: node
-  linkType: hard
-
-"ethereumjs-block@npm:2.2.2, ethereumjs-block@npm:^2.2.2, ethereumjs-block@npm:~2.2.0, ethereumjs-block@npm:~2.2.2":
-  version: 2.2.2
-  resolution: "ethereumjs-block@npm:2.2.2"
-  dependencies:
-    async: ^2.0.1
-    ethereumjs-common: ^1.5.0
-    ethereumjs-tx: ^2.1.1
-    ethereumjs-util: ^5.0.0
-    merkle-patricia-tree: ^2.1.2
-  checksum: 91f7f60820394e072c9a115da2871a096414644109d2449d4a79b30be67b0080bc848dfa7e2ae7b2ab255de3be4f6736c6cb2b418c29eada794d018cc384e189
-  languageName: node
-  linkType: hard
-
-"ethereumjs-block@npm:^1.2.2, ethereumjs-block@npm:^1.4.1, ethereumjs-block@npm:^1.6.0":
-  version: 1.7.1
-  resolution: "ethereumjs-block@npm:1.7.1"
-  dependencies:
-    async: ^2.0.1
-    ethereum-common: 0.2.0
-    ethereumjs-tx: ^1.2.2
-    ethereumjs-util: ^5.0.0
-    merkle-patricia-tree: ^2.1.2
-  checksum: 9967c3674af77ea8475a3c023fa160ef6b614450ec50fa32ac083909ead22d3d1c3148f9407b6593d3ccfbe0c51f889c26aa1c15b17026fc2d35cbc542822af8
-  languageName: node
-  linkType: hard
-
-"ethereumjs-blockchain@npm:^4.0.3":
-  version: 4.0.4
-  resolution: "ethereumjs-blockchain@npm:4.0.4"
-  dependencies:
-    async: ^2.6.1
-    ethashjs: ~0.0.7
-    ethereumjs-block: ~2.2.2
-    ethereumjs-common: ^1.5.0
-    ethereumjs-util: ^6.1.0
-    flow-stoplight: ^1.0.0
-    level-mem: ^3.0.1
-    lru-cache: ^5.1.1
-    rlp: ^2.2.2
-    semaphore: ^1.1.0
-  checksum: efa04b2e2d02ce9c524f246f862b1ca779bbfd9f795cc7a9e471f0d96229de5188f1f6b17e54948f640100116b646ed03242494c23cd66f0f7e8384a4f217ba4
-  languageName: node
-  linkType: hard
-
-"ethereumjs-common@npm:1.5.0":
-  version: 1.5.0
-  resolution: "ethereumjs-common@npm:1.5.0"
-  checksum: a30474986a88b8f3ee53f9fb34027528f12d1bc7ecee8b80aa8060a09ccde3b2af4dd24c928287018003e4e206cd4f6311cdd508442d1452d02ec3d8e7a0601e
-  languageName: node
-  linkType: hard
-
-"ethereumjs-common@npm:^1.1.0, ethereumjs-common@npm:^1.3.2, ethereumjs-common@npm:^1.5.0":
-  version: 1.5.2
-  resolution: "ethereumjs-common@npm:1.5.2"
-  checksum: 3fc64faced268e0c61da50c5db76d18cfd44325d5706792f32ac8c85c0e800d52db284f042c3bd0623daf59b946176ef7dbea476d1b0252492137fa4549a3349
-  languageName: node
-  linkType: hard
-
-"ethereumjs-tx@npm:2.1.2, ethereumjs-tx@npm:^2.1.1, ethereumjs-tx@npm:^2.1.2":
-  version: 2.1.2
-  resolution: "ethereumjs-tx@npm:2.1.2"
-  dependencies:
-    ethereumjs-common: ^1.5.0
-    ethereumjs-util: ^6.0.0
-  checksum: a5b607b4e125ed696d76a9e4db8a95e03a967323c66694912d799619b16fa43985336924221f9e7582dc1b09ff88a62116bf2290ee14d952bf7e6715e5728525
-  languageName: node
-  linkType: hard
-
-"ethereumjs-tx@npm:^1.1.1, ethereumjs-tx@npm:^1.2.0, ethereumjs-tx@npm:^1.2.2, ethereumjs-tx@npm:^1.3.3":
-  version: 1.3.7
-  resolution: "ethereumjs-tx@npm:1.3.7"
-  dependencies:
-    ethereum-common: ^0.0.18
-    ethereumjs-util: ^5.0.0
-  checksum: fe2323fe7db7f5dda85715dc67c31dd1f2925bf5a88e393ba939dbe699b73df008f1332f711b1aa37e943193acf3b6976202a33f2fab1f7675b6d2dd70f424d4
-  languageName: node
-  linkType: hard
-
-"ethereumjs-util@npm:6.2.1, ethereumjs-util@npm:^6.0.0, ethereumjs-util@npm:^6.1.0, ethereumjs-util@npm:^6.2.0, ethereumjs-util@npm:^6.2.1":
+"ethereumjs-util@npm:6.2.1, ethereumjs-util@npm:^6.0.0, ethereumjs-util@npm:^6.2.1":
   version: 6.2.1
   resolution: "ethereumjs-util@npm:6.2.1"
   dependencies:
@@ -7098,35 +5205,20 @@ __metadata:
   languageName: node
   linkType: hard
 
-"ethereumjs-util@npm:^4.3.0":
-  version: 4.5.1
-  resolution: "ethereumjs-util@npm:4.5.1"
-  dependencies:
-    bn.js: ^4.8.0
-    create-hash: ^1.1.2
-    elliptic: ^6.5.2
-    ethereum-cryptography: ^0.1.3
-    rlp: ^2.0.0
-  checksum: ee91fbd29634d40cad9adf90f202158324c089bbc10b405d2ef139f4542090e6f76a616d16c601b52d6b5c5d59ddb6c8387cf60cc732884e732dad9a62b8a539
-  languageName: node
-  linkType: hard
-
-"ethereumjs-util@npm:^5.0.0, ethereumjs-util@npm:^5.0.1, ethereumjs-util@npm:^5.1.1, ethereumjs-util@npm:^5.1.2, ethereumjs-util@npm:^5.1.3, ethereumjs-util@npm:^5.1.5, ethereumjs-util@npm:^5.2.0":
-  version: 5.2.1
-  resolution: "ethereumjs-util@npm:5.2.1"
+"ethereumjs-util@npm:7.1.3":
+  version: 7.1.3
+  resolution: "ethereumjs-util@npm:7.1.3"
   dependencies:
-    bn.js: ^4.11.0
+    "@types/bn.js": ^5.1.0
+    bn.js: ^5.1.2
     create-hash: ^1.1.2
-    elliptic: ^6.5.2
     ethereum-cryptography: ^0.1.3
-    ethjs-util: ^0.1.3
-    rlp: ^2.0.0
-    safe-buffer: ^5.1.1
-  checksum: 20db6c639d92b35739fd5f7a71e64a92e85442ea0d176b59b5cd5828265b6cf42bd4868cf81a9b20a83738db1ffa7a2f778f1d850d663627a1a5209f7904b44f
+    rlp: ^2.2.4
+  checksum: 6de7a32af05c7265c96163ecd15ad97327afab9deb36092ef26250616657a8c0b5df8e698328247c8193e7b87c643c967f64f0b3cff2b2937cafa870ff5fcb41
   languageName: node
   linkType: hard
 
-"ethereumjs-util@npm:^7.0.2, ethereumjs-util@npm:^7.0.3":
+"ethereumjs-util@npm:^7.0.3, ethereumjs-util@npm:^7.1.1, ethereumjs-util@npm:^7.1.3, ethereumjs-util@npm:^7.1.4, ethereumjs-util@npm:^7.1.5":
   version: 7.1.5
   resolution: "ethereumjs-util@npm:7.1.5"
   dependencies:
@@ -7139,66 +5231,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"ethereumjs-vm@npm:4.2.0":
-  version: 4.2.0
-  resolution: "ethereumjs-vm@npm:4.2.0"
-  dependencies:
-    async: ^2.1.2
-    async-eventemitter: ^0.2.2
-    core-js-pure: ^3.0.1
-    ethereumjs-account: ^3.0.0
-    ethereumjs-block: ^2.2.2
-    ethereumjs-blockchain: ^4.0.3
-    ethereumjs-common: ^1.5.0
-    ethereumjs-tx: ^2.1.2
-    ethereumjs-util: ^6.2.0
-    fake-merkle-patricia-tree: ^1.0.1
-    functional-red-black-tree: ^1.0.1
-    merkle-patricia-tree: ^2.3.2
-    rustbn.js: ~0.2.0
-    safe-buffer: ^5.1.1
-    util.promisify: ^1.0.0
-  checksum: ca73c406d55baefacafbdd8cefce80740098e5834096042e93285dc386ee670b4fed2f7846b78e3078fdf41231d04b3f1c40e435e639d072e0529ccb560b797b
-  languageName: node
-  linkType: hard
-
-"ethereumjs-vm@npm:^2.1.0, ethereumjs-vm@npm:^2.3.4, ethereumjs-vm@npm:^2.6.0":
-  version: 2.6.0
-  resolution: "ethereumjs-vm@npm:2.6.0"
-  dependencies:
-    async: ^2.1.2
-    async-eventemitter: ^0.2.2
-    ethereumjs-account: ^2.0.3
-    ethereumjs-block: ~2.2.0
-    ethereumjs-common: ^1.1.0
-    ethereumjs-util: ^6.0.0
-    fake-merkle-patricia-tree: ^1.0.1
-    functional-red-black-tree: ^1.0.1
-    merkle-patricia-tree: ^2.3.2
-    rustbn.js: ~0.2.0
-    safe-buffer: ^5.1.1
-  checksum: 3b3098b2ac3d5335797e4d73fceb76d1b776e453abb5fa4d1cd94f6391f493e95e3c89a8ee602558bc2a3b36b89977e66473de73faa87c8540b1954aa7b8c3fd
-  languageName: node
-  linkType: hard
-
-"ethereumjs-wallet@npm:0.6.5":
-  version: 0.6.5
-  resolution: "ethereumjs-wallet@npm:0.6.5"
-  dependencies:
-    aes-js: ^3.1.1
-    bs58check: ^2.1.2
-    ethereum-cryptography: ^0.1.3
-    ethereumjs-util: ^6.0.0
-    randombytes: ^2.0.6
-    safe-buffer: ^5.1.2
-    scryptsy: ^1.2.1
-    utf8: ^3.0.0
-    uuid: ^3.3.2
-  checksum: 54a9cc8beb8ea55e9be9b024b6ed09349423145fd8c49b8662d60d9258039330163c830fec055f92becc71ea54b430d2ef29f6bd73fa49d93ea854af01d13e58
-  languageName: node
-  linkType: hard
-
-"ethers@npm:^5.0.1, ethers@npm:^5.0.2, ethers@npm:^5.5.2, ethers@npm:^5.6.9, ethers@npm:^5.7.1, ethers@npm:^5.7.2":
+"ethers-v5@npm:ethers@^5.7.0, ethers@npm:^5.7.2":
   version: 5.7.2
   resolution: "ethers@npm:5.7.2"
   dependencies:
@@ -7236,6 +5269,21 @@ __metadata:
   languageName: node
   linkType: hard
 
+"ethers@npm:^6.6.0":
+  version: 6.11.1
+  resolution: "ethers@npm:6.11.1"
+  dependencies:
+    "@adraffy/ens-normalize": 1.10.1
+    "@noble/curves": 1.2.0
+    "@noble/hashes": 1.3.2
+    "@types/node": 18.15.13
+    aes-js: 4.0.0-beta.5
+    tslib: 2.4.0
+    ws: 8.5.0
+  checksum: e8027c5071ad0370c61a1978f0602ab950d840c5923948f55e88b9808300e4e02e792bb793ea109ce7fa0e748f30a40a05f1202204a2b0402cdffbcb64a218e4
+  languageName: node
+  linkType: hard
+
 "ethjs-unit@npm:0.1.6":
   version: 0.1.6
   resolution: "ethjs-unit@npm:0.1.6"
@@ -7246,7 +5294,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"ethjs-util@npm:0.1.6, ethjs-util@npm:^0.1.3, ethjs-util@npm:^0.1.6":
+"ethjs-util@npm:0.1.6, ethjs-util@npm:^0.1.6":
   version: 0.1.6
   resolution: "ethjs-util@npm:0.1.6"
   dependencies:
@@ -7263,21 +5311,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"eventemitter3@npm:4.0.4":
-  version: 4.0.4
-  resolution: "eventemitter3@npm:4.0.4"
-  checksum: 7afb1cd851d19898bc99cc55ca894fe18cb1f8a07b0758652830a09bd6f36082879a25345be6219b81d74764140688b1a8fa75bcd1073d96b9a6661e444bc2ea
-  languageName: node
-  linkType: hard
-
-"events@npm:^3.0.0":
-  version: 3.3.0
-  resolution: "events@npm:3.3.0"
-  checksum: f6f487ad2198aa41d878fa31452f1a3c00958f46e9019286ff4787c84aac329332ab45c9cdc8c445928fc6d7ded294b9e005a7fce9426488518017831b272780
-  languageName: node
-  linkType: hard
-
-"evp_bytestokey@npm:^1.0.0, evp_bytestokey@npm:^1.0.3":
+"evp_bytestokey@npm:^1.0.3":
   version: 1.0.3
   resolution: "evp_bytestokey@npm:1.0.3"
   dependencies:
@@ -7321,21 +5355,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"expand-brackets@npm:^2.1.4":
-  version: 2.1.4
-  resolution: "expand-brackets@npm:2.1.4"
-  dependencies:
-    debug: ^2.3.3
-    define-property: ^0.2.5
-    extend-shallow: ^2.0.1
-    posix-character-classes: ^0.1.0
-    regex-not: ^1.0.0
-    snapdragon: ^0.8.1
-    to-regex: ^3.0.1
-  checksum: 1781d422e7edfa20009e2abda673cadb040a6037f0bd30fcd7357304f4f0c284afd420d7622722ca4a016f39b6d091841ab57b401c1f7e2e5131ac65b9f14fa1
-  languageName: node
-  linkType: hard
-
 "exponential-backoff@npm:^3.1.1":
   version: 3.1.1
   resolution: "exponential-backoff@npm:3.1.1"
@@ -7343,73 +5362,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"express@npm:^4.14.0":
-  version: 4.18.2
-  resolution: "express@npm:4.18.2"
-  dependencies:
-    accepts: ~1.3.8
-    array-flatten: 1.1.1
-    body-parser: 1.20.1
-    content-disposition: 0.5.4
-    content-type: ~1.0.4
-    cookie: 0.5.0
-    cookie-signature: 1.0.6
-    debug: 2.6.9
-    depd: 2.0.0
-    encodeurl: ~1.0.2
-    escape-html: ~1.0.3
-    etag: ~1.8.1
-    finalhandler: 1.2.0
-    fresh: 0.5.2
-    http-errors: 2.0.0
-    merge-descriptors: 1.0.1
-    methods: ~1.1.2
-    on-finished: 2.4.1
-    parseurl: ~1.3.3
-    path-to-regexp: 0.1.7
-    proxy-addr: ~2.0.7
-    qs: 6.11.0
-    range-parser: ~1.2.1
-    safe-buffer: 5.2.1
-    send: 0.18.0
-    serve-static: 1.15.0
-    setprototypeof: 1.2.0
-    statuses: 2.0.1
-    type-is: ~1.6.18
-    utils-merge: 1.0.1
-    vary: ~1.1.2
-  checksum: 3c4b9b076879442f6b968fe53d85d9f1eeacbb4f4c41e5f16cc36d77ce39a2b0d81b3f250514982110d815b2f7173f5561367f9110fcc541f9371948e8c8b037
-  languageName: node
-  linkType: hard
-
-"ext@npm:^1.1.2":
-  version: 1.7.0
-  resolution: "ext@npm:1.7.0"
-  dependencies:
-    type: ^2.7.2
-  checksum: ef481f9ef45434d8c867cfd09d0393b60945b7c8a1798bedc4514cb35aac342ccb8d8ecb66a513e6a2b4ec1e294a338e3124c49b29736f8e7c735721af352c31
-  languageName: node
-  linkType: hard
-
-"extend-shallow@npm:^2.0.1":
-  version: 2.0.1
-  resolution: "extend-shallow@npm:2.0.1"
-  dependencies:
-    is-extendable: ^0.1.0
-  checksum: 8fb58d9d7a511f4baf78d383e637bd7d2e80843bd9cd0853649108ea835208fb614da502a553acc30208e1325240bb7cc4a68473021612496bb89725483656d8
-  languageName: node
-  linkType: hard
-
-"extend-shallow@npm:^3.0.0, extend-shallow@npm:^3.0.2":
-  version: 3.0.2
-  resolution: "extend-shallow@npm:3.0.2"
-  dependencies:
-    assign-symbols: ^1.0.0
-    is-extendable: ^1.0.1
-  checksum: a920b0cd5838a9995ace31dfd11ab5e79bf6e295aa566910ce53dff19f4b1c0fda2ef21f26b28586c7a2450ca2b42d97bd8c0f5cec9351a819222bf861e02461
-  languageName: node
-  linkType: hard
-
 "extend@npm:~3.0.2":
   version: 3.0.2
   resolution: "extend@npm:3.0.2"
@@ -7428,22 +5380,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"extglob@npm:^2.0.4":
-  version: 2.0.4
-  resolution: "extglob@npm:2.0.4"
-  dependencies:
-    array-unique: ^0.3.2
-    define-property: ^1.0.0
-    expand-brackets: ^2.1.4
-    extend-shallow: ^2.0.1
-    fragment-cache: ^0.2.1
-    regex-not: ^1.0.0
-    snapdragon: ^0.8.1
-    to-regex: ^3.0.1
-  checksum: a41531b8934735b684cef5e8c5a01d0f298d7d384500ceca38793a9ce098125aab04ee73e2d75d5b2901bc5dddd2b64e1b5e3bf19139ea48bac52af4a92f1d00
-  languageName: node
-  linkType: hard
-
 "extsprintf@npm:1.3.0":
   version: 1.3.0
   resolution: "extsprintf@npm:1.3.0"
@@ -7465,15 +5401,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"fake-merkle-patricia-tree@npm:^1.0.1":
-  version: 1.0.1
-  resolution: "fake-merkle-patricia-tree@npm:1.0.1"
-  dependencies:
-    checkpoint-store: ^1.1.0
-  checksum: 8f9fe05bb5beabb31e4fbb8d2cfe83cfb36fd9f6ba78193dea8fab7a679470d45bb04c6f052d4f79da03e81129c5b5bed528902430184e1e11b4959f397019ac
-  languageName: node
-  linkType: hard
-
 "fast-base64-decode@npm:^1.0.0":
   version: 1.0.0
   resolution: "fast-base64-decode@npm:1.0.0"
@@ -7538,15 +5465,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"fetch-ponyfill@npm:^4.0.0":
-  version: 4.1.0
-  resolution: "fetch-ponyfill@npm:4.1.0"
-  dependencies:
-    node-fetch: ~1.7.1
-  checksum: 00c85b661a8314e18cb314640b69d3b6e9635517d54290c8f366ddcb21b506ac8fa5d92f899c0fe21bc2163238130be2cf73ffd9d5a8a41a9866a55c52f57f16
-  languageName: node
-  linkType: hard
-
 "figures@npm:^3.0.0":
   version: 3.2.0
   resolution: "figures@npm:3.2.0"
@@ -7574,18 +5492,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"fill-range@npm:^4.0.0":
-  version: 4.0.0
-  resolution: "fill-range@npm:4.0.0"
-  dependencies:
-    extend-shallow: ^2.0.1
-    is-number: ^3.0.0
-    repeat-string: ^1.6.1
-    to-regex-range: ^2.1.0
-  checksum: dbb5102467786ab42bc7a3ec7380ae5d6bfd1b5177b2216de89e4a541193f8ba599a6db84651bd2c58c8921db41b8cc3d699ea83b477342d3ce404020f73c298
-  languageName: node
-  linkType: hard
-
 "fill-range@npm:^7.0.1":
   version: 7.0.1
   resolution: "fill-range@npm:7.0.1"
@@ -7595,31 +5501,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"finalhandler@npm:1.2.0":
-  version: 1.2.0
-  resolution: "finalhandler@npm:1.2.0"
-  dependencies:
-    debug: 2.6.9
-    encodeurl: ~1.0.2
-    escape-html: ~1.0.3
-    on-finished: 2.4.1
-    parseurl: ~1.3.3
-    statuses: 2.0.1
-    unpipe: ~1.0.0
-  checksum: 92effbfd32e22a7dff2994acedbd9bcc3aa646a3e919ea6a53238090e87097f8ef07cced90aa2cc421abdf993aefbdd5b00104d55c7c5479a8d00ed105b45716
-  languageName: node
-  linkType: hard
-
-"find-replace@npm:^1.0.3":
-  version: 1.0.3
-  resolution: "find-replace@npm:1.0.3"
-  dependencies:
-    array-back: ^1.0.4
-    test-value: ^2.1.0
-  checksum: fd95f44e59bd54ea1c0169480952b339a4642cd62d81236fef7f87146d3bc00a042b17d81f896712e8542e01fe5c84e82ac37b6b77b4e3422abbcf7c13bbacfd
-  languageName: node
-  linkType: hard
-
 "find-replace@npm:^3.0.0":
   version: 3.0.0
   resolution: "find-replace@npm:3.0.0"
@@ -7639,16 +5520,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"find-up@npm:^1.0.0":
-  version: 1.1.2
-  resolution: "find-up@npm:1.1.2"
-  dependencies:
-    path-exists: ^2.0.0
-    pinkie-promise: ^2.0.0
-  checksum: a2cb9f4c9f06ee3a1e92ed71d5aed41ac8ae30aefa568132f6c556fac7678a5035126153b59eaec68da78ac409eef02503b2b059706bdbf232668d7245e3240a
-  languageName: node
-  linkType: hard
-
 "find-up@npm:^2.1.0":
   version: 2.1.0
   resolution: "find-up@npm:2.1.0"
@@ -7667,25 +5538,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"find-yarn-workspace-root@npm:^1.2.1":
-  version: 1.2.1
-  resolution: "find-yarn-workspace-root@npm:1.2.1"
-  dependencies:
-    fs-extra: ^4.0.3
-    micromatch: ^3.1.4
-  checksum: a8f4565fb1ead6122acc0d324fa3257c20f7b0c91b7b266dab9eee7251fb5558fcff5b35dbfd301bfd1cbb91c1cdd1799b28ffa5b9a92efd8c7ded3663652bbe
-  languageName: node
-  linkType: hard
-
-"find-yarn-workspace-root@npm:^2.0.0":
-  version: 2.0.0
-  resolution: "find-yarn-workspace-root@npm:2.0.0"
-  dependencies:
-    micromatch: ^4.0.2
-  checksum: fa5ca8f9d08fe7a54ce7c0a5931ff9b7e36f9ee7b9475fb13752bcea80ec6b5f180fa5102d60b376d5526ce924ea3fc6b19301262efa0a5d248dd710f3644242
-  languageName: node
-  linkType: hard
-
 "flat-cache@npm:^2.0.1":
   version: 2.0.1
   resolution: "flat-cache@npm:2.0.1"
@@ -7731,13 +5583,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"flow-stoplight@npm:^1.0.0":
-  version: 1.0.0
-  resolution: "flow-stoplight@npm:1.0.0"
-  checksum: 2f1f34629e724afe7de7b6cb7b5f9ef1b37fa5a4b8a10e24b9c1043872777c41f4c7e09994ecfd5bc70138a04966c3153c4e15187a24771f5d5151a325a96a2e
-  languageName: node
-  linkType: hard
-
 "follow-redirects@npm:^1.12.1, follow-redirects@npm:^1.14.0, follow-redirects@npm:^1.15.4":
   version: 1.15.5
   resolution: "follow-redirects@npm:1.15.5"
@@ -7748,7 +5593,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"for-each@npm:^0.3.3, for-each@npm:~0.3.3":
+"for-each@npm:^0.3.3":
   version: 0.3.3
   resolution: "for-each@npm:0.3.3"
   dependencies:
@@ -7757,13 +5602,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"for-in@npm:^1.0.2":
-  version: 1.0.2
-  resolution: "for-in@npm:1.0.2"
-  checksum: 09f4ae93ce785d253ac963d94c7f3432d89398bf25ac7a24ed034ca393bf74380bdeccc40e0f2d721a895e54211b07c8fad7132e8157827f6f7f059b70b4043d
-  languageName: node
-  linkType: hard
-
 "foreground-child@npm:^3.1.0":
   version: 3.1.1
   resolution: "foreground-child@npm:3.1.1"
@@ -7814,13 +5652,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"forwarded@npm:0.2.0":
-  version: 0.2.0
-  resolution: "forwarded@npm:0.2.0"
-  checksum: fd27e2394d8887ebd16a66ffc889dc983fbbd797d5d3f01087c020283c0f019a7d05ee85669383d8e0d216b116d720fc0cef2f6e9b7eb9f4c90c6e0bc7fd28e6
-  languageName: node
-  linkType: hard
-
 "fp-ts@npm:1.19.3":
   version: 1.19.3
   resolution: "fp-ts@npm:1.19.3"
@@ -7835,22 +5666,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"fragment-cache@npm:^0.2.1":
-  version: 0.2.1
-  resolution: "fragment-cache@npm:0.2.1"
-  dependencies:
-    map-cache: ^0.2.2
-  checksum: 1cbbd0b0116b67d5790175de0038a11df23c1cd2e8dcdbade58ebba5594c2d641dade6b4f126d82a7b4a6ffc2ea12e3d387dbb64ea2ae97cf02847d436f60fdc
-  languageName: node
-  linkType: hard
-
-"fresh@npm:0.5.2":
-  version: 0.5.2
-  resolution: "fresh@npm:0.5.2"
-  checksum: 13ea8b08f91e669a64e3ba3a20eb79d7ca5379a81f1ff7f4310d54e2320645503cc0c78daedc93dfb6191287295f6479544a649c64d8e41a1c0fb0c221552346
-  languageName: node
-  linkType: hard
-
 "fs-constants@npm:^1.0.0":
   version: 1.0.0
   resolution: "fs-constants@npm:1.0.0"
@@ -7871,17 +5686,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"fs-extra@npm:^4.0.2, fs-extra@npm:^4.0.3":
-  version: 4.0.3
-  resolution: "fs-extra@npm:4.0.3"
-  dependencies:
-    graceful-fs: ^4.1.2
-    jsonfile: ^4.0.0
-    universalify: ^0.1.0
-  checksum: c5ae3c7043ad7187128e619c0371da01b58694c1ffa02c36fb3f5b459925d9c27c3cb1e095d9df0a34a85ca993d8b8ff6f6ecef868fd5ebb243548afa7fc0936
-  languageName: node
-  linkType: hard
-
 "fs-extra@npm:^7.0.0, fs-extra@npm:^7.0.1":
   version: 7.0.1
   resolution: "fs-extra@npm:7.0.1"
@@ -7922,16 +5726,7 @@ __metadata:
   dependencies:
     minimatch: ^3.0.2
     rimraf: ^2.6.3
-  checksum: 486a2974f5bbd3181b787416ff9c5fe128e2fa4a902e7314c659f0e141431ff075da1c674b98ba96e4f5b667a5f492231c51703ac3f073920f6388221394e92b
-  languageName: node
-  linkType: hard
-
-"fs-minipass@npm:^1.2.7":
-  version: 1.2.7
-  resolution: "fs-minipass@npm:1.2.7"
-  dependencies:
-    minipass: ^2.6.0
-  checksum: 40fd46a2b5dcb74b3a580269f9a0c36f9098c2ebd22cef2e1a004f375b7b665c11f1507ec3f66ee6efab5664109f72d0a74ea19c3370842214c3da5168d6fdd7
+  checksum: 486a2974f5bbd3181b787416ff9c5fe128e2fa4a902e7314c659f0e141431ff075da1c674b98ba96e4f5b667a5f492231c51703ac3f073920f6388221394e92b
   languageName: node
   linkType: hard
 
@@ -8019,7 +5814,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"ganache-cli@npm:^6.12.2":
+"ganache-cli@npm:latest":
   version: 6.12.2
   resolution: "ganache-cli@npm:6.12.2"
   dependencies:
@@ -8032,53 +5827,29 @@ __metadata:
   languageName: node
   linkType: hard
 
-"ganache-core@npm:^2.13.2":
-  version: 2.13.2
-  resolution: "ganache-core@npm:2.13.2"
+"ganache@npm:7.4.3":
+  version: 7.4.3
+  resolution: "ganache@npm:7.4.3"
   dependencies:
-    abstract-leveldown: 3.0.0
-    async: 2.6.2
-    bip39: 2.5.0
-    cachedown: 1.0.0
-    clone: 2.1.2
-    debug: 3.2.6
-    encoding-down: 5.0.4
-    eth-sig-util: 3.0.0
-    ethereumjs-abi: 0.6.8
-    ethereumjs-account: 3.0.0
-    ethereumjs-block: 2.2.2
-    ethereumjs-common: 1.5.0
-    ethereumjs-tx: 2.1.2
-    ethereumjs-util: 6.2.1
-    ethereumjs-vm: 4.2.0
-    ethereumjs-wallet: 0.6.5
-    heap: 0.2.6
-    keccak: 3.0.1
-    level-sublevel: 6.6.4
-    levelup: 3.1.1
-    lodash: 4.17.20
-    lru-cache: 5.1.1
-    merkle-patricia-tree: 3.0.0
-    patch-package: 6.2.2
-    seedrandom: 3.0.1
-    source-map-support: 0.5.12
-    tmp: 0.1.0
-    web3: 1.2.11
-    web3-provider-engine: 14.2.1
-    websocket: 1.0.32
+    "@trufflesuite/bigint-buffer": 1.1.10
+    "@types/bn.js": ^5.1.0
+    "@types/lru-cache": 5.1.1
+    "@types/seedrandom": 3.0.1
+    bufferutil: 4.0.5
+    emittery: 0.10.0
+    keccak: 3.0.2
+    leveldown: 6.1.0
+    secp256k1: 4.0.3
+    utf-8-validate: 5.0.7
   dependenciesMeta:
-    ethereumjs-wallet:
+    bufferutil:
       optional: true
-    web3:
+    utf-8-validate:
       optional: true
-  checksum: 799b275abd09259c88a4e78c335e807d14cc12d3a1ceb9d7cdeef484cf5fab541847edf9cf209f448190199dbd0796393d308d50e6823565154c17dd0c3a4048
-  languageName: node
-  linkType: hard
-
-"get-caller-file@npm:^1.0.1":
-  version: 1.0.3
-  resolution: "get-caller-file@npm:1.0.3"
-  checksum: 2b90a7f848896abcebcdc0acc627a435bcf05b9cd280599bc980ebfcdc222416c3df12c24c4845f69adc4346728e8966f70b758f9369f3534182791dfbc25c05
+  bin:
+    ganache: dist/node/cli.js
+    ganache-cli: dist/node/cli.js
+  checksum: 170dde8c2ecd88e7f02a92bf582149e6497a2fdfb05abe9ab63a5b7cf33c061d71390f9719ef3d716dad4149299f8a87c71612ab4b40d1c57c55d7a185314630
   languageName: node
   linkType: hard
 
@@ -8130,7 +5901,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"get-stream@npm:^4.0.0, get-stream@npm:^4.1.0":
+"get-stream@npm:^4.0.0":
   version: 4.1.0
   resolution: "get-stream@npm:4.1.0"
   dependencies:
@@ -8139,7 +5910,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"get-stream@npm:^5.0.0, get-stream@npm:^5.1.0":
+"get-stream@npm:^5.0.0":
   version: 5.2.0
   resolution: "get-stream@npm:5.2.0"
   dependencies:
@@ -8158,13 +5929,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"get-value@npm:^2.0.3, get-value@npm:^2.0.6":
-  version: 2.0.6
-  resolution: "get-value@npm:2.0.6"
-  checksum: 5c3b99cb5398ea8016bf46ff17afc5d1d286874d2ad38ca5edb6e87d75c0965b0094cb9a9dddef2c59c23d250702323539a7fbdd870620db38c7e7d7ec87c1eb
-  languageName: node
-  linkType: hard
-
 "getpass@npm:^0.1.1":
   version: 0.1.7
   resolution: "getpass@npm:0.1.7"
@@ -8260,7 +6024,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"glob@npm:^7.0.0, glob@npm:^7.1.2, glob@npm:^7.1.3, glob@npm:^7.1.6, glob@npm:~7.2.3":
+"glob@npm:^7.0.0, glob@npm:^7.1.2, glob@npm:^7.1.3, glob@npm:^7.1.6":
   version: 7.2.3
   resolution: "glob@npm:7.2.3"
   dependencies:
@@ -8307,16 +6071,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"global@npm:~4.4.0":
-  version: 4.4.0
-  resolution: "global@npm:4.4.0"
-  dependencies:
-    min-document: ^2.19.0
-    process: ^0.11.10
-  checksum: 9c057557c8f5a5bcfbeb9378ba4fe2255d04679452be504608dd5f13b54edf79f7be1db1031ea06a4ec6edd3b9f5f17d2d172fb47e6c69dae57fd84b7e72b77f
-  languageName: node
-  linkType: hard
-
 "globals@npm:^12.1.0":
   version: 12.4.0
   resolution: "globals@npm:12.4.0"
@@ -8335,13 +6089,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"globals@npm:^9.18.0":
-  version: 9.18.0
-  resolution: "globals@npm:9.18.0"
-  checksum: e9c066aecfdc5ea6f727344a4246ecc243aaf66ede3bffee10ddc0c73351794c25e727dd046090dcecd821199a63b9de6af299a6e3ba292c8b22f0a80ea32073
-  languageName: node
-  linkType: hard
-
 "globalthis@npm:^1.0.3":
   version: 1.0.3
   resolution: "globalthis@npm:1.0.3"
@@ -8430,45 +6177,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"got@npm:9.6.0":
-  version: 9.6.0
-  resolution: "got@npm:9.6.0"
-  dependencies:
-    "@sindresorhus/is": ^0.14.0
-    "@szmarczak/http-timer": ^1.1.2
-    cacheable-request: ^6.0.0
-    decompress-response: ^3.3.0
-    duplexer3: ^0.1.4
-    get-stream: ^4.1.0
-    lowercase-keys: ^1.0.1
-    mimic-response: ^1.0.1
-    p-cancelable: ^1.0.0
-    to-readable-stream: ^1.0.0
-    url-parse-lax: ^3.0.0
-  checksum: 941807bd9704bacf5eb401f0cc1212ffa1f67c6642f2d028fd75900471c221b1da2b8527f4553d2558f3faeda62ea1cf31665f8b002c6137f5de8732f07370b0
-  languageName: node
-  linkType: hard
-
-"got@npm:^11.8.5":
-  version: 11.8.6
-  resolution: "got@npm:11.8.6"
-  dependencies:
-    "@sindresorhus/is": ^4.0.0
-    "@szmarczak/http-timer": ^4.0.5
-    "@types/cacheable-request": ^6.0.1
-    "@types/responselike": ^1.0.0
-    cacheable-lookup: ^5.0.3
-    cacheable-request: ^7.0.2
-    decompress-response: ^6.0.0
-    http2-wrapper: ^1.0.0-beta.5.2
-    lowercase-keys: ^2.0.0
-    p-cancelable: ^2.0.0
-    responselike: ^2.0.0
-  checksum: bbc783578a8d5030c8164ef7f57ce41b5ad7db2ed13371e1944bef157eeca5a7475530e07c0aaa71610d7085474d0d96222c9f4268d41db333a17e39b463f45d
-  languageName: node
-  linkType: hard
-
-"graceful-fs@npm:^4.1.11, graceful-fs@npm:^4.1.2, graceful-fs@npm:^4.1.6, graceful-fs@npm:^4.1.9, graceful-fs@npm:^4.2.0, graceful-fs@npm:^4.2.4, graceful-fs@npm:^4.2.6":
+"graceful-fs@npm:^4.1.2, graceful-fs@npm:^4.1.6, graceful-fs@npm:^4.1.9, graceful-fs@npm:^4.2.0, graceful-fs@npm:^4.2.4, graceful-fs@npm:^4.2.6":
   version: 4.2.11
   resolution: "graceful-fs@npm:4.2.11"
   checksum: ac85f94da92d8eb6b7f5a8b20ce65e43d66761c55ce85ac96df6865308390da45a8d3f0296dd3a663de65d30ba497bd46c696cc1e248c72b13d6d567138a4fc7
@@ -8524,7 +6233,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"hardhat-gas-reporter@npm:^1.0.9":
+"hardhat-gas-reporter@npm:latest":
   version: 1.0.10
   resolution: "hardhat-gas-reporter@npm:1.0.10"
   dependencies:
@@ -8537,22 +6246,16 @@ __metadata:
   languageName: node
   linkType: hard
 
-"hardhat@npm:^2.19.4":
-  version: 2.19.5
-  resolution: "hardhat@npm:2.19.5"
+"hardhat@npm:^2.22.1":
+  version: 2.22.1
+  resolution: "hardhat@npm:2.22.1"
   dependencies:
     "@ethersproject/abi": ^5.1.2
     "@metamask/eth-sig-util": ^4.0.0
-    "@nomicfoundation/ethereumjs-block": 5.0.2
-    "@nomicfoundation/ethereumjs-blockchain": 7.0.2
-    "@nomicfoundation/ethereumjs-common": 4.0.2
-    "@nomicfoundation/ethereumjs-evm": 2.0.2
-    "@nomicfoundation/ethereumjs-rlp": 5.0.2
-    "@nomicfoundation/ethereumjs-statemanager": 2.0.2
-    "@nomicfoundation/ethereumjs-trie": 6.0.2
-    "@nomicfoundation/ethereumjs-tx": 5.0.2
-    "@nomicfoundation/ethereumjs-util": 9.0.2
-    "@nomicfoundation/ethereumjs-vm": 7.0.2
+    "@nomicfoundation/edr": ^0.3.1
+    "@nomicfoundation/ethereumjs-common": 4.0.4
+    "@nomicfoundation/ethereumjs-tx": 5.0.4
+    "@nomicfoundation/ethereumjs-util": 9.0.4
     "@nomicfoundation/solidity-analyzer": ^0.1.0
     "@sentry/node": ^5.18.1
     "@types/bn.js": ^5.1.0
@@ -8600,16 +6303,7 @@ __metadata:
       optional: true
   bin:
     hardhat: internal/cli/bootstrap.js
-  checksum: 316b03a1d090360e6ed471fe125360ec0c66c5bb62e29492898932b1a9a5227c12d7a18343877c59725f321647a01fde0841649bf7d8a4a746148a0d38b0ee27
-  languageName: node
-  linkType: hard
-
-"has-ansi@npm:^2.0.0":
-  version: 2.0.0
-  resolution: "has-ansi@npm:2.0.0"
-  dependencies:
-    ansi-regex: ^2.0.0
-  checksum: 1b51daa0214440db171ff359d0a2d17bc20061164c57e76234f614c91dbd2a79ddd68dfc8ee73629366f7be45a6df5f2ea9de83f52e1ca24433f2cc78c35d8ec
+  checksum: 6494697d37198d32b9151e8303b8e771f1d10f50ddd5488c619a8b6d36c6ee391a274ce75f7ac17b574fec84e6e1dc11f63487d308013873183cd2af58865200
   languageName: node
   linkType: hard
 
@@ -8673,52 +6367,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"has-value@npm:^0.3.1":
-  version: 0.3.1
-  resolution: "has-value@npm:0.3.1"
-  dependencies:
-    get-value: ^2.0.3
-    has-values: ^0.1.4
-    isobject: ^2.0.0
-  checksum: 29e2a1e6571dad83451b769c7ce032fce6009f65bccace07c2962d3ad4d5530b6743d8f3229e4ecf3ea8e905d23a752c5f7089100c1f3162039fa6dc3976558f
-  languageName: node
-  linkType: hard
-
-"has-value@npm:^1.0.0":
-  version: 1.0.0
-  resolution: "has-value@npm:1.0.0"
-  dependencies:
-    get-value: ^2.0.6
-    has-values: ^1.0.0
-    isobject: ^3.0.0
-  checksum: b9421d354e44f03d3272ac39fd49f804f19bc1e4fa3ceef7745df43d6b402053f828445c03226b21d7d934a21ac9cf4bc569396dc312f496ddff873197bbd847
-  languageName: node
-  linkType: hard
-
-"has-values@npm:^0.1.4":
-  version: 0.1.4
-  resolution: "has-values@npm:0.1.4"
-  checksum: ab1c4bcaf811ccd1856c11cfe90e62fca9e2b026ebe474233a3d282d8d67e3b59ed85b622c7673bac3db198cb98bd1da2b39300a2f98e453729b115350af49bc
-  languageName: node
-  linkType: hard
-
-"has-values@npm:^1.0.0":
-  version: 1.0.0
-  resolution: "has-values@npm:1.0.0"
-  dependencies:
-    is-number: ^3.0.0
-    kind-of: ^4.0.0
-  checksum: 77e6693f732b5e4cf6c38dfe85fdcefad0fab011af74995c3e83863fabf5e3a836f406d83565816baa0bc0a523c9410db8b990fe977074d61aeb6d8f4fcffa11
-  languageName: node
-  linkType: hard
-
-"has@npm:~1.0.3":
-  version: 1.0.4
-  resolution: "has@npm:1.0.4"
-  checksum: 8a11ba062e0627c9578a1d08285401e39f1d071a9692ddf793199070edb5648b21c774dd733e2a181edd635bf6862731885f476f4ccf67c998d7a5ff7cef2550
-  languageName: node
-  linkType: hard
-
 "hash-base@npm:^3.0.0":
   version: 3.1.0
   resolution: "hash-base@npm:3.1.0"
@@ -8758,13 +6406,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"heap@npm:0.2.6":
-  version: 0.2.6
-  resolution: "heap@npm:0.2.6"
-  checksum: 1291b9b9efb5090d01c6d04a89c91ca6e0e0eb7f3694d8254f7a5effcc5ab9249bc3d16767b276645ffe86d9b2bbd82ed977f8988f55375e9f2a2c80647ebbdc
-  languageName: node
-  linkType: hard
-
 "heap@npm:>= 0.2.0":
   version: 0.2.7
   resolution: "heap@npm:0.2.7"
@@ -8783,17 +6424,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"home-or-tmp@npm:^2.0.0":
-  version: 2.0.0
-  resolution: "home-or-tmp@npm:2.0.0"
-  dependencies:
-    os-homedir: ^1.0.0
-    os-tmpdir: ^1.0.1
-  checksum: b783c6ffd22f716d82f53e8c781cbe49bc9f4109a89ea86a27951e54c0bd335caf06bd828be2958cd9f4681986df1739558ae786abda6298cdd6d3edc2c362f1
-  languageName: node
-  linkType: hard
-
-"hosted-git-info@npm:^2.1.4, hosted-git-info@npm:^2.6.0":
+"hosted-git-info@npm:^2.6.0":
   version: 2.8.9
   resolution: "hosted-git-info@npm:2.8.9"
   checksum: c955394bdab888a1e9bb10eb33029e0f7ce5a2ac7b3f158099dc8c486c99e73809dca609f5694b223920ca2174db33d32b12f9a2a47141dc59607c29da5a62dd
@@ -8812,7 +6443,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"http-cache-semantics@npm:^4.0.0, http-cache-semantics@npm:^4.1.1":
+"http-cache-semantics@npm:^4.1.1":
   version: 4.1.1
   resolution: "http-cache-semantics@npm:4.1.1"
   checksum: 83ac0bc60b17a3a36f9953e7be55e5c8f41acc61b22583060e8dedc9dd5e3607c823a88d0926f9150e571f90946835c7fe150732801010845c72cd8bbff1a236
@@ -8832,13 +6463,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"http-https@npm:^1.0.0":
-  version: 1.0.0
-  resolution: "http-https@npm:1.0.0"
-  checksum: 82fc4d2e512c64b35680944d1ae13e68220acfa05b06329832e271fd199c5c7fcff1f53fc1f91a1cd65a737ee4de14004dd3ba9a73cce33da970940c6e6ca774
-  languageName: node
-  linkType: hard
-
 "http-proxy-agent@npm:^7.0.0":
   version: 7.0.0
   resolution: "http-proxy-agent@npm:7.0.0"
@@ -8869,16 +6493,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"http2-wrapper@npm:^1.0.0-beta.5.2":
-  version: 1.0.3
-  resolution: "http2-wrapper@npm:1.0.3"
-  dependencies:
-    quick-lru: ^5.1.1
-    resolve-alpn: ^1.0.0
-  checksum: 74160b862ec699e3f859739101ff592d52ce1cb207b7950295bf7962e4aa1597ef709b4292c673bece9c9b300efad0559fc86c71b1409c7a1e02b7229456003e
-  languageName: node
-  linkType: hard
-
 "https-proxy-agent@npm:^5.0.0":
   version: 5.0.1
   resolution: "https-proxy-agent@npm:5.0.1"
@@ -8924,15 +6538,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"idna-uts46-hx@npm:^2.3.1":
-  version: 2.3.1
-  resolution: "idna-uts46-hx@npm:2.3.1"
-  dependencies:
-    punycode: 2.1.0
-  checksum: d434c3558d2bc1090eb90f978f995101f469cb26593414ac57aa082c9352e49972b332c6e4188b9b15538172ccfeae3121e5a19b96972a97e6aeb0676d86639c
-  languageName: node
-  linkType: hard
-
 "ieee754@npm:^1.1.13, ieee754@npm:^1.1.4, ieee754@npm:^1.2.1":
   version: 1.2.1
   resolution: "ieee754@npm:1.2.1"
@@ -9016,7 +6621,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"inherits@npm:2, inherits@npm:2.0.4, inherits@npm:^2.0.1, inherits@npm:^2.0.3, inherits@npm:^2.0.4, inherits@npm:~2.0.1, inherits@npm:~2.0.3, inherits@npm:~2.0.4":
+"inherits@npm:2, inherits@npm:2.0.4, inherits@npm:^2.0.1, inherits@npm:^2.0.3, inherits@npm:^2.0.4, inherits@npm:~2.0.1, inherits@npm:~2.0.3":
   version: 2.0.4
   resolution: "inherits@npm:2.0.4"
   checksum: 4a48a733847879d6cf6691860a6b1e3f0f4754176e4d71494c41f3475553768b10f84b5ce1d40fbd0e34e6bfbb864ee35858ad4dd2cf31e02fc4a154b724d7f1
@@ -9087,22 +6692,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"invariant@npm:^2.2.2":
-  version: 2.2.4
-  resolution: "invariant@npm:2.2.4"
-  dependencies:
-    loose-envify: ^1.0.0
-  checksum: cc3182d793aad82a8d1f0af697b462939cb46066ec48bbf1707c150ad5fad6406137e91a262022c269702e01621f35ef60269f6c0d7fd178487959809acdfb14
-  languageName: node
-  linkType: hard
-
-"invert-kv@npm:^1.0.0":
-  version: 1.0.0
-  resolution: "invert-kv@npm:1.0.0"
-  checksum: aebeee31dda3b3d25ffd242e9a050926e7fe5df642d60953ab183aca1a7d1ffb39922eb2618affb0e850cf2923116f0da1345367759d88d097df5da1f1e1590e
-  languageName: node
-  linkType: hard
-
 "invert-kv@npm:^2.0.0":
   version: 2.0.0
   resolution: "invert-kv@npm:2.0.0"
@@ -9133,13 +6722,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"ipaddr.js@npm:1.9.1":
-  version: 1.9.1
-  resolution: "ipaddr.js@npm:1.9.1"
-  checksum: f88d3825981486f5a1942414c8d77dd6674dd71c065adcfa46f578d677edcb99fda25af42675cb59db492fdf427b34a5abfcde3982da11a8fd83a500b41cfe77
-  languageName: node
-  linkType: hard
-
 "ipfs-core-types@npm:^0.9.0":
   version: 0.9.0
   resolution: "ipfs-core-types@npm:0.9.0"
@@ -9240,25 +6822,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"is-accessor-descriptor@npm:^1.0.1":
-  version: 1.0.1
-  resolution: "is-accessor-descriptor@npm:1.0.1"
-  dependencies:
-    hasown: ^2.0.0
-  checksum: 8db44c02230a5e9b9dec390a343178791f073d5d5556a400527d2fd67a72d93b226abab2bd4123305c268f5dc22831bfdbd38430441fda82ea9e0b95ddc6b267
-  languageName: node
-  linkType: hard
-
-"is-arguments@npm:^1.1.1":
-  version: 1.1.1
-  resolution: "is-arguments@npm:1.1.1"
-  dependencies:
-    call-bind: ^1.0.2
-    has-tostringtag: ^1.0.0
-  checksum: 7f02700ec2171b691ef3e4d0e3e6c0ba408e8434368504bb593d0d7c891c0dbfda6d19d30808b904a6cb1929bca648c061ba438c39f296c2a8ca083229c49f27
-  languageName: node
-  linkType: hard
-
 "is-array-buffer@npm:^3.0.2, is-array-buffer@npm:^3.0.4":
   version: 3.0.4
   resolution: "is-array-buffer@npm:3.0.4"
@@ -9304,13 +6867,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"is-buffer@npm:^1.1.5":
-  version: 1.1.6
-  resolution: "is-buffer@npm:1.1.6"
-  checksum: 4a186d995d8bbf9153b4bd9ff9fd04ae75068fe695d29025d25e592d9488911eeece84eefbd8fa41b8ddcc0711058a71d4c466dcf6f1f6e1d83830052d8ca707
-  languageName: node
-  linkType: hard
-
 "is-buffer@npm:^2.0.5":
   version: 2.0.5
   resolution: "is-buffer@npm:2.0.5"
@@ -9325,17 +6881,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"is-ci@npm:^2.0.0":
-  version: 2.0.0
-  resolution: "is-ci@npm:2.0.0"
-  dependencies:
-    ci-info: ^2.0.0
-  bin:
-    is-ci: bin.js
-  checksum: 77b869057510f3efa439bbb36e9be429d53b3f51abd4776eeea79ab3b221337fe1753d1e50058a9e2c650d38246108beffb15ccfd443929d77748d8c0cc90144
-  languageName: node
-  linkType: hard
-
 "is-core-module@npm:^2.11.0, is-core-module@npm:^2.13.0, is-core-module@npm:^2.13.1":
   version: 2.13.1
   resolution: "is-core-module@npm:2.13.1"
@@ -9345,16 +6890,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"is-data-descriptor@npm:^1.0.1":
-  version: 1.0.1
-  resolution: "is-data-descriptor@npm:1.0.1"
-  dependencies:
-    hasown: ^2.0.0
-  checksum: fc6da5be5177149d554c5612cc382e9549418ed72f2d3ed5a3e6511b03dd119ae1b2258320ca94931df50b7e9ee012894eccd4ca45bbcadf0d5b27da6faeb15a
-  languageName: node
-  linkType: hard
-
-"is-date-object@npm:^1.0.1, is-date-object@npm:^1.0.5":
+"is-date-object@npm:^1.0.1":
   version: 1.0.5
   resolution: "is-date-object@npm:1.0.5"
   dependencies:
@@ -9363,35 +6899,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"is-descriptor@npm:^0.1.0":
-  version: 0.1.7
-  resolution: "is-descriptor@npm:0.1.7"
-  dependencies:
-    is-accessor-descriptor: ^1.0.1
-    is-data-descriptor: ^1.0.1
-  checksum: 45743109f0bb03f9fa989c34d31ece87cc15792649f147b896a7c4db2906a02fca685867619f4d312e024d7bbd53b945a47c6830d01f5e73efcc6388ac211963
-  languageName: node
-  linkType: hard
-
-"is-descriptor@npm:^1.0.0, is-descriptor@npm:^1.0.2":
-  version: 1.0.3
-  resolution: "is-descriptor@npm:1.0.3"
-  dependencies:
-    is-accessor-descriptor: ^1.0.1
-    is-data-descriptor: ^1.0.1
-  checksum: 316153b2fd86ac23b0a2f28b77744ae0a4e3c7a54fe52fa70b125d0971eb0a3bcfb562fa8e74537af0dad5bc405cc606726eb501fc748a241c10910deea89cfb
-  languageName: node
-  linkType: hard
-
-"is-docker@npm:^2.0.0":
-  version: 2.2.1
-  resolution: "is-docker@npm:2.2.1"
-  bin:
-    is-docker: cli.js
-  checksum: 3fef7ddbf0be25958e8991ad941901bf5922ab2753c46980b60b05c1bf9c9c2402d35e6dc32e4380b980ef5e1970a5d9d5e5aa2e02d77727c3b6b5e918474c56
-  languageName: node
-  linkType: hard
-
 "is-electron@npm:^2.2.0":
   version: 2.2.2
   resolution: "is-electron@npm:2.2.2"
@@ -9399,22 +6906,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"is-extendable@npm:^0.1.0, is-extendable@npm:^0.1.1":
-  version: 0.1.1
-  resolution: "is-extendable@npm:0.1.1"
-  checksum: 3875571d20a7563772ecc7a5f36cb03167e9be31ad259041b4a8f73f33f885441f778cee1f1fe0085eb4bc71679b9d8c923690003a36a6a5fdf8023e6e3f0672
-  languageName: node
-  linkType: hard
-
-"is-extendable@npm:^1.0.1":
-  version: 1.0.1
-  resolution: "is-extendable@npm:1.0.1"
-  dependencies:
-    is-plain-object: ^2.0.4
-  checksum: db07bc1e9de6170de70eff7001943691f05b9d1547730b11be01c0ebfe67362912ba743cf4be6fd20a5e03b4180c685dad80b7c509fe717037e3eee30ad8e84f
-  languageName: node
-  linkType: hard
-
 "is-extglob@npm:^2.1.1":
   version: 2.1.1
   resolution: "is-extglob@npm:2.1.1"
@@ -9422,29 +6913,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"is-finite@npm:^1.0.0":
-  version: 1.1.0
-  resolution: "is-finite@npm:1.1.0"
-  checksum: 532b97ed3d03e04c6bd203984d9e4ba3c0c390efee492bad5d1d1cd1802a68ab27adbd3ef6382f6312bed6c8bb1bd3e325ea79a8dc8fe080ed7a06f5f97b93e7
-  languageName: node
-  linkType: hard
-
-"is-fn@npm:^1.0.0":
-  version: 1.0.0
-  resolution: "is-fn@npm:1.0.0"
-  checksum: eeea1e536716f93a92dc1a8550b2c0909fe74bb5144d0fb6d65e0d31eb9c06c30559f69d83a9351d2288cc7293b43bc074e0fab5fae19e312ff38aa0c7672827
-  languageName: node
-  linkType: hard
-
-"is-fullwidth-code-point@npm:^1.0.0":
-  version: 1.0.0
-  resolution: "is-fullwidth-code-point@npm:1.0.0"
-  dependencies:
-    number-is-nan: ^1.0.0
-  checksum: 4d46a7465a66a8aebcc5340d3b63a56602133874af576a9ca42c6f0f4bd787a743605771c5f246db77da96605fefeffb65fc1dbe862dcc7328f4b4d03edf5a57
-  languageName: node
-  linkType: hard
-
 "is-fullwidth-code-point@npm:^2.0.0":
   version: 2.0.0
   resolution: "is-fullwidth-code-point@npm:2.0.0"
@@ -9459,13 +6927,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"is-function@npm:^1.0.1":
-  version: 1.0.2
-  resolution: "is-function@npm:1.0.2"
-  checksum: 7d564562e07b4b51359547d3ccc10fb93bb392fd1b8177ae2601ee4982a0ece86d952323fc172a9000743a3971f09689495ab78a1d49a9b14fc97a7e28521dc0
-  languageName: node
-  linkType: hard
-
 "is-glob@npm:^4.0.0, is-glob@npm:^4.0.1, is-glob@npm:^4.0.3, is-glob@npm:~4.0.1":
   version: 4.0.3
   resolution: "is-glob@npm:4.0.3"
@@ -9521,15 +6982,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"is-number@npm:^3.0.0":
-  version: 3.0.0
-  resolution: "is-number@npm:3.0.0"
-  dependencies:
-    kind-of: ^3.0.2
-  checksum: 0c62bf8e9d72c4dd203a74d8cfc751c746e75513380fef420cda8237e619a988ee43e678ddb23c87ac24d91ac0fe9f22e4ffb1301a50310c697e9d73ca3994e9
-  languageName: node
-  linkType: hard
-
 "is-number@npm:^7.0.0":
   version: 7.0.0
   resolution: "is-number@npm:7.0.0"
@@ -9551,16 +7003,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"is-plain-object@npm:^2.0.3, is-plain-object@npm:^2.0.4":
-  version: 2.0.4
-  resolution: "is-plain-object@npm:2.0.4"
-  dependencies:
-    isobject: ^3.0.1
-  checksum: 2a401140cfd86cabe25214956ae2cfee6fbd8186809555cd0e84574f88de7b17abacb2e477a6a658fa54c6083ecbda1e6ae404c7720244cd198903848fca70ca
-  languageName: node
-  linkType: hard
-
-"is-regex@npm:^1.1.4, is-regex@npm:~1.1.4":
+"is-regex@npm:^1.1.4":
   version: 1.1.4
   resolution: "is-regex@npm:1.1.4"
   dependencies:
@@ -9579,7 +7022,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"is-stream@npm:^1.0.1, is-stream@npm:^1.1.0":
+"is-stream@npm:^1.1.0":
   version: 1.1.0
   resolution: "is-stream@npm:1.1.0"
   checksum: 063c6bec9d5647aa6d42108d4c59723d2bd4ae42135a2d4db6eadbd49b7ea05b750fd69d279e5c7c45cf9da753ad2c00d8978be354d65aa9f6bb434969c6a2ae
@@ -9620,7 +7063,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"is-typedarray@npm:^1.0.0, is-typedarray@npm:~1.0.0":
+"is-typedarray@npm:~1.0.0":
   version: 1.0.0
   resolution: "is-typedarray@npm:1.0.0"
   checksum: 3508c6cd0a9ee2e0df2fa2e9baabcdc89e911c7bd5cf64604586697212feec525aa21050e48affb5ffc3df20f0f5d2e2cf79b08caa64e1ccc9578e251763aef7
@@ -9641,13 +7084,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"is-utf8@npm:^0.2.0":
-  version: 0.2.1
-  resolution: "is-utf8@npm:0.2.1"
-  checksum: 167ccd2be869fc228cc62c1a28df4b78c6b5485d15a29027d3b5dceb09b383e86a3522008b56dcac14b592b22f0a224388718c2505027a994fd8471465de54b3
-  languageName: node
-  linkType: hard
-
 "is-weakref@npm:^1.0.2":
   version: 1.0.2
   resolution: "is-weakref@npm:1.0.2"
@@ -9657,22 +7093,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"is-windows@npm:^1.0.2":
-  version: 1.0.2
-  resolution: "is-windows@npm:1.0.2"
-  checksum: 438b7e52656fe3b9b293b180defb4e448088e7023a523ec21a91a80b9ff8cdb3377ddb5b6e60f7c7de4fa8b63ab56e121b6705fe081b3cf1b828b0a380009ad7
-  languageName: node
-  linkType: hard
-
-"is-wsl@npm:^2.1.1":
-  version: 2.2.0
-  resolution: "is-wsl@npm:2.2.0"
-  dependencies:
-    is-docker: ^2.0.0
-  checksum: 20849846ae414997d290b75e16868e5261e86ff5047f104027026fd61d8b5a9b0b3ade16239f35e1a067b3c7cc02f70183cb661010ed16f4b6c7c93dad1b19d8
-  languageName: node
-  linkType: hard
-
 "isarray@npm:0.0.1":
   version: 0.0.1
   resolution: "isarray@npm:0.0.1"
@@ -9680,7 +7100,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"isarray@npm:1.0.0, isarray@npm:^1.0.0, isarray@npm:~1.0.0":
+"isarray@npm:^1.0.0, isarray@npm:~1.0.0":
   version: 1.0.0
   resolution: "isarray@npm:1.0.0"
   checksum: f032df8e02dce8ec565cf2eb605ea939bdccea528dbcf565cdf92bfa2da9110461159d86a537388ef1acef8815a330642d7885b29010e8f7eac967c9993b65ab
@@ -9715,22 +7135,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"isobject@npm:^2.0.0":
-  version: 2.1.0
-  resolution: "isobject@npm:2.1.0"
-  dependencies:
-    isarray: 1.0.0
-  checksum: 811c6f5a866877d31f0606a88af4a45f282544de886bf29f6a34c46616a1ae2ed17076cc6bf34c0128f33eecf7e1fcaa2c82cf3770560d3e26810894e96ae79f
-  languageName: node
-  linkType: hard
-
-"isobject@npm:^3.0.0, isobject@npm:^3.0.1":
-  version: 3.0.1
-  resolution: "isobject@npm:3.0.1"
-  checksum: db85c4c970ce30693676487cca0e61da2ca34e8d4967c2e1309143ff910c207133a969f9e4ddb2dc6aba670aabce4e0e307146c310350b298e74a31f7d464703
-  languageName: node
-  linkType: hard
-
 "isomorphic-unfetch@npm:^3.0.0":
   version: 3.1.0
   resolution: "isomorphic-unfetch@npm:3.1.0"
@@ -9858,13 +7262,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"js-sdsl@npm:^4.1.4":
-  version: 4.4.2
-  resolution: "js-sdsl@npm:4.4.2"
-  checksum: ba705adc1788bf3c6f6c8e5077824f2bb4f0acab5a984420ce5cc492c7fff3daddc26335ad2c9a67d4f5e3241ec790f9e5b72a625adcf20cf321d2fd85e62b8b
-  languageName: node
-  linkType: hard
-
 "js-sha3@npm:0.8.0, js-sha3@npm:^0.8.0":
   version: 0.8.0
   resolution: "js-sha3@npm:0.8.0"
@@ -9872,27 +7269,13 @@ __metadata:
   languageName: node
   linkType: hard
 
-"js-sha3@npm:^0.5.7":
-  version: 0.5.7
-  resolution: "js-sha3@npm:0.5.7"
-  checksum: 973a28ea4b26cc7f12d2ab24f796e24ee4a71eef45a6634a052f6eb38cf8b2333db798e896e6e094ea6fa4dfe8e42a2a7942b425cf40da3f866623fd05bb91ea
-  languageName: node
-  linkType: hard
-
-"js-tokens@npm:^3.0.0 || ^4.0.0, js-tokens@npm:^4.0.0":
+"js-tokens@npm:^4.0.0":
   version: 4.0.0
   resolution: "js-tokens@npm:4.0.0"
   checksum: 8a95213a5a77deb6cbe94d86340e8d9ace2b93bc367790b260101d2f36a2eaf4e4e22d9fa9cf459b38af3a32fb4190e638024cf82ec95ef708680e405ea7cc78
   languageName: node
   linkType: hard
 
-"js-tokens@npm:^3.0.2":
-  version: 3.0.2
-  resolution: "js-tokens@npm:3.0.2"
-  checksum: ff24cf90e6e4ac446eba56e604781c1aaf3bdaf9b13a00596a0ebd972fa3b25dc83c0f0f67289c33252abb4111e0d14e952a5d9ffb61f5c22532d555ebd8d8a9
-  languageName: node
-  linkType: hard
-
 "js-yaml@npm:3.x, js-yaml@npm:^3.13.1":
   version: 3.14.1
   resolution: "js-yaml@npm:3.14.1"
@@ -9923,28 +7306,12 @@ __metadata:
   languageName: node
   linkType: hard
 
-"jsesc@npm:^1.3.0":
-  version: 1.3.0
-  resolution: "jsesc@npm:1.3.0"
-  bin:
-    jsesc: bin/jsesc
-  checksum: 9384cc72bf8ef7f2eb75fea64176b8b0c1c5e77604854c72cb4670b7072e112e3baaa69ef134be98cb078834a7812b0bfe676ad441ccd749a59427f5ed2127f1
-  languageName: node
-  linkType: hard
-
-"jsesc@npm:~0.5.0":
-  version: 0.5.0
-  resolution: "jsesc@npm:0.5.0"
-  bin:
-    jsesc: bin/jsesc
-  checksum: b8b44cbfc92f198ad972fba706ee6a1dfa7485321ee8c0b25f5cedd538dcb20cde3197de16a7265430fce8277a12db066219369e3d51055038946039f6e20e17
-  languageName: node
-  linkType: hard
-
-"json-buffer@npm:3.0.0":
-  version: 3.0.0
-  resolution: "json-buffer@npm:3.0.0"
-  checksum: 0cecacb8025370686a916069a2ff81f7d55167421b6aa7270ee74e244012650dd6bce22b0852202ea7ff8624fce50ff0ec1bdf95914ccb4553426e290d5a63fa
+"json-bigint@npm:^1.0.0":
+  version: 1.0.0
+  resolution: "json-bigint@npm:1.0.0"
+  dependencies:
+    bignumber.js: ^9.0.0
+  checksum: c67bb93ccb3c291e60eb4b62931403e378906aab113ec1c2a8dd0f9a7f065ad6fd9713d627b732abefae2e244ac9ce1721c7a3142b2979532f12b258634ce6f6
   languageName: node
   linkType: hard
 
@@ -9962,36 +7329,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"json-rpc-engine@npm:^3.4.0, json-rpc-engine@npm:^3.6.0":
-  version: 3.8.0
-  resolution: "json-rpc-engine@npm:3.8.0"
-  dependencies:
-    async: ^2.0.1
-    babel-preset-env: ^1.7.0
-    babelify: ^7.3.0
-    json-rpc-error: ^2.0.0
-    promise-to-callback: ^1.0.0
-    safe-event-emitter: ^1.0.1
-  checksum: 4a02ddda196b68717cdcdf9bc8eac91f956b717431daf1f317e016d564bd5b8974e8a66f75fd1f069d63b8e944128020ec7c371f28cf29ac0951d3338b2f667c
-  languageName: node
-  linkType: hard
-
-"json-rpc-error@npm:^2.0.0":
-  version: 2.0.0
-  resolution: "json-rpc-error@npm:2.0.0"
-  dependencies:
-    inherits: ^2.0.1
-  checksum: bbfb1ff82d0605b4dfd4ac6d093e863a8f623e0e83a098ccab5711a08d2ae09ea603260d4573a524e596701e64733690a5c31901e99daebe05b09053d8702d0c
-  languageName: node
-  linkType: hard
-
-"json-rpc-random-id@npm:^1.0.0":
-  version: 1.0.1
-  resolution: "json-rpc-random-id@npm:1.0.1"
-  checksum: fcd2e884193a129ace4002bd65a86e9cdb206733b4693baea77bd8b372cf8de3043fbea27716a2c9a716581a908ca8d978d9dfec4847eb2cf77edb4cf4b2252c
-  languageName: node
-  linkType: hard
-
 "json-schema-traverse@npm:^0.4.1":
   version: 0.4.1
   resolution: "json-schema-traverse@npm:0.4.1"
@@ -10020,18 +7357,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"json-stable-stringify@npm:^1.0.1":
-  version: 1.1.1
-  resolution: "json-stable-stringify@npm:1.1.1"
-  dependencies:
-    call-bind: ^1.0.5
-    isarray: ^2.0.5
-    jsonify: ^0.0.1
-    object-keys: ^1.1.1
-  checksum: e1ba06600fd278767eeff53f28e408e29c867e79abf564e7aadc3ce8f31f667258f8db278ef28831e45884dd687388fa1910f46e599fc19fb94c9afbbe3a4de8
-  languageName: node
-  linkType: hard
-
 "json-stringify-safe@npm:^5.0.1, json-stringify-safe@npm:~5.0.1":
   version: 5.0.1
   resolution: "json-stringify-safe@npm:5.0.1"
@@ -10039,15 +7364,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"json5@npm:^0.5.1":
-  version: 0.5.1
-  resolution: "json5@npm:0.5.1"
-  bin:
-    json5: lib/cli.js
-  checksum: 9b85bf06955b23eaa4b7328aa8892e3887e81ca731dd27af04a5f5f1458fbc5e1de57a24442e3272f8a888dd1abe1cb68eb693324035f6b3aeba4fcab7667d62
-  languageName: node
-  linkType: hard
-
 "json5@npm:^1.0.2":
   version: 1.0.2
   resolution: "json5@npm:1.0.2"
@@ -10092,14 +7408,7 @@ __metadata:
   dependenciesMeta:
     graceful-fs:
       optional: true
-  checksum: 7af3b8e1ac8fe7f1eccc6263c6ca14e1966fcbc74b618d3c78a0a2075579487547b94f72b7a1114e844a1e15bb00d440e5d1720bfc4612d790a6f285d5ea8354
-  languageName: node
-  linkType: hard
-
-"jsonify@npm:^0.0.1":
-  version: 0.0.1
-  resolution: "jsonify@npm:0.0.1"
-  checksum: 027287e1c0294fce15f18c0ff990cfc2318e7f01fb76515f784d5cd0784abfec6fc5c2355c3a2f2cb0ad7f4aa2f5b74ebbfe4e80476c35b2d13cabdb572e1134
+  checksum: 7af3b8e1ac8fe7f1eccc6263c6ca14e1966fcbc74b618d3c78a0a2075579487547b94f72b7a1114e844a1e15bb00d440e5d1720bfc4612d790a6f285d5ea8354
   languageName: node
   linkType: hard
 
@@ -10140,28 +7449,31 @@ __metadata:
   languageName: node
   linkType: hard
 
-"keccak@npm:^3.0.0, keccak@npm:^3.0.2":
-  version: 3.0.4
-  resolution: "keccak@npm:3.0.4"
+"keccak@npm:3.0.2":
+  version: 3.0.2
+  resolution: "keccak@npm:3.0.2"
   dependencies:
     node-addon-api: ^2.0.0
     node-gyp: latest
     node-gyp-build: ^4.2.0
     readable-stream: ^3.6.0
-  checksum: 2bf27b97b2f24225b1b44027de62be547f5c7326d87d249605665abd0c8c599d774671c35504c62c9b922cae02758504c6f76a73a84234d23af8a2211afaaa11
+  checksum: 39a7d6128b8ee4cb7dcd186fc7e20c6087cc39f573a0f81b147c323f688f1f7c2b34f62c4ae189fe9b81c6730b2d1228d8a399cdc1f3d8a4c8f030cdc4f20272
   languageName: node
   linkType: hard
 
-"keyv@npm:^3.0.0":
-  version: 3.1.0
-  resolution: "keyv@npm:3.1.0"
+"keccak@npm:^3.0.0, keccak@npm:^3.0.2":
+  version: 3.0.4
+  resolution: "keccak@npm:3.0.4"
   dependencies:
-    json-buffer: 3.0.0
-  checksum: bb7e8f3acffdbafbc2dd5b63f377fe6ec4c0e2c44fc82720449ef8ab54f4a7ce3802671ed94c0f475ae0a8549703353a2124561fcf3317010c141b32ca1ce903
+    node-addon-api: ^2.0.0
+    node-gyp: latest
+    node-gyp-build: ^4.2.0
+    readable-stream: ^3.6.0
+  checksum: 2bf27b97b2f24225b1b44027de62be547f5c7326d87d249605665abd0c8c599d774671c35504c62c9b922cae02758504c6f76a73a84234d23af8a2211afaaa11
   languageName: node
   linkType: hard
 
-"keyv@npm:^4.0.0, keyv@npm:^4.5.3":
+"keyv@npm:^4.5.3":
   version: 4.5.4
   resolution: "keyv@npm:4.5.4"
   dependencies:
@@ -10170,24 +7482,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"kind-of@npm:^3.0.2, kind-of@npm:^3.0.3, kind-of@npm:^3.2.0":
-  version: 3.2.2
-  resolution: "kind-of@npm:3.2.2"
-  dependencies:
-    is-buffer: ^1.1.5
-  checksum: e898df8ca2f31038f27d24f0b8080da7be274f986bc6ed176f37c77c454d76627619e1681f6f9d2e8d2fd7557a18ecc419a6bb54e422abcbb8da8f1a75e4b386
-  languageName: node
-  linkType: hard
-
-"kind-of@npm:^4.0.0":
-  version: 4.0.0
-  resolution: "kind-of@npm:4.0.0"
-  dependencies:
-    is-buffer: ^1.1.5
-  checksum: 1b9e7624a8771b5a2489026e820f3bbbcc67893e1345804a56b23a91e9069965854d2a223a7c6ee563c45be9d8c6ff1ef87f28ed5f0d1a8d00d9dcbb067c529f
-  languageName: node
-  linkType: hard
-
 "kind-of@npm:^6.0.2":
   version: 6.0.3
   resolution: "kind-of@npm:6.0.3"
@@ -10195,15 +7489,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"klaw-sync@npm:^6.0.0":
-  version: 6.0.0
-  resolution: "klaw-sync@npm:6.0.0"
-  dependencies:
-    graceful-fs: ^4.1.11
-  checksum: 0da397f8961313c3ef8f79fb63af9002cde5a8fb2aeb1a37351feff0dd6006129c790400c3f5c3b4e757bedcabb13d21ec0a5eaef5a593d59515d4f2c291e475
-  languageName: node
-  linkType: hard
-
 "klaw@npm:^1.0.0":
   version: 1.3.1
   resolution: "klaw@npm:1.3.1"
@@ -10216,15 +7501,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"lcid@npm:^1.0.0":
-  version: 1.0.0
-  resolution: "lcid@npm:1.0.0"
-  dependencies:
-    invert-kv: ^1.0.0
-  checksum: e8c7a4db07663068c5c44b650938a2bc41aa992037eebb69376214320f202c1250e70b50c32f939e28345fd30c2d35b8e8cd9a19d5932c398246a864ce54843d
-  languageName: node
-  linkType: hard
-
 "lcid@npm:^2.0.0":
   version: 2.0.0
   resolution: "lcid@npm:2.0.0"
@@ -10243,19 +7519,19 @@ __metadata:
   languageName: node
   linkType: hard
 
-"level-codec@npm:~7.0.0":
-  version: 7.0.1
-  resolution: "level-codec@npm:7.0.1"
-  checksum: 2565c131d93aea0786af5eda9bb907e3f5152fade03fd7a7751e2f95301fc5241063eb927c2f7df086fac33592523aab8df86bcf7ecc46ed53de11453b600329
+"level-concat-iterator@npm:^3.0.0":
+  version: 3.1.0
+  resolution: "level-concat-iterator@npm:3.1.0"
+  dependencies:
+    catering: ^2.1.0
+  checksum: a15bc4c5fbbb30c1efa7fad06b72feaac84d90990b356b461593c198a833336f31f6daff8f40c3908fabd14cfd8856d1c5ecae9e1cb0575037b65fa607e760e9
   languageName: node
   linkType: hard
 
-"level-errors@npm:^1.0.3":
-  version: 1.1.2
-  resolution: "level-errors@npm:1.1.2"
-  dependencies:
-    errno: ~0.1.1
-  checksum: 18c22fd574ff31567642a85d9a306604a32cbe969b8469fee29620c10488214a6b5e6bbf19e3b5e2042859e4b81041af537319c18132a1aaa56d4ed5981157b7
+"level-concat-iterator@npm:~2.0.0":
+  version: 2.0.1
+  resolution: "level-concat-iterator@npm:2.0.1"
+  checksum: 562583ef1292215f8e749c402510cb61c4d6fccf4541082b3d21dfa5ecde9fcccfe52bdcb5cfff9d2384e7ce5891f44df9439a6ddb39b0ffe31015600b4a828a
   languageName: node
   linkType: hard
 
@@ -10268,169 +7544,86 @@ __metadata:
   languageName: node
   linkType: hard
 
-"level-errors@npm:~1.0.3":
-  version: 1.0.5
-  resolution: "level-errors@npm:1.0.5"
-  dependencies:
-    errno: ~0.1.1
-  checksum: a62df2a24987c0100855ec03f03655ddc6170b33a83987a53858ba0a7dbe125b4b5382e01068a1dc899ccf7f9d12b824702da15488bd06b4b3ee7a1e4232cb0a
-  languageName: node
-  linkType: hard
-
-"level-iterator-stream@npm:^2.0.3":
-  version: 2.0.3
-  resolution: "level-iterator-stream@npm:2.0.3"
-  dependencies:
-    inherits: ^2.0.1
-    readable-stream: ^2.0.5
-    xtend: ^4.0.0
-  checksum: dd4211798d032a06ebc3e9c5a3a969b003cb15f1fe6398d9c50c87dc8b0bf8b07197cada253fd7f8c4a933f3c86e12bb041df1561c89b749ac4b991d6e68b17f
-  languageName: node
-  linkType: hard
-
-"level-iterator-stream@npm:~1.3.0":
-  version: 1.3.1
-  resolution: "level-iterator-stream@npm:1.3.1"
-  dependencies:
-    inherits: ^2.0.1
-    level-errors: ^1.0.3
-    readable-stream: ^1.0.33
-    xtend: ^4.0.0
-  checksum: bf57d8dcee6e7ec68e6c580edc768d2e3960f93e741d7d4adcc7d86f267c741ebcfba5353b3b6551ca10d12e30939c90f1a13303313b1b719325111f0ff14540
-  languageName: node
-  linkType: hard
-
-"level-iterator-stream@npm:~3.0.0":
-  version: 3.0.1
-  resolution: "level-iterator-stream@npm:3.0.1"
-  dependencies:
-    inherits: ^2.0.1
-    readable-stream: ^2.3.6
-    xtend: ^4.0.0
-  checksum: f3348316907c70163ea15319ef7e28c21c6b4b948616e11dcbbb8e3dab9ec5b39f7bf13e0d53f7d23c69641b7a2985a4911c5c9a03bd57a07f1af469aba6e3a8
-  languageName: node
-  linkType: hard
-
-"level-mem@npm:^3.0.1":
-  version: 3.0.1
-  resolution: "level-mem@npm:3.0.1"
-  dependencies:
-    level-packager: ~4.0.0
-    memdown: ~3.0.0
-  checksum: e4c680922afc3c8cd4502d761ab610c8aa7bcacde2550a0a463e1db069eeb55b6b7bec0bb7fda564cec82422944776f9909fe101b0d7746ad8f4f7446ec2a5cd
-  languageName: node
-  linkType: hard
-
-"level-packager@npm:~4.0.0":
-  version: 4.0.1
-  resolution: "level-packager@npm:4.0.1"
+"level-iterator-stream@npm:~4.0.0":
+  version: 4.0.2
+  resolution: "level-iterator-stream@npm:4.0.2"
   dependencies:
-    encoding-down: ~5.0.0
-    levelup: ^3.0.0
-  checksum: af33054cfdf1f3cb409941c2e6a67190c0437f8b57a518fa1d40d3f9fd75edbb72c2c17595a52b10030fe2d64c8ef474ddb570f925d88402c94cfc95263865cb
+    inherits: ^2.0.4
+    readable-stream: ^3.4.0
+    xtend: ^4.0.2
+  checksum: 239e2c7e62bffb485ed696bcd3b98de7a2bc455d13be4fce175ae3544fe9cda81c2ed93d3e88b61380ae6d28cce02511862d77b86fb2ba5b5cf00471f3c1eccc
   languageName: node
   linkType: hard
 
-"level-post@npm:^1.0.7":
-  version: 1.0.7
-  resolution: "level-post@npm:1.0.7"
+"level-mem@npm:^5.0.1":
+  version: 5.0.1
+  resolution: "level-mem@npm:5.0.1"
   dependencies:
-    ltgt: ^2.1.2
-  checksum: 27239cfebe2004036d7ed0ace860d03f829f099de62baf727cce53bd99cb06bfc4a202fa7cb828847fa01c421bab13d9d3e79c9554f5cffff681541dda575218
+    level-packager: ^5.0.3
+    memdown: ^5.0.0
+  checksum: 37a38163b0c7cc55f64385fdff78438669f953bc08dc751739e2f1edd401472a89001a73a95cc8b81f38f989e46279797c11eb82e702690ea9a171e02bf31e84
   languageName: node
   linkType: hard
 
-"level-sublevel@npm:6.6.4":
-  version: 6.6.4
-  resolution: "level-sublevel@npm:6.6.4"
+"level-packager@npm:^5.0.3":
+  version: 5.1.1
+  resolution: "level-packager@npm:5.1.1"
   dependencies:
-    bytewise: ~1.1.0
-    level-codec: ^9.0.0
-    level-errors: ^2.0.0
-    level-iterator-stream: ^2.0.3
-    ltgt: ~2.1.1
-    pull-defer: ^0.2.2
-    pull-level: ^2.0.3
-    pull-stream: ^3.6.8
-    typewiselite: ~1.0.0
-    xtend: ~4.0.0
-  checksum: 8370e6fbf67bf08daa23de07699d3d2ccf6a349a28db4025a890d4c07857811808372fdf5029c4afedf24e2ff828be6bb7cd9fd0b676090daba38981b2e75cff
+    encoding-down: ^6.3.0
+    levelup: ^4.3.2
+  checksum: befe2aa54f2010a6ecf7ddce392c8dee225e1839205080a2704d75e560e28b01191b345494696196777b70d376e3eaae4c9e7c330cc70d3000839f5b18dd78f2
   languageName: node
   linkType: hard
 
-"level-supports@npm:^4.0.0":
-  version: 4.0.1
-  resolution: "level-supports@npm:4.0.1"
-  checksum: d4552b42bb8cdeada07b0f6356c7a90fefe76279147331f291aceae26e3e56d5f927b09ce921647c0230bfe03ddfbdcef332be921e5c2194421ae2bfa3cf6368
+"level-supports@npm:^2.0.1":
+  version: 2.1.0
+  resolution: "level-supports@npm:2.1.0"
+  checksum: f7b16aea7ddd13326ee4fbc2c1099bcaf8a74dc95346af9ebedea4e02518c6f7a438e829b79b7890d67489b59f615a9428369a0a065021797aa7cb6b6bd84d75
   languageName: node
   linkType: hard
 
-"level-transcoder@npm:^1.0.1":
+"level-supports@npm:~1.0.0":
   version: 1.0.1
-  resolution: "level-transcoder@npm:1.0.1"
-  dependencies:
-    buffer: ^6.0.3
-    module-error: ^1.0.1
-  checksum: 304f08d802faf3491a533b6d87ad8be3cabfd27f2713bbe9d4c633bf50fcb9460eab5a6776bf015e101ead7ba1c1853e05e7f341112f17a9d0cb37ee5a421a25
-  languageName: node
-  linkType: hard
-
-"level-ws@npm:0.0.0":
-  version: 0.0.0
-  resolution: "level-ws@npm:0.0.0"
+  resolution: "level-supports@npm:1.0.1"
   dependencies:
-    readable-stream: ~1.0.15
-    xtend: ~2.1.1
-  checksum: fcc3e6993b538ed8931612a74ef26cf32b53d71c059a819bb1006c075f0c1198afb79026a69aeeafcbd4598c45b4b214315b4216b44eca68587fce1b5ad61b75
+    xtend: ^4.0.2
+  checksum: 5d6bdb88cf00c3d9adcde970db06a548c72c5a94bf42c72f998b58341a105bfe2ea30d313ce1e84396b98cc9ddbc0a9bd94574955a86e929f73c986e10fc0df0
   languageName: node
   linkType: hard
 
-"level-ws@npm:^1.0.0":
-  version: 1.0.0
-  resolution: "level-ws@npm:1.0.0"
+"level-ws@npm:^2.0.0":
+  version: 2.0.0
+  resolution: "level-ws@npm:2.0.0"
   dependencies:
     inherits: ^2.0.3
-    readable-stream: ^2.2.8
+    readable-stream: ^3.1.0
     xtend: ^4.0.1
-  checksum: 752fd0f89eb1ccf811c09de24ca8987437ea84f88e672d0037324fb5d71c5bc022c25ba64d6a00fca33beec48a81e3cd1ef99c2f9fff267b3a4f2233939fad35
+  checksum: 4e5cbf090a07367373f693c98ad5b4797e7e694ea801ce5cd4103e06837ec883bdce9588ac11e0b9963ca144b96c95c6401c9e43583028ba1e4f847e81ec9ad6
   languageName: node
   linkType: hard
 
-"level@npm:^8.0.0":
-  version: 8.0.1
-  resolution: "level@npm:8.0.1"
+"leveldown@npm:6.1.0":
+  version: 6.1.0
+  resolution: "leveldown@npm:6.1.0"
   dependencies:
-    abstract-level: ^1.0.4
-    browser-level: ^1.0.1
-    classic-level: ^1.2.0
-  checksum: c5641cbba666ef9eb0292aad01d86a4f1af18e637d1fc097c65bf0109ab8d7e6fba8c8faf6c74ae4e48edac4310f7dd87def26ffeebfe395c7afd9bd2461ab97
+    abstract-leveldown: ^7.2.0
+    napi-macros: ~2.0.0
+    node-gyp: latest
+    node-gyp-build: ^4.3.0
+  checksum: e984b61e9fbe057cfd5c81ac0afe5d7e35d695ff130a95991e0ecb66390e4c4ff6aa3980a65b6c53edaba80527a47790bb26e3cfbd52a054957b3546d9941fe4
   languageName: node
   linkType: hard
 
-"levelup@npm:3.1.1, levelup@npm:^3.0.0":
-  version: 3.1.1
-  resolution: "levelup@npm:3.1.1"
+"levelup@npm:^4.3.2":
+  version: 4.4.0
+  resolution: "levelup@npm:4.4.0"
   dependencies:
-    deferred-leveldown: ~4.0.0
+    deferred-leveldown: ~5.3.0
     level-errors: ~2.0.0
-    level-iterator-stream: ~3.0.0
-    xtend: ~4.0.0
-  checksum: cddcac2cf5eddcf85ade62efd21f11326cd83559619db6a78696725eac5c5cd16f62d8d49f6594fd3097d9329a1d04847f6d7df23bf4d69f18c16e49afd4a416
-  languageName: node
-  linkType: hard
-
-"levelup@npm:^1.2.1":
-  version: 1.3.9
-  resolution: "levelup@npm:1.3.9"
-  dependencies:
-    deferred-leveldown: ~1.2.1
-    level-codec: ~7.0.0
-    level-errors: ~1.0.3
-    level-iterator-stream: ~1.3.0
-    prr: ~1.0.1
-    semver: ~5.4.1
+    level-iterator-stream: ~4.0.0
+    level-supports: ~1.0.0
     xtend: ~4.0.0
-  checksum: df3b534b948c17d724050f6ecc2b21eb2fde357bd0c68582cd3a5eb4bf943a3057cd2e9db6bd7253020fcb853c83a70943bff9264f5132afa8cf3c25c3c7cd8e
+  checksum: 5a09e34c78cd7c23f9f6cb73563f1ebe8121ffc5f9f5f232242529d4fbdd40e8d1ffb337d2defa0b842334e0dbd4028fbfe7a072eebfe2c4d07174f0aa4aabca
   languageName: node
   linkType: hard
 
@@ -10461,19 +7654,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"load-json-file@npm:^1.0.0":
-  version: 1.1.0
-  resolution: "load-json-file@npm:1.1.0"
-  dependencies:
-    graceful-fs: ^4.1.2
-    parse-json: ^2.2.0
-    pify: ^2.0.0
-    pinkie-promise: ^2.0.0
-    strip-bom: ^2.0.0
-  checksum: 0e4e4f380d897e13aa236246a917527ea5a14e4fc34d49e01ce4e7e2a1e08e2740ee463a03fb021c04f594f29a178f4adb994087549d7c1c5315fcd29bf9934b
-  languageName: node
-  linkType: hard
-
 "locate-path@npm:^2.0.0":
   version: 2.0.0
   resolution: "locate-path@npm:2.0.0"
@@ -10503,13 +7683,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"lodash.assign@npm:^4.0.3, lodash.assign@npm:^4.0.6":
-  version: 4.2.0
-  resolution: "lodash.assign@npm:4.2.0"
-  checksum: 75bbc6733c9f577c448031b4051f990f068802708891f94be9d4c2faffd6a9ec67a2c49671dafc908a068d35687765464853282842b4560b662e6c903d11cc90
-  languageName: node
-  linkType: hard
-
 "lodash.camelcase@npm:^4.3.0":
   version: 4.3.0
   resolution: "lodash.camelcase@npm:4.3.0"
@@ -10531,13 +7704,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"lodash.isequalwith@npm:^4.4.0":
-  version: 4.4.0
-  resolution: "lodash.isequalwith@npm:4.4.0"
-  checksum: 428ba7a57c47ec05e2dd18c03a4b4c45dac524a46af7ce3f412594bfc7be6a5acaa51acf9ea113d0002598e9aafc6e19ee8d20bc28363145fcb4d21808c9039f
-  languageName: node
-  linkType: hard
-
 "lodash.kebabcase@npm:^4.1.1":
   version: 4.1.1
   resolution: "lodash.kebabcase@npm:4.1.1"
@@ -10650,14 +7816,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"lodash@npm:4.17.20":
-  version: 4.17.20
-  resolution: "lodash@npm:4.17.20"
-  checksum: b31afa09739b7292a88ec49ffdb2fcaeb41f690def010f7a067eeedffece32da6b6847bfe4d38a77e6f41778b9b2bca75eeab91209936518173271f0b69376ea
-  languageName: node
-  linkType: hard
-
-"lodash@npm:^4.17.11, lodash@npm:^4.17.14, lodash@npm:^4.17.15, lodash@npm:^4.17.19, lodash@npm:^4.17.21, lodash@npm:^4.17.4":
+"lodash@npm:^4.17.11, lodash@npm:^4.17.14, lodash@npm:^4.17.15, lodash@npm:^4.17.19, lodash@npm:^4.17.21":
   version: 4.17.21
   resolution: "lodash@npm:4.17.21"
   checksum: eb835a2e51d381e561e508ce932ea50a8e5a68f4ebdd771ea240d3048244a8d13658acbd502cd4829768c56f2e16bdd4340b9ea141297d472517b83868e677f7
@@ -10690,31 +7849,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"looper@npm:^2.0.0":
-  version: 2.0.0
-  resolution: "looper@npm:2.0.0"
-  checksum: ee5124d54c97cd9e778e602e297ed37dd6405b7c36830f90bb1aaa6adb8d64f2a228aa341459e6bf2db9a8d7dc9eb8c16ec9c6bffeab1c47f91efe213858ce36
-  languageName: node
-  linkType: hard
-
-"looper@npm:^3.0.0":
-  version: 3.0.0
-  resolution: "looper@npm:3.0.0"
-  checksum: 2ec29b4161e95d33f2257867b0b9ab7f2fef5425582362c966f8f9041a2a6032466b8be159af99323655aca9e6fe1c9da086cf208f6346bd97c9f83ab77ccce0
-  languageName: node
-  linkType: hard
-
-"loose-envify@npm:^1.0.0":
-  version: 1.4.0
-  resolution: "loose-envify@npm:1.4.0"
-  dependencies:
-    js-tokens: ^3.0.0 || ^4.0.0
-  bin:
-    loose-envify: cli.js
-  checksum: 6517e24e0cad87ec9888f500c5b5947032cdfe6ef65e1c1936a0c48a524b81e65542c9c3edc91c97d5bddc806ee2a985dbc79be89215d613b1de5db6d1cfe6f4
-  languageName: node
-  linkType: hard
-
 "loupe@npm:^2.3.6":
   version: 2.3.7
   resolution: "loupe@npm:2.3.7"
@@ -10724,29 +7858,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"lowercase-keys@npm:^1.0.0, lowercase-keys@npm:^1.0.1":
-  version: 1.0.1
-  resolution: "lowercase-keys@npm:1.0.1"
-  checksum: 4d045026595936e09953e3867722e309415ff2c80d7701d067546d75ef698dac218a4f53c6d1d0e7368b47e45fd7529df47e6cb56fbb90523ba599f898b3d147
-  languageName: node
-  linkType: hard
-
-"lowercase-keys@npm:^2.0.0":
-  version: 2.0.0
-  resolution: "lowercase-keys@npm:2.0.0"
-  checksum: 24d7ebd56ccdf15ff529ca9e08863f3c54b0b9d1edb97a3ae1af34940ae666c01a1e6d200707bce730a8ef76cb57cc10e65f245ecaaf7e6bc8639f2fb460ac23
-  languageName: node
-  linkType: hard
-
-"lru-cache@npm:5.1.1, lru-cache@npm:^5.1.1":
-  version: 5.1.1
-  resolution: "lru-cache@npm:5.1.1"
-  dependencies:
-    yallist: ^3.0.2
-  checksum: c154ae1cbb0c2206d1501a0e94df349653c92c8cbb25236d7e85190bcaf4567a03ac6eb43166fabfa36fd35623694da7233e88d9601fbf411a9a481d85dbd2cb
-  languageName: node
-  linkType: hard
-
 "lru-cache@npm:^10.0.1, lru-cache@npm:^9.1.1 || ^10.0.0":
   version: 10.2.0
   resolution: "lru-cache@npm:10.2.0"
@@ -10754,12 +7865,12 @@ __metadata:
   languageName: node
   linkType: hard
 
-"lru-cache@npm:^3.2.0":
-  version: 3.2.0
-  resolution: "lru-cache@npm:3.2.0"
+"lru-cache@npm:^5.1.1":
+  version: 5.1.1
+  resolution: "lru-cache@npm:5.1.1"
   dependencies:
-    pseudomap: ^1.0.1
-  checksum: 8e5fb3d7a83401165b8dc9fe16d74828df5754aaeda1061e4f2ea1d0e984b9071a6487f1c3f6f034f935429629f94366abbfb753827ab2977a56b3f5c276e736
+    yallist: ^3.0.2
+  checksum: c154ae1cbb0c2206d1501a0e94df349653c92c8cbb25236d7e85190bcaf4567a03ac6eb43166fabfa36fd35623694da7233e88d9601fbf411a9a481d85dbd2cb
   languageName: node
   linkType: hard
 
@@ -10779,20 +7890,13 @@ __metadata:
   languageName: node
   linkType: hard
 
-"ltgt@npm:^2.1.2, ltgt@npm:~2.2.0":
+"ltgt@npm:~2.2.0":
   version: 2.2.1
   resolution: "ltgt@npm:2.2.1"
   checksum: 7e3874296f7538bc8087b428ac4208008d7b76916354b34a08818ca7c83958c1df10ec427eeeaad895f6b81e41e24745b18d30f89abcc21d228b94f6961d50a2
   languageName: node
   linkType: hard
 
-"ltgt@npm:~2.1.1":
-  version: 2.1.3
-  resolution: "ltgt@npm:2.1.3"
-  checksum: b09281f6aeccb34eda52588d21f9116f6e5b7ae1c79f6180bba06edcdcba50de9c6d199be7f817a7ae59819064e3ca7d066fe0bcc67e2458006e4e45cd05cb11
-  languageName: node
-  linkType: hard
-
 "make-error@npm:^1.1.1":
   version: 1.3.6
   resolution: "make-error@npm:1.3.6"
@@ -10828,22 +7932,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"map-cache@npm:^0.2.2":
-  version: 0.2.2
-  resolution: "map-cache@npm:0.2.2"
-  checksum: 3067cea54285c43848bb4539f978a15dedc63c03022abeec6ef05c8cb6829f920f13b94bcaf04142fc6a088318e564c4785704072910d120d55dbc2e0c421969
-  languageName: node
-  linkType: hard
-
-"map-visit@npm:^1.0.0":
-  version: 1.0.0
-  resolution: "map-visit@npm:1.0.0"
-  dependencies:
-    object-visit: ^1.0.0
-  checksum: c27045a5021c344fc19b9132eb30313e441863b2951029f8f8b66f79d3d8c1e7e5091578075a996f74e417479506fe9ede28c44ca7bc351a61c9d8073daec36a
-  languageName: node
-  linkType: hard
-
 "markdown-table@npm:^1.1.3":
   version: 1.1.3
   resolution: "markdown-table@npm:1.1.3"
@@ -10869,13 +7957,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"media-typer@npm:0.3.0":
-  version: 0.3.0
-  resolution: "media-typer@npm:0.3.0"
-  checksum: af1b38516c28ec95d6b0826f6c8f276c58aec391f76be42aa07646b4e39d317723e869700933ca6995b056db4b09a78c92d5440dc23657e6764be5d28874bba1
-  languageName: node
-  linkType: hard
-
 "mem@npm:^4.0.0":
   version: 4.3.0
   resolution: "mem@npm:4.3.0"
@@ -10887,42 +7968,17 @@ __metadata:
   languageName: node
   linkType: hard
 
-"memdown@npm:^1.0.0":
-  version: 1.4.1
-  resolution: "memdown@npm:1.4.1"
-  dependencies:
-    abstract-leveldown: ~2.7.1
-    functional-red-black-tree: ^1.0.1
-    immediate: ^3.2.3
-    inherits: ~2.0.1
-    ltgt: ~2.2.0
-    safe-buffer: ~5.1.1
-  checksum: 3f89142a12389b1ebfc7adaf3be19ed57cd073f84160eb7419b61c8e188e2b82eb787dad168d7b00ca68355b6b952067d9badaa5ac88c8ee014e4b0af2bfaea0
-  languageName: node
-  linkType: hard
-
-"memdown@npm:~3.0.0":
-  version: 3.0.0
-  resolution: "memdown@npm:3.0.0"
+"memdown@npm:^5.0.0":
+  version: 5.1.0
+  resolution: "memdown@npm:5.1.0"
   dependencies:
-    abstract-leveldown: ~5.0.0
+    abstract-leveldown: ~6.2.1
     functional-red-black-tree: ~1.0.1
     immediate: ~3.2.3
     inherits: ~2.0.1
     ltgt: ~2.2.0
-    safe-buffer: ~5.1.1
-  checksum: 4446fdf7198dcdbae764324200526f41738c9f2a32decb59b5a4dbb1bdfc72e2fc046e9bbe016469ab8a0a52e5d5c8b36bf3829e90dd4674a5f4c961e059d4de
-  languageName: node
-  linkType: hard
-
-"memory-level@npm:^1.0.0":
-  version: 1.0.0
-  resolution: "memory-level@npm:1.0.0"
-  dependencies:
-    abstract-level: ^1.0.0
-    functional-red-black-tree: ^1.0.1
-    module-error: ^1.0.1
-  checksum: 80b1b7aedaf936e754adbcd7b9303018c3684fb32f9992fd967c448f145d177f16c724fbba9ed3c3590a9475fd563151eae664d69b83d2ad48714852e9fc5c72
+    safe-buffer: ~5.2.0
+  checksum: 23e4414034e975eae1edd6864874bbe77501d41814fc27e8ead946c3379cb1cbea303d724083d08a6a269af9bf5d55073f1f767dfa7ad6e70465769f87e29794
   languageName: node
   linkType: hard
 
@@ -10933,13 +7989,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"merge-descriptors@npm:1.0.1":
-  version: 1.0.1
-  resolution: "merge-descriptors@npm:1.0.1"
-  checksum: 5abc259d2ae25bb06d19ce2b94a21632583c74e2a9109ee1ba7fd147aa7362b380d971e0251069f8b3eb7d48c21ac839e21fa177b335e82c76ec172e30c31a26
-  languageName: node
-  linkType: hard
-
 "merge-options@npm:^3.0.4":
   version: 3.0.4
   resolution: "merge-options@npm:3.0.4"
@@ -10963,41 +8012,17 @@ __metadata:
   languageName: node
   linkType: hard
 
-"merkle-patricia-tree@npm:3.0.0":
-  version: 3.0.0
-  resolution: "merkle-patricia-tree@npm:3.0.0"
-  dependencies:
-    async: ^2.6.1
-    ethereumjs-util: ^5.2.0
-    level-mem: ^3.0.1
-    level-ws: ^1.0.0
-    readable-stream: ^3.0.6
-    rlp: ^2.0.0
-    semaphore: ">=1.0.1"
-  checksum: a500f00e7954eea132309310c48ee2635e9a190e0a775811236a0dc375465ff7e01b230ac0ee213ca13bb995399066719eedb4218e0f47596e9cab79cebc575e
-  languageName: node
-  linkType: hard
-
-"merkle-patricia-tree@npm:^2.1.2, merkle-patricia-tree@npm:^2.3.2":
-  version: 2.3.2
-  resolution: "merkle-patricia-tree@npm:2.3.2"
+"merkle-patricia-tree@npm:^4.2.2, merkle-patricia-tree@npm:^4.2.4":
+  version: 4.2.4
+  resolution: "merkle-patricia-tree@npm:4.2.4"
   dependencies:
-    async: ^1.4.2
-    ethereumjs-util: ^5.0.0
-    level-ws: 0.0.0
-    levelup: ^1.2.1
-    memdown: ^1.0.0
-    readable-stream: ^2.0.0
-    rlp: ^2.0.0
-    semaphore: ">=1.0.1"
-  checksum: f6066a16e08190b9e8d3aa28d8e861a3e884ee0be8109c4f5e879965fdfb8181cfc04bae3aaf97c7fb6d07446d94b4f3e1cce502dde4a5699a03acf6df518b12
-  languageName: node
-  linkType: hard
-
-"methods@npm:~1.1.2":
-  version: 1.1.2
-  resolution: "methods@npm:1.1.2"
-  checksum: 0917ff4041fa8e2f2fda5425a955fe16ca411591fbd123c0d722fcf02b73971ed6f764d85f0a6f547ce49ee0221ce2c19a5fa692157931cecb422984f1dcd13a
+    "@types/levelup": ^4.3.0
+    ethereumjs-util: ^7.1.4
+    level-mem: ^5.0.1
+    level-ws: ^2.0.0
+    readable-stream: ^3.6.0
+    semaphore-async-await: ^1.5.1
+  checksum: acedc7eea7bb14b97da01e8e023406ed55742f8e82bdd28d1ed821e3bd0cfed9e92f18c7cb300aee0d38f319c960026fd4d4e601f61e2a8665b73c0786d9f799
   languageName: node
   linkType: hard
 
@@ -11008,28 +8033,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"micromatch@npm:^3.1.4":
-  version: 3.1.10
-  resolution: "micromatch@npm:3.1.10"
-  dependencies:
-    arr-diff: ^4.0.0
-    array-unique: ^0.3.2
-    braces: ^2.3.1
-    define-property: ^2.0.2
-    extend-shallow: ^3.0.2
-    extglob: ^2.0.4
-    fragment-cache: ^0.2.1
-    kind-of: ^6.0.2
-    nanomatch: ^1.2.9
-    object.pick: ^1.3.0
-    regex-not: ^1.0.0
-    snapdragon: ^0.8.1
-    to-regex: ^3.0.2
-  checksum: ad226cba4daa95b4eaf47b2ca331c8d2e038d7b41ae7ed0697cde27f3f1d6142881ab03d4da51b65d9d315eceb5e4cdddb3fbb55f5f72cfa19cf3ea469d054dc
-  languageName: node
-  linkType: hard
-
-"micromatch@npm:^4.0.2, micromatch@npm:^4.0.4":
+"micromatch@npm:^4.0.4":
   version: 4.0.5
   resolution: "micromatch@npm:4.0.5"
   dependencies:
@@ -11058,7 +8062,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"mime-types@npm:^2.1.12, mime-types@npm:^2.1.16, mime-types@npm:~2.1.19, mime-types@npm:~2.1.24, mime-types@npm:~2.1.34":
+"mime-types@npm:^2.1.12, mime-types@npm:~2.1.19":
   version: 2.1.35
   resolution: "mime-types@npm:2.1.35"
   dependencies:
@@ -11067,15 +8071,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"mime@npm:1.6.0":
-  version: 1.6.0
-  resolution: "mime@npm:1.6.0"
-  bin:
-    mime: cli.js
-  checksum: fef25e39263e6d207580bdc629f8872a3f9772c923c7f8c7e793175cee22777bbe8bba95e5d509a40aaa292d8974514ce634ae35769faa45f22d17edda5e8557
-  languageName: node
-  linkType: hard
-
 "mimic-fn@npm:^2.0.0, mimic-fn@npm:^2.1.0":
   version: 2.1.0
   resolution: "mimic-fn@npm:2.1.0"
@@ -11083,29 +8078,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"mimic-response@npm:^1.0.0, mimic-response@npm:^1.0.1":
-  version: 1.0.1
-  resolution: "mimic-response@npm:1.0.1"
-  checksum: 034c78753b0e622bc03c983663b1cdf66d03861050e0c8606563d149bc2b02d63f62ce4d32be4ab50d0553ae0ffe647fc34d1f5281184c6e1e8cf4d85e8d9823
-  languageName: node
-  linkType: hard
-
-"mimic-response@npm:^3.1.0":
-  version: 3.1.0
-  resolution: "mimic-response@npm:3.1.0"
-  checksum: 25739fee32c17f433626bf19f016df9036b75b3d84a3046c7d156e72ec963dd29d7fc8a302f55a3d6c5a4ff24259676b15d915aad6480815a969ff2ec0836867
-  languageName: node
-  linkType: hard
-
-"min-document@npm:^2.19.0":
-  version: 2.19.0
-  resolution: "min-document@npm:2.19.0"
-  dependencies:
-    dom-walk: ^0.1.0
-  checksum: da6437562ea2228041542a2384528e74e22d1daa1a4ec439c165abf0b9d8a63e17e3b8a6dc6e0c731845e85301198730426932a0e813d23f932ca668340c9623
-  languageName: node
-  linkType: hard
-
 "minimalistic-assert@npm:^1.0.0, minimalistic-assert@npm:^1.0.1":
   version: 1.0.1
   resolution: "minimalistic-assert@npm:1.0.1"
@@ -11156,7 +8128,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"minimist@npm:^1.2.0, minimist@npm:^1.2.5, minimist@npm:^1.2.6, minimist@npm:^1.2.7, minimist@npm:~1.2.8":
+"minimist@npm:^1.2.0, minimist@npm:^1.2.5, minimist@npm:^1.2.6, minimist@npm:^1.2.7":
   version: 1.2.8
   resolution: "minimist@npm:1.2.8"
   checksum: 75a6d645fb122dad29c06a7597bddea977258957ed88d7a6df59b5cd3fe4a527e253e9bbf2e783e4b73657f9098b96a5fe96ab8a113655d4109108577ecf85b0
@@ -11214,16 +8186,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"minipass@npm:^2.6.0, minipass@npm:^2.9.0":
-  version: 2.9.0
-  resolution: "minipass@npm:2.9.0"
-  dependencies:
-    safe-buffer: ^5.1.2
-    yallist: ^3.0.0
-  checksum: 077b66f31ba44fd5a0d27d12a9e6a86bff8f97a4978dedb0373167156b5599fadb6920fdde0d9f803374164d810e05e8462ce28e86abbf7f0bea293a93711fc6
-  languageName: node
-  linkType: hard
-
 "minipass@npm:^3.0.0":
   version: 3.3.6
   resolution: "minipass@npm:3.3.6"
@@ -11247,54 +8209,17 @@ __metadata:
   languageName: node
   linkType: hard
 
-"minizlib@npm:^1.3.3":
-  version: 1.3.3
-  resolution: "minizlib@npm:1.3.3"
-  dependencies:
-    minipass: ^2.9.0
-  checksum: b0425c04d2ae6aad5027462665f07cc0d52075f7fa16e942b4611115f9b31f02924073b7221be6f75929d3c47ab93750c63f6dc2bbe8619ceacb3de1f77732c0
-  languageName: node
-  linkType: hard
-
-"minizlib@npm:^2.1.1, minizlib@npm:^2.1.2":
-  version: 2.1.2
-  resolution: "minizlib@npm:2.1.2"
-  dependencies:
-    minipass: ^3.0.0
-    yallist: ^4.0.0
-  checksum: f1fdeac0b07cf8f30fcf12f4b586795b97be856edea22b5e9072707be51fc95d41487faec3f265b42973a304fe3a64acd91a44a3826a963e37b37bafde0212c3
-  languageName: node
-  linkType: hard
-
-"mixin-deep@npm:^1.2.0":
-  version: 1.3.2
-  resolution: "mixin-deep@npm:1.3.2"
-  dependencies:
-    for-in: ^1.0.2
-    is-extendable: ^1.0.1
-  checksum: 820d5a51fcb7479f2926b97f2c3bb223546bc915e6b3a3eb5d906dda871bba569863595424a76682f2b15718252954644f3891437cb7e3f220949bed54b1750d
-  languageName: node
-  linkType: hard
-
-"mkdirp-promise@npm:^5.0.1":
-  version: 5.0.1
-  resolution: "mkdirp-promise@npm:5.0.1"
-  dependencies:
-    mkdirp: "*"
-  checksum: 31ddc9478216adf6d6bee9ea7ce9ccfe90356d9fcd1dfb18128eac075390b4161356d64c3a7b0a75f9de01a90aadd990a0ec8c7434036563985c4b853a053ee2
-  languageName: node
-  linkType: hard
-
-"mkdirp@npm:*":
-  version: 3.0.1
-  resolution: "mkdirp@npm:3.0.1"
-  bin:
-    mkdirp: dist/cjs/src/bin.js
-  checksum: 972deb188e8fb55547f1e58d66bd6b4a3623bf0c7137802582602d73e6480c1c2268dcbafbfb1be466e00cc7e56ac514d7fd9334b7cf33e3e2ab547c16f83a8d
+"minizlib@npm:^2.1.1, minizlib@npm:^2.1.2":
+  version: 2.1.2
+  resolution: "minizlib@npm:2.1.2"
+  dependencies:
+    minipass: ^3.0.0
+    yallist: ^4.0.0
+  checksum: f1fdeac0b07cf8f30fcf12f4b586795b97be856edea22b5e9072707be51fc95d41487faec3f265b42973a304fe3a64acd91a44a3826a963e37b37bafde0212c3
   languageName: node
   linkType: hard
 
-"mkdirp@npm:0.5.x, mkdirp@npm:^0.5.1, mkdirp@npm:^0.5.5":
+"mkdirp@npm:0.5.x, mkdirp@npm:^0.5.1":
   version: 0.5.6
   resolution: "mkdirp@npm:0.5.6"
   dependencies:
@@ -11355,34 +8280,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"mock-fs@npm:^4.1.0":
-  version: 4.14.0
-  resolution: "mock-fs@npm:4.14.0"
-  checksum: dccd976a8d753e19d3c7602ea422d1f7137def3c1128c177e1f5500fe8c50ec15fe0937cfc3a15c4577fe7adb9a37628b92da9294d13d90f08be4b669b0fca76
-  languageName: node
-  linkType: hard
-
-"mock-property@npm:~1.0.0":
-  version: 1.0.3
-  resolution: "mock-property@npm:1.0.3"
-  dependencies:
-    define-data-property: ^1.1.1
-    functions-have-names: ^1.2.3
-    gopd: ^1.0.1
-    has-property-descriptors: ^1.0.0
-    hasown: ^2.0.0
-    isarray: ^2.0.5
-  checksum: 835b106e38580c929def6803dad58fc8299d77ed876faed0098f9eb2076e30a2ef36fb5098adac87a4901c13532de86a859e63c8b6769fb7527e1dbbb6430cce
-  languageName: node
-  linkType: hard
-
-"module-error@npm:^1.0.1, module-error@npm:^1.0.2":
-  version: 1.0.2
-  resolution: "module-error@npm:1.0.2"
-  checksum: 5d653e35bd55b3e95f8aee2cdac108082ea892e71b8f651be92cde43e4ee86abee4fa8bd7fc3fe5e68b63926d42f63c54cd17b87a560c31f18739295575a3962
-  languageName: node
-  linkType: hard
-
 "ms@npm:2.0.0":
   version: 2.0.0
   resolution: "ms@npm:2.0.0"
@@ -11427,45 +8324,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"multibase@npm:^0.7.0":
-  version: 0.7.0
-  resolution: "multibase@npm:0.7.0"
-  dependencies:
-    base-x: ^3.0.8
-    buffer: ^5.5.0
-  checksum: 3a520897d706b3064b59ddee286a9e1a5b35bb19bd830f93d7ddecdbf69fa46648c8fda0fec49a5d4640b8b7ac9d5fe360417d6de2906599aa535f55bf6b8e58
-  languageName: node
-  linkType: hard
-
-"multibase@npm:~0.6.0":
-  version: 0.6.1
-  resolution: "multibase@npm:0.6.1"
-  dependencies:
-    base-x: ^3.0.8
-    buffer: ^5.5.0
-  checksum: 0e25a978d2b5cf73e4cce31d032bad85230ea99e9394d259210f676a76539316e7c51bd7dcc9d83523ec7ea1f0e7a3353c5f69397639d78be9acbefa29431faa
-  languageName: node
-  linkType: hard
-
-"multicodec@npm:^0.5.5":
-  version: 0.5.7
-  resolution: "multicodec@npm:0.5.7"
-  dependencies:
-    varint: ^5.0.0
-  checksum: 5af1febc3bb5381c303c964a4c3bacb9d0d16615599426d58c68722c46e66a7085082995479943084322028324ad692cd70ea14b5eefb2791d325fa00ead04a3
-  languageName: node
-  linkType: hard
-
-"multicodec@npm:^1.0.0":
-  version: 1.0.4
-  resolution: "multicodec@npm:1.0.4"
-  dependencies:
-    buffer: ^5.6.0
-    varint: ^5.0.0
-  checksum: e6a2916fa76c023b1c90b32ae74f8a781cf0727f71660b245a5ed1db46add6f2ce1586bee5713b16caf0a724e81bfe0678d89910c20d3bb5fd9649dacb2be79e
-  languageName: node
-  linkType: hard
-
 "multiformats@npm:^9.4.13, multiformats@npm:^9.4.2, multiformats@npm:^9.4.5, multiformats@npm:^9.5.4":
   version: 9.9.0
   resolution: "multiformats@npm:9.9.0"
@@ -11473,17 +8331,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"multihashes@npm:^0.4.15, multihashes@npm:~0.4.15":
-  version: 0.4.21
-  resolution: "multihashes@npm:0.4.21"
-  dependencies:
-    buffer: ^5.5.0
-    multibase: ^0.7.0
-    varint: ^5.0.0
-  checksum: 688731560cf7384e899dc75c0da51e426eb7d058c5ea5eb57b224720a1108deb8797f1cd7f45599344d512d2877de99dd6a7b7773a095812365dea4ffe6ebd4c
-  languageName: node
-  linkType: hard
-
 "mustache@npm:^4.2.0":
   version: 4.2.0
   resolution: "mustache@npm:4.2.0"
@@ -11500,13 +8347,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"nano-json-stream-parser@npm:^0.1.2":
-  version: 0.1.2
-  resolution: "nano-json-stream-parser@npm:0.1.2"
-  checksum: 5bfe146358c659e0aa7d5e0003416be929c9bd02ba11b1e022b78dddf25be655e33d810249c1687d2c9abdcee5cd4d00856afd1b266a5a127236c0d16416d33a
-  languageName: node
-  linkType: hard
-
 "nanoid@npm:3.3.3":
   version: 3.3.3
   resolution: "nanoid@npm:3.3.3"
@@ -11525,29 +8365,10 @@ __metadata:
   languageName: node
   linkType: hard
 
-"nanomatch@npm:^1.2.9":
-  version: 1.2.13
-  resolution: "nanomatch@npm:1.2.13"
-  dependencies:
-    arr-diff: ^4.0.0
-    array-unique: ^0.3.2
-    define-property: ^2.0.2
-    extend-shallow: ^3.0.2
-    fragment-cache: ^0.2.1
-    is-windows: ^1.0.2
-    kind-of: ^6.0.2
-    object.pick: ^1.3.0
-    regex-not: ^1.0.0
-    snapdragon: ^0.8.1
-    to-regex: ^3.0.1
-  checksum: 54d4166d6ef08db41252eb4e96d4109ebcb8029f0374f9db873bd91a1f896c32ec780d2a2ea65c0b2d7caf1f28d5e1ea33746a470f32146ac8bba821d80d38d8
-  languageName: node
-  linkType: hard
-
-"napi-macros@npm:^2.2.2":
-  version: 2.2.2
-  resolution: "napi-macros@npm:2.2.2"
-  checksum: c6f9bd71cdbbc37ddc3535aa5be481238641d89585b8a3f4d301cb89abf459e2d294810432bb7d12056d1f9350b1a0899a5afcf460237a3da6c398cf0fec7629
+"napi-macros@npm:~2.0.0":
+  version: 2.0.0
+  resolution: "napi-macros@npm:2.0.0"
+  checksum: 30384819386977c1f82034757014163fa60ab3c5a538094f778d38788bebb52534966279956f796a92ea771c7f8ae072b975df65de910d051ffbdc927f62320c
   languageName: node
   linkType: hard
 
@@ -11583,7 +8404,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"negotiator@npm:0.6.3, negotiator@npm:^0.6.3":
+"negotiator@npm:^0.6.3":
   version: 0.6.3
   resolution: "negotiator@npm:0.6.3"
   checksum: b8ffeb1e262eff7968fc90a2b6767b04cfd9842582a9d0ece0af7049537266e7b2506dfb1d107a32f06dd849ab2aea834d5830f7f4d0e5cb7d36e1ae55d021d9
@@ -11597,13 +8418,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"next-tick@npm:^1.1.0":
-  version: 1.1.0
-  resolution: "next-tick@npm:1.1.0"
-  checksum: 83b5cf36027a53ee6d8b7f9c0782f2ba87f4858d977342bfc3c20c21629290a2111f8374d13a81221179603ffc4364f38374b5655d17b6a8f8a8c77bdea4fe8b
-  languageName: node
-  linkType: hard
-
 "nice-try@npm:^1.0.4":
   version: 1.0.5
   resolution: "nice-try@npm:1.0.5"
@@ -11643,13 +8457,25 @@ __metadata:
   languageName: node
   linkType: hard
 
-"node-fetch@npm:~1.7.1":
-  version: 1.7.3
-  resolution: "node-fetch@npm:1.7.3"
-  dependencies:
-    encoding: ^0.1.11
-    is-stream: ^1.0.1
-  checksum: 3bb0528c05d541316ebe52770d71ee25a6dce334df4231fd55df41a644143e07f068637488c18a5b0c43f05041dbd3346752f9e19b50df50569a802484544d5b
+"node-gyp-build@npm:4.3.0":
+  version: 4.3.0
+  resolution: "node-gyp-build@npm:4.3.0"
+  bin:
+    node-gyp-build: bin.js
+    node-gyp-build-optional: optional.js
+    node-gyp-build-test: build-test.js
+  checksum: 1ecab16d9f275174d516e223f60f65ebe07540347d5c04a6a7d6921060b7f2e3af4f19463d9d1dcedc452e275c2ae71354a99405e55ebd5b655bb2f38025c728
+  languageName: node
+  linkType: hard
+
+"node-gyp-build@npm:4.4.0":
+  version: 4.4.0
+  resolution: "node-gyp-build@npm:4.4.0"
+  bin:
+    node-gyp-build: bin.js
+    node-gyp-build-optional: optional.js
+    node-gyp-build-test: build-test.js
+  checksum: 972a059f960253d254e0b23ce10f54c8982236fc0edcab85166d0b7f87443b2ce98391c877cfb2f6eeafcf03c538c5f4dd3e0bfff03828eb48634f58f4c64343
   languageName: node
   linkType: hard
 
@@ -11713,18 +8539,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"normalize-package-data@npm:^2.3.2":
-  version: 2.5.0
-  resolution: "normalize-package-data@npm:2.5.0"
-  dependencies:
-    hosted-git-info: ^2.1.4
-    resolve: ^1.10.0
-    semver: 2 || 3 || 4 || 5
-    validate-npm-package-license: ^3.0.1
-  checksum: 7999112efc35a6259bc22db460540cae06564aa65d0271e3bdfa86876d08b0e578b7b5b0028ee61b23f1cae9fc0e7847e4edc0948d3068a39a2a82853efc8499
-  languageName: node
-  linkType: hard
-
 "normalize-path@npm:^3.0.0, normalize-path@npm:~3.0.0":
   version: 3.0.0
   resolution: "normalize-path@npm:3.0.0"
@@ -11732,20 +8546,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"normalize-url@npm:^4.1.0":
-  version: 4.5.1
-  resolution: "normalize-url@npm:4.5.1"
-  checksum: 9a9dee01df02ad23e171171893e56e22d752f7cff86fb96aafeae074819b572ea655b60f8302e2d85dbb834dc885c972cc1c573892fea24df46b2765065dd05a
-  languageName: node
-  linkType: hard
-
-"normalize-url@npm:^6.0.1":
-  version: 6.1.0
-  resolution: "normalize-url@npm:6.1.0"
-  checksum: 4a4944631173e7d521d6b80e4c85ccaeceb2870f315584fa30121f505a6dfd86439c5e3fdd8cd9e0e291290c41d0c3599f0cb12ab356722ed242584c30348e50
-  languageName: node
-  linkType: hard
-
 "npm-run-path@npm:^2.0.0":
   version: 2.0.2
   resolution: "npm-run-path@npm:2.0.2"
@@ -11764,13 +8564,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"number-is-nan@npm:^1.0.0":
-  version: 1.0.1
-  resolution: "number-is-nan@npm:1.0.1"
-  checksum: 13656bc9aa771b96cef209ffca31c31a03b507ca6862ba7c3f638a283560620d723d52e626d57892c7fff475f4c36ac07f0600f14544692ff595abff214b9ffb
-  languageName: node
-  linkType: hard
-
 "number-to-bn@npm:1.7.0":
   version: 1.7.0
   resolution: "number-to-bn@npm:1.7.0"
@@ -11788,24 +8581,13 @@ __metadata:
   languageName: node
   linkType: hard
 
-"object-assign@npm:^4, object-assign@npm:^4.0.0, object-assign@npm:^4.1.0, object-assign@npm:^4.1.1":
+"object-assign@npm:^4.1.0":
   version: 4.1.1
   resolution: "object-assign@npm:4.1.1"
   checksum: fcc6e4ea8c7fe48abfbb552578b1c53e0d194086e2e6bbbf59e0a536381a292f39943c6e9628af05b5528aa5e3318bb30d6b2e53cadaf5b8fe9e12c4b69af23f
   languageName: node
   linkType: hard
 
-"object-copy@npm:^0.1.0":
-  version: 0.1.0
-  resolution: "object-copy@npm:0.1.0"
-  dependencies:
-    copy-descriptor: ^0.1.0
-    define-property: ^0.2.5
-    kind-of: ^3.0.3
-  checksum: a9e35f07e3a2c882a7e979090360d1a20ab51d1fa19dfdac3aa8873b328a7c4c7683946ee97c824ae40079d848d6740a3788fa14f2185155dab7ed970a72c783
-  languageName: node
-  linkType: hard
-
 "object-inspect@npm:^1.13.1, object-inspect@npm:^1.9.0":
   version: 1.13.1
   resolution: "object-inspect@npm:1.13.1"
@@ -11813,23 +8595,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"object-inspect@npm:~1.12.3":
-  version: 1.12.3
-  resolution: "object-inspect@npm:1.12.3"
-  checksum: dabfd824d97a5f407e6d5d24810d888859f6be394d8b733a77442b277e0808860555176719c5905e765e3743a7cada6b8b0a3b85e5331c530fd418cc8ae991db
-  languageName: node
-  linkType: hard
-
-"object-is@npm:^1.1.5":
-  version: 1.1.5
-  resolution: "object-is@npm:1.1.5"
-  dependencies:
-    call-bind: ^1.0.2
-    define-properties: ^1.1.3
-  checksum: 989b18c4cba258a6b74dc1d74a41805c1a1425bce29f6cabb50dcb1a6a651ea9104a1b07046739a49a5bb1bc49727bcb00efd5c55f932f6ea04ec8927a7901fe
-  languageName: node
-  linkType: hard
-
 "object-keys@npm:^1.1.1":
   version: 1.1.1
   resolution: "object-keys@npm:1.1.1"
@@ -11837,22 +8602,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"object-keys@npm:~0.4.0":
-  version: 0.4.0
-  resolution: "object-keys@npm:0.4.0"
-  checksum: 1be3ebe9b48c0d5eda8e4a30657d887a748cb42435e0e2eaf49faf557bdd602cd2b7558b8ce90a4eb2b8592d16b875a1900bce859cbb0f35b21c67e11a45313c
-  languageName: node
-  linkType: hard
-
-"object-visit@npm:^1.0.0":
-  version: 1.0.1
-  resolution: "object-visit@npm:1.0.1"
-  dependencies:
-    isobject: ^3.0.0
-  checksum: b0ee07f5bf3bb881b881ff53b467ebbde2b37ebb38649d6944a6cd7681b32eedd99da9bd1e01c55facf81f54ed06b13af61aba6ad87f0052982995e09333f790
-  languageName: node
-  linkType: hard
-
 "object.assign@npm:^4.1.4":
   version: 4.1.5
   resolution: "object.assign@npm:4.1.5"
@@ -11876,19 +8625,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"object.getownpropertydescriptors@npm:^2.1.6":
-  version: 2.1.7
-  resolution: "object.getownpropertydescriptors@npm:2.1.7"
-  dependencies:
-    array.prototype.reduce: ^1.0.6
-    call-bind: ^1.0.2
-    define-properties: ^1.2.0
-    es-abstract: ^1.22.1
-    safe-array-concat: ^1.0.0
-  checksum: 8e7ae1d522a3874d2d23a3d0fb75828cbcee60958b65c2ad8e58ce227f4efba8cc2b59c7431a0fd48b20d9e04ec075bc0e0d694b1d2c2296e534daf558beb10b
-  languageName: node
-  linkType: hard
-
 "object.groupby@npm:^1.0.1":
   version: 1.0.2
   resolution: "object.groupby@npm:1.0.2"
@@ -11902,15 +8638,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"object.pick@npm:^1.3.0":
-  version: 1.3.0
-  resolution: "object.pick@npm:1.3.0"
-  dependencies:
-    isobject: ^3.0.1
-  checksum: 77fb6eed57c67adf75e9901187e37af39f052ef601cb4480386436561357eb9e459e820762f01fd02c5c1b42ece839ad393717a6d1850d848ee11fbabb3e580a
-  languageName: node
-  linkType: hard
-
 "object.values@npm:^1.1.7":
   version: 1.1.7
   resolution: "object.values@npm:1.1.7"
@@ -11929,24 +8656,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"oboe@npm:2.1.4":
-  version: 2.1.4
-  resolution: "oboe@npm:2.1.4"
-  dependencies:
-    http-https: ^1.0.0
-  checksum: b9172453fba362aec86c45d7bcb4f512302bb23ef34c7c9c498974dc4e7ec0e298931bac5a093445fd946d5604e5dd16563e2d2ae922101ac4b47be2e18e30cc
-  languageName: node
-  linkType: hard
-
-"on-finished@npm:2.4.1":
-  version: 2.4.1
-  resolution: "on-finished@npm:2.4.1"
-  dependencies:
-    ee-first: 1.1.1
-  checksum: d20929a25e7f0bb62f937a425b5edeb4e4cde0540d77ba146ec9357f00b0d497cdb3b9b05b9c8e46222407d1548d08166bff69cc56dfa55ba0e4469228920ff0
-  languageName: node
-  linkType: hard
-
 "once@npm:1.x, once@npm:^1.3.0, once@npm:^1.3.1, once@npm:^1.4.0":
   version: 1.4.0
   resolution: "once@npm:1.4.0"
@@ -11965,16 +8674,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"open@npm:^7.4.2":
-  version: 7.4.2
-  resolution: "open@npm:7.4.2"
-  dependencies:
-    is-docker: ^2.0.0
-    is-wsl: ^2.1.1
-  checksum: 3333900ec0e420d64c23b831bc3467e57031461d843c801f569b2204a1acc3cd7b3ec3c7897afc9dde86491dfa289708eb92bba164093d8bd88fb2c231843c91
-  languageName: node
-  linkType: hard
-
 "opencollective-postinstall@npm:^2.0.0":
   version: 2.0.3
   resolution: "opencollective-postinstall@npm:2.0.3"
@@ -12035,22 +8734,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"os-homedir@npm:^1.0.0":
-  version: 1.0.2
-  resolution: "os-homedir@npm:1.0.2"
-  checksum: af609f5a7ab72de2f6ca9be6d6b91a599777afc122ac5cad47e126c1f67c176fe9b52516b9eeca1ff6ca0ab8587fe66208bc85e40a3940125f03cdb91408e9d2
-  languageName: node
-  linkType: hard
-
-"os-locale@npm:^1.4.0":
-  version: 1.4.0
-  resolution: "os-locale@npm:1.4.0"
-  dependencies:
-    lcid: ^1.0.0
-  checksum: 0161a1b6b5a8492f99f4b47fe465df9fc521c55ba5414fce6444c45e2500487b8ed5b40a47a98a2363fe83ff04ab033785300ed8df717255ec4c3b625e55b1fb
-  languageName: node
-  linkType: hard
-
 "os-locale@npm:^3.1.0":
   version: 3.1.0
   resolution: "os-locale@npm:3.1.0"
@@ -12062,27 +8745,13 @@ __metadata:
   languageName: node
   linkType: hard
 
-"os-tmpdir@npm:^1.0.1, os-tmpdir@npm:~1.0.2":
+"os-tmpdir@npm:~1.0.2":
   version: 1.0.2
   resolution: "os-tmpdir@npm:1.0.2"
   checksum: 5666560f7b9f10182548bf7013883265be33620b1c1b4a4d405c25be2636f970c5488ff3e6c48de75b55d02bde037249fe5dbfbb4c0fb7714953d56aed062e6d
   languageName: node
   linkType: hard
 
-"p-cancelable@npm:^1.0.0":
-  version: 1.1.0
-  resolution: "p-cancelable@npm:1.1.0"
-  checksum: 2db3814fef6d9025787f30afaee4496a8857a28be3c5706432cbad76c688a6db1874308f48e364a42f5317f5e41e8e7b4f2ff5c8ff2256dbb6264bc361704ece
-  languageName: node
-  linkType: hard
-
-"p-cancelable@npm:^2.0.0":
-  version: 2.1.1
-  resolution: "p-cancelable@npm:2.1.1"
-  checksum: 3dba12b4fb4a1e3e34524535c7858fc82381bbbd0f247cc32dedc4018592a3950ce66b106d0880b4ec4c2d8d6576f98ca885dc1d7d0f274d1370be20e9523ddf
-  languageName: node
-  linkType: hard
-
 "p-defer@npm:^1.0.0":
   version: 1.0.0
   resolution: "p-defer@npm:1.0.0"
@@ -12214,19 +8883,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"parse-asn1@npm:^5.0.0, parse-asn1@npm:^5.1.6":
-  version: 5.1.6
-  resolution: "parse-asn1@npm:5.1.6"
-  dependencies:
-    asn1.js: ^5.2.0
-    browserify-aes: ^1.0.0
-    evp_bytestokey: ^1.0.0
-    pbkdf2: ^3.0.3
-    safe-buffer: ^5.1.1
-  checksum: 9243311d1f88089bc9f2158972aa38d1abd5452f7b7cabf84954ed766048fe574d434d82c6f5a39b988683e96fb84cd933071dda38927e03469dc8c8d14463c7
-  languageName: node
-  linkType: hard
-
 "parse-cache-control@npm:^1.0.1":
   version: 1.0.1
   resolution: "parse-cache-control@npm:1.0.1"
@@ -12241,22 +8897,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"parse-headers@npm:^2.0.0":
-  version: 2.0.5
-  resolution: "parse-headers@npm:2.0.5"
-  checksum: 3e97f01e4c7f960bfbfd0ee489f0bd8d3c72b6c814f1f79b66abec2cca8eaf8e4ecd89deba0b6e61266469aed87350bc932001181c01ff8c29a59e696abe251f
-  languageName: node
-  linkType: hard
-
-"parse-json@npm:^2.2.0":
-  version: 2.2.0
-  resolution: "parse-json@npm:2.2.0"
-  dependencies:
-    error-ex: ^1.2.0
-  checksum: dda78a63e57a47b713a038630868538f718a7ca0cd172a36887b0392ccf544ed0374902eb28f8bf3409e8b71d62b79d17062f8543afccf2745f9b0b2d2bb80ca
-  languageName: node
-  linkType: hard
-
 "parse-json@npm:^5.0.0, parse-json@npm:^5.2.0":
   version: 5.2.0
   resolution: "parse-json@npm:5.2.0"
@@ -12269,66 +8909,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"parseurl@npm:~1.3.3":
-  version: 1.3.3
-  resolution: "parseurl@npm:1.3.3"
-  checksum: 407cee8e0a3a4c5cd472559bca8b6a45b82c124e9a4703302326e9ab60fc1081442ada4e02628efef1eb16197ddc7f8822f5a91fd7d7c86b51f530aedb17dfa2
-  languageName: node
-  linkType: hard
-
-"pascalcase@npm:^0.1.1":
-  version: 0.1.1
-  resolution: "pascalcase@npm:0.1.1"
-  checksum: f83681c3c8ff75fa473a2bb2b113289952f802ff895d435edd717e7cb898b0408cbdb247117a938edcbc5d141020909846cc2b92c47213d764e2a94d2ad2b925
-  languageName: node
-  linkType: hard
-
-"patch-package@npm:6.2.2":
-  version: 6.2.2
-  resolution: "patch-package@npm:6.2.2"
-  dependencies:
-    "@yarnpkg/lockfile": ^1.1.0
-    chalk: ^2.4.2
-    cross-spawn: ^6.0.5
-    find-yarn-workspace-root: ^1.2.1
-    fs-extra: ^7.0.1
-    is-ci: ^2.0.0
-    klaw-sync: ^6.0.0
-    minimist: ^1.2.0
-    rimraf: ^2.6.3
-    semver: ^5.6.0
-    slash: ^2.0.0
-    tmp: ^0.0.33
-  bin:
-    patch-package: index.js
-  checksum: 5e2f49457b0dc56b5ce0a9d23e281e062e9f225d87a832540f02ffed29ffa7f298b1877daf13c16500ef8a759109c975e3d28d6bd63b0d953f349177abee1767
-  languageName: node
-  linkType: hard
-
-"patch-package@npm:^6.2.2":
-  version: 6.5.1
-  resolution: "patch-package@npm:6.5.1"
-  dependencies:
-    "@yarnpkg/lockfile": ^1.1.0
-    chalk: ^4.1.2
-    cross-spawn: ^6.0.5
-    find-yarn-workspace-root: ^2.0.0
-    fs-extra: ^9.0.0
-    is-ci: ^2.0.0
-    klaw-sync: ^6.0.0
-    minimist: ^1.2.6
-    open: ^7.4.2
-    rimraf: ^2.6.3
-    semver: ^5.6.0
-    slash: ^2.0.0
-    tmp: ^0.0.33
-    yaml: ^1.10.2
-  bin:
-    patch-package: index.js
-  checksum: 8530ffa30f11136b527c6eddf6da48fa12856ee510a47edb1f9cdf8a025636adb82968f5fae778b5e04ce8c87915ebdf5911422b54add59a5a42e372a8f30eb2
-  languageName: node
-  linkType: hard
-
 "path-browserify@npm:^1.0.0":
   version: 1.0.1
   resolution: "path-browserify@npm:1.0.1"
@@ -12336,15 +8916,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"path-exists@npm:^2.0.0":
-  version: 2.1.0
-  resolution: "path-exists@npm:2.1.0"
-  dependencies:
-    pinkie-promise: ^2.0.0
-  checksum: fdb734f1d00f225f7a0033ce6d73bff6a7f76ea08936abf0e5196fa6e54a645103538cd8aedcb90d6d8c3fa3705ded0c58a4da5948ae92aa8834892c1ab44a84
-  languageName: node
-  linkType: hard
-
 "path-exists@npm:^3.0.0":
   version: 3.0.0
   resolution: "path-exists@npm:3.0.0"
@@ -12359,7 +8930,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"path-is-absolute@npm:^1.0.0, path-is-absolute@npm:^1.0.1":
+"path-is-absolute@npm:^1.0.0":
   version: 1.0.1
   resolution: "path-is-absolute@npm:1.0.1"
   checksum: 060840f92cf8effa293bcc1bea81281bd7d363731d214cbe5c227df207c34cd727430f70c6037b5159c8a870b9157cba65e775446b0ab06fd5ecc7e54615a3b8
@@ -12397,24 +8968,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"path-to-regexp@npm:0.1.7":
-  version: 0.1.7
-  resolution: "path-to-regexp@npm:0.1.7"
-  checksum: 69a14ea24db543e8b0f4353305c5eac6907917031340e5a8b37df688e52accd09e3cebfe1660b70d76b6bd89152f52183f28c74813dbf454ba1a01c82a38abce
-  languageName: node
-  linkType: hard
-
-"path-type@npm:^1.0.0":
-  version: 1.1.0
-  resolution: "path-type@npm:1.1.0"
-  dependencies:
-    graceful-fs: ^4.1.2
-    pify: ^2.0.0
-    pinkie-promise: ^2.0.0
-  checksum: 59a4b2c0e566baf4db3021a1ed4ec09a8b36fca960a490b54a6bcefdb9987dafe772852982b6011cd09579478a96e57960a01f75fa78a794192853c9d468fc79
-  languageName: node
-  linkType: hard
-
 "path-type@npm:^4.0.0":
   version: 4.0.0
   resolution: "path-type@npm:4.0.0"
@@ -12429,7 +8982,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"pbkdf2@npm:^3.0.17, pbkdf2@npm:^3.0.3, pbkdf2@npm:^3.0.9":
+"pbkdf2@npm:^3.0.17, pbkdf2@npm:^3.0.9":
   version: 3.1.2
   resolution: "pbkdf2@npm:3.1.2"
   dependencies:
@@ -12456,13 +9009,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"pify@npm:^2.0.0, pify@npm:^2.3.0":
-  version: 2.3.0
-  resolution: "pify@npm:2.3.0"
-  checksum: 9503aaeaf4577acc58642ad1d25c45c6d90288596238fb68f82811c08104c800e5a7870398e9f015d82b44ecbcbef3dc3d4251a1cbb582f6e5959fe09884b2ba
-  languageName: node
-  linkType: hard
-
 "pify@npm:^4.0.1":
   version: 4.0.1
   resolution: "pify@npm:4.0.1"
@@ -12470,22 +9016,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"pinkie-promise@npm:^2.0.0":
-  version: 2.0.1
-  resolution: "pinkie-promise@npm:2.0.1"
-  dependencies:
-    pinkie: ^2.0.0
-  checksum: b53a4a2e73bf56b6f421eef711e7bdcb693d6abb474d57c5c413b809f654ba5ee750c6a96dd7225052d4b96c4d053cdcb34b708a86fceed4663303abee52fcca
-  languageName: node
-  linkType: hard
-
-"pinkie@npm:^2.0.0":
-  version: 2.0.4
-  resolution: "pinkie@npm:2.0.4"
-  checksum: b12b10afea1177595aab036fc220785488f67b4b0fc49e7a27979472592e971614fa1c728e63ad3e7eb748b4ec3c3dbd780819331dad6f7d635c77c10537b9db
-  languageName: node
-  linkType: hard
-
 "pkginfo@npm:^0.4.1":
   version: 0.4.1
   resolution: "pkginfo@npm:0.4.1"
@@ -12500,27 +9030,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"posix-character-classes@npm:^0.1.0":
-  version: 0.1.1
-  resolution: "posix-character-classes@npm:0.1.1"
-  checksum: dedb99913c60625a16050cfed2fb5c017648fc075be41ac18474e1c6c3549ef4ada201c8bd9bd006d36827e289c571b6092e1ef6e756cdbab2fd7046b25c6442
-  languageName: node
-  linkType: hard
-
-"postinstall-postinstall@npm:^2.1.0":
-  version: 2.1.0
-  resolution: "postinstall-postinstall@npm:2.1.0"
-  checksum: e1d34252cf8d2c5641c7d2db7426ec96e3d7a975f01c174c68f09ef5b8327bc8d5a9aa2001a45e693db2cdbf69577094d3fe6597b564ad2d2202b65fba76134b
-  languageName: node
-  linkType: hard
-
-"precond@npm:0.2":
-  version: 0.2.3
-  resolution: "precond@npm:0.2.3"
-  checksum: c613e7d68af3e0b43a294a994bf067cc2bc44b03fd17bc4fb133e30617a4f5b49414b08e9b392d52d7c6822d8a71f66a7fe93a8a1e7d02240177202cff3f63ef
-  languageName: node
-  linkType: hard
-
 "prelude-ls@npm:^1.2.1":
   version: 1.2.1
   resolution: "prelude-ls@npm:1.2.1"
@@ -12535,13 +9044,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"prepend-http@npm:^2.0.0":
-  version: 2.0.0
-  resolution: "prepend-http@npm:2.0.0"
-  checksum: 7694a9525405447662c1ffd352fcb41b6410c705b739b6f4e3a3e21cf5fdede8377890088e8934436b8b17ba55365a615f153960f30877bf0d0392f9e93503ea
-  languageName: node
-  linkType: hard
-
 "prettier-linter-helpers@npm:^1.0.0":
   version: 1.0.0
   resolution: "prettier-linter-helpers@npm:1.0.0"
@@ -12573,7 +9075,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"prettier@npm:^2.1.2, prettier@npm:^2.3.1, prettier@npm:^2.7.1, prettier@npm:^2.8.3":
+"prettier@npm:^2.3.1, prettier@npm:^2.7.1, prettier@npm:^2.8.3":
   version: 2.8.8
   resolution: "prettier@npm:2.8.8"
   bin:
@@ -12582,13 +9084,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"private@npm:^0.1.6, private@npm:^0.1.8":
-  version: 0.1.8
-  resolution: "private@npm:0.1.8"
-  checksum: a00abd713d25389f6de7294f0e7879b8a5d09a9ec5fd81cc2f21b29d4f9a80ec53bc4222927d3a281d4aadd4cd373d9a28726fca3935921950dc75fd71d1fdbb
-  languageName: node
-  linkType: hard
-
 "proc-log@npm:^3.0.0":
   version: 3.0.0
   resolution: "proc-log@npm:3.0.0"
@@ -12603,13 +9098,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"process@npm:^0.11.10":
-  version: 0.11.10
-  resolution: "process@npm:0.11.10"
-  checksum: bfcce49814f7d172a6e6a14d5fa3ac92cc3d0c3b9feb1279774708a719e19acd673995226351a082a9ae99978254e320ccda4240ddc474ba31a76c79491ca7c3
-  languageName: node
-  linkType: hard
-
 "progress@npm:^2.0.0":
   version: 2.0.3
   resolution: "progress@npm:2.0.3"
@@ -12627,16 +9115,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"promise-to-callback@npm:^1.0.0":
-  version: 1.0.0
-  resolution: "promise-to-callback@npm:1.0.0"
-  dependencies:
-    is-fn: ^1.0.0
-    set-immediate-shim: ^1.0.1
-  checksum: 8c9e1327386e00f799589cdf96fff2586a13b52b0185222bc3199e1305ba9344589eedfd4038dcbaf5592d85d567097d1507b81e948b7fff6ffdd3de49d54e14
-  languageName: node
-  linkType: hard
-
 "promise@npm:^8.0.0":
   version: 8.3.0
   resolution: "promise@npm:8.3.0"
@@ -12681,16 +9159,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"proxy-addr@npm:~2.0.7":
-  version: 2.0.7
-  resolution: "proxy-addr@npm:2.0.7"
-  dependencies:
-    forwarded: 0.2.0
-    ipaddr.js: 1.9.1
-  checksum: 29c6990ce9364648255454842f06f8c46fcd124d3e6d7c5066df44662de63cdc0bad032e9bf5a3d653ff72141cc7b6019873d685708ac8210c30458ad99f2b74
-  languageName: node
-  linkType: hard
-
 "proxy-from-env@npm:^1.1.0":
   version: 1.1.0
   resolution: "proxy-from-env@npm:1.1.0"
@@ -12705,13 +9173,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"pseudomap@npm:^1.0.1":
-  version: 1.0.2
-  resolution: "pseudomap@npm:1.0.2"
-  checksum: 856c0aae0ff2ad60881168334448e898ad7a0e45fe7386d114b150084254c01e200c957cf378378025df4e052c7890c5bd933939b0e0d2ecfcc1dc2f0b2991f5
-  languageName: node
-  linkType: hard
-
 "psl@npm:^1.1.28":
   version: 1.9.0
   resolution: "psl@npm:1.9.0"
@@ -12719,82 +9180,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"public-encrypt@npm:^4.0.0":
-  version: 4.0.3
-  resolution: "public-encrypt@npm:4.0.3"
-  dependencies:
-    bn.js: ^4.1.0
-    browserify-rsa: ^4.0.0
-    create-hash: ^1.1.0
-    parse-asn1: ^5.0.0
-    randombytes: ^2.0.1
-    safe-buffer: ^5.1.2
-  checksum: 215d446e43cef021a20b67c1df455e5eea134af0b1f9b8a35f9e850abf32991b0c307327bc5b9bc07162c288d5cdb3d4a783ea6c6640979ed7b5017e3e0c9935
-  languageName: node
-  linkType: hard
-
-"pull-cat@npm:^1.1.9":
-  version: 1.1.11
-  resolution: "pull-cat@npm:1.1.11"
-  checksum: 785173d94732ba5e6e65f27ee128542522aeb87519c5d72aa9b8bc510f6c4f67b91fcfd565782a20aafc116e57354f2dd0fa8fd039b45a61b8da89b0253a7440
-  languageName: node
-  linkType: hard
-
-"pull-defer@npm:^0.2.2":
-  version: 0.2.3
-  resolution: "pull-defer@npm:0.2.3"
-  checksum: 4ea99ed64a2d79167e87293aba5088cde91f210a319c690a65aa6704d829be33b76cecc732f8d4ed3eee47e7eb09a6f77042897ea6414862bacbd722ce182d66
-  languageName: node
-  linkType: hard
-
-"pull-level@npm:^2.0.3":
-  version: 2.0.4
-  resolution: "pull-level@npm:2.0.4"
-  dependencies:
-    level-post: ^1.0.7
-    pull-cat: ^1.1.9
-    pull-live: ^1.0.1
-    pull-pushable: ^2.0.0
-    pull-stream: ^3.4.0
-    pull-window: ^2.1.4
-    stream-to-pull-stream: ^1.7.1
-  checksum: f4e0573b3ff3f3659eb50ac86b505aee12d5f4c1d8bafc3bf6fd67d173b3b39a3fe5161d8bfa5eba8a0c5873fbda75f3b160276cfa678d5edd517dcd3349ecc2
-  languageName: node
-  linkType: hard
-
-"pull-live@npm:^1.0.1":
-  version: 1.0.1
-  resolution: "pull-live@npm:1.0.1"
-  dependencies:
-    pull-cat: ^1.1.9
-    pull-stream: ^3.4.0
-  checksum: e4328771e811aec1e03996d1070ec8fecb2560cc48b96814cd9f4aebd870a710903f8693e423765d3d65d8021b3b9ccc38c8660baef3df45e217c9b1bbc5581a
-  languageName: node
-  linkType: hard
-
-"pull-pushable@npm:^2.0.0":
-  version: 2.2.0
-  resolution: "pull-pushable@npm:2.2.0"
-  checksum: 1c88ef55f6f14799ae5cf060415d089d15452ef865d874f075c155f8224c321371cb7f04a10b3fba263b6f128158c78253efd18bcb54afbb99f9cae846f883a6
-  languageName: node
-  linkType: hard
-
-"pull-stream@npm:^3.2.3, pull-stream@npm:^3.4.0, pull-stream@npm:^3.6.8":
-  version: 3.7.0
-  resolution: "pull-stream@npm:3.7.0"
-  checksum: df0b864fd92bb61e84d02764a064bf023188c1c917d854029a5b8e543e163f9aaf1a9553067d4fdf5e248b0d96338e0a23fac9257e86cf740e7d03e05b7a77a3
-  languageName: node
-  linkType: hard
-
-"pull-window@npm:^2.1.4":
-  version: 2.1.4
-  resolution: "pull-window@npm:2.1.4"
-  dependencies:
-    looper: ^2.0.0
-  checksum: e006995108a80c81eea93dfaadf68285dc5b9b3cbaf654da39731ca3f308376f15b0546c61730cd0fa38303e273a1845c6d65f0fda35ed9c66252a65e446df18
-  languageName: node
-  linkType: hard
-
 "pump@npm:^1.0.0":
   version: 1.0.3
   resolution: "pump@npm:1.0.3"
@@ -12815,13 +9200,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"punycode@npm:2.1.0":
-  version: 2.1.0
-  resolution: "punycode@npm:2.1.0"
-  checksum: d125d8f86cd89303c33bad829388c49ca23197e16ccf8cd398dcbd81b026978f6543f5066c66825b25b1dfea7790a42edbeea82908e103474931789714ab86cd
-  languageName: node
-  linkType: hard
-
 "punycode@npm:^1.4.1":
   version: 1.4.1
   resolution: "punycode@npm:1.4.1"
@@ -12836,15 +9214,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"qs@npm:6.11.0":
-  version: 6.11.0
-  resolution: "qs@npm:6.11.0"
-  dependencies:
-    side-channel: ^1.0.4
-  checksum: 6e1f29dd5385f7488ec74ac7b6c92f4d09a90408882d0c208414a34dd33badc1a621019d4c799a3df15ab9b1d0292f97c1dd71dc7c045e69f81a8064e5af7297
-  languageName: node
-  linkType: hard
-
 "qs@npm:^6.11.2, qs@npm:^6.4.0":
   version: 6.11.2
   resolution: "qs@npm:6.11.2"
@@ -12861,17 +9230,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"query-string@npm:^5.0.1":
-  version: 5.1.1
-  resolution: "query-string@npm:5.1.1"
-  dependencies:
-    decode-uri-component: ^0.2.0
-    object-assign: ^4.1.0
-    strict-uri-encode: ^1.0.0
-  checksum: 4ac760d9778d413ef5f94f030ed14b1a07a1708dd13fd3bc54f8b9ef7b425942c7577f30de0bf5a7d227ee65a9a0350dfa3a43d1d266880882fb7ce4c434a4dd
-  languageName: node
-  linkType: hard
-
 "queue-microtask@npm:^1.2.2, queue-microtask@npm:^1.2.3":
   version: 1.2.3
   resolution: "queue-microtask@npm:1.2.3"
@@ -12879,14 +9237,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"quick-lru@npm:^5.1.1":
-  version: 5.1.1
-  resolution: "quick-lru@npm:5.1.1"
-  checksum: a516faa25574be7947969883e6068dbe4aa19e8ef8e8e0fd96cddd6d36485e9106d85c0041a27153286b0770b381328f4072aa40d3b18a19f5f7d2b78b94b5ed
-  languageName: node
-  linkType: hard
-
-"randombytes@npm:^2.0.0, randombytes@npm:^2.0.1, randombytes@npm:^2.0.5, randombytes@npm:^2.0.6, randombytes@npm:^2.1.0":
+"randombytes@npm:^2.0.1, randombytes@npm:^2.1.0":
   version: 2.1.0
   resolution: "randombytes@npm:2.1.0"
   dependencies:
@@ -12895,36 +9246,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"randomfill@npm:^1.0.3":
-  version: 1.0.4
-  resolution: "randomfill@npm:1.0.4"
-  dependencies:
-    randombytes: ^2.0.5
-    safe-buffer: ^5.1.0
-  checksum: 33734bb578a868d29ee1b8555e21a36711db084065d94e019a6d03caa67debef8d6a1bfd06a2b597e32901ddc761ab483a85393f0d9a75838f1912461d4dbfc7
-  languageName: node
-  linkType: hard
-
-"range-parser@npm:~1.2.1":
-  version: 1.2.1
-  resolution: "range-parser@npm:1.2.1"
-  checksum: 0a268d4fea508661cf5743dfe3d5f47ce214fd6b7dec1de0da4d669dd4ef3d2144468ebe4179049eff253d9d27e719c88dae55be64f954e80135a0cada804ec9
-  languageName: node
-  linkType: hard
-
-"raw-body@npm:2.5.1":
-  version: 2.5.1
-  resolution: "raw-body@npm:2.5.1"
-  dependencies:
-    bytes: 3.1.2
-    http-errors: 2.0.0
-    iconv-lite: 0.4.24
-    unpipe: 1.0.0
-  checksum: 5362adff1575d691bb3f75998803a0ffed8c64eabeaa06e54b4ada25a0cd1b2ae7f4f5ec46565d1bec337e08b5ac90c76eaa0758de6f72a633f025d754dec29e
-  languageName: node
-  linkType: hard
-
-"raw-body@npm:2.5.2, raw-body@npm:^2.4.1":
+"raw-body@npm:^2.4.1":
   version: 2.5.2
   resolution: "raw-body@npm:2.5.2"
   dependencies:
@@ -12945,40 +9267,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"read-pkg-up@npm:^1.0.1":
-  version: 1.0.1
-  resolution: "read-pkg-up@npm:1.0.1"
-  dependencies:
-    find-up: ^1.0.0
-    read-pkg: ^1.0.0
-  checksum: d18399a0f46e2da32beb2f041edd0cda49d2f2cc30195a05c759ef3ed9b5e6e19ba1ad1bae2362bdec8c6a9f2c3d18f4d5e8c369e808b03d498d5781cb9122c7
-  languageName: node
-  linkType: hard
-
-"read-pkg@npm:^1.0.0":
-  version: 1.1.0
-  resolution: "read-pkg@npm:1.1.0"
-  dependencies:
-    load-json-file: ^1.0.0
-    normalize-package-data: ^2.3.2
-    path-type: ^1.0.0
-  checksum: a0f5d5e32227ec8e6a028dd5c5134eab229768dcb7a5d9a41a284ed28ad4b9284fecc47383dc1593b5694f4de603a7ffaee84b738956b9b77e0999567485a366
-  languageName: node
-  linkType: hard
-
-"readable-stream@npm:^1.0.33":
-  version: 1.1.14
-  resolution: "readable-stream@npm:1.1.14"
-  dependencies:
-    core-util-is: ~1.0.0
-    inherits: ~2.0.1
-    isarray: 0.0.1
-    string_decoder: ~0.10.x
-  checksum: 17dfeae3e909945a4a1abc5613ea92d03269ef54c49288599507fc98ff4615988a1c39a999dcf9aacba70233d9b7040bc11a5f2bfc947e262dedcc0a8b32b5a0
-  languageName: node
-  linkType: hard
-
-"readable-stream@npm:^2.0.0, readable-stream@npm:^2.0.5, readable-stream@npm:^2.2.2, readable-stream@npm:^2.2.8, readable-stream@npm:^2.2.9, readable-stream@npm:^2.3.0, readable-stream@npm:^2.3.5, readable-stream@npm:^2.3.6, readable-stream@npm:~2.3.6":
+"readable-stream@npm:^2.2.2, readable-stream@npm:^2.3.0, readable-stream@npm:^2.3.5":
   version: 2.3.8
   resolution: "readable-stream@npm:2.3.8"
   dependencies:
@@ -12993,7 +9282,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"readable-stream@npm:^3.0.6, readable-stream@npm:^3.6.0, readable-stream@npm:^3.6.2":
+"readable-stream@npm:^3.1.0, readable-stream@npm:^3.4.0, readable-stream@npm:^3.6.0":
   version: 3.6.2
   resolution: "readable-stream@npm:3.6.2"
   dependencies:
@@ -13004,7 +9293,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"readable-stream@npm:~1.0.15, readable-stream@npm:~1.0.26-4":
+"readable-stream@npm:~1.0.26-4":
   version: 1.0.34
   resolution: "readable-stream@npm:1.0.34"
   dependencies:
@@ -13059,41 +9348,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"regenerate@npm:^1.2.1":
-  version: 1.4.2
-  resolution: "regenerate@npm:1.4.2"
-  checksum: 3317a09b2f802da8db09aa276e469b57a6c0dd818347e05b8862959c6193408242f150db5de83c12c3fa99091ad95fb42a6db2c3329bfaa12a0ea4cbbeb30cb0
-  languageName: node
-  linkType: hard
-
-"regenerator-runtime@npm:^0.11.0":
-  version: 0.11.1
-  resolution: "regenerator-runtime@npm:0.11.1"
-  checksum: 3c97bd2c7b2b3247e6f8e2147a002eb78c995323732dad5dc70fac8d8d0b758d0295e7015b90d3d444446ae77cbd24b9f9123ec3a77018e81d8999818301b4f4
-  languageName: node
-  linkType: hard
-
-"regenerator-transform@npm:^0.10.0":
-  version: 0.10.1
-  resolution: "regenerator-transform@npm:0.10.1"
-  dependencies:
-    babel-runtime: ^6.18.0
-    babel-types: ^6.19.0
-    private: ^0.1.6
-  checksum: bd366a3b0fa0d0975c48fb9eff250363a9ab28c25b472ecdc397bb19a836746640a30d8f641718a895f9178564bd8a01a0179a9c8e5813f76fc29e62a115d9d7
-  languageName: node
-  linkType: hard
-
-"regex-not@npm:^1.0.0, regex-not@npm:^1.0.2":
-  version: 1.0.2
-  resolution: "regex-not@npm:1.0.2"
-  dependencies:
-    extend-shallow: ^3.0.2
-    safe-regex: ^1.1.0
-  checksum: 3081403de79559387a35ef9d033740e41818a559512668cef3d12da4e8a29ef34ee13c8ed1256b07e27ae392790172e8a15c8a06b72962fd4550476cde3d8f77
-  languageName: node
-  linkType: hard
-
 "regexp.prototype.flags@npm:^1.5.1":
   version: 1.5.1
   resolution: "regexp.prototype.flags@npm:1.5.1"
@@ -13119,58 +9373,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"regexpu-core@npm:^2.0.0":
-  version: 2.0.0
-  resolution: "regexpu-core@npm:2.0.0"
-  dependencies:
-    regenerate: ^1.2.1
-    regjsgen: ^0.2.0
-    regjsparser: ^0.1.4
-  checksum: 14a78eb4608fa991ded6a1433ee6a570f95a4cfb7fe312145a44d6ecbb3dc8c707016a099494c741aa0ac75a1329b40814d30ff134c0d67679c80187029c7d2d
-  languageName: node
-  linkType: hard
-
-"regjsgen@npm:^0.2.0":
-  version: 0.2.0
-  resolution: "regjsgen@npm:0.2.0"
-  checksum: 1f3ae570151e2c29193cdc5a5890c0b83cd8c5029ed69315b0ea303bc2644f9ab5d536d2288fd9b70293fd351d7dd7fc1fc99ebe24554015c894dbce883bcf2b
-  languageName: node
-  linkType: hard
-
-"regjsparser@npm:^0.1.4":
-  version: 0.1.5
-  resolution: "regjsparser@npm:0.1.5"
-  dependencies:
-    jsesc: ~0.5.0
-  bin:
-    regjsparser: bin/parser
-  checksum: 1feba2f3f2d4f1ef9f5f4e0f20c827cf866d4f65c51502eb64db4d4dd9c656f8c70f6c79537c892bf0fc9592c96f732519f7d8ad4a82f3b622756118ac737970
-  languageName: node
-  linkType: hard
-
-"repeat-element@npm:^1.1.2":
-  version: 1.1.4
-  resolution: "repeat-element@npm:1.1.4"
-  checksum: 1edd0301b7edad71808baad226f0890ba709443f03a698224c9ee4f2494c317892dc5211b2ba8cbea7194a9ddbcac01e283bd66de0467ab24ee1fc1a3711d8a9
-  languageName: node
-  linkType: hard
-
-"repeat-string@npm:^1.6.1":
-  version: 1.6.1
-  resolution: "repeat-string@npm:1.6.1"
-  checksum: 1b809fc6db97decdc68f5b12c4d1a671c8e3f65ec4a40c238bc5200e44e85bcc52a54f78268ab9c29fcf5fe4f1343e805420056d1f30fa9a9ee4c2d93e3cc6c0
-  languageName: node
-  linkType: hard
-
-"repeating@npm:^2.0.0":
-  version: 2.0.1
-  resolution: "repeating@npm:2.0.1"
-  dependencies:
-    is-finite: ^1.0.0
-  checksum: d2db0b69c5cb0c14dd750036e0abcd6b3c3f7b2da3ee179786b755cf737ca15fa0fff417ca72de33d6966056f4695440e680a352401fc02c95ade59899afbdd0
-  languageName: node
-  linkType: hard
-
 "req-cwd@npm:^2.0.0":
   version: 2.0.0
   resolution: "req-cwd@npm:2.0.0"
@@ -13189,7 +9391,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"request@npm:^2.79.0, request@npm:^2.85.0, request@npm:^2.88.0":
+"request@npm:^2.85.0, request@npm:^2.88.0":
   version: 2.88.2
   resolution: "request@npm:2.88.2"
   dependencies:
@@ -13224,13 +9426,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"require-from-string@npm:^1.1.0":
-  version: 1.2.1
-  resolution: "require-from-string@npm:1.2.1"
-  checksum: d2e0b0c798fe45d86456a32425635bd9d2a75a20e87f67294fa5cce5ed61fdf41e0c7c57afa981fb836299bfb0c37c915adb4d22478dc8d12edbf80a304e9324
-  languageName: node
-  linkType: hard
-
 "require-from-string@npm:^2.0.0, require-from-string@npm:^2.0.2":
   version: 2.0.2
   resolution: "require-from-string@npm:2.0.2"
@@ -13238,13 +9433,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"require-main-filename@npm:^1.0.1":
-  version: 1.0.1
-  resolution: "require-main-filename@npm:1.0.1"
-  checksum: 1fef30754da961f4e13c450c3eb60c7ae898a529c6ad6fa708a70bd2eed01564ceb299187b2899f5562804d797a059f39a5789884d0ac7b7ae1defc68fba4abf
-  languageName: node
-  linkType: hard
-
 "require-main-filename@npm:^2.0.0":
   version: 2.0.0
   resolution: "require-main-filename@npm:2.0.0"
@@ -13252,13 +9440,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"resolve-alpn@npm:^1.0.0":
-  version: 1.2.1
-  resolution: "resolve-alpn@npm:1.2.1"
-  checksum: f558071fcb2c60b04054c99aebd572a2af97ef64128d59bef7ab73bd50d896a222a056de40ffc545b633d99b304c259ea9d0c06830d5c867c34f0bfa60b8eae0
-  languageName: node
-  linkType: hard
-
 "resolve-from@npm:^3.0.0":
   version: 3.0.0
   resolution: "resolve-from@npm:3.0.0"
@@ -13273,13 +9454,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"resolve-url@npm:^0.2.1":
-  version: 0.2.1
-  resolution: "resolve-url@npm:0.2.1"
-  checksum: 7b7035b9ed6e7bc7d289e90aef1eab5a43834539695dac6416ca6e91f1a94132ae4796bbd173cdacfdc2ade90b5f38a3fb6186bebc1b221cd157777a23b9ad14
-  languageName: node
-  linkType: hard
-
 "resolve@npm:1.1.x":
   version: 1.1.7
   resolution: "resolve@npm:1.1.7"
@@ -13296,7 +9470,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"resolve@npm:^1.1.6, resolve@npm:^1.10.0, resolve@npm:^1.10.1, resolve@npm:^1.22.1, resolve@npm:^1.22.4, resolve@npm:^1.8.1, resolve@npm:~1.22.6":
+"resolve@npm:^1.1.6, resolve@npm:^1.10.1, resolve@npm:^1.22.1, resolve@npm:^1.22.4":
   version: 1.22.8
   resolution: "resolve@npm:1.22.8"
   dependencies:
@@ -13325,7 +9499,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"resolve@patch:resolve@^1.1.6#~builtin<compat/resolve>, resolve@patch:resolve@^1.10.0#~builtin<compat/resolve>, resolve@patch:resolve@^1.10.1#~builtin<compat/resolve>, resolve@patch:resolve@^1.22.1#~builtin<compat/resolve>, resolve@patch:resolve@^1.22.4#~builtin<compat/resolve>, resolve@patch:resolve@^1.8.1#~builtin<compat/resolve>, resolve@patch:resolve@~1.22.6#~builtin<compat/resolve>":
+"resolve@patch:resolve@^1.1.6#~builtin<compat/resolve>, resolve@patch:resolve@^1.10.1#~builtin<compat/resolve>, resolve@patch:resolve@^1.22.1#~builtin<compat/resolve>, resolve@patch:resolve@^1.22.4#~builtin<compat/resolve>":
   version: 1.22.8
   resolution: "resolve@patch:resolve@npm%3A1.22.8#~builtin<compat/resolve>::version=1.22.8&hash=07638b"
   dependencies:
@@ -13338,24 +9512,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"responselike@npm:^1.0.2":
-  version: 1.0.2
-  resolution: "responselike@npm:1.0.2"
-  dependencies:
-    lowercase-keys: ^1.0.0
-  checksum: 2e9e70f1dcca3da621a80ce71f2f9a9cad12c047145c6ece20df22f0743f051cf7c73505e109814915f23f9e34fb0d358e22827723ee3d56b623533cab8eafcd
-  languageName: node
-  linkType: hard
-
-"responselike@npm:^2.0.0":
-  version: 2.0.1
-  resolution: "responselike@npm:2.0.1"
-  dependencies:
-    lowercase-keys: ^2.0.0
-  checksum: b122535466e9c97b55e69c7f18e2be0ce3823c5d47ee8de0d9c0b114aa55741c6db8bfbfce3766a94d1272e61bfb1ebf0a15e9310ac5629fbb7446a861b4fd3a
-  languageName: node
-  linkType: hard
-
 "restore-cursor@npm:^3.1.0":
   version: 3.1.0
   resolution: "restore-cursor@npm:3.1.0"
@@ -13366,13 +9522,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"ret@npm:~0.1.10":
-  version: 0.1.15
-  resolution: "ret@npm:0.1.15"
-  checksum: d76a9159eb8c946586567bd934358dfc08a36367b3257f7a3d7255fdd7b56597235af23c6afa0d7f0254159e8051f93c918809962ebd6df24ca2a83dbe4d4151
-  languageName: node
-  linkType: hard
-
 "retimer@npm:^3.0.0":
   version: 3.0.0
   resolution: "retimer@npm:3.0.0"
@@ -13444,7 +9593,18 @@ __metadata:
   languageName: node
   linkType: hard
 
-"rlp@npm:^2.0.0, rlp@npm:^2.2.1, rlp@npm:^2.2.2, rlp@npm:^2.2.3, rlp@npm:^2.2.4":
+"rlp@npm:2.2.6":
+  version: 2.2.6
+  resolution: "rlp@npm:2.2.6"
+  dependencies:
+    bn.js: ^4.11.1
+  bin:
+    rlp: bin/rlp
+  checksum: 2601225df0fe7aa3b497b33a12fd9fbaf8fb1d2989ecc5c091918ed93ee77d1c3fab20ddd3891a9ca66a8ba66d993e6079be6fb31f450fcf38ba30873102ca46
+  languageName: node
+  linkType: hard
+
+"rlp@npm:^2.2.3, rlp@npm:^2.2.4":
   version: 2.2.7
   resolution: "rlp@npm:2.2.7"
   dependencies:
@@ -13462,15 +9622,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"run-parallel-limit@npm:^1.1.0":
-  version: 1.1.0
-  resolution: "run-parallel-limit@npm:1.1.0"
-  dependencies:
-    queue-microtask: ^1.2.2
-  checksum: 672c3b87e7f939c684b9965222b361421db0930223ed1e43ebf0e7e48ccc1a022ea4de080bef4d5468434e2577c33b7681e3f03b7593fdc49ad250a55381123c
-  languageName: node
-  linkType: hard
-
 "run-parallel@npm:^1.1.9":
   version: 1.2.0
   resolution: "run-parallel@npm:1.2.0"
@@ -13496,16 +9647,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"rxjs@npm:^7.2.0":
-  version: 7.8.1
-  resolution: "rxjs@npm:7.8.1"
-  dependencies:
-    tslib: ^2.1.0
-  checksum: de4b53db1063e618ec2eca0f7965d9137cabe98cf6be9272efe6c86b47c17b987383df8574861bcced18ebd590764125a901d5506082be84a8b8e364bf05f119
-  languageName: node
-  linkType: hard
-
-"safe-array-concat@npm:^1.0.0, safe-array-concat@npm:^1.0.1":
+"safe-array-concat@npm:^1.0.1":
   version: 1.1.0
   resolution: "safe-array-concat@npm:1.1.0"
   dependencies:
@@ -13517,7 +9659,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"safe-buffer@npm:5.2.1, safe-buffer@npm:^5.0.1, safe-buffer@npm:^5.1.0, safe-buffer@npm:^5.1.1, safe-buffer@npm:^5.1.2, safe-buffer@npm:^5.2.0, safe-buffer@npm:^5.2.1, safe-buffer@npm:~5.2.0":
+"safe-buffer@npm:^5.0.1, safe-buffer@npm:^5.1.0, safe-buffer@npm:^5.1.1, safe-buffer@npm:^5.1.2, safe-buffer@npm:^5.2.0, safe-buffer@npm:~5.2.0":
   version: 5.2.1
   resolution: "safe-buffer@npm:5.2.1"
   checksum: b99c4b41fdd67a6aaf280fcd05e9ffb0813654894223afb78a31f14a19ad220bba8aba1cb14eddce1fcfb037155fe6de4e861784eb434f7d11ed58d1e70dd491
@@ -13531,15 +9673,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"safe-event-emitter@npm:^1.0.1":
-  version: 1.0.1
-  resolution: "safe-event-emitter@npm:1.0.1"
-  dependencies:
-    events: ^3.0.0
-  checksum: 2a15094bd28b0966571693f219b5a846949ae24f7ba87c6024f0ed552bef63ebe72970a784b85b77b1f03f1c95e78fabe19306d44538dbc4a3a685bed31c18c4
-  languageName: node
-  linkType: hard
-
 "safe-regex-test@npm:^1.0.0":
   version: 1.0.2
   resolution: "safe-regex-test@npm:1.0.2"
@@ -13551,15 +9684,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"safe-regex@npm:^1.1.0":
-  version: 1.1.0
-  resolution: "safe-regex@npm:1.1.0"
-  dependencies:
-    ret: ~0.1.10
-  checksum: 9a8bba57c87a841f7997b3b951e8e403b1128c1a4fd1182f40cc1a20e2d490593d7c2a21030fadfea320c8e859219019e136f678c6689ed5960b391b822f01d5
-  languageName: node
-  linkType: hard
-
 "safer-buffer@npm:>= 2.1.2 < 3, safer-buffer@npm:>= 2.1.2 < 3.0.0, safer-buffer@npm:^2.0.2, safer-buffer@npm:^2.1.0, safer-buffer@npm:~2.1.0":
   version: 2.1.2
   resolution: "safer-buffer@npm:2.1.2"
@@ -13591,23 +9715,14 @@ __metadata:
   languageName: node
   linkType: hard
 
-"scrypt-js@npm:3.0.1, scrypt-js@npm:^3.0.0, scrypt-js@npm:^3.0.1":
+"scrypt-js@npm:3.0.1, scrypt-js@npm:^3.0.0":
   version: 3.0.1
   resolution: "scrypt-js@npm:3.0.1"
   checksum: b7c7d1a68d6ca946f2fbb0778e0c4ec63c65501b54023b2af7d7e9f48fdb6c6580d6f7675cd53bda5944c5ebc057560d5a6365079752546865defb3b79dea454
   languageName: node
   linkType: hard
 
-"scryptsy@npm:^1.2.1":
-  version: 1.2.1
-  resolution: "scryptsy@npm:1.2.1"
-  dependencies:
-    pbkdf2: ^3.0.3
-  checksum: e09cf253b0974171bbcb77fa46405bb07cb8e241e2851fc5f23b38526a33105f0f7748a4d60027642f40bd4518ada30b1dce5005c05d17a25cbcefad371d4259
-  languageName: node
-  linkType: hard
-
-"secp256k1@npm:^4.0.1":
+"secp256k1@npm:4.0.3, secp256k1@npm:^4.0.1":
   version: 4.0.3
   resolution: "secp256k1@npm:4.0.3"
   dependencies:
@@ -13619,21 +9734,21 @@ __metadata:
   languageName: node
   linkType: hard
 
-"seedrandom@npm:3.0.1":
-  version: 3.0.1
-  resolution: "seedrandom@npm:3.0.1"
-  checksum: a8f5bd0e918c4d4b59afd6f5dbd28f5ab8d5f118ee59892c3712f581de51574ac6622aa38fa2d03476b661f8407e98d6ff32af3d7cfdb02c90d046e7f5f91952
+"seedrandom@npm:3.0.5":
+  version: 3.0.5
+  resolution: "seedrandom@npm:3.0.5"
+  checksum: 728b56bc3bc1b9ddeabd381e449b51cb31bdc0aa86e27fcd0190cea8c44613d5bcb2f6bb63ed79f78180cbe791c20b8ec31a9627f7b7fc7f476fd2bdb7e2da9f
   languageName: node
   linkType: hard
 
-"semaphore@npm:>=1.0.1, semaphore@npm:^1.0.3, semaphore@npm:^1.1.0":
-  version: 1.1.0
-  resolution: "semaphore@npm:1.1.0"
-  checksum: d2445d232ad9959048d4748ef54eb01bc7b60436be2b42fb7de20c4cffacf70eafeeecd3772c1baf408cfdce3805fa6618a4389590335671f18cde54ef3cfae4
+"semaphore-async-await@npm:^1.5.1":
+  version: 1.5.1
+  resolution: "semaphore-async-await@npm:1.5.1"
+  checksum: 2dedf7c59ba5f2da860fed95a81017189de6257cbe06c9de0ff2e610a3ae427e9bde1ab7685a62b03ebc28982dee437110492215d75fd6dc8257ce7a38e66b74
   languageName: node
   linkType: hard
 
-"semver@npm:2 || 3 || 4 || 5, semver@npm:^5.3.0, semver@npm:^5.5.0, semver@npm:^5.6.0":
+"semver@npm:^5.5.0":
   version: 5.7.2
   resolution: "semver@npm:5.7.2"
   bin:
@@ -13662,36 +9777,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"semver@npm:~5.4.1":
-  version: 5.4.1
-  resolution: "semver@npm:5.4.1"
-  bin:
-    semver: ./bin/semver
-  checksum: d4bf8cc6a95b065a545ab35082b6ac6c5f4ebe1e1c570f72c252afe9b7e622f2479fb2a5cef3e937d8807d37bfdad2d1feebcc8610e06f556e552c22cad070a2
-  languageName: node
-  linkType: hard
-
-"send@npm:0.18.0":
-  version: 0.18.0
-  resolution: "send@npm:0.18.0"
-  dependencies:
-    debug: 2.6.9
-    depd: 2.0.0
-    destroy: 1.2.0
-    encodeurl: ~1.0.2
-    escape-html: ~1.0.3
-    etag: ~1.8.1
-    fresh: 0.5.2
-    http-errors: 2.0.0
-    mime: 1.6.0
-    ms: 2.1.3
-    on-finished: 2.4.1
-    range-parser: ~1.2.1
-    statuses: 2.0.1
-  checksum: 74fc07ebb58566b87b078ec63e5a3e41ecd987e4272ba67b7467e86c6ad51bc6b0b0154133b6d8b08a2ddda360464f71382f7ef864700f34844a76c8027817a8
-  languageName: node
-  linkType: hard
-
 "serialize-javascript@npm:6.0.0":
   version: 6.0.0
   resolution: "serialize-javascript@npm:6.0.0"
@@ -13701,31 +9786,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"serve-static@npm:1.15.0":
-  version: 1.15.0
-  resolution: "serve-static@npm:1.15.0"
-  dependencies:
-    encodeurl: ~1.0.2
-    escape-html: ~1.0.3
-    parseurl: ~1.3.3
-    send: 0.18.0
-  checksum: af57fc13be40d90a12562e98c0b7855cf6e8bd4c107fe9a45c212bf023058d54a1871b1c89511c3958f70626fff47faeb795f5d83f8cf88514dbaeb2b724464d
-  languageName: node
-  linkType: hard
-
-"servify@npm:^0.1.12":
-  version: 0.1.12
-  resolution: "servify@npm:0.1.12"
-  dependencies:
-    body-parser: ^1.16.0
-    cors: ^2.8.1
-    express: ^4.14.0
-    request: ^2.79.0
-    xhr: ^2.3.3
-  checksum: f90e8f4e31b2981b31e3fa8be0b570b0876136b4cf818ba3bfb65e1bfb3c54cb90a0c30898a7c2974b586800bd26ff525c838a8c170148d9e6674c2170f535d8
-  languageName: node
-  linkType: hard
-
 "set-blocking@npm:^2.0.0":
   version: 2.0.0
   resolution: "set-blocking@npm:2.0.0"
@@ -13751,28 +9811,9 @@ __metadata:
   resolution: "set-function-name@npm:2.0.1"
   dependencies:
     define-data-property: ^1.0.1
-    functions-have-names: ^1.2.3
-    has-property-descriptors: ^1.0.0
-  checksum: 4975d17d90c40168eee2c7c9c59d023429f0a1690a89d75656306481ece0c3c1fb1ebcc0150ea546d1913e35fbd037bace91372c69e543e51fc5d1f31a9fa126
-  languageName: node
-  linkType: hard
-
-"set-immediate-shim@npm:^1.0.1":
-  version: 1.0.1
-  resolution: "set-immediate-shim@npm:1.0.1"
-  checksum: 5085c84039d1e5eee73d2bf48ce765fcec76159021d0cc7b40e23bcdf62cb6d450ffb781e3c62c1118425242c48eae96df712cba0a20a437e86b0d4a15d51a11
-  languageName: node
-  linkType: hard
-
-"set-value@npm:^2.0.0, set-value@npm:^2.0.1":
-  version: 2.0.1
-  resolution: "set-value@npm:2.0.1"
-  dependencies:
-    extend-shallow: ^2.0.1
-    is-extendable: ^0.1.1
-    is-plain-object: ^2.0.3
-    split-string: ^3.0.1
-  checksum: 09a4bc72c94641aeae950eb60dc2755943b863780fcc32e441eda964b64df5e3f50603d5ebdd33394ede722528bd55ed43aae26e9df469b4d32e2292b427b601
+    functions-have-names: ^1.2.3
+    has-property-descriptors: ^1.0.0
+  checksum: 4975d17d90c40168eee2c7c9c59d023429f0a1690a89d75656306481ece0c3c1fb1ebcc0150ea546d1913e35fbd037bace91372c69e543e51fc5d1f31a9fa126
   languageName: node
   linkType: hard
 
@@ -13882,38 +9923,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"simple-concat@npm:^1.0.0":
-  version: 1.0.1
-  resolution: "simple-concat@npm:1.0.1"
-  checksum: 4d211042cc3d73a718c21ac6c4e7d7a0363e184be6a5ad25c8a1502e49df6d0a0253979e3d50dbdd3f60ef6c6c58d756b5d66ac1e05cda9cacd2e9fc59e3876a
-  languageName: node
-  linkType: hard
-
-"simple-get@npm:^2.7.0":
-  version: 2.8.2
-  resolution: "simple-get@npm:2.8.2"
-  dependencies:
-    decompress-response: ^3.3.0
-    once: ^1.3.1
-    simple-concat: ^1.0.0
-  checksum: 230bd931d3198f21a5a1a566687a5ee1ef651b13b61c7a01b547b2a0c2bf72769b5fe14a3b4dd518e99a18ba1002ba8af3901c0e61e8a0d1e7631a3c2eb1f7a9
-  languageName: node
-  linkType: hard
-
-"slash@npm:^1.0.0":
-  version: 1.0.0
-  resolution: "slash@npm:1.0.0"
-  checksum: 4b6e21b1fba6184a7e2efb1dd173f692d8a845584c1bbf9dc818ff86f5a52fc91b413008223d17cc684604ee8bb9263a420b1182027ad9762e35388434918860
-  languageName: node
-  linkType: hard
-
-"slash@npm:^2.0.0":
-  version: 2.0.0
-  resolution: "slash@npm:2.0.0"
-  checksum: 512d4350735375bd11647233cb0e2f93beca6f53441015eea241fe784d8068281c3987fbaa93e7ef1c38df68d9c60013045c92837423c69115297d6169aa85e6
-  languageName: node
-  linkType: hard
-
 "slash@npm:^3.0.0":
   version: 3.0.0
   resolution: "slash@npm:3.0.0"
@@ -13950,42 +9959,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"snapdragon-node@npm:^2.0.1":
-  version: 2.1.1
-  resolution: "snapdragon-node@npm:2.1.1"
-  dependencies:
-    define-property: ^1.0.0
-    isobject: ^3.0.0
-    snapdragon-util: ^3.0.1
-  checksum: 9bb57d759f9e2a27935dbab0e4a790137adebace832b393e350a8bf5db461ee9206bb642d4fe47568ee0b44080479c8b4a9ad0ebe3712422d77edf9992a672fd
-  languageName: node
-  linkType: hard
-
-"snapdragon-util@npm:^3.0.1":
-  version: 3.0.1
-  resolution: "snapdragon-util@npm:3.0.1"
-  dependencies:
-    kind-of: ^3.2.0
-  checksum: 684997dbe37ec995c03fd3f412fba2b711fc34cb4010452b7eb668be72e8811a86a12938b511e8b19baf853b325178c56d8b78d655305e5cfb0bb8b21677e7b7
-  languageName: node
-  linkType: hard
-
-"snapdragon@npm:^0.8.1":
-  version: 0.8.2
-  resolution: "snapdragon@npm:0.8.2"
-  dependencies:
-    base: ^0.11.1
-    debug: ^2.2.0
-    define-property: ^0.2.5
-    extend-shallow: ^2.0.1
-    map-cache: ^0.2.2
-    source-map: ^0.5.6
-    source-map-resolve: ^0.5.0
-    use: ^3.1.0
-  checksum: a197f242a8f48b11036563065b2487e9b7068f50a20dd81d9161eca6af422174fc158b8beeadbe59ce5ef172aa5718143312b3aebaae551c124b7824387c8312
-  languageName: node
-  linkType: hard
-
 "socks-proxy-agent@npm:^8.0.1":
   version: 8.0.2
   resolution: "socks-proxy-agent@npm:8.0.2"
@@ -14026,36 +9999,20 @@ __metadata:
   languageName: node
   linkType: hard
 
-"solc@npm:^0.4.20":
-  version: 0.4.26
-  resolution: "solc@npm:0.4.26"
-  dependencies:
-    fs-extra: ^0.30.0
-    memorystream: ^0.3.1
-    require-from-string: ^1.1.0
-    semver: ^5.3.0
-    yargs: ^4.7.1
-  bin:
-    solcjs: solcjs
-  checksum: 041da7ff725c19023ef34a17f83b3303971d2e62bcea9d0fd3c7af728d6f40ff7cdf2b806d0208a3336d3c9be18c321955e1712ab39ee57390ba00d512def946
-  languageName: node
-  linkType: hard
-
-"solc@npm:^0.6.3":
-  version: 0.6.12
-  resolution: "solc@npm:0.6.12"
+"solc@npm:0.8.15":
+  version: 0.8.15
+  resolution: "solc@npm:0.8.15"
   dependencies:
     command-exists: ^1.2.8
-    commander: 3.0.2
-    fs-extra: ^0.30.0
+    commander: ^8.1.0
+    follow-redirects: ^1.12.1
     js-sha3: 0.8.0
     memorystream: ^0.3.1
-    require-from-string: ^2.0.0
     semver: ^5.5.0
     tmp: 0.0.33
   bin:
-    solcjs: solcjs
-  checksum: 1e2bf927f3ef4f3b195b7619ff64f715916d94dc59091a8a710e47bdd4b18e0bd92b55ea43a04ce7fabce9ad7a3e4e73ccaf127a50ebbf963a9de9046576e3b6
+    solcjs: solc.js
+  checksum: a11de198bc5d481485a4a4803fb08a81a56dd9ffa7cdc62f8d6d5fc669f72e7cb4b22789004d54481353463421f6e6e3d1dffe7365b6d0ed5f37baee303266db
   languageName: node
   linkType: hard
 
@@ -14138,19 +10095,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"source-map-resolve@npm:^0.5.0":
-  version: 0.5.3
-  resolution: "source-map-resolve@npm:0.5.3"
-  dependencies:
-    atob: ^2.1.2
-    decode-uri-component: ^0.2.0
-    resolve-url: ^0.2.1
-    source-map-url: ^0.4.0
-    urix: ^0.1.0
-  checksum: c73fa44ac00783f025f6ad9e038ab1a2e007cd6a6b86f47fe717c3d0765b4a08d264f6966f3bd7cd9dbcd69e4832783d5472e43247775b2a550d6f2155d24bae
-  languageName: node
-  linkType: hard
-
 "source-map-support@npm:0.5.12":
   version: 0.5.12
   resolution: "source-map-support@npm:0.5.12"
@@ -14161,15 +10105,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"source-map-support@npm:^0.4.15":
-  version: 0.4.18
-  resolution: "source-map-support@npm:0.4.18"
-  dependencies:
-    source-map: ^0.5.6
-  checksum: 669aa7e992fec586fac0ba9a8dea8ce81b7328f92806335f018ffac5709afb2920e3870b4e56c68164282607229f04b8bbcf5d0e5c845eb1b5119b092e7585c0
-  languageName: node
-  linkType: hard
-
 "source-map-support@npm:^0.5.11, source-map-support@npm:^0.5.13, source-map-support@npm:^0.5.16":
   version: 0.5.21
   resolution: "source-map-support@npm:0.5.21"
@@ -14180,20 +10115,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"source-map-url@npm:^0.4.0":
-  version: 0.4.1
-  resolution: "source-map-url@npm:0.4.1"
-  checksum: 64c5c2c77aff815a6e61a4120c309ae4cac01298d9bcbb3deb1b46a4dd4c46d4a1eaeda79ec9f684766ae80e8dc86367b89326ce9dd2b89947bd9291fc1ac08c
-  languageName: node
-  linkType: hard
-
-"source-map@npm:^0.5.6, source-map@npm:^0.5.7":
-  version: 0.5.7
-  resolution: "source-map@npm:0.5.7"
-  checksum: 5dc2043b93d2f194142c7f38f74a24670cd7a0063acdaf4bf01d2964b402257ae843c2a8fa822ad5b71013b5fcafa55af7421383da919752f22ff488bc553f4d
-  languageName: node
-  linkType: hard
-
 "source-map@npm:^0.6.0, source-map@npm:^0.6.1":
   version: 0.6.1
   resolution: "source-map@npm:0.6.1"
@@ -14210,40 +10131,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"spdx-correct@npm:^3.0.0":
-  version: 3.2.0
-  resolution: "spdx-correct@npm:3.2.0"
-  dependencies:
-    spdx-expression-parse: ^3.0.0
-    spdx-license-ids: ^3.0.0
-  checksum: e9ae98d22f69c88e7aff5b8778dc01c361ef635580e82d29e5c60a6533cc8f4d820803e67d7432581af0cc4fb49973125076ee3b90df191d153e223c004193b2
-  languageName: node
-  linkType: hard
-
-"spdx-exceptions@npm:^2.1.0":
-  version: 2.4.0
-  resolution: "spdx-exceptions@npm:2.4.0"
-  checksum: b1b650a8d94424473bf9629cf972c86a91c03cccc260f5c901bce0e4b92d831627fec28c9e0a1e9c34c5ebad0a12cf2eab887bec088e0a862abb9d720c2fd0a1
-  languageName: node
-  linkType: hard
-
-"spdx-expression-parse@npm:^3.0.0":
-  version: 3.0.1
-  resolution: "spdx-expression-parse@npm:3.0.1"
-  dependencies:
-    spdx-exceptions: ^2.1.0
-    spdx-license-ids: ^3.0.0
-  checksum: a1c6e104a2cbada7a593eaa9f430bd5e148ef5290d4c0409899855ce8b1c39652bcc88a725259491a82601159d6dc790bedefc9016c7472f7de8de7361f8ccde
-  languageName: node
-  linkType: hard
-
-"spdx-license-ids@npm:^3.0.0":
-  version: 3.0.16
-  resolution: "spdx-license-ids@npm:3.0.16"
-  checksum: 5cdaa85aaa24bd02f9353a2e357b4df0a4f205cb35655f3fd0a5674a4fb77081f28ffd425379214bc3be2c2b7593ce1215df6bcc75884aeee0a9811207feabe2
-  languageName: node
-  linkType: hard
-
 "split-ca@npm:^1.0.0":
   version: 1.0.1
   resolution: "split-ca@npm:1.0.1"
@@ -14251,15 +10138,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"split-string@npm:^3.0.1, split-string@npm:^3.0.2":
-  version: 3.1.0
-  resolution: "split-string@npm:3.1.0"
-  dependencies:
-    extend-shallow: ^3.0.0
-  checksum: ae5af5c91bdc3633628821bde92fdf9492fa0e8a63cf6a0376ed6afde93c701422a1610916f59be61972717070119e848d10dfbbd5024b7729d6a71972d2a84c
-  languageName: node
-  linkType: hard
-
 "sprintf-js@npm:~1.0.2":
   version: 1.0.3
   resolution: "sprintf-js@npm:1.0.3"
@@ -14306,16 +10184,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"static-extend@npm:^0.1.1":
-  version: 0.1.2
-  resolution: "static-extend@npm:0.1.2"
-  dependencies:
-    define-property: ^0.2.5
-    object-copy: ^0.1.0
-  checksum: 8657485b831f79e388a437260baf22784540417a9b29e11572c87735df24c22b84eda42107403a64b30861b2faf13df9f7fc5525d51f9d1d2303aba5cbf4e12c
-  languageName: node
-  linkType: hard
-
 "statuses@npm:2.0.1":
   version: 2.0.1
   resolution: "statuses@npm:2.0.1"
@@ -14332,23 +10200,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"stream-to-pull-stream@npm:^1.7.1":
-  version: 1.7.3
-  resolution: "stream-to-pull-stream@npm:1.7.3"
-  dependencies:
-    looper: ^3.0.0
-    pull-stream: ^3.2.3
-  checksum: 2b878e3b3d5f435802866bfec8897361b9de4ce69f77669da1103cfc45f54833e7c183922468f30c046d375a1642f5a4801a808a8da0d3927c5de41d42a59bc0
-  languageName: node
-  linkType: hard
-
-"strict-uri-encode@npm:^1.0.0":
-  version: 1.1.0
-  resolution: "strict-uri-encode@npm:1.1.0"
-  checksum: 9466d371f7b36768d43f7803f26137657559e4c8b0161fb9e320efb8edba3ae22f8e99d4b0d91da023b05a13f62ec5412c3f4f764b5788fac11d1fea93720bb3
-  languageName: node
-  linkType: hard
-
 "string-format@npm:^2.0.0":
   version: 2.0.0
   resolution: "string-format@npm:2.0.0"
@@ -14367,17 +10218,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"string-width@npm:^1.0.1":
-  version: 1.0.2
-  resolution: "string-width@npm:1.0.2"
-  dependencies:
-    code-point-at: ^1.0.0
-    is-fullwidth-code-point: ^1.0.0
-    strip-ansi: ^3.0.0
-  checksum: 5c79439e95bc3bd7233a332c5f5926ab2ee90b23816ed4faa380ce3b2576d7800b0a5bb15ae88ed28737acc7ea06a518c2eef39142dd727adad0e45c776cd37e
-  languageName: node
-  linkType: hard
-
 "string-width@npm:^2.1.1":
   version: 2.1.1
   resolution: "string-width@npm:2.1.1"
@@ -14410,7 +10250,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"string.prototype.trim@npm:^1.2.8, string.prototype.trim@npm:~1.2.8":
+"string.prototype.trim@npm:^1.2.8":
   version: 1.2.8
   resolution: "string.prototype.trim@npm:1.2.8"
   dependencies:
@@ -14477,15 +10317,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"strip-ansi@npm:^3.0.0, strip-ansi@npm:^3.0.1":
-  version: 3.0.1
-  resolution: "strip-ansi@npm:3.0.1"
-  dependencies:
-    ansi-regex: ^2.0.0
-  checksum: 9b974de611ce5075c70629c00fa98c46144043db92ae17748fb780f706f7a789e9989fd10597b7c2053ae8d1513fd707816a91f1879b2f71e6ac0b6a863db465
-  languageName: node
-  linkType: hard
-
 "strip-ansi@npm:^4.0.0":
   version: 4.0.0
   resolution: "strip-ansi@npm:4.0.0"
@@ -14513,15 +10344,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"strip-bom@npm:^2.0.0":
-  version: 2.0.0
-  resolution: "strip-bom@npm:2.0.0"
-  dependencies:
-    is-utf8: ^0.2.0
-  checksum: 08efb746bc67b10814cd03d79eb31bac633393a782e3f35efbc1b61b5165d3806d03332a97f362822cf0d4dd14ba2e12707fcff44fe1c870c48a063a0c9e4944
-  languageName: node
-  linkType: hard
-
 "strip-bom@npm:^3.0.0":
   version: 3.0.0
   resolution: "strip-bom@npm:3.0.0"
@@ -14568,13 +10390,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"supports-color@npm:^2.0.0":
-  version: 2.0.0
-  resolution: "supports-color@npm:2.0.0"
-  checksum: 602538c5812b9006404370b5a4b885d3e2a1f6567d314f8b4a41974ffe7d08e525bf92ae0f9c7030e3b4c78e4e34ace55d6a67a74f1571bc205959f5972f88f0
-  languageName: node
-  linkType: hard
-
 "supports-color@npm:^3.1.0":
   version: 3.2.3
   resolution: "supports-color@npm:3.2.3"
@@ -14609,25 +10424,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"swarm-js@npm:^0.1.40":
-  version: 0.1.42
-  resolution: "swarm-js@npm:0.1.42"
-  dependencies:
-    bluebird: ^3.5.0
-    buffer: ^5.0.5
-    eth-lib: ^0.1.26
-    fs-extra: ^4.0.2
-    got: ^11.8.5
-    mime-types: ^2.1.16
-    mkdirp-promise: ^5.0.1
-    mock-fs: ^4.1.0
-    setimmediate: ^1.0.5
-    tar: ^4.0.2
-    xhr-request: ^1.0.1
-  checksum: bbb54b84232ef113ee106cf8158d1c827fbf84b309799576f61603f63d7653fde7e71df981d07f9e4c41781bbbbd72be77e5a47e6b694d6a83b96a6a20641475
-  languageName: node
-  linkType: hard
-
 "sync-request@npm:^6.0.0":
   version: 6.1.0
   resolution: "sync-request@npm:6.1.0"
@@ -14685,32 +10481,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"tape@npm:^4.6.3":
-  version: 4.17.0
-  resolution: "tape@npm:4.17.0"
-  dependencies:
-    "@ljharb/resumer": ~0.0.1
-    "@ljharb/through": ~2.3.9
-    call-bind: ~1.0.2
-    deep-equal: ~1.1.1
-    defined: ~1.0.1
-    dotignore: ~0.1.2
-    for-each: ~0.3.3
-    glob: ~7.2.3
-    has: ~1.0.3
-    inherits: ~2.0.4
-    is-regex: ~1.1.4
-    minimist: ~1.2.8
-    mock-property: ~1.0.0
-    object-inspect: ~1.12.3
-    resolve: ~1.22.6
-    string.prototype.trim: ~1.2.8
-  bin:
-    tape: bin/tape
-  checksum: b785f4997f4323d9a1b6f5bda97aaea65a4c68f81296ab46bd126776f3c6f4203073187d5a4bcaa98884bf28e3cfaa50c2d8d81cc0025e4777054455837390dc
-  languageName: node
-  linkType: hard
-
 "tar-fs@npm:~1.16.3":
   version: 1.16.3
   resolution: "tar-fs@npm:1.16.3"
@@ -14738,21 +10508,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"tar@npm:^4.0.2":
-  version: 4.4.19
-  resolution: "tar@npm:4.4.19"
-  dependencies:
-    chownr: ^1.1.4
-    fs-minipass: ^1.2.7
-    minipass: ^2.9.0
-    minizlib: ^1.3.3
-    mkdirp: ^0.5.5
-    safe-buffer: ^5.2.1
-    yallist: ^3.1.1
-  checksum: 423c8259b17f8f612cef9c96805d65f90ba9a28e19be582cd9d0fcb217038219f29b7547198e8fd617da5f436376d6a74b99827acd1238d2f49cf62330f9664e
-  languageName: node
-  linkType: hard
-
 "tar@npm:^6.1.11, tar@npm:^6.1.2":
   version: 6.2.0
   resolution: "tar@npm:6.2.0"
@@ -14767,23 +10522,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"test-value@npm:^2.1.0":
-  version: 2.1.0
-  resolution: "test-value@npm:2.1.0"
-  dependencies:
-    array-back: ^1.0.3
-    typical: ^2.6.0
-  checksum: ce41ef4100c9ac84630e78d1ca06706714587faf255e44296ace1fc7bf5b888c160b8c0229d31467252a3b2b57197965194391f6ee0c54f33e0b8e3af3a33a0c
-  languageName: node
-  linkType: hard
-
-"testrpc@npm:0.0.1":
-  version: 0.0.1
-  resolution: "testrpc@npm:0.0.1"
-  checksum: e27778552df2d0b938b062fdf41d44557f0eb3de75903cb90b87909f55a82a6345dd13e40d1498e718272b4e5225872dca66da73646c35df1031486bb0ed0fda
-  languageName: node
-  linkType: hard
-
 "text-table@npm:^0.2.0":
   version: 0.2.0
   resolution: "text-table@npm:0.2.0"
@@ -14810,16 +10548,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"through2@npm:^2.0.3":
-  version: 2.0.5
-  resolution: "through2@npm:2.0.5"
-  dependencies:
-    readable-stream: ~2.3.6
-    xtend: ~4.0.1
-  checksum: beb0f338aa2931e5660ec7bf3ad949e6d2e068c31f4737b9525e5201b824ac40cac6a337224856b56bd1ddd866334bbfb92a9f57cd6f66bc3f18d3d86fc0fe50
-  languageName: node
-  linkType: hard
-
 "through@npm:>=2.2.7 <3, through@npm:^2.3.6":
   version: 2.3.8
   resolution: "through@npm:2.3.8"
@@ -14827,13 +10555,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"timed-out@npm:^4.0.1":
-  version: 4.0.1
-  resolution: "timed-out@npm:4.0.1"
-  checksum: 98efc5d6fc0d2a329277bd4d34f65c1bf44d9ca2b14fd267495df92898f522e6f563c5e9e467c418e0836f5ca1f47a84ca3ee1de79b1cc6fe433834b7f02ec54
-  languageName: node
-  linkType: hard
-
 "timeout-abort-controller@npm:^2.0.0":
   version: 2.0.0
   resolution: "timeout-abort-controller@npm:2.0.0"
@@ -14863,15 +10584,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"tmp@npm:0.1.0":
-  version: 0.1.0
-  resolution: "tmp@npm:0.1.0"
-  dependencies:
-    rimraf: ^2.6.3
-  checksum: 6bab8431de9d245d4264bd8cd6bb216f9d22f179f935dada92a11d1315572c8eb7c3334201e00594b4708608bd536fad3a63bfb037e7804d827d66aa53a1afcd
-  languageName: node
-  linkType: hard
-
 "tmp@npm:^0.2.0":
   version: 0.2.1
   resolution: "tmp@npm:0.2.1"
@@ -14888,39 +10600,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"to-fast-properties@npm:^1.0.3":
-  version: 1.0.3
-  resolution: "to-fast-properties@npm:1.0.3"
-  checksum: bd0abb58c4722851df63419de3f6d901d5118f0440d3f71293ed776dd363f2657edaaf2dc470e3f6b7b48eb84aa411193b60db8a4a552adac30de9516c5cc580
-  languageName: node
-  linkType: hard
-
-"to-object-path@npm:^0.3.0":
-  version: 0.3.0
-  resolution: "to-object-path@npm:0.3.0"
-  dependencies:
-    kind-of: ^3.0.2
-  checksum: 9425effee5b43e61d720940fa2b889623f77473d459c2ce3d4a580a4405df4403eec7be6b857455908070566352f9e2417304641ed158dda6f6a365fe3e66d70
-  languageName: node
-  linkType: hard
-
-"to-readable-stream@npm:^1.0.0":
-  version: 1.0.0
-  resolution: "to-readable-stream@npm:1.0.0"
-  checksum: 2bd7778490b6214a2c40276065dd88949f4cf7037ce3964c76838b8cb212893aeb9cceaaf4352a4c486e3336214c350270f3263e1ce7a0c38863a715a4d9aeb5
-  languageName: node
-  linkType: hard
-
-"to-regex-range@npm:^2.1.0":
-  version: 2.1.1
-  resolution: "to-regex-range@npm:2.1.1"
-  dependencies:
-    is-number: ^3.0.0
-    repeat-string: ^1.6.1
-  checksum: 46093cc14be2da905cc931e442d280b2e544e2bfdb9a24b3cf821be8d342f804785e5736c108d5be026021a05d7b38144980a61917eee3c88de0a5e710e10320
-  languageName: node
-  linkType: hard
-
 "to-regex-range@npm:^5.0.1":
   version: 5.0.1
   resolution: "to-regex-range@npm:5.0.1"
@@ -14930,18 +10609,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"to-regex@npm:^3.0.1, to-regex@npm:^3.0.2":
-  version: 3.0.2
-  resolution: "to-regex@npm:3.0.2"
-  dependencies:
-    define-property: ^2.0.2
-    extend-shallow: ^3.0.2
-    regex-not: ^1.0.2
-    safe-regex: ^1.1.0
-  checksum: 4ed4a619059b64e204aad84e4e5f3ea82d97410988bcece7cf6cbfdbf193d11bff48cf53842d88b8bb00b1bfc0d048f61f20f0709e6f393fd8fe0122662d9db4
-  languageName: node
-  linkType: hard
-
 "toidentifier@npm:1.0.1":
   version: 1.0.1
   resolution: "toidentifier@npm:1.0.1"
@@ -14966,13 +10633,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"trim-right@npm:^1.0.1":
-  version: 1.0.1
-  resolution: "trim-right@npm:1.0.1"
-  checksum: 9120af534e006a7424a4f9358710e6e707887b6ccf7ea69e50d6ac6464db1fe22268400def01752f09769025d480395159778153fb98d4a2f6f40d4cf5d4f3b6
-  languageName: node
-  linkType: hard
-
 "ts-command-line-args@npm:^2.2.0":
   version: 2.5.1
   resolution: "ts-command-line-args@npm:2.5.1"
@@ -14987,22 +10647,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"ts-essentials@npm:^1.0.0":
-  version: 1.0.4
-  resolution: "ts-essentials@npm:1.0.4"
-  checksum: 2e19bbe51203707ca732dcc6c3f238b2cf22bb9213d26ae0246c02325fb3e5f17c32505ac79c1bd538b7951a798155b07422e263a95cb295070a48233e45a1b5
-  languageName: node
-  linkType: hard
-
-"ts-essentials@npm:^6.0.3":
-  version: 6.0.7
-  resolution: "ts-essentials@npm:6.0.7"
-  peerDependencies:
-    typescript: ">=3.7.0"
-  checksum: b47a1793df9ea997d50d2cc9155433952b189cfca0c534a6f3f3dce6aa782a37574d2179dee6d55ed918835aa17addda49619ff2bd2eb3e60e331db3ce30a79b
-  languageName: node
-  linkType: hard
-
 "ts-essentials@npm:^7.0.1":
   version: 7.0.3
   resolution: "ts-essentials@npm:7.0.3"
@@ -15012,25 +10656,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"ts-generator@npm:^0.1.1":
-  version: 0.1.1
-  resolution: "ts-generator@npm:0.1.1"
-  dependencies:
-    "@types/mkdirp": ^0.5.2
-    "@types/prettier": ^2.1.1
-    "@types/resolve": ^0.0.8
-    chalk: ^2.4.1
-    glob: ^7.1.2
-    mkdirp: ^0.5.1
-    prettier: ^2.1.2
-    resolve: ^1.8.1
-    ts-essentials: ^1.0.0
-  bin:
-    ts-generator: dist/cli/run.js
-  checksum: 3add2e76afd7a4d9d9aee1ff26477ee4e8b4cc740b35787f9ea780c11aefc88e6c7833837eacc12b944c1883680639dc9cc47fe173eff95c62112f3a41132146
-  languageName: node
-  linkType: hard
-
 "ts-node@npm:^10.9.1":
   version: 10.9.2
   resolution: "ts-node@npm:10.9.2"
@@ -15081,6 +10706,13 @@ __metadata:
   languageName: node
   linkType: hard
 
+"tslib@npm:2.4.0":
+  version: 2.4.0
+  resolution: "tslib@npm:2.4.0"
+  checksum: 8c4aa6a3c5a754bf76aefc38026134180c053b7bd2f81338cb5e5ebf96fefa0f417bff221592bf801077f5bf990562f6264fecbc42cd3309b33872cb6fc3b113
+  languageName: node
+  linkType: hard
+
 "tslib@npm:^1.11.1, tslib@npm:^1.8.1, tslib@npm:^1.9.0, tslib@npm:^1.9.3":
   version: 1.14.1
   resolution: "tslib@npm:1.14.1"
@@ -15088,7 +10720,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"tslib@npm:^2.1.0, tslib@npm:^2.3.1, tslib@npm:^2.5.0":
+"tslib@npm:^2.3.1, tslib@npm:^2.5.0":
   version: 2.6.2
   resolution: "tslib@npm:2.6.2"
   checksum: 329ea56123005922f39642318e3d1f0f8265d1e7fcb92c633e0809521da75eeaca28d2cf96d7248229deb40e5c19adf408259f4b9640afd20d13aecc1430f3ad
@@ -15122,7 +10754,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"tweetnacl-util@npm:^0.15.0, tweetnacl-util@npm:^0.15.1":
+"tweetnacl-util@npm:^0.15.1":
   version: 0.15.1
   resolution: "tweetnacl-util@npm:0.15.1"
   checksum: ae6aa8a52cdd21a95103a4cc10657d6a2040b36c7a6da7b9d3ab811c6750a2d5db77e8c36969e75fdee11f511aa2b91c552496c6e8e989b6e490e54aca2864fc
@@ -15136,7 +10768,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"tweetnacl@npm:^1.0.0, tweetnacl@npm:^1.0.3":
+"tweetnacl@npm:^1.0.3":
   version: 1.0.3
   resolution: "tweetnacl@npm:1.0.3"
   checksum: e4a57cac188f0c53f24c7a33279e223618a2bfb5fea426231991652a13247bea06b081fd745d71291fcae0f4428d29beba1b984b1f1ce6f66b06a6d1ab90645c
@@ -15196,48 +10828,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"type-is@npm:~1.6.18":
-  version: 1.6.18
-  resolution: "type-is@npm:1.6.18"
-  dependencies:
-    media-typer: 0.3.0
-    mime-types: ~2.1.24
-  checksum: 2c8e47675d55f8b4e404bcf529abdf5036c537a04c2b20177bcf78c9e3c1da69da3942b1346e6edb09e823228c0ee656ef0e033765ec39a70d496ef601a0c657
-  languageName: node
-  linkType: hard
-
-"type@npm:^1.0.1":
-  version: 1.2.0
-  resolution: "type@npm:1.2.0"
-  checksum: dae8c64f82c648b985caf321e9dd6e8b7f4f2e2d4f846fc6fd2c8e9dc7769382d8a52369ddbaccd59aeeceb0df7f52fb339c465be5f2e543e81e810e413451ee
-  languageName: node
-  linkType: hard
-
-"type@npm:^2.7.2":
-  version: 2.7.2
-  resolution: "type@npm:2.7.2"
-  checksum: 0f42379a8adb67fe529add238a3e3d16699d95b42d01adfe7b9a7c5da297f5c1ba93de39265ba30ffeb37dfd0afb3fb66ae09f58d6515da442219c086219f6f4
-  languageName: node
-  linkType: hard
-
-"typechain@npm:^3.0.0":
-  version: 3.0.0
-  resolution: "typechain@npm:3.0.0"
-  dependencies:
-    command-line-args: ^4.0.7
-    debug: ^4.1.1
-    fs-extra: ^7.0.0
-    js-sha3: ^0.8.0
-    lodash: ^4.17.15
-    ts-essentials: ^6.0.3
-    ts-generator: ^0.1.1
-  bin:
-    typechain: ./dist/cli/cli.js
-  checksum: a38aff5e89c41e20e2c3a1f7b5f04666dbc94b5592eba70ba7d1e0aeb49089d22ed3d35e55a0b0d1f0bfdcea9818157fa4ee3854ef818f46f6aa899520fe7c25
-  languageName: node
-  linkType: hard
-
-"typechain@npm:^8.1.0":
+"typechain@npm:^8.0.0, typechain@npm:^8.1.0":
   version: 8.3.2
   resolution: "typechain@npm:8.3.2"
   dependencies:
@@ -15306,15 +10897,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"typedarray-to-buffer@npm:^3.1.5":
-  version: 3.1.5
-  resolution: "typedarray-to-buffer@npm:3.1.5"
-  dependencies:
-    is-typedarray: ^1.0.0
-  checksum: 99c11aaa8f45189fcfba6b8a4825fd684a321caa9bd7a76a27cf0c7732c174d198b99f449c52c3818107430b5f41c0ccbbfb75cb2ee3ca4a9451710986d61a60
-  languageName: node
-  linkType: hard
-
 "typedarray@npm:^0.0.6":
   version: 0.0.6
   resolution: "typedarray@npm:0.0.6"
@@ -15345,50 +10927,20 @@ __metadata:
 "typescript@patch:typescript@^3.5.2#~builtin<compat/typescript>":
   version: 3.9.10
   resolution: "typescript@patch:typescript@npm%3A3.9.10#~builtin<compat/typescript>::version=3.9.10&hash=7ad353"
-  bin:
-    tsc: bin/tsc
-    tsserver: bin/tsserver
-  checksum: dc7141ab555b23a8650a6787f98845fc11692063d02b75ff49433091b3af2fe3d773650dea18389d7c21f47d620fb3b110ea363dab4ab039417a6ccbbaf96fc2
-  languageName: node
-  linkType: hard
-
-"typescript@patch:typescript@^4.7.4#~builtin<compat/typescript>":
-  version: 4.9.5
-  resolution: "typescript@patch:typescript@npm%3A4.9.5#~builtin<compat/typescript>::version=4.9.5&hash=7ad353"
-  bin:
-    tsc: bin/tsc
-    tsserver: bin/tsserver
-  checksum: 2eee5c37cad4390385db5db5a8e81470e42e8f1401b0358d7390095d6f681b410f2c4a0c496c6ff9ebd775423c7785cdace7bcdad76c7bee283df3d9718c0f20
-  languageName: node
-  linkType: hard
-
-"typewise-core@npm:^1.2, typewise-core@npm:^1.2.0":
-  version: 1.2.0
-  resolution: "typewise-core@npm:1.2.0"
-  checksum: c21e83544546d1aba2f17377c25ae0eb571c2153b2e3705932515bef103dbe43e05d2286f238ad139341b1000da40583115a44cb5e69a2ef408572b13dab844b
-  languageName: node
-  linkType: hard
-
-"typewise@npm:^1.0.3":
-  version: 1.0.3
-  resolution: "typewise@npm:1.0.3"
-  dependencies:
-    typewise-core: ^1.2.0
-  checksum: eb3452b1387df8bf8e3b620720d240425a50ce402d7c064c21ac4b5d88c551ee4d1f26cd649b8a17a6d06f7a3675733de841723f8e06bb3edabfeacc4924af4a
-  languageName: node
-  linkType: hard
-
-"typewiselite@npm:~1.0.0":
-  version: 1.0.0
-  resolution: "typewiselite@npm:1.0.0"
-  checksum: 2e13a652c041680e9e37501129715f97c2ff2b8f52b5e82acd9355c070ca7c126633ff96d2ad03945254c271c0d1cf9f4956090c93ad750717e00d100cbd0c87
+  bin:
+    tsc: bin/tsc
+    tsserver: bin/tsserver
+  checksum: dc7141ab555b23a8650a6787f98845fc11692063d02b75ff49433091b3af2fe3d773650dea18389d7c21f47d620fb3b110ea363dab4ab039417a6ccbbaf96fc2
   languageName: node
   linkType: hard
 
-"typical@npm:^2.6.0, typical@npm:^2.6.1":
-  version: 2.6.1
-  resolution: "typical@npm:2.6.1"
-  checksum: 6af04fefe50d90d3471f058b2cdc0f49b7436bdd605cd00acea7965926ff388a5a7d692ef144f45fccee6f8e896c065702ecc44b69057e2ce88c09e897c7d3a4
+"typescript@patch:typescript@^4.7.4#~builtin<compat/typescript>":
+  version: 4.9.5
+  resolution: "typescript@patch:typescript@npm%3A4.9.5#~builtin<compat/typescript>::version=4.9.5&hash=7ad353"
+  bin:
+    tsc: bin/tsc
+    tsserver: bin/tsserver
+  checksum: 2eee5c37cad4390385db5db5a8e81470e42e8f1401b0358d7390095d6f681b410f2c4a0c496c6ff9ebd775423c7785cdace7bcdad76c7bee283df3d9718c0f20
   languageName: node
   linkType: hard
 
@@ -15424,13 +10976,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"ultron@npm:~1.1.0":
-  version: 1.1.1
-  resolution: "ultron@npm:1.1.1"
-  checksum: aa7b5ebb1b6e33287b9d873c6756c4b7aa6d1b23d7162ff25b0c0ce5c3c7e26e2ab141a5dc6e96c10ac4d00a372e682ce298d784f06ffcd520936590b4bc0653
-  languageName: node
-  linkType: hard
-
 "unbox-primitive@npm:^1.0.2":
   version: 1.0.2
   resolution: "unbox-primitive@npm:1.0.2"
@@ -15443,13 +10988,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"underscore@npm:1.9.1":
-  version: 1.9.1
-  resolution: "underscore@npm:1.9.1"
-  checksum: bee6f587661a6a9ca2f77e611896141e0287af51d8ca6034b11d0d4163ddbdd181a9720078ddbe94d265b7694f4880bc7f4c2ad260cfb8985ee2f9adcf13df03
-  languageName: node
-  linkType: hard
-
 "undici-types@npm:~5.26.4":
   version: 5.26.5
   resolution: "undici-types@npm:5.26.5"
@@ -15457,7 +10995,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"undici@npm:^5.14.0":
+"undici@npm:^5.14.0, undici@npm:^5.28.2":
   version: 5.28.3
   resolution: "undici@npm:5.28.3"
   dependencies:
@@ -15473,18 +11011,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"union-value@npm:^1.0.0":
-  version: 1.0.1
-  resolution: "union-value@npm:1.0.1"
-  dependencies:
-    arr-union: ^3.1.0
-    get-value: ^2.0.6
-    is-extendable: ^0.1.1
-    set-value: ^2.0.1
-  checksum: a3464097d3f27f6aa90cf103ed9387541bccfc006517559381a10e0dffa62f465a9d9a09c9b9c3d26d0f4cbe61d4d010e2fbd710fd4bf1267a768ba8a774b0ba
-  languageName: node
-  linkType: hard
-
 "unique-filename@npm:^3.0.0":
   version: 3.0.0
   resolution: "unique-filename@npm:3.0.0"
@@ -15517,30 +11043,13 @@ __metadata:
   languageName: node
   linkType: hard
 
-"unorm@npm:^1.3.3":
-  version: 1.6.0
-  resolution: "unorm@npm:1.6.0"
-  checksum: 9a86546256a45f855b6cfe719086785d6aada94f63778cecdecece8d814ac26af76cb6da70130da0a08b8803bbf0986e56c7ec4249038198f3de02607fffd811
-  languageName: node
-  linkType: hard
-
-"unpipe@npm:1.0.0, unpipe@npm:~1.0.0":
+"unpipe@npm:1.0.0":
   version: 1.0.0
   resolution: "unpipe@npm:1.0.0"
   checksum: 4fa18d8d8d977c55cb09715385c203197105e10a6d220087ec819f50cb68870f02942244f1017565484237f1f8c5d3cd413631b1ae104d3096f24fdfde1b4aa2
   languageName: node
   linkType: hard
 
-"unset-value@npm:^1.0.0":
-  version: 1.0.0
-  resolution: "unset-value@npm:1.0.0"
-  dependencies:
-    has-value: ^0.3.1
-    isobject: ^3.0.0
-  checksum: 5990ecf660672be2781fc9fb322543c4aa592b68ed9a3312fa4df0e9ba709d42e823af090fc8f95775b4cd2c9a5169f7388f0cec39238b6d0d55a69fc2ab6b29
-  languageName: node
-  linkType: hard
-
 "uri-js@npm:^4.2.2":
   version: 4.4.1
   resolution: "uri-js@npm:4.4.1"
@@ -15550,29 +11059,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"urix@npm:^0.1.0":
-  version: 0.1.0
-  resolution: "urix@npm:0.1.0"
-  checksum: 4c076ecfbf3411e888547fe844e52378ab5ada2d2f27625139011eada79925e77f7fbf0e4016d45e6a9e9adb6b7e64981bd49b22700c7c401c5fc15f423303b3
-  languageName: node
-  linkType: hard
-
-"url-parse-lax@npm:^3.0.0":
-  version: 3.0.0
-  resolution: "url-parse-lax@npm:3.0.0"
-  dependencies:
-    prepend-http: ^2.0.0
-  checksum: 1040e357750451173132228036aff1fd04abbd43eac1fb3e4fca7495a078bcb8d33cb765fe71ad7e473d9c94d98fd67adca63bd2716c815a2da066198dd37217
-  languageName: node
-  linkType: hard
-
-"url-set-query@npm:^1.0.0":
-  version: 1.0.0
-  resolution: "url-set-query@npm:1.0.0"
-  checksum: 5ad73525e8f3ab55c6bf3ddc70a43912e65ff9ce655d7868fdcefdf79f509cfdddde4b07150797f76186f1a47c0ecd2b7bb3687df8f84757dee4110cf006e12d
-  languageName: node
-  linkType: hard
-
 "url@npm:^0.11.0":
   version: 0.11.3
   resolution: "url@npm:0.11.3"
@@ -15583,24 +11069,17 @@ __metadata:
   languageName: node
   linkType: hard
 
-"use@npm:^3.1.0":
-  version: 3.1.1
-  resolution: "use@npm:3.1.1"
-  checksum: 08a130289f5238fcbf8f59a18951286a6e660d17acccc9d58d9b69dfa0ee19aa038e8f95721b00b432c36d1629a9e32a464bf2e7e0ae6a244c42ddb30bdd8b33
-  languageName: node
-  linkType: hard
-
-"utf-8-validate@npm:^5.0.2":
-  version: 5.0.10
-  resolution: "utf-8-validate@npm:5.0.10"
+"utf-8-validate@npm:5.0.7":
+  version: 5.0.7
+  resolution: "utf-8-validate@npm:5.0.7"
   dependencies:
     node-gyp: latest
     node-gyp-build: ^4.3.0
-  checksum: 5579350a023c66a2326752b6c8804cc7b39dcd251bb088241da38db994b8d78352e388dcc24ad398ab98385ba3c5ffcadb6b5b14b2637e43f767869055e46ba6
+  checksum: 588d272b359bf555a0c4c2ffe97286edc73126de132f63f4f0c80110bd06b67d3ce44d2b3d24feea6da13ced50c04d774ba4d25fe28576371cd714cd013bd3b7
   languageName: node
   linkType: hard
 
-"utf8@npm:3.0.0, utf8@npm:^3.0.0":
+"utf8@npm:3.0.0":
   version: 3.0.0
   resolution: "utf8@npm:3.0.0"
   checksum: cb89a69ad9ab393e3eae9b25305b3ff08bebca9adc839191a34f90777eb2942f86a96369d2839925fea58f8f722f7e27031d697f10f5f39690f8c5047303e62d
@@ -15614,37 +11093,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"util.promisify@npm:^1.0.0":
-  version: 1.1.2
-  resolution: "util.promisify@npm:1.1.2"
-  dependencies:
-    call-bind: ^1.0.2
-    define-properties: ^1.2.0
-    for-each: ^0.3.3
-    has-proto: ^1.0.1
-    has-symbols: ^1.0.3
-    object.getownpropertydescriptors: ^2.1.6
-    safe-array-concat: ^1.0.0
-  checksum: 9a5233e7fd067ca24abe2310f9c93e6df3adb644a662fcd826454d30539d3dd1d557b75bfed4cedd4993203012ea6add6d7dd268fed35bbdac4736dce9446373
-  languageName: node
-  linkType: hard
-
-"utils-merge@npm:1.0.1":
-  version: 1.0.1
-  resolution: "utils-merge@npm:1.0.1"
-  checksum: c81095493225ecfc28add49c106ca4f09cdf56bc66731aa8dabc2edbbccb1e1bfe2de6a115e5c6a380d3ea166d1636410b62ef216bb07b3feb1cfde1d95d5080
-  languageName: node
-  linkType: hard
-
-"uuid@npm:3.3.2":
-  version: 3.3.2
-  resolution: "uuid@npm:3.3.2"
-  bin:
-    uuid: ./bin/uuid
-  checksum: 8793629d2799f500aeea9fcd0aec6c4e9fbcc4d62ed42159ad96be345c3fffac1bbf61a23e18e2782600884fee05e6d4012ce4b70d0037c8e987533ae6a77870
-  languageName: node
-  linkType: hard
-
 "uuid@npm:^3.3.2":
   version: 3.4.0
   resolution: "uuid@npm:3.4.0"
@@ -15677,23 +11125,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"validate-npm-package-license@npm:^3.0.1":
-  version: 3.0.4
-  resolution: "validate-npm-package-license@npm:3.0.4"
-  dependencies:
-    spdx-correct: ^3.0.0
-    spdx-expression-parse: ^3.0.0
-  checksum: 35703ac889d419cf2aceef63daeadbe4e77227c39ab6287eeb6c1b36a746b364f50ba22e88591f5d017bc54685d8137bc2d328d0a896e4d3fd22093c0f32a9ad
-  languageName: node
-  linkType: hard
-
-"varint@npm:^5.0.0":
-  version: 5.0.2
-  resolution: "varint@npm:5.0.2"
-  checksum: e1a66bf9a6cea96d1f13259170d4d41b845833acf3a9df990ea1e760d279bd70d5b1f4c002a50197efd2168a2fd43eb0b808444600fd4d23651e8d42fe90eb05
-  languageName: node
-  linkType: hard
-
 "varint@npm:^6.0.0":
   version: 6.0.0
   resolution: "varint@npm:6.0.0"
@@ -15701,13 +11132,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"vary@npm:^1, vary@npm:~1.1.2":
-  version: 1.1.2
-  resolution: "vary@npm:1.1.2"
-  checksum: ae0123222c6df65b437669d63dfa8c36cee20a504101b2fcd97b8bf76f91259c17f9f2b4d70a1e3c6bbcee7f51b28392833adb6b2770b23b01abec84e369660b
-  languageName: node
-  linkType: hard
-
 "verror@npm:1.10.0":
   version: 1.10.0
   resolution: "verror@npm:1.10.0"
@@ -15728,301 +11152,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"web3-bzz@npm:1.2.11":
-  version: 1.2.11
-  resolution: "web3-bzz@npm:1.2.11"
-  dependencies:
-    "@types/node": ^12.12.6
-    got: 9.6.0
-    swarm-js: ^0.1.40
-    underscore: 1.9.1
-  checksum: 45136e7282819260357efdcdf6d81cb7b733b212aa1e46f1bbcaff70a33a2e3f6558936e6e1fc3bf75bb4c3220f844fc6b9d5bfaaa68a2f6ed0e8c0b02c97523
-  languageName: node
-  linkType: hard
-
-"web3-core-helpers@npm:1.2.11":
-  version: 1.2.11
-  resolution: "web3-core-helpers@npm:1.2.11"
-  dependencies:
-    underscore: 1.9.1
-    web3-eth-iban: 1.2.11
-    web3-utils: 1.2.11
-  checksum: dac2ab85b8bec8251647d40f1dc5fcf30b2245de6d216328c51c9d619d12a567906c5bf8b542846552a56bf969edcfcb16fb67e3780461195df85cd506591f68
-  languageName: node
-  linkType: hard
-
-"web3-core-method@npm:1.2.11":
-  version: 1.2.11
-  resolution: "web3-core-method@npm:1.2.11"
-  dependencies:
-    "@ethersproject/transactions": ^5.0.0-beta.135
-    underscore: 1.9.1
-    web3-core-helpers: 1.2.11
-    web3-core-promievent: 1.2.11
-    web3-core-subscriptions: 1.2.11
-    web3-utils: 1.2.11
-  checksum: 7533c5b8c42df49969b9c95a2c9cb0abcd55a304ef4b276a5cc43673d27ffd9767a0caabe09271979b5afd0f788a51416f7018bc704d734ad78846c68dba15a7
-  languageName: node
-  linkType: hard
-
-"web3-core-promievent@npm:1.2.11":
-  version: 1.2.11
-  resolution: "web3-core-promievent@npm:1.2.11"
-  dependencies:
-    eventemitter3: 4.0.4
-  checksum: bd3661978f252ec0033881b32a5d4dec1bfeb7fb0f018d77c077c77b60c0f965215dcbd54c5fcbef739441dd7efbdbd6c9b20e275e05f5b4d2cee762937d95cc
-  languageName: node
-  linkType: hard
-
-"web3-core-requestmanager@npm:1.2.11":
-  version: 1.2.11
-  resolution: "web3-core-requestmanager@npm:1.2.11"
-  dependencies:
-    underscore: 1.9.1
-    web3-core-helpers: 1.2.11
-    web3-providers-http: 1.2.11
-    web3-providers-ipc: 1.2.11
-    web3-providers-ws: 1.2.11
-  checksum: 84898bfec26319d06ccf7ae63821b7fbea8efc8a76015921530cc4eb85db39598c16598f1e51f95ed79146d7defafe7b924b5c6f6927fb2a153d01eb0862182c
-  languageName: node
-  linkType: hard
-
-"web3-core-subscriptions@npm:1.2.11":
-  version: 1.2.11
-  resolution: "web3-core-subscriptions@npm:1.2.11"
-  dependencies:
-    eventemitter3: 4.0.4
-    underscore: 1.9.1
-    web3-core-helpers: 1.2.11
-  checksum: 7c8c07ea79fc9cf4ecb15ea37c5db38cc38e4b0545247d9ccc7ff6f4257565c03bcee569695a93abe02b8a98a6a9c227df880911ae324c0c6218a9571a3811f6
-  languageName: node
-  linkType: hard
-
-"web3-core@npm:1.2.11":
-  version: 1.2.11
-  resolution: "web3-core@npm:1.2.11"
-  dependencies:
-    "@types/bn.js": ^4.11.5
-    "@types/node": ^12.12.6
-    bignumber.js: ^9.0.0
-    web3-core-helpers: 1.2.11
-    web3-core-method: 1.2.11
-    web3-core-requestmanager: 1.2.11
-    web3-utils: 1.2.11
-  checksum: 1793affddb4fa811f9781dc644b4017d95c6084a21bb866e0dc626f6d48bfc29eacf02237608b587ca49094e9342da878b64173510d99a6e9171f7a697e8cb36
-  languageName: node
-  linkType: hard
-
-"web3-eth-abi@npm:1.2.11":
-  version: 1.2.11
-  resolution: "web3-eth-abi@npm:1.2.11"
-  dependencies:
-    "@ethersproject/abi": 5.0.0-beta.153
-    underscore: 1.9.1
-    web3-utils: 1.2.11
-  checksum: ef96c9c0faad2634d69f1c6dbf3414d0f292c0e534e477f47a1b14512c7099237a09d6b6ba91b624cea348e51e759106b128b0fe463d62f17f447e0a47071d76
-  languageName: node
-  linkType: hard
-
-"web3-eth-accounts@npm:1.2.11":
-  version: 1.2.11
-  resolution: "web3-eth-accounts@npm:1.2.11"
-  dependencies:
-    crypto-browserify: 3.12.0
-    eth-lib: 0.2.8
-    ethereumjs-common: ^1.3.2
-    ethereumjs-tx: ^2.1.1
-    scrypt-js: ^3.0.1
-    underscore: 1.9.1
-    uuid: 3.3.2
-    web3-core: 1.2.11
-    web3-core-helpers: 1.2.11
-    web3-core-method: 1.2.11
-    web3-utils: 1.2.11
-  checksum: 1653a7548337b538b280ced0d25dbf8b105954a5bf61726d5def25128ffc87c49d0d38b678a32e7d259e687f5e72cc452d92e14eaa8c9976a9153347e4afe7eb
-  languageName: node
-  linkType: hard
-
-"web3-eth-contract@npm:1.2.11":
-  version: 1.2.11
-  resolution: "web3-eth-contract@npm:1.2.11"
-  dependencies:
-    "@types/bn.js": ^4.11.5
-    underscore: 1.9.1
-    web3-core: 1.2.11
-    web3-core-helpers: 1.2.11
-    web3-core-method: 1.2.11
-    web3-core-promievent: 1.2.11
-    web3-core-subscriptions: 1.2.11
-    web3-eth-abi: 1.2.11
-    web3-utils: 1.2.11
-  checksum: 1dc74e11f09c895bd5b26c5dfb3a0818d6a38a573de9252a3a943acf6ba88a058313e2977c95564ab56c3696f1ca975237ae4f10c93d34d2978f11bb1119b4d7
-  languageName: node
-  linkType: hard
-
-"web3-eth-ens@npm:1.2.11":
-  version: 1.2.11
-  resolution: "web3-eth-ens@npm:1.2.11"
-  dependencies:
-    content-hash: ^2.5.2
-    eth-ens-namehash: 2.0.8
-    underscore: 1.9.1
-    web3-core: 1.2.11
-    web3-core-helpers: 1.2.11
-    web3-core-promievent: 1.2.11
-    web3-eth-abi: 1.2.11
-    web3-eth-contract: 1.2.11
-    web3-utils: 1.2.11
-  checksum: 987999713c5c79f23a67ad244813212e9582566f6a7665312f887ce0eda77d91b85d3c0df21af14ef6ab6e970626d5d02129a2df3a8c257151f9540d6968a748
-  languageName: node
-  linkType: hard
-
-"web3-eth-iban@npm:1.2.11":
-  version: 1.2.11
-  resolution: "web3-eth-iban@npm:1.2.11"
-  dependencies:
-    bn.js: ^4.11.9
-    web3-utils: 1.2.11
-  checksum: 1c28b3ad2cad2af0a76b051fe2c05ed933476eaa99f2c245862f66d4e3d56e60ad26cf55120513f78648ab1ff2b8a6b751e63448cdb01b53b542334bf148286f
-  languageName: node
-  linkType: hard
-
-"web3-eth-personal@npm:1.2.11":
-  version: 1.2.11
-  resolution: "web3-eth-personal@npm:1.2.11"
-  dependencies:
-    "@types/node": ^12.12.6
-    web3-core: 1.2.11
-    web3-core-helpers: 1.2.11
-    web3-core-method: 1.2.11
-    web3-net: 1.2.11
-    web3-utils: 1.2.11
-  checksum: a754a16aaed1e97baf963f594b69c83bc4c1cf3f5b181b18720ce292583b4a1b70c7a5c22433679c3e66166773bb43731535d085db3bcfc72af48290553f5122
-  languageName: node
-  linkType: hard
-
-"web3-eth@npm:1.2.11":
-  version: 1.2.11
-  resolution: "web3-eth@npm:1.2.11"
-  dependencies:
-    underscore: 1.9.1
-    web3-core: 1.2.11
-    web3-core-helpers: 1.2.11
-    web3-core-method: 1.2.11
-    web3-core-subscriptions: 1.2.11
-    web3-eth-abi: 1.2.11
-    web3-eth-accounts: 1.2.11
-    web3-eth-contract: 1.2.11
-    web3-eth-ens: 1.2.11
-    web3-eth-iban: 1.2.11
-    web3-eth-personal: 1.2.11
-    web3-net: 1.2.11
-    web3-utils: 1.2.11
-  checksum: eaf361bc59859e7e9078e57f438564f10ea5c0cc00404d3ccf537f3c8d11d963b74f8c3981f4160f1ed2e3c4d9d97a5ff85b33744d5083afde8dfd5dde887034
-  languageName: node
-  linkType: hard
-
-"web3-net@npm:1.2.11":
-  version: 1.2.11
-  resolution: "web3-net@npm:1.2.11"
-  dependencies:
-    web3-core: 1.2.11
-    web3-core-method: 1.2.11
-    web3-utils: 1.2.11
-  checksum: 76a99815699674709b869b60bf950d20167b999fe93f7d091b01ce3fd0e3dd9c30ef3519156c04eb01703791c049b19b295e6901dd41d208ea600149961f7ee6
-  languageName: node
-  linkType: hard
-
-"web3-provider-engine@npm:14.2.1":
-  version: 14.2.1
-  resolution: "web3-provider-engine@npm:14.2.1"
-  dependencies:
-    async: ^2.5.0
-    backoff: ^2.5.0
-    clone: ^2.0.0
-    cross-fetch: ^2.1.0
-    eth-block-tracker: ^3.0.0
-    eth-json-rpc-infura: ^3.1.0
-    eth-sig-util: ^1.4.2
-    ethereumjs-block: ^1.2.2
-    ethereumjs-tx: ^1.2.0
-    ethereumjs-util: ^5.1.5
-    ethereumjs-vm: ^2.3.4
-    json-rpc-error: ^2.0.0
-    json-stable-stringify: ^1.0.1
-    promise-to-callback: ^1.0.0
-    readable-stream: ^2.2.9
-    request: ^2.85.0
-    semaphore: ^1.0.3
-    ws: ^5.1.1
-    xhr: ^2.2.0
-    xtend: ^4.0.1
-  checksum: 45441e22633184bd5f6ea645e20f99c8002b3b64d3e564cd9d0f65bad7f0755ad2cdf9a88fcac9585e908aacea28cc6e80c0939498ee4f4c6c49107d16e011bf
-  languageName: node
-  linkType: hard
-
-"web3-providers-http@npm:1.2.11":
-  version: 1.2.11
-  resolution: "web3-providers-http@npm:1.2.11"
-  dependencies:
-    web3-core-helpers: 1.2.11
-    xhr2-cookies: 1.1.0
-  checksum: 64760032d68826865de084c31d81be70bebc54cd82138ef724da13b60f7b341d4c0c6716912616b928680756ea6f2cef42be7d16fa9dd143a09ac55701232193
-  languageName: node
-  linkType: hard
-
-"web3-providers-ipc@npm:1.2.11":
-  version: 1.2.11
-  resolution: "web3-providers-ipc@npm:1.2.11"
-  dependencies:
-    oboe: 2.1.4
-    underscore: 1.9.1
-    web3-core-helpers: 1.2.11
-  checksum: 0fab2f824e4c7f080fee26b76c9c8448eb51abfd285a04f3c9efe92c3b9a8742096804ec02f56bc8297e375ea12f0f2205bb6c0ae376c44c005cdfeec65d0b7e
-  languageName: node
-  linkType: hard
-
-"web3-providers-ws@npm:1.2.11":
-  version: 1.2.11
-  resolution: "web3-providers-ws@npm:1.2.11"
-  dependencies:
-    eventemitter3: 4.0.4
-    underscore: 1.9.1
-    web3-core-helpers: 1.2.11
-    websocket: ^1.0.31
-  checksum: 4a4c591c2bd9724748e9dba124e59048b91239aa7cd435394f2a1d8e7914132920a17e56bc646f46912844fcfbbc38333b7023ebec298af36106ec4814d2ff5c
-  languageName: node
-  linkType: hard
-
-"web3-shh@npm:1.2.11":
-  version: 1.2.11
-  resolution: "web3-shh@npm:1.2.11"
-  dependencies:
-    web3-core: 1.2.11
-    web3-core-method: 1.2.11
-    web3-core-subscriptions: 1.2.11
-    web3-net: 1.2.11
-  checksum: 64c4a1f03bc3975a2baff9fa6d89a0050a06f179f1ec4d6e28f480b761d0efe56a9a79a5a320821e1dd503e82d44e73dd69b883b9e69d96cced3f979e0a3f4ff
-  languageName: node
-  linkType: hard
-
-"web3-utils@npm:1.2.11":
-  version: 1.2.11
-  resolution: "web3-utils@npm:1.2.11"
-  dependencies:
-    bn.js: ^4.11.9
-    eth-lib: 0.2.8
-    ethereum-bloom-filters: ^1.0.6
-    ethjs-unit: 0.1.6
-    number-to-bn: 1.7.0
-    randombytes: ^2.1.0
-    underscore: 1.9.1
-    utf8: 3.0.0
-  checksum: 1e43235963d5176e447b20b201a66fabccbe7bd4ef8bbb2edfa5ea80a41e8202a8e8f3db128b2a1662855a627a52d100e3207b81a739b937b5b3b4f9114c008f
-  languageName: node
-  linkType: hard
-
-"web3-utils@npm:^1.0.0-beta.31, web3-utils@npm:^1.3.6":
+"web3-utils@npm:^1.3.6":
   version: 1.10.4
   resolution: "web3-utils@npm:1.10.4"
   dependencies:
@@ -16038,21 +11168,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"web3@npm:1.2.11":
-  version: 1.2.11
-  resolution: "web3@npm:1.2.11"
-  dependencies:
-    web3-bzz: 1.2.11
-    web3-core: 1.2.11
-    web3-eth: 1.2.11
-    web3-eth-personal: 1.2.11
-    web3-net: 1.2.11
-    web3-shh: 1.2.11
-    web3-utils: 1.2.11
-  checksum: c4fa6ddaddc2de31c561590eb3703e9446c0a9bd87155f536fd72c3c22337056bbd045baf36fec6152e58ae67e552fffad29e794030cd87634becb99a079e91f
-  languageName: node
-  linkType: hard
-
 "webidl-conversions@npm:^3.0.0":
   version: 3.0.1
   resolution: "webidl-conversions@npm:3.0.1"
@@ -16060,41 +11175,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"websocket@npm:1.0.32":
-  version: 1.0.32
-  resolution: "websocket@npm:1.0.32"
-  dependencies:
-    bufferutil: ^4.0.1
-    debug: ^2.2.0
-    es5-ext: ^0.10.50
-    typedarray-to-buffer: ^3.1.5
-    utf-8-validate: ^5.0.2
-    yaeti: ^0.0.6
-  checksum: a29777a1942bf802f955782c7cf948797d19731a911b81adb957873e74b1d5356c621f217a972b075ecf04417a76897ea98dbfc19394007c4cf5e97cd4d494ac
-  languageName: node
-  linkType: hard
-
-"websocket@npm:^1.0.31":
-  version: 1.0.34
-  resolution: "websocket@npm:1.0.34"
-  dependencies:
-    bufferutil: ^4.0.1
-    debug: ^2.2.0
-    es5-ext: ^0.10.50
-    typedarray-to-buffer: ^3.1.5
-    utf-8-validate: ^5.0.2
-    yaeti: ^0.0.6
-  checksum: 8a0ce6d79cc1334bb6ea0d607f0092f3d32700b4dd19e4d5540f2a85f3b50e1f8110da0e4716737056584dde70bbebcb40bbd94bbb437d7468c71abfbfa077d8
-  languageName: node
-  linkType: hard
-
-"whatwg-fetch@npm:^2.0.4":
-  version: 2.0.4
-  resolution: "whatwg-fetch@npm:2.0.4"
-  checksum: de7c65a68d7d62e2f144a6b30293370b3ad82b65ebcd68f2ac8e8bbe7ede90febd98ba9486b78c1cbc950e0e8838fa5c2727f939899ab3fc7b71a04be52d33a5
-  languageName: node
-  linkType: hard
-
 "whatwg-url@npm:^5.0.0":
   version: 5.0.0
   resolution: "whatwg-url@npm:5.0.0"
@@ -16118,13 +11198,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"which-module@npm:^1.0.0":
-  version: 1.0.0
-  resolution: "which-module@npm:1.0.0"
-  checksum: 98434f7deb36350cb543c1f15612188541737e1f12d39b23b1c371dff5cf4aa4746210f2bdec202d5fe9da8682adaf8e3f7c44c520687d30948cfc59d5534edb
-  languageName: node
-  linkType: hard
-
 "which-module@npm:^2.0.0":
   version: 2.0.1
   resolution: "which-module@npm:2.0.1"
@@ -16187,15 +11260,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"window-size@npm:^0.2.0":
-  version: 0.2.0
-  resolution: "window-size@npm:0.2.0"
-  bin:
-    window-size: cli.js
-  checksum: a85e2acf156cfa194301294809867bdadd8a48ee5d972d9fa8e3e1b3420a1d0201b13ac8eb0348a0d14bbf2c3316565b6a749749c2384c5d286caf8a064c4f90
-  languageName: node
-  linkType: hard
-
 "word-wrap@npm:~1.2.3":
   version: 1.2.5
   resolution: "word-wrap@npm:1.2.5"
@@ -16238,16 +11302,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"wrap-ansi@npm:^2.0.0":
-  version: 2.1.0
-  resolution: "wrap-ansi@npm:2.1.0"
-  dependencies:
-    string-width: ^1.0.1
-    strip-ansi: ^3.0.1
-  checksum: 2dacd4b3636f7a53ee13d4d0fe7fa2ed9ad81e9967e17231924ea88a286ec4619a78288de8d41881ee483f4449ab2c0287cde8154ba1bd0126c10271101b2ee3
-  languageName: node
-  linkType: hard
-
 "wrap-ansi@npm:^5.1.0":
   version: 5.1.0
   resolution: "wrap-ansi@npm:5.1.0"
@@ -16301,23 +11355,18 @@ __metadata:
   languageName: node
   linkType: hard
 
-"ws@npm:^3.0.0":
-  version: 3.3.3
-  resolution: "ws@npm:3.3.3"
-  dependencies:
-    async-limiter: ~1.0.0
-    safe-buffer: ~5.1.0
-    ultron: ~1.1.0
-  checksum: 20b7bf34bb88715b9e2d435b76088d770e063641e7ee697b07543815fabdb752335261c507a973955e823229d0af8549f39cc669825e5c8404aa0422615c81d9
-  languageName: node
-  linkType: hard
-
-"ws@npm:^5.1.1":
-  version: 5.2.3
-  resolution: "ws@npm:5.2.3"
-  dependencies:
-    async-limiter: ~1.0.0
-  checksum: bdb2223a40c2c68cf91b25a6c9b8c67d5275378ec6187f343314d3df7530e55b77cb9fe79fb1c6a9758389ac5aefc569d24236924b5c65c5dbbaff409ef739fc
+"ws@npm:8.5.0":
+  version: 8.5.0
+  resolution: "ws@npm:8.5.0"
+  peerDependencies:
+    bufferutil: ^4.0.1
+    utf-8-validate: ^5.0.2
+  peerDependenciesMeta:
+    bufferutil:
+      optional: true
+    utf-8-validate:
+      optional: true
+  checksum: 76f2f90e40344bf18fd544194e7067812fb1372b2a37865678d8f12afe4b478ff2ebc0c7c0aff82cd5e6b66fc43d889eec0f1865c2365d8f7a66d92da7744a77
   languageName: node
   linkType: hard
 
@@ -16336,74 +11385,13 @@ __metadata:
   languageName: node
   linkType: hard
 
-"xhr-request-promise@npm:^0.1.2":
-  version: 0.1.3
-  resolution: "xhr-request-promise@npm:0.1.3"
-  dependencies:
-    xhr-request: ^1.1.0
-  checksum: 2e127c0de063db0aa704b8d5b805fd34f0f07cac21284a88c81f96727eb71af7d2dfa3ad43e96ed3e851e05a1bd88933048ec183378b48594dfbead1c9043aee
-  languageName: node
-  linkType: hard
-
-"xhr-request@npm:^1.0.1, xhr-request@npm:^1.1.0":
-  version: 1.1.0
-  resolution: "xhr-request@npm:1.1.0"
-  dependencies:
-    buffer-to-arraybuffer: ^0.0.5
-    object-assign: ^4.1.1
-    query-string: ^5.0.1
-    simple-get: ^2.7.0
-    timed-out: ^4.0.1
-    url-set-query: ^1.0.0
-    xhr: ^2.0.4
-  checksum: fd8186f33e8696dabcd1ad2983f8125366f4cd799c6bf30aa8d942ac481a7e685a5ee8c38eeee6fca715a7084b432a3a326991375557dc4505c928d3f7b0f0a8
-  languageName: node
-  linkType: hard
-
-"xhr2-cookies@npm:1.1.0":
-  version: 1.1.0
-  resolution: "xhr2-cookies@npm:1.1.0"
-  dependencies:
-    cookiejar: ^2.1.1
-  checksum: 6a9fc45f3490cc53e6a308bd7164dab07ecb94f6345e78951ed4a1e8f8c4c7707a1b039a6b4ef7c9d611d9465d6f94d7d4260c43bc34eed8d6f9210a775eb719
-  languageName: node
-  linkType: hard
-
-"xhr@npm:^2.0.4, xhr@npm:^2.2.0, xhr@npm:^2.3.3":
-  version: 2.6.0
-  resolution: "xhr@npm:2.6.0"
-  dependencies:
-    global: ~4.4.0
-    is-function: ^1.0.1
-    parse-headers: ^2.0.0
-    xtend: ^4.0.0
-  checksum: a1db277e37737caf3ed363d2a33ce4b4ea5b5fc190b663a6f70bc252799185b840ccaa166eaeeea4841c9c60b87741f0a24e29cbcf6708dd425986d4df186d2f
-  languageName: node
-  linkType: hard
-
-"xtend@npm:^4.0.0, xtend@npm:^4.0.1, xtend@npm:~4.0.0, xtend@npm:~4.0.1":
+"xtend@npm:^4.0.0, xtend@npm:^4.0.1, xtend@npm:^4.0.2, xtend@npm:~4.0.0":
   version: 4.0.2
   resolution: "xtend@npm:4.0.2"
   checksum: ac5dfa738b21f6e7f0dd6e65e1b3155036d68104e67e5d5d1bde74892e327d7e5636a076f625599dc394330a731861e87343ff184b0047fef1360a7ec0a5a36a
   languageName: node
   linkType: hard
 
-"xtend@npm:~2.1.1":
-  version: 2.1.2
-  resolution: "xtend@npm:2.1.2"
-  dependencies:
-    object-keys: ~0.4.0
-  checksum: a8b79f31502c163205984eaa2b196051cd2fab0882b49758e30f2f9018255bc6c462e32a090bf3385d1bda04755ad8cc0052a09e049b0038f49eb9b950d9c447
-  languageName: node
-  linkType: hard
-
-"y18n@npm:^3.2.1":
-  version: 3.2.2
-  resolution: "y18n@npm:3.2.2"
-  checksum: 6154fd7544f8bbf5b18cdf77692ed88d389be49c87238ecb4e0d6a5276446cd2a5c29cc4bdbdddfc7e4e498b08df9d7e38df4a1453cf75eecfead392246ea74a
-  languageName: node
-  linkType: hard
-
 "y18n@npm:^4.0.0":
   version: 4.0.3
   resolution: "y18n@npm:4.0.3"
@@ -16418,14 +11406,7 @@ __metadata:
   languageName: node
   linkType: hard
 
-"yaeti@npm:^0.0.6":
-  version: 0.0.6
-  resolution: "yaeti@npm:0.0.6"
-  checksum: 6db12c152f7c363b80071086a3ebf5032e03332604eeda988872be50d6c8469e1f13316175544fa320f72edad696c2d83843ad0ff370659045c1a68bcecfcfea
-  languageName: node
-  linkType: hard
-
-"yallist@npm:^3.0.0, yallist@npm:^3.0.2, yallist@npm:^3.1.1":
+"yallist@npm:^3.0.2":
   version: 3.1.1
   resolution: "yallist@npm:3.1.1"
   checksum: 48f7bb00dc19fc635a13a39fe547f527b10c9290e7b3e836b9a8f1ca04d4d342e85714416b3c2ab74949c9c66f9cebb0473e6bc353b79035356103b47641285d
@@ -16473,16 +11454,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"yargs-parser@npm:^2.4.1":
-  version: 2.4.1
-  resolution: "yargs-parser@npm:2.4.1"
-  dependencies:
-    camelcase: ^3.0.0
-    lodash.assign: ^4.0.6
-  checksum: f57946a93a9e0986fccbc7999a3fc8179d4693e4551ef0ace3d599c38ec004a3783efb9eed9fa5d738b30db1cfa1d3a07f4dd6ae060cfce6fe61c3ae7b7a347b
-  languageName: node
-  linkType: hard
-
 "yargs-parser@npm:^20.2.2":
   version: 20.2.9
   resolution: "yargs-parser@npm:20.2.9"
@@ -16536,28 +11507,6 @@ __metadata:
   languageName: node
   linkType: hard
 
-"yargs@npm:^4.7.1":
-  version: 4.8.1
-  resolution: "yargs@npm:4.8.1"
-  dependencies:
-    cliui: ^3.2.0
-    decamelize: ^1.1.1
-    get-caller-file: ^1.0.1
-    lodash.assign: ^4.0.3
-    os-locale: ^1.4.0
-    read-pkg-up: ^1.0.1
-    require-directory: ^2.1.1
-    require-main-filename: ^1.0.1
-    set-blocking: ^2.0.0
-    string-width: ^1.0.1
-    which-module: ^1.0.0
-    window-size: ^0.2.0
-    y18n: ^3.2.1
-    yargs-parser: ^2.4.1
-  checksum: 5d0a45dceaf8cff1c6a7164b2c944755a09cced3cb1d585bbc79ffed758ef9f9b54ead0879e3dacfc696ccd15fec9e6e29183c24517d7f578b47cd0614a3851d
-  languageName: node
-  linkType: hard
-
 "yn@npm:3.1.1":
   version: 3.1.1
   resolution: "yn@npm:3.1.1"