diff --git a/.env.example b/.env.example
index e3bd56db..a3367bd0 100644
--- a/.env.example
+++ b/.env.example
@@ -1,7 +1,7 @@
 export MNEMONIC="adapt mosquito move limb mobile illegal tree voyage juice mosquito burger raise father hope layer"
 export PRIVATE_KEY_FHEVM_DEPLOYER="0c66d8cde71d2faa29d0cb6e3a567d31279b6eace67b0a9d9ba869c119843a5e"
-export PRIVATE_KEY_GATEWAY_DEPLOYER="717fd99986df414889fd8b51069d4f90a50af72e542c58ee065f5883779099c6"
-export PRIVATE_KEY_GATEWAY_RELAYER="7ec931411ad75a7c201469a385d6f18a325d4923f9f213bd882bbea87e160b67"
+export PRIVATE_KEY_DECRYPTION_ORACLE_DEPLOYER="717fd99986df414889fd8b51069d4f90a50af72e542c58ee065f5883779099c6"
+export PRIVATE_KEY_DECRYPTION_ORACLE_RELAYER="7ec931411ad75a7c201469a385d6f18a325d4923f9f213bd882bbea87e160b67"
 export NUM_KMS_SIGNERS="1"
 export PRIVATE_KEY_KMS_SIGNER_0="388b7680e4e1afa06efbfd45cdd1fe39f3c6af381df6555a19661f283b97de91"
 export PRIVATE_KEY_KMS_SIGNER_1="bbaed91514fa4b7c86aa4f73becbabcf4bce0ae130240f0d6ac3f87e06812440"
diff --git a/.npmignore b/.npmignore
index 56e2a23e..5c801fc4 100644
--- a/.npmignore
+++ b/.npmignore
@@ -1,6 +1,6 @@
 *
 !lib/**
-!gateway/**
+!decryption/**
 !config/**
 !package.json
 !README.md
diff --git a/decryption/DecryptionOracleCaller.sol b/decryption/DecryptionOracleCaller.sol
new file mode 100644
index 00000000..1b772498
--- /dev/null
+++ b/decryption/DecryptionOracleCaller.sol
@@ -0,0 +1,259 @@
+// SPDX-License-Identifier: BSD-3-Clause-Clear
+
+pragma solidity ^0.8.24;
+
+import "../lib/TFHE.sol";
+import "../lib/Impl.sol";
+
+interface IKMSVerifier {
+    function verifyDecryptionEIP712KMSSignatures(
+        address aclAddress,
+        uint256[] memory handlesList,
+        bytes memory decryptedResult,
+        bytes[] memory signatures
+    ) external returns (bool);
+}
+
+interface IDecryptionOracle {
+    function requestDecryption(uint256[] calldata ctsHandles, bytes4 callbackSelector) external returns (uint256);
+}
+
+struct DecryptionOracleConfigStruct {
+    address DecryptionOracleAddress;
+}
+
+abstract contract DecryptionOracleCaller {
+    error HandlesAlreadySavedForRequestID();
+    error NoHandleFoundForRequestID();
+    error InvalidKMSSignatures();
+    error UnsupportedHandleType();
+
+    mapping(uint256 => ebool[]) private paramsEBool;
+    mapping(uint256 => euint4[]) private paramsEUint4;
+    mapping(uint256 => euint8[]) private paramsEUint8;
+    mapping(uint256 => euint16[]) private paramsEUint16;
+    mapping(uint256 => euint32[]) private paramsEUint32;
+    mapping(uint256 => euint64[]) private paramsEUint64;
+    mapping(uint256 => eaddress[]) private paramsEAddress;
+    mapping(uint256 => address[]) private paramsAddress;
+    mapping(uint256 => uint256[]) private paramsUint256;
+    mapping(uint256 => uint256[]) private requestedHandles;
+
+    constructor() {}
+
+    function addParamsEBool(uint256 requestID, ebool _ebool) internal {
+        paramsEBool[requestID].push(_ebool);
+    }
+
+    function addParamsEUint4(uint256 requestID, euint4 _euint4) internal {
+        paramsEUint4[requestID].push(_euint4);
+    }
+
+    function addParamsEUint8(uint256 requestID, euint8 _euint8) internal {
+        paramsEUint8[requestID].push(_euint8);
+    }
+
+    function addParamsEUint16(uint256 requestID, euint16 _euint16) internal {
+        paramsEUint16[requestID].push(_euint16);
+    }
+
+    function addParamsEUint32(uint256 requestID, euint32 _euint32) internal {
+        paramsEUint32[requestID].push(_euint32);
+    }
+
+    function addParamsEUint64(uint256 requestID, euint64 _euint64) internal {
+        paramsEUint64[requestID].push(_euint64);
+    }
+
+    function addParamsEAddress(uint256 requestID, eaddress _eaddress) internal {
+        paramsEAddress[requestID].push(_eaddress);
+    }
+
+    function addParamsAddress(uint256 requestID, address _address) internal {
+        paramsAddress[requestID].push(_address);
+    }
+
+    function addParamsUint256(uint256 requestID, uint256 _uint) internal {
+        paramsUint256[requestID].push(_uint);
+    }
+
+    function saveRequestedHandles(uint256 requestID, uint256[] memory handlesList) internal {
+        if (requestedHandles[requestID].length != 0) {
+            revert HandlesAlreadySavedForRequestID();
+        }
+        requestedHandles[requestID] = handlesList;
+    }
+
+    function loadRequestedHandles(uint256 requestID) internal view returns (uint256[] memory) {
+        if (requestedHandles[requestID].length == 0) {
+            revert NoHandleFoundForRequestID();
+        }
+        return requestedHandles[requestID];
+    }
+
+    function getParamsEBool(uint256 requestID) internal view returns (ebool[] memory) {
+        return paramsEBool[requestID];
+    }
+
+    function getParamsEUint4(uint256 requestID) internal view returns (euint4[] memory) {
+        return paramsEUint4[requestID];
+    }
+
+    function getParamsEUint8(uint256 requestID) internal view returns (euint8[] memory) {
+        return paramsEUint8[requestID];
+    }
+
+    function getParamsEUint16(uint256 requestID) internal view returns (euint16[] memory) {
+        return paramsEUint16[requestID];
+    }
+
+    function getParamsEUint32(uint256 requestID) internal view returns (euint32[] memory) {
+        return paramsEUint32[requestID];
+    }
+
+    function getParamsEUint64(uint256 requestID) internal view returns (euint64[] memory) {
+        return paramsEUint64[requestID];
+    }
+
+    function getParamsEAddress(uint256 requestID) internal view returns (eaddress[] memory) {
+        return paramsEAddress[requestID];
+    }
+
+    function getParamsAddress(uint256 requestID) internal view returns (address[] memory) {
+        return paramsAddress[requestID];
+    }
+
+    function getParamsUint256(uint256 requestID) internal view returns (uint256[] memory) {
+        return paramsUint256[requestID];
+    }
+
+    // keccak256(abi.encode(uint256(keccak256("fhevm.storage.DecryptionOracleConfig")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 private constant DecryptionOracleLocation =
+        0xde725b831312c6c6cbab76ff954da6836e26d78fc467781757c36be9c3d67d00;
+
+    function getDecryptionOracleConfig() internal pure returns (DecryptionOracleConfigStruct storage $) {
+        assembly {
+            $.slot := DecryptionOracleLocation
+        }
+    }
+
+    function setDecryptionOracle(address decryptionOracleAddress) internal {
+        DecryptionOracleConfigStruct storage $ = getDecryptionOracleConfig();
+        $.DecryptionOracleAddress = decryptionOracleAddress;
+    }
+
+    function gatewayContractAddress() internal view returns (address) {
+        DecryptionOracleConfigStruct storage $ = getDecryptionOracleConfig();
+        return $.DecryptionOracleAddress;
+    }
+
+    function toUint256(ebool newCT) internal pure returns (uint256 ct) {
+        ct = ebool.unwrap(newCT);
+    }
+
+    function toUint256(euint4 newCT) internal pure returns (uint256 ct) {
+        ct = euint4.unwrap(newCT);
+    }
+
+    function toUint256(euint8 newCT) internal pure returns (uint256 ct) {
+        ct = euint8.unwrap(newCT);
+    }
+
+    function toUint256(euint16 newCT) internal pure returns (uint256 ct) {
+        ct = euint16.unwrap(newCT);
+    }
+
+    function toUint256(euint32 newCT) internal pure returns (uint256 ct) {
+        ct = euint32.unwrap(newCT);
+    }
+
+    function toUint256(euint64 newCT) internal pure returns (uint256 ct) {
+        ct = euint64.unwrap(newCT);
+    }
+
+    function toUint256(euint128 newCT) internal pure returns (uint256 ct) {
+        ct = euint128.unwrap(newCT);
+    }
+
+    function toUint256(eaddress newCT) internal pure returns (uint256 ct) {
+        ct = eaddress.unwrap(newCT);
+    }
+
+    function toUint256(euint256 newCT) internal pure returns (uint256 ct) {
+        ct = euint256.unwrap(newCT);
+    }
+
+    function toUint256(ebytes64 newCT) internal pure returns (uint256 ct) {
+        ct = ebytes64.unwrap(newCT);
+    }
+
+    function toUint256(ebytes128 newCT) internal pure returns (uint256 ct) {
+        ct = ebytes128.unwrap(newCT);
+    }
+
+    function toUint256(ebytes256 newCT) internal pure returns (uint256 ct) {
+        ct = ebytes256.unwrap(newCT);
+    }
+
+    function requestDecryption(
+        uint256[] memory ctsHandles,
+        bytes4 callbackSelector
+    ) internal returns (uint256 requestID) {
+        FHEVMConfigStruct storage $ = Impl.getFHEVMConfig();
+        IACL($.ACLAddress).allowForDecryption(ctsHandles);
+        DecryptionOracleConfigStruct storage $$ = getDecryptionOracleConfig();
+        requestID = IDecryptionOracle($$.DecryptionOracleAddress).requestDecryption(ctsHandles, callbackSelector);
+        saveRequestedHandles(requestID, ctsHandles);
+    }
+
+    /// @dev this function should be called inside the callback function the dApp contract to verify the signatures
+    function verifySignatures(uint256[] memory handlesList, bytes[] memory signatures) internal returns (bool) {
+        uint256 start = 4 + 32; // start position after skipping the selector (4 bytes) and the first argument (index, 32 bytes)
+        uint256 length = getSignedDataLength(handlesList);
+        bytes memory decryptedResult = new bytes(length);
+        assembly {
+            calldatacopy(add(decryptedResult, 0x20), start, length) // Copy the relevant part of calldata to decryptedResult memory
+        }
+        FHEVMConfigStruct storage $ = Impl.getFHEVMConfig();
+        return
+            IKMSVerifier($.KMSVerifierAddress).verifyDecryptionEIP712KMSSignatures(
+                $.ACLAddress,
+                handlesList,
+                decryptedResult,
+                signatures
+            );
+    }
+
+    function getSignedDataLength(uint256[] memory handlesList) private pure returns (uint256) {
+        uint256 handlesListlen = handlesList.length;
+        uint256 signedDataLength;
+        for (uint256 i = 0; i < handlesListlen; i++) {
+            uint8 typeCt = uint8(handlesList[i] >> 8);
+            if (typeCt < 9) {
+                signedDataLength += 32;
+            } else if (typeCt == 9) {
+                //ebytes64
+                signedDataLength += 128;
+            } else if (typeCt == 10) {
+                //ebytes128
+                signedDataLength += 192;
+            } else if (typeCt == 11) {
+                //ebytes256
+                signedDataLength += 320;
+            } else {
+                revert UnsupportedHandleType();
+            }
+        }
+        signedDataLength += 32; // add offset of signatures
+        return signedDataLength;
+    }
+
+    modifier checkSignatures(uint256 requestID, bytes[] memory signatures) {
+        uint256[] memory handlesList = loadRequestedHandles(requestID);
+        bool isVerified = verifySignatures(handlesList, signatures);
+        if (!isVerified) {
+            revert InvalidKMSSignatures();
+        }
+        _;
+    }
+}
diff --git a/examples/BlindAuction.sol b/examples/BlindAuction.sol
deleted file mode 100644
index 2c554869..00000000
--- a/examples/BlindAuction.sol
+++ /dev/null
@@ -1,241 +0,0 @@
-// SPDX-License-Identifier: BSD-3-Clause-Clear
-
-pragma solidity ^0.8.24;
-
-import "../lib/TFHE.sol";
-import "./FHEVMConfig.sol";
-import "./GatewayConfig.sol";
-import "./EncryptedERC20.sol";
-import "@openzeppelin/contracts/access/Ownable2Step.sol";
-import "../gateway/GatewayCaller.sol";
-
-/// @notice Main contract for the blind auction
-contract BlindAuction is Ownable2Step, GatewayCaller {
-    /// @notice Auction end time
-    uint256 public endTime;
-
-    /// @notice Address of the beneficiary
-    address public beneficiary;
-
-    /// @notice Current highest bid
-    euint64 private highestBid;
-
-    /// @notice Ticket corresponding to the highest bid
-    /// @dev Used during reencryption to know if a user has won the bid
-    euint64 private winningTicket;
-
-    /// @notice Decryption of winningTicket
-    /// @dev Can be requested by anyone after auction ends
-    uint64 private decryptedWinningTicket;
-
-    /// @notice Ticket randomly sampled for each user
-    /// @dev WARNING: We assume probability of duplicated tickets is null
-    /// @dev An improved implementation could sample 4 random euint64 tickets per user for negligible collision probability
-    mapping(address account => euint64 ticket) private userTickets;
-
-    /// @notice Mapping from bidder to their bid value
-    mapping(address account => euint64 bidAmount) private bids;
-
-    /// @notice Number of bids
-    uint256 public bidCounter;
-
-    /// @notice The token contract used for encrypted bids
-    EncryptedERC20 public tokenContract;
-
-    /// @notice Flag indicating whether the auction object has been claimed
-    /// @dev WARNING : If there is a draw, only the first highest bidder will get the prize
-    ///      An improved implementation could handle this case differently
-    ebool private objectClaimed;
-
-    /// @notice Flag to check if the token has been transferred to the beneficiary
-    bool public tokenTransferred;
-
-    /// @notice Flag to determine if the auction can be stopped manually
-    bool public stoppable;
-
-    /// @notice Flag to check if the auction has been manually stopped
-    bool public manuallyStopped = false;
-
-    /// @notice Error thrown when a function is called too early
-    /// @dev Includes the time when the function can be called
-    error TooEarly(uint256 time);
-
-    /// @notice Error thrown when a function is called too late
-    /// @dev Includes the time after which the function cannot be called
-    error TooLate(uint256 time);
-
-    /// @notice Constructor to initialize the auction
-    /// @param _beneficiary Address of the beneficiary who will receive the highest bid
-    /// @param _tokenContract Address of the EncryptedERC20 token contract used for bidding
-    /// @param biddingTime Duration of the auction in seconds
-    /// @param isStoppable Flag to determine if the auction can be stopped manually
-    constructor(
-        address _beneficiary,
-        EncryptedERC20 _tokenContract,
-        uint256 biddingTime,
-        bool isStoppable
-    ) Ownable(msg.sender) {
-        TFHE.setFHEVM(FHEVMConfig.defaultConfig());
-        Gateway.setGateway(GatewayConfig.defaultGatewayContract());
-        beneficiary = _beneficiary;
-        tokenContract = _tokenContract;
-        endTime = block.timestamp + biddingTime;
-        objectClaimed = TFHE.asEbool(false);
-        TFHE.allowThis(objectClaimed);
-        tokenTransferred = false;
-        bidCounter = 0;
-        stoppable = isStoppable;
-    }
-
-    /// @notice Submit a bid with an encrypted value
-    /// @dev Transfers tokens from the bidder to the contract
-    /// @param encryptedValue The encrypted bid amount
-    /// @param inputProof Proof for the encrypted input
-    function bid(einput encryptedValue, bytes calldata inputProof) external onlyBeforeEnd {
-        euint64 value = TFHE.asEuint64(encryptedValue, inputProof);
-        euint64 existingBid = bids[msg.sender];
-        euint64 sentBalance;
-        if (TFHE.isInitialized(existingBid)) {
-            euint64 balanceBefore = tokenContract.balanceOf(address(this));
-            ebool isHigher = TFHE.lt(existingBid, value);
-            euint64 toTransfer = TFHE.sub(value, existingBid);
-
-            // Transfer only if bid is higher, also to avoid overflow from previous line
-            euint64 amount = TFHE.select(isHigher, toTransfer, TFHE.asEuint64(0));
-            TFHE.allowTransient(amount, address(tokenContract));
-            tokenContract.transferFrom(msg.sender, address(this), amount);
-
-            euint64 balanceAfter = tokenContract.balanceOf(address(this));
-            sentBalance = TFHE.sub(balanceAfter, balanceBefore);
-            euint64 newBid = TFHE.add(existingBid, sentBalance);
-            bids[msg.sender] = newBid;
-        } else {
-            bidCounter++;
-            euint64 balanceBefore = tokenContract.balanceOf(address(this));
-            TFHE.allowTransient(value, address(tokenContract));
-            tokenContract.transferFrom(msg.sender, address(this), value);
-            euint64 balanceAfter = tokenContract.balanceOf(address(this));
-            sentBalance = TFHE.sub(balanceAfter, balanceBefore);
-            bids[msg.sender] = sentBalance;
-        }
-        euint64 currentBid = bids[msg.sender];
-        TFHE.allowThis(currentBid);
-        TFHE.allow(currentBid, msg.sender);
-
-        euint64 randTicket = TFHE.randEuint64();
-        euint64 userTicket;
-        if (TFHE.isInitialized(highestBid)) {
-            userTicket = TFHE.select(TFHE.ne(sentBalance, 0), randTicket, userTickets[msg.sender]); // don't update ticket if sentBalance is null (or else winner sending an additional zero bid would lose the prize)
-        } else {
-            userTicket = randTicket;
-        }
-        userTickets[msg.sender] = userTicket;
-
-        if (!TFHE.isInitialized(highestBid)) {
-            highestBid = currentBid;
-            winningTicket = userTicket;
-        } else {
-            ebool isNewWinner = TFHE.lt(highestBid, currentBid);
-            highestBid = TFHE.select(isNewWinner, currentBid, highestBid);
-            winningTicket = TFHE.select(isNewWinner, userTicket, winningTicket);
-        }
-        TFHE.allowThis(highestBid);
-        TFHE.allowThis(winningTicket);
-        TFHE.allow(userTicket, msg.sender);
-    }
-
-    /// @notice Get the encrypted bid of a specific account
-    /// @dev Can be used in a reencryption request
-    /// @param account The address of the bidder
-    /// @return The encrypted bid amount
-    function getBid(address account) external view returns (euint64) {
-        return bids[account];
-    }
-
-    /// @notice Manually stop the auction
-    /// @dev Can only be called by the owner and if the auction is stoppable
-    function stop() external onlyOwner {
-        require(stoppable);
-        manuallyStopped = true;
-    }
-
-    /// @notice Get the encrypted ticket of a specific account
-    /// @dev Can be used in a reencryption request
-    /// @param account The address of the bidder
-    /// @return The encrypted ticket
-    function ticketUser(address account) external view returns (euint64) {
-        return userTickets[account];
-    }
-
-    /// @notice Initiate the decryption of the winning ticket
-    /// @dev Can only be called after the auction ends
-    function decryptWinningTicket() public onlyAfterEnd {
-        uint256[] memory cts = new uint256[](1);
-        cts[0] = Gateway.toUint256(winningTicket);
-        Gateway.requestDecryption(cts, this.setDecryptedWinningTicket.selector, 0, block.timestamp + 100, false);
-    }
-
-    /// @notice Callback function to set the decrypted winning ticket
-    /// @dev Can only be called by the Gateway
-    /// @param resultDecryption The decrypted winning ticket
-    function setDecryptedWinningTicket(uint256, uint64 resultDecryption) public onlyGateway {
-        decryptedWinningTicket = resultDecryption;
-    }
-
-    /// @notice Get the decrypted winning ticket
-    /// @dev Can only be called after the winning ticket has been decrypted - if `userTickets[account]` is an encryption of decryptedWinningTicket, then `account` won and can call `claim` succesfully
-    /// @return The decrypted winning ticket
-    function getDecryptedWinningTicket() external view returns (uint64) {
-        require(decryptedWinningTicket != 0, "Winning ticket has not been decrypted yet");
-        return decryptedWinningTicket;
-    }
-
-    /// @notice Claim the auction object
-    /// @dev Succeeds only if the caller was the first to get the highest bid
-    function claim() public onlyAfterEnd {
-        ebool canClaim = TFHE.and(TFHE.eq(winningTicket, userTickets[msg.sender]), TFHE.not(objectClaimed));
-        objectClaimed = TFHE.or(canClaim, objectClaimed);
-        TFHE.allowThis(objectClaimed);
-        euint64 newBid = TFHE.select(canClaim, TFHE.asEuint64(0), bids[msg.sender]);
-        bids[msg.sender] = newBid;
-        TFHE.allowThis(bids[msg.sender]);
-        TFHE.allow(bids[msg.sender], msg.sender);
-    }
-
-    /// @notice Transfer the highest bid to the beneficiary
-    /// @dev Can only be called once after the auction ends
-    function auctionEnd() public onlyAfterEnd {
-        require(!tokenTransferred);
-        tokenTransferred = true;
-        TFHE.allowTransient(highestBid, address(tokenContract));
-        tokenContract.transfer(beneficiary, highestBid);
-    }
-
-    /// @notice Withdraw a bid from the auction
-    /// @dev Can only be called after the auction ends and by non-winning bidders
-    function withdraw() public onlyAfterEnd {
-        euint64 bidValue = bids[msg.sender];
-        ebool canWithdraw = TFHE.ne(winningTicket, userTickets[msg.sender]);
-        euint64 amount = TFHE.select(canWithdraw, bidValue, TFHE.asEuint64(0));
-        TFHE.allowTransient(amount, address(tokenContract));
-        tokenContract.transfer(msg.sender, amount);
-        euint64 newBid = TFHE.select(canWithdraw, TFHE.asEuint64(0), bids[msg.sender]);
-        bids[msg.sender] = newBid;
-        TFHE.allowThis(newBid);
-        TFHE.allow(newBid, msg.sender);
-    }
-
-    /// @notice Modifier to ensure function is called before auction ends
-    /// @dev Reverts if called after the auction end time or if manually stopped
-    modifier onlyBeforeEnd() {
-        if (block.timestamp >= endTime || manuallyStopped == true) revert TooLate(endTime);
-        _;
-    }
-
-    /// @notice Modifier to ensure function is called after auction ends
-    /// @dev Reverts if called before the auction end time and not manually stopped
-    modifier onlyAfterEnd() {
-        if (block.timestamp < endTime && manuallyStopped == false) revert TooEarly(endTime);
-        _;
-    }
-}
diff --git a/examples/DecryptionOracleConfig.sol b/examples/DecryptionOracleConfig.sol
new file mode 100644
index 00000000..ec002ab4
--- /dev/null
+++ b/examples/DecryptionOracleConfig.sol
@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: BSD-3-Clause-Clear
+pragma solidity ^0.8.24;
+
+import "fhevm-core-contracts/addresses/DecryptionOracleAddress.sol";
+
+/**
+ * @title   DecryptionOracleConfig
+ * @notice  This library returns the DecryptionOracle address
+ */
+library DecryptionOracleConfig {
+    /**
+     * @notice This function returns a the gateway contract address.
+     */
+    function defaultDecryptionOracle() internal pure returns (address) {
+        return DECRYPTION_ORACLE_ADDRESS;
+    }
+}
diff --git a/examples/GatewayConfig.sol b/examples/GatewayConfig.sol
deleted file mode 100644
index 04b3b7bf..00000000
--- a/examples/GatewayConfig.sol
+++ /dev/null
@@ -1,17 +0,0 @@
-// SPDX-License-Identifier: BSD-3-Clause-Clear
-pragma solidity ^0.8.24;
-
-import "fhevm-core-contracts/addresses/GatewayContractAddress.sol";
-
-/**
- * @title   FHEVMConfig
- * @notice  This library returns the GatewayContract address
- */
-library GatewayConfig {
-    /**
-     * @notice This function returns a the gateway contract address.
-     */
-    function defaultGatewayContract() internal pure returns (address) {
-        return GATEWAY_CONTRACT_PREDEPLOY_ADDRESS;
-    }
-}
diff --git a/examples/README.md b/examples/README.md
index fa611c4d..dad372d1 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -48,37 +48,3 @@ graph TD
 ### 2. **TestAsyncDecrypt.sol**
 
 Tests asynchronous decryption of various encrypted data types using the Gateway. This contract is essential for understanding how to safely decrypt data when needed, without compromising the overall security of the encrypted system.
-
-### 3. **BlindAuction.sol**
-
-Implements a blind auction system using encrypted bids. Key features include:
-
-- Encrypted bid submission
-- Timed auction periods
-- Winner determination without revealing losing bids
-- Claim and withdrawal mechanisms
-
-This contract showcases how FHE can be used to create fair and private auction systems on the blockchain, ensuring bid confidentiality until the auction ends.
-
-```mermaid
-graph TD
-    subgraph Bidding Phase
-        A[User Submits Encrypted Bid]
-        B[Contract Stores Encrypted Bid]
-        C[Update Highest Bid & Winning Ticket]
-    end
-    subgraph Auction End
-        D[Decrypt Winning Ticket]
-        E[Winner Claims Prize]
-        F[Non-Winners Withdraw Bids]
-        G[Transfer Highest Bid to Beneficiary]
-    end
-    A --> B
-    B --> C
-    C --> |Auction Ends| D
-    D --> E
-    D --> F
-    D --> G
-```
-
-This diagram illustrates the main processes in the BlindAuction contract, from bid submission to the final distribution of funds and prizes.
diff --git a/examples/TestAsyncDecrypt.sol b/examples/TestAsyncDecrypt.sol
index 7c55854c..2654e5f0 100644
--- a/examples/TestAsyncDecrypt.sol
+++ b/examples/TestAsyncDecrypt.sol
@@ -4,11 +4,11 @@ pragma solidity ^0.8.24;
 
 import "../lib/TFHE.sol";
 import "./FHEVMConfig.sol";
-import "./GatewayConfig.sol";
-import "../gateway/GatewayCaller.sol";
+import "../decryption/DecryptionOracleCaller.sol";
+import "./DecryptionOracleConfig.sol";
 
 /// @notice Contract for testing asynchronous decryption using the Gateway
-contract TestAsyncDecrypt is GatewayCaller {
+contract TestAsyncDecrypt is DecryptionOracleCaller {
     /// @dev Encrypted state variables
     ebool xBool;
     euint4 xUint4;
@@ -46,7 +46,7 @@ contract TestAsyncDecrypt is GatewayCaller {
     /// @notice Constructor to initialize the contract and set up encrypted values
     constructor() {
         TFHE.setFHEVM(FHEVMConfig.defaultConfig());
-        Gateway.setGateway(GatewayConfig.defaultGatewayContract());
+        setDecryptionOracle(DECRYPTION_ORACLE_ADDRESS);
 
         /// @dev Initialize encrypted variables with sample values
         xBool = TFHE.asEbool(true);
@@ -78,12 +78,16 @@ contract TestAsyncDecrypt is GatewayCaller {
     /// @notice Function to request decryption of a boolean value with an infinite loop in the callback
     function requestBoolInfinite() public {
         uint256[] memory cts = new uint256[](1);
-        cts[0] = Gateway.toUint256(xBool);
-        Gateway.requestDecryption(cts, this.callbackBoolInfinite.selector, 0, block.timestamp + 100, false);
+        cts[0] = toUint256(xBool);
+        requestDecryption(cts, this.callbackBoolInfinite.selector);
     }
 
     /// @notice Callback function for the infinite loop decryption request (WARNING: This function will never complete)
-    function callbackBoolInfinite(uint256 /*requestID*/, bool decryptedInput) public onlyGateway returns (bool) {
+    function callbackBoolInfinite(
+        uint256 requestID,
+        bool decryptedInput,
+        bytes[] memory signatures
+    ) public checkSignatures(requestID, signatures) returns (bool) {
         uint256 i = 0;
         while (true) {
             i++;
@@ -92,37 +96,11 @@ contract TestAsyncDecrypt is GatewayCaller {
         return yBool;
     }
 
-    /// @notice Function to request decryption with an excessive delay (should revert)
-    function requestBoolAboveDelay() public {
-        /// @dev This should revert due to the excessive delay
-        uint256[] memory cts = new uint256[](1);
-        cts[0] = Gateway.toUint256(xBool);
-        Gateway.requestDecryption(cts, this.callbackBool.selector, 0, block.timestamp + 2 days, false);
-    }
-
     /// @notice Request decryption of a boolean value
     function requestBool() public {
         uint256[] memory cts = new uint256[](1);
-        cts[0] = Gateway.toUint256(xBool);
-        /// @dev Request decryption with a 100-second deadline and non-trustless mode
-        Gateway.requestDecryption(cts, this.callbackBool.selector, 0, block.timestamp + 100, false);
-    }
-
-    /// @notice Request decryption of a boolean value in trustless mode
-    function requestBoolTrustless() public {
-        uint256[] memory cts = new uint256[](1);
-        cts[0] = Gateway.toUint256(xBool);
-        /// @dev Request decryption with a 100-second deadline and trustless mode (true)
-        uint256 requestID = Gateway.requestDecryption(
-            cts,
-            this.callbackBoolTrustless.selector,
-            0,
-            block.timestamp + 100,
-            true
-        );
-        latestRequestID = requestID;
-        /// @dev Save the requested handles for later verification
-        saveRequestedHandles(requestID, cts);
+        cts[0] = toUint256(xBool);
+        requestDecryption(cts, this.callbackBool.selector);
     }
 
     /// @notice Attempt to request decryption of a fake boolean value (should revert)
@@ -130,29 +108,15 @@ contract TestAsyncDecrypt is GatewayCaller {
         uint256[] memory cts = new uint256[](1);
         cts[0] = uint256(0x4200000000000000000000000000000000000000000000000000000000000000);
         /// @dev This should revert because the previous ebool is not honestly obtained
-        Gateway.requestDecryption(cts, this.callbackBool.selector, 0, block.timestamp + 100, false);
+        requestDecryption(cts, this.callbackBool.selector);
     }
 
-    /// @notice Callback function for non-trustless boolean decryption
-    function callbackBool(uint256, bool decryptedInput) public onlyGateway returns (bool) {
-        yBool = decryptedInput;
-        return yBool;
-    }
-
-    /// @notice Callback function for trustless boolean decryption
-    function callbackBoolTrustless(
+    /// @notice Callback function for boolean decryption
+    function callbackBool(
         uint256 requestID,
         bool decryptedInput,
         bytes[] memory signatures
-    ) public onlyGateway returns (bool) {
-        /// @dev Verify that the requestID matches the latest request
-        require(latestRequestID == requestID, "wrong requestID passed by Gateway");
-        /// @dev Load the previously saved handles for verification
-        uint256[] memory requestedHandles = loadRequestedHandles(latestRequestID);
-        /// @dev Verify the signatures provided by the KMS (Key Management Service)
-        bool isKMSVerified = Gateway.verifySignatures(requestedHandles, signatures);
-        require(isKMSVerified, "KMS did not verify this decryption result");
-        /// @dev If verification passes, store the decrypted value
+    ) public checkSignatures(requestID, signatures) returns (bool) {
         yBool = decryptedInput;
         return yBool;
     }
@@ -160,8 +124,8 @@ contract TestAsyncDecrypt is GatewayCaller {
     /// @notice Request decryption of a 4-bit unsigned integer
     function requestUint4() public {
         uint256[] memory cts = new uint256[](1);
-        cts[0] = Gateway.toUint256(xUint4);
-        Gateway.requestDecryption(cts, this.callbackUint4.selector, 0, block.timestamp + 100, false);
+        cts[0] = toUint256(xUint4);
+        requestDecryption(cts, this.callbackUint4.selector);
     }
 
     /// @notice Attempt to request decryption of a fake 4-bit unsigned integer (should revert)
@@ -169,13 +133,17 @@ contract TestAsyncDecrypt is GatewayCaller {
         uint256[] memory cts = new uint256[](1);
         cts[0] = uint256(0x4200000000000000000000000000000000000000000000000000000000000100);
         /// @dev This should revert because the previous handle is not honestly obtained
-        Gateway.requestDecryption(cts, this.callbackUint4.selector, 0, block.timestamp + 100, false);
+        requestDecryption(cts, this.callbackUint4.selector);
     }
 
     /// @notice Callback function for 4-bit unsigned integer decryption
     /// @param decryptedInput The decrypted 4-bit unsigned integer
     /// @return The decrypted value
-    function callbackUint4(uint256, uint8 decryptedInput) public onlyGateway returns (uint8) {
+    function callbackUint4(
+        uint256 requestID,
+        uint8 decryptedInput,
+        bytes[] memory signatures
+    ) public checkSignatures(requestID, signatures) returns (uint8) {
         yUint4 = decryptedInput;
         return decryptedInput;
     }
@@ -183,8 +151,8 @@ contract TestAsyncDecrypt is GatewayCaller {
     /// @notice Request decryption of an 8-bit unsigned integer
     function requestUint8() public {
         uint256[] memory cts = new uint256[](1);
-        cts[0] = Gateway.toUint256(xUint8);
-        Gateway.requestDecryption(cts, this.callbackUint8.selector, 0, block.timestamp + 100, false);
+        cts[0] = toUint256(xUint8);
+        requestDecryption(cts, this.callbackUint8.selector);
     }
 
     /// @notice Attempt to request decryption of a fake 8-bit unsigned integer (should revert)
@@ -192,13 +160,17 @@ contract TestAsyncDecrypt is GatewayCaller {
         uint256[] memory cts = new uint256[](1);
         cts[0] = uint256(0x4200000000000000000000000000000000000000000000000000000000000200);
         /// @dev This should revert because the previous handle is not honestly obtained
-        Gateway.requestDecryption(cts, this.callbackUint8.selector, 0, block.timestamp + 100, false);
+        requestDecryption(cts, this.callbackUint8.selector);
     }
 
     /// @notice Callback function for 8-bit unsigned integer decryption
     /// @param decryptedInput The decrypted 8-bit unsigned integer
     /// @return The decrypted value
-    function callbackUint8(uint256, uint8 decryptedInput) public onlyGateway returns (uint8) {
+    function callbackUint8(
+        uint256 requestID,
+        uint8 decryptedInput,
+        bytes[] memory signatures
+    ) public checkSignatures(requestID, signatures) returns (uint8) {
         yUint8 = decryptedInput;
         return decryptedInput;
     }
@@ -206,8 +178,8 @@ contract TestAsyncDecrypt is GatewayCaller {
     /// @notice Request decryption of a 16-bit unsigned integer
     function requestUint16() public {
         uint256[] memory cts = new uint256[](1);
-        cts[0] = Gateway.toUint256(xUint16);
-        Gateway.requestDecryption(cts, this.callbackUint16.selector, 0, block.timestamp + 100, false);
+        cts[0] = toUint256(xUint16);
+        requestDecryption(cts, this.callbackUint16.selector);
     }
 
     /// @notice Attempt to request decryption of a fake 16-bit unsigned integer (should revert)
@@ -215,13 +187,17 @@ contract TestAsyncDecrypt is GatewayCaller {
         uint256[] memory cts = new uint256[](1);
         cts[0] = uint256(0x4200000000000000000000000000000000000000000000000000000000000300);
         /// @dev This should revert because the previous handle is not honestly obtained
-        Gateway.requestDecryption(cts, this.callbackUint16.selector, 0, block.timestamp + 100, false);
+        requestDecryption(cts, this.callbackUint16.selector);
     }
 
     /// @notice Callback function for 16-bit unsigned integer decryption
     /// @param decryptedInput The decrypted 16-bit unsigned integer
     /// @return The decrypted value
-    function callbackUint16(uint256, uint16 decryptedInput) public onlyGateway returns (uint16) {
+    function callbackUint16(
+        uint256 requestID,
+        uint16 decryptedInput,
+        bytes[] memory signatures
+    ) public checkSignatures(requestID, signatures) returns (uint16) {
         yUint16 = decryptedInput;
         return decryptedInput;
     }
@@ -231,14 +207,8 @@ contract TestAsyncDecrypt is GatewayCaller {
     /// @param input2 Second additional input
     function requestUint32(uint32 input1, uint32 input2) public {
         uint256[] memory cts = new uint256[](1);
-        cts[0] = Gateway.toUint256(xUint32);
-        uint256 requestID = Gateway.requestDecryption(
-            cts,
-            this.callbackUint32.selector,
-            0,
-            block.timestamp + 100,
-            false
-        );
+        cts[0] = toUint256(xUint32);
+        uint256 requestID = requestDecryption(cts, this.callbackUint32.selector);
         addParamsUint256(requestID, input1);
         addParamsUint256(requestID, input2);
     }
@@ -248,14 +218,18 @@ contract TestAsyncDecrypt is GatewayCaller {
         uint256[] memory cts = new uint256[](1);
         cts[0] = uint256(0x4200000000000000000000000000000000000000000000000000000000000400);
         /// @dev This should revert because the previous handle is not honestly obtained
-        Gateway.requestDecryption(cts, this.callbackUint32.selector, 0, block.timestamp + 100, false);
+        requestDecryption(cts, this.callbackUint32.selector);
     }
 
     /// @notice Callback function for 32-bit unsigned integer decryption
     /// @param requestID The ID of the decryption request
     /// @param decryptedInput The decrypted 32-bit unsigned integer
     /// @return The result of the computation
-    function callbackUint32(uint256 requestID, uint32 decryptedInput) public onlyGateway returns (uint32) {
+    function callbackUint32(
+        uint256 requestID,
+        uint32 decryptedInput,
+        bytes[] memory signatures
+    ) public checkSignatures(requestID, signatures) returns (uint32) {
         uint256[] memory params = getParamsUint256(requestID);
         unchecked {
             uint32 result = uint32(params[0]) + uint32(params[1]) + decryptedInput;
@@ -267,8 +241,8 @@ contract TestAsyncDecrypt is GatewayCaller {
     /// @notice Request decryption of a 64-bit unsigned integer
     function requestUint64() public {
         uint256[] memory cts = new uint256[](1);
-        cts[0] = Gateway.toUint256(xUint64);
-        Gateway.requestDecryption(cts, this.callbackUint64.selector, 0, block.timestamp + 100, false);
+        cts[0] = toUint256(xUint64);
+        requestDecryption(cts, this.callbackUint64.selector);
     }
 
     /// @notice Attempt to request decryption of a fake 64-bit unsigned integer (should revert)
@@ -276,7 +250,7 @@ contract TestAsyncDecrypt is GatewayCaller {
         uint256[] memory cts = new uint256[](1);
         cts[0] = uint256(0x4200000000000000000000000000000000000000000000000000000000000500);
         /// @dev This should revert because the previous handle is not honestly obtained
-        Gateway.requestDecryption(cts, this.callbackUint64.selector, 0, block.timestamp + 100, false);
+        requestDecryption(cts, this.callbackUint64.selector);
     }
 
     /// @notice Request decryption of a non-trivial 64-bit unsigned integer
@@ -285,50 +259,62 @@ contract TestAsyncDecrypt is GatewayCaller {
     function requestUint64NonTrivial(einput inputHandle, bytes calldata inputProof) public {
         euint64 inputNonTrivial = TFHE.asEuint64(inputHandle, inputProof);
         uint256[] memory cts = new uint256[](1);
-        cts[0] = Gateway.toUint256(inputNonTrivial);
-        Gateway.requestDecryption(cts, this.callbackUint64.selector, 0, block.timestamp + 100, false);
+        cts[0] = toUint256(inputNonTrivial);
+        requestDecryption(cts, this.callbackUint64.selector);
     }
 
     /// @notice Callback function for 64-bit unsigned integer decryption
     /// @param decryptedInput The decrypted 64-bit unsigned integer
     /// @return The decrypted value
-    function callbackUint64(uint256, uint64 decryptedInput) public onlyGateway returns (uint64) {
+    function callbackUint64(
+        uint256 requestID,
+        uint64 decryptedInput,
+        bytes[] memory signatures
+    ) public checkSignatures(requestID, signatures) returns (uint64) {
         yUint64 = decryptedInput;
         return decryptedInput;
     }
 
     function requestUint128() public {
         uint256[] memory cts = new uint256[](1);
-        cts[0] = Gateway.toUint256(xUint128);
-        Gateway.requestDecryption(cts, this.callbackUint128.selector, 0, block.timestamp + 100, false);
+        cts[0] = toUint256(xUint128);
+        requestDecryption(cts, this.callbackUint128.selector);
     }
 
     function requestUint128NonTrivial(einput inputHandle, bytes calldata inputProof) public {
         euint128 inputNonTrivial = TFHE.asEuint128(inputHandle, inputProof);
         uint256[] memory cts = new uint256[](1);
-        cts[0] = Gateway.toUint256(inputNonTrivial);
-        Gateway.requestDecryption(cts, this.callbackUint128.selector, 0, block.timestamp + 100, false);
+        cts[0] = toUint256(inputNonTrivial);
+        requestDecryption(cts, this.callbackUint128.selector);
     }
 
-    function callbackUint128(uint256, uint128 decryptedInput) public onlyGateway returns (uint128) {
+    function callbackUint128(
+        uint256 requestID,
+        uint128 decryptedInput,
+        bytes[] memory signatures
+    ) public checkSignatures(requestID, signatures) returns (uint128) {
         yUint128 = decryptedInput;
         return decryptedInput;
     }
 
     function requestUint256() public {
         uint256[] memory cts = new uint256[](1);
-        cts[0] = Gateway.toUint256(xUint256);
-        Gateway.requestDecryption(cts, this.callbackUint256.selector, 0, block.timestamp + 100, false);
+        cts[0] = toUint256(xUint256);
+        requestDecryption(cts, this.callbackUint256.selector);
     }
 
     function requestUint256NonTrivial(einput inputHandle, bytes calldata inputProof) public {
         euint256 inputNonTrivial = TFHE.asEuint256(inputHandle, inputProof);
         uint256[] memory cts = new uint256[](1);
-        cts[0] = Gateway.toUint256(inputNonTrivial);
-        Gateway.requestDecryption(cts, this.callbackUint256.selector, 0, block.timestamp + 100, false);
+        cts[0] = toUint256(inputNonTrivial);
+        requestDecryption(cts, this.callbackUint256.selector);
     }
 
-    function callbackUint256(uint256, uint256 decryptedInput) public onlyGateway returns (uint256) {
+    function callbackUint256(
+        uint256 requestID,
+        uint256 decryptedInput,
+        bytes[] memory signatures
+    ) public checkSignatures(requestID, signatures) returns (uint256) {
         yUint256 = decryptedInput;
         return decryptedInput;
     }
@@ -336,18 +322,22 @@ contract TestAsyncDecrypt is GatewayCaller {
     function requestEbytes64NonTrivial(einput inputHandle, bytes calldata inputProof) public {
         ebytes64 inputNonTrivial = TFHE.asEbytes64(inputHandle, inputProof);
         uint256[] memory cts = new uint256[](1);
-        cts[0] = Gateway.toUint256(inputNonTrivial);
-        Gateway.requestDecryption(cts, this.callbackBytes64.selector, 0, block.timestamp + 100, false);
+        cts[0] = toUint256(inputNonTrivial);
+        requestDecryption(cts, this.callbackBytes64.selector);
     }
 
     function requestEbytes64Trivial(bytes calldata value) public {
         ebytes64 inputTrivial = TFHE.asEbytes64(TFHE.padToBytes64(value));
         uint256[] memory cts = new uint256[](1);
-        cts[0] = Gateway.toUint256(inputTrivial);
-        Gateway.requestDecryption(cts, this.callbackBytes64.selector, 0, block.timestamp + 100, false);
+        cts[0] = toUint256(inputTrivial);
+        requestDecryption(cts, this.callbackBytes64.selector);
     }
 
-    function callbackBytes64(uint256, bytes calldata decryptedInput) public onlyGateway returns (bytes memory) {
+    function callbackBytes64(
+        uint256 requestID,
+        bytes calldata decryptedInput,
+        bytes[] memory signatures
+    ) public checkSignatures(requestID, signatures) returns (bytes memory) {
         yBytes64 = decryptedInput;
         return decryptedInput;
     }
@@ -355,18 +345,22 @@ contract TestAsyncDecrypt is GatewayCaller {
     function requestEbytes128NonTrivial(einput inputHandle, bytes calldata inputProof) public {
         ebytes128 inputNonTrivial = TFHE.asEbytes128(inputHandle, inputProof);
         uint256[] memory cts = new uint256[](1);
-        cts[0] = Gateway.toUint256(inputNonTrivial);
-        Gateway.requestDecryption(cts, this.callbackBytes128.selector, 0, block.timestamp + 100, false);
+        cts[0] = toUint256(inputNonTrivial);
+        requestDecryption(cts, this.callbackBytes128.selector);
     }
 
     function requestEbytes128Trivial(bytes calldata value) public {
         ebytes128 inputTrivial = TFHE.asEbytes128(TFHE.padToBytes128(value));
         uint256[] memory cts = new uint256[](1);
-        cts[0] = Gateway.toUint256(inputTrivial);
-        Gateway.requestDecryption(cts, this.callbackBytes128.selector, 0, block.timestamp + 100, false);
+        cts[0] = toUint256(inputTrivial);
+        requestDecryption(cts, this.callbackBytes128.selector);
     }
 
-    function callbackBytes128(uint256, bytes calldata decryptedInput) public onlyGateway returns (bytes memory) {
+    function callbackBytes128(
+        uint256 requestID,
+        bytes calldata decryptedInput,
+        bytes[] memory signatures
+    ) public checkSignatures(requestID, signatures) returns (bytes memory) {
         yBytes128 = decryptedInput;
         return decryptedInput;
     }
@@ -374,21 +368,25 @@ contract TestAsyncDecrypt is GatewayCaller {
     function requestEbytes256Trivial(bytes calldata value) public {
         ebytes256 inputTrivial = TFHE.asEbytes256(TFHE.padToBytes256(value));
         uint256[] memory cts = new uint256[](1);
-        cts[0] = Gateway.toUint256(inputTrivial);
-        Gateway.requestDecryption(cts, this.callbackBytes256.selector, 0, block.timestamp + 100, false);
+        cts[0] = toUint256(inputTrivial);
+        requestDecryption(cts, this.callbackBytes256.selector);
     }
 
     function requestEbytes256NonTrivial(einput inputHandle, bytes calldata inputProof) public {
         ebytes256 inputNonTrivial = TFHE.asEbytes256(inputHandle, inputProof);
         uint256[] memory cts = new uint256[](1);
-        cts[0] = Gateway.toUint256(inputNonTrivial);
-        Gateway.requestDecryption(cts, this.callbackBytes256.selector, 0, block.timestamp + 100, false);
+        cts[0] = toUint256(inputNonTrivial);
+        requestDecryption(cts, this.callbackBytes256.selector);
     }
 
     /// @notice Callback function for 256-bit encrypted bytes decryption
     /// @param decryptedInput The decrypted 256-bit bytes
     /// @return The decrypted value
-    function callbackBytes256(uint256, bytes calldata decryptedInput) public onlyGateway returns (bytes memory) {
+    function callbackBytes256(
+        uint256 requestID,
+        bytes calldata decryptedInput,
+        bytes[] memory signatures
+    ) public checkSignatures(requestID, signatures) returns (bytes memory) {
         yBytes256 = decryptedInput;
         return decryptedInput;
     }
@@ -396,16 +394,16 @@ contract TestAsyncDecrypt is GatewayCaller {
     /// @notice Request decryption of an encrypted address
     function requestAddress() public {
         uint256[] memory cts = new uint256[](1);
-        cts[0] = Gateway.toUint256(xAddress);
-        Gateway.requestDecryption(cts, this.callbackAddress.selector, 0, block.timestamp + 100, false);
+        cts[0] = toUint256(xAddress);
+        requestDecryption(cts, this.callbackAddress.selector);
     }
 
     /// @notice Request decryption of multiple encrypted addresses
     function requestSeveralAddresses() public {
         uint256[] memory cts = new uint256[](2);
-        cts[0] = Gateway.toUint256(xAddress);
-        cts[1] = Gateway.toUint256(xAddress2);
-        Gateway.requestDecryption(cts, this.callbackAddresses.selector, 0, block.timestamp + 100, false);
+        cts[0] = toUint256(xAddress);
+        cts[1] = toUint256(xAddress2);
+        requestDecryption(cts, this.callbackAddresses.selector);
     }
 
     /// @notice Callback function for multiple address decryption
@@ -413,10 +411,11 @@ contract TestAsyncDecrypt is GatewayCaller {
     /// @param decryptedInput2 The second decrypted address
     /// @return The first decrypted address
     function callbackAddresses(
-        uint256 /*requestID*/,
+        uint256 requestID,
         address decryptedInput1,
-        address decryptedInput2
-    ) public onlyGateway returns (address) {
+        address decryptedInput2,
+        bytes[] memory signatures
+    ) public checkSignatures(requestID, signatures) returns (address) {
         yAddress = decryptedInput1;
         yAddress2 = decryptedInput2;
         return decryptedInput1;
@@ -427,13 +426,17 @@ contract TestAsyncDecrypt is GatewayCaller {
         uint256[] memory cts = new uint256[](1);
         cts[0] = uint256(0x4200000000000000000000000000000000000000000000000000000000000700);
         /// @dev This should revert because the previous handle is not honestly obtained
-        Gateway.requestDecryption(cts, this.callbackAddress.selector, 0, block.timestamp + 100, false);
+        requestDecryption(cts, this.callbackAddress.selector);
     }
 
     /// @notice Callback function for address decryption
     /// @param decryptedInput The decrypted address
     /// @return The decrypted address
-    function callbackAddress(uint256, address decryptedInput) public onlyGateway returns (address) {
+    function callbackAddress(
+        uint256 requestID,
+        address decryptedInput,
+        bytes[] memory signatures
+    ) public checkSignatures(requestID, signatures) returns (address) {
         yAddress = decryptedInput;
         return decryptedInput;
     }
@@ -444,23 +447,17 @@ contract TestAsyncDecrypt is GatewayCaller {
     /// @param input2 Second additional input parameter for the callback function
     function requestMixed(uint32 input1, uint32 input2) public {
         uint256[] memory cts = new uint256[](10);
-        cts[0] = Gateway.toUint256(xBool);
-        cts[1] = Gateway.toUint256(xBool);
-        cts[2] = Gateway.toUint256(xUint4);
-        cts[3] = Gateway.toUint256(xUint8);
-        cts[4] = Gateway.toUint256(xUint16);
-        cts[5] = Gateway.toUint256(xUint32);
-        cts[6] = Gateway.toUint256(xUint64);
-        cts[7] = Gateway.toUint256(xUint64);
-        cts[8] = Gateway.toUint256(xUint64);
-        cts[9] = Gateway.toUint256(xAddress);
-        uint256 requestID = Gateway.requestDecryption(
-            cts,
-            this.callbackMixed.selector,
-            0,
-            block.timestamp + 100,
-            false
-        );
+        cts[0] = toUint256(xBool);
+        cts[1] = toUint256(xBool);
+        cts[2] = toUint256(xUint4);
+        cts[3] = toUint256(xUint8);
+        cts[4] = toUint256(xUint16);
+        cts[5] = toUint256(xUint32);
+        cts[6] = toUint256(xUint64);
+        cts[7] = toUint256(xUint64);
+        cts[8] = toUint256(xUint64);
+        cts[9] = toUint256(xAddress);
+        uint256 requestID = requestDecryption(cts, this.callbackMixed.selector);
         addParamsUint256(requestID, input1);
         addParamsUint256(requestID, input2);
     }
@@ -490,8 +487,9 @@ contract TestAsyncDecrypt is GatewayCaller {
         uint64 decUint64_1,
         uint64 decUint64_2,
         uint64 decUint64_3,
-        address decAddress
-    ) public onlyGateway returns (uint8) {
+        address decAddress,
+        bytes[] memory signatures
+    ) public checkSignatures(requestID, signatures) returns (uint8) {
         yBool = decBool_1;
         require(decBool_1 == decBool_2, "Wrong decryption");
         yUint4 = decUint4;
@@ -515,12 +513,12 @@ contract TestAsyncDecrypt is GatewayCaller {
     function requestMixedBytes256(einput inputHandle, bytes calldata inputProof) public {
         ebytes256 xBytes256 = TFHE.asEbytes256(inputHandle, inputProof);
         uint256[] memory cts = new uint256[](4);
-        cts[0] = Gateway.toUint256(xBool);
-        cts[1] = Gateway.toUint256(xAddress);
-        cts[2] = Gateway.toUint256(xBytes256);
+        cts[0] = toUint256(xBool);
+        cts[1] = toUint256(xAddress);
+        cts[2] = toUint256(xBytes256);
         ebytes64 input64Bytes = TFHE.asEbytes64(TFHE.padToBytes64(hex"aaff42"));
-        cts[3] = Gateway.toUint256(input64Bytes);
-        Gateway.requestDecryption(cts, this.callbackMixedBytes256.selector, 0, block.timestamp + 100, false);
+        cts[3] = toUint256(input64Bytes);
+        requestDecryption(cts, this.callbackMixedBytes256.selector);
     }
 
     /// @notice Callback function for mixed data type decryption including 256-bit encrypted bytes
@@ -529,97 +527,16 @@ contract TestAsyncDecrypt is GatewayCaller {
     /// @param decAddress Decrypted address
     /// @param bytesRes Decrypted 256-bit bytes
     function callbackMixedBytes256(
-        uint256,
-        bool decBool,
-        address decAddress,
-        bytes memory bytesRes,
-        bytes memory bytesRes2
-    ) public onlyGateway {
-        yBool = decBool;
-        yAddress = decAddress;
-        yBytes256 = bytesRes;
-        yBytes64 = bytesRes2;
-    }
-
-    /// @notice Request trustless decryption of non-trivial 256-bit encrypted bytes
-    /// @dev Demonstrates how to request trustless decryption for complex encrypted bytes256
-    /// @param inputHandle The encrypted input handle for the bytes256
-    /// @param inputProof The proof for the encrypted bytes256
-    function requestEbytes256NonTrivialTrustless(einput inputHandle, bytes calldata inputProof) public {
-        ebytes256 inputNonTrivial = TFHE.asEbytes256(inputHandle, inputProof);
-        uint256[] memory cts = new uint256[](1);
-        cts[0] = Gateway.toUint256(inputNonTrivial);
-        uint256 requestID = Gateway.requestDecryption(
-            cts,
-            this.callbackBytes256Trustless.selector,
-            0,
-            block.timestamp + 100,
-            true
-        );
-        latestRequestID = requestID;
-        saveRequestedHandles(requestID, cts);
-    }
-
-    /// @notice Callback function for trustless decryption of 256-bit encrypted bytes
-    /// @dev Verifies the decryption result using KMS signatures
-    /// @param requestID The ID of the decryption request
-    /// @param decryptedInput The decrypted bytes256 value
-    /// @param signatures The signatures from the KMS for verification
-    /// @return The decrypted bytes256 value
-    function callbackBytes256Trustless(
-        uint256 requestID,
-        bytes calldata decryptedInput,
-        bytes[] memory signatures
-    ) public onlyGateway returns (bytes memory) {
-        require(latestRequestID == requestID, "wrong requestID passed by Gateway");
-        uint256[] memory requestedHandles = loadRequestedHandles(latestRequestID);
-        bool isKMSVerified = Gateway.verifySignatures(requestedHandles, signatures);
-        require(isKMSVerified, "KMS did not verify this decryption result");
-        yBytes256 = decryptedInput;
-        return decryptedInput;
-    }
-
-    /// @notice Request trustless decryption of mixed data types including 256-bit encrypted bytes
-    /// @dev Demonstrates how to request trustless decryption for multiple data types
-    /// @param inputHandle The encrypted input handle for the bytes256
-    /// @param inputProof The proof for the encrypted bytes256
-    function requestMixedBytes256Trustless(einput inputHandle, bytes calldata inputProof) public {
-        ebytes256 xBytes256 = TFHE.asEbytes256(inputHandle, inputProof);
-        uint256[] memory cts = new uint256[](3);
-        cts[0] = Gateway.toUint256(xBool);
-        cts[1] = Gateway.toUint256(xBytes256);
-        cts[2] = Gateway.toUint256(xAddress);
-        uint256 requestID = Gateway.requestDecryption(
-            cts,
-            this.callbackMixedBytes256Trustless.selector,
-            0,
-            block.timestamp + 100,
-            true
-        );
-        latestRequestID = requestID;
-        saveRequestedHandles(requestID, cts);
-    }
-
-    /// @notice Callback function for trustless decryption of mixed data types including 256-bit encrypted bytes
-    /// @dev Verifies and processes the decrypted values
-    /// @param requestID The ID of the decryption request
-    /// @param decBool Decrypted boolean
-    /// @param bytesRes Decrypted 256-bit bytes
-    /// @param decAddress Decrypted address
-    /// @param signatures The signatures from the KMS for verification
-    function callbackMixedBytes256Trustless(
         uint256 requestID,
         bool decBool,
-        bytes memory bytesRes,
         address decAddress,
+        bytes memory bytesRes,
+        bytes memory bytesRes2,
         bytes[] memory signatures
-    ) public onlyGateway {
-        require(latestRequestID == requestID, "wrong requestID passed by Gateway");
-        uint256[] memory requestedHandles = loadRequestedHandles(latestRequestID);
-        bool isKMSVerified = Gateway.verifySignatures(requestedHandles, signatures);
-        require(isKMSVerified, "KMS did not verify this decryption result");
+    ) public checkSignatures(requestID, signatures) {
         yBool = decBool;
         yAddress = decAddress;
         yBytes256 = bytesRes;
+        yBytes64 = bytesRes2;
     }
 }
diff --git a/gateway/GatewayCaller.sol b/gateway/GatewayCaller.sol
deleted file mode 100644
index 79b4699f..00000000
--- a/gateway/GatewayCaller.sol
+++ /dev/null
@@ -1,107 +0,0 @@
-// SPDX-License-Identifier: BSD-3-Clause-Clear
-
-pragma solidity ^0.8.24;
-
-import "../lib/TFHE.sol";
-import "./lib/Gateway.sol";
-
-abstract contract GatewayCaller {
-    modifier onlyGateway() {
-        require(msg.sender == Gateway.gatewayContractAddress());
-        _;
-    }
-    mapping(uint256 => ebool[]) private paramsEBool;
-    mapping(uint256 => euint4[]) private paramsEUint4;
-    mapping(uint256 => euint8[]) private paramsEUint8;
-    mapping(uint256 => euint16[]) private paramsEUint16;
-    mapping(uint256 => euint32[]) private paramsEUint32;
-    mapping(uint256 => euint64[]) private paramsEUint64;
-    mapping(uint256 => eaddress[]) private paramsEAddress;
-    mapping(uint256 => address[]) private paramsAddress;
-    mapping(uint256 => uint256[]) private paramsUint256;
-    mapping(uint256 => uint256[]) private requestedHandles;
-
-    constructor() {}
-
-    function addParamsEBool(uint256 requestID, ebool _ebool) internal {
-        paramsEBool[requestID].push(_ebool);
-    }
-
-    function addParamsEUint4(uint256 requestID, euint4 _euint4) internal {
-        paramsEUint4[requestID].push(_euint4);
-    }
-
-    function addParamsEUint8(uint256 requestID, euint8 _euint8) internal {
-        paramsEUint8[requestID].push(_euint8);
-    }
-
-    function addParamsEUint16(uint256 requestID, euint16 _euint16) internal {
-        paramsEUint16[requestID].push(_euint16);
-    }
-
-    function addParamsEUint32(uint256 requestID, euint32 _euint32) internal {
-        paramsEUint32[requestID].push(_euint32);
-    }
-
-    function addParamsEUint64(uint256 requestID, euint64 _euint64) internal {
-        paramsEUint64[requestID].push(_euint64);
-    }
-
-    function addParamsEAddress(uint256 requestID, eaddress _eaddress) internal {
-        paramsEAddress[requestID].push(_eaddress);
-    }
-
-    function addParamsAddress(uint256 requestID, address _address) internal {
-        paramsAddress[requestID].push(_address);
-    }
-
-    function addParamsUint256(uint256 requestID, uint256 _uint) internal {
-        paramsUint256[requestID].push(_uint);
-    }
-
-    function saveRequestedHandles(uint256 requestID, uint256[] memory handlesList) internal {
-        require(requestedHandles[requestID].length == 0, "requested handles already saved");
-        requestedHandles[requestID] = handlesList;
-    }
-
-    function loadRequestedHandles(uint256 requestID) internal view returns (uint256[] memory) {
-        require(requestedHandles[requestID].length != 0, "requested handles were not saved for this requestID");
-        return requestedHandles[requestID];
-    }
-
-    function getParamsEBool(uint256 requestID) internal view returns (ebool[] memory) {
-        return paramsEBool[requestID];
-    }
-
-    function getParamsEUint4(uint256 requestID) internal view returns (euint4[] memory) {
-        return paramsEUint4[requestID];
-    }
-
-    function getParamsEUint8(uint256 requestID) internal view returns (euint8[] memory) {
-        return paramsEUint8[requestID];
-    }
-
-    function getParamsEUint16(uint256 requestID) internal view returns (euint16[] memory) {
-        return paramsEUint16[requestID];
-    }
-
-    function getParamsEUint32(uint256 requestID) internal view returns (euint32[] memory) {
-        return paramsEUint32[requestID];
-    }
-
-    function getParamsEUint64(uint256 requestID) internal view returns (euint64[] memory) {
-        return paramsEUint64[requestID];
-    }
-
-    function getParamsEAddress(uint256 requestID) internal view returns (eaddress[] memory) {
-        return paramsEAddress[requestID];
-    }
-
-    function getParamsAddress(uint256 requestID) internal view returns (address[] memory) {
-        return paramsAddress[requestID];
-    }
-
-    function getParamsUint256(uint256 requestID) internal view returns (uint256[] memory) {
-        return paramsUint256[requestID];
-    }
-}
diff --git a/gateway/lib/Gateway.sol b/gateway/lib/Gateway.sol
deleted file mode 100644
index e34a83d1..00000000
--- a/gateway/lib/Gateway.sol
+++ /dev/null
@@ -1,199 +0,0 @@
-// SPDX-License-Identifier: BSD-3-Clause-Clear
-
-pragma solidity ^0.8.24;
-
-import "../../lib/Impl.sol";
-
-interface IKMSVerifier {
-    function verifyDecryptionEIP712KMSSignatures(
-        address aclAddress,
-        uint256[] memory handlesList,
-        bytes memory decryptedResult,
-        bytes[] memory signatures
-    ) external returns (bool);
-}
-
-interface IGatewayContract {
-    function requestDecryption(
-        uint256[] calldata ctsHandles,
-        bytes4 callbackSelector,
-        uint256 msgValue,
-        uint256 maxTimestamp,
-        bool passSignaturesToCaller
-    ) external returns (uint256);
-}
-
-struct GatewayConfigStruct {
-    address GatewayContractAddress;
-}
-
-library Gateway {
-    // keccak256(abi.encode(uint256(keccak256("fhevm.storage.GatewayConfig")) - 1)) & ~bytes32(uint256(0xff))
-    bytes32 private constant GatewayLocation = 0x93ab6e17f2c461cce6ea5d4ec117e51dda77a64affc2b2c05f8cd440def0e700;
-
-    function getGetwayConfig() internal pure returns (GatewayConfigStruct storage $) {
-        assembly {
-            $.slot := GatewayLocation
-        }
-    }
-
-    function setGateway(address gatewayAddress) internal {
-        GatewayConfigStruct storage $ = getGetwayConfig();
-        $.GatewayContractAddress = gatewayAddress;
-    }
-
-    function gatewayContractAddress() internal view returns (address) {
-        GatewayConfigStruct storage $ = getGetwayConfig();
-        return $.GatewayContractAddress;
-    }
-
-    function toUint256(ebool newCT) internal pure returns (uint256 ct) {
-        ct = ebool.unwrap(newCT);
-    }
-
-    function toUint256(euint4 newCT) internal pure returns (uint256 ct) {
-        ct = euint4.unwrap(newCT);
-    }
-
-    function toUint256(euint8 newCT) internal pure returns (uint256 ct) {
-        ct = euint8.unwrap(newCT);
-    }
-
-    function toUint256(euint16 newCT) internal pure returns (uint256 ct) {
-        ct = euint16.unwrap(newCT);
-    }
-
-    function toUint256(euint32 newCT) internal pure returns (uint256 ct) {
-        ct = euint32.unwrap(newCT);
-    }
-
-    function toUint256(euint64 newCT) internal pure returns (uint256 ct) {
-        ct = euint64.unwrap(newCT);
-    }
-
-    function toUint256(euint128 newCT) internal pure returns (uint256 ct) {
-        ct = euint128.unwrap(newCT);
-    }
-
-    function toUint256(eaddress newCT) internal pure returns (uint256 ct) {
-        ct = eaddress.unwrap(newCT);
-    }
-
-    function toUint256(euint256 newCT) internal pure returns (uint256 ct) {
-        ct = euint256.unwrap(newCT);
-    }
-
-    function toUint256(ebytes64 newCT) internal pure returns (uint256 ct) {
-        ct = ebytes64.unwrap(newCT);
-    }
-
-    function toUint256(ebytes128 newCT) internal pure returns (uint256 ct) {
-        ct = ebytes128.unwrap(newCT);
-    }
-
-    function toUint256(ebytes256 newCT) internal pure returns (uint256 ct) {
-        ct = ebytes256.unwrap(newCT);
-    }
-
-    function requestDecryption(
-        uint256[] memory ctsHandles,
-        bytes4 callbackSelector,
-        uint256 msgValue,
-        uint256 maxTimestamp,
-        bool passSignaturesToCaller
-    ) internal returns (uint256 requestID) {
-        FHEVMConfigStruct storage $ = Impl.getFHEVMConfig();
-        IACL($.ACLAddress).allowForDecryption(ctsHandles);
-        GatewayConfigStruct storage $$ = getGetwayConfig();
-        requestID = IGatewayContract($$.GatewayContractAddress).requestDecryption(
-            ctsHandles,
-            callbackSelector,
-            msgValue,
-            maxTimestamp,
-            passSignaturesToCaller
-        );
-    }
-
-    /// @dev this function is supposed to be called inside the callback function if the dev wants the dApp contract to verify the signatures
-    /// @dev this is useful to give dev the choice not to rely on trusting the GatewayContract.
-    /// @notice this could be used only when signatures are made available to the callback, i.e when `passSignaturesToCaller` is set to true during request
-    function verifySignatures(uint256[] memory handlesList, bytes[] memory signatures) internal returns (bool) {
-        uint256 start = 4 + 32; // start position after skipping the selector (4 bytes) and the first argument (index, 32 bytes)
-        uint256 length = getSignedDataLength(handlesList);
-        bytes memory decryptedResult = new bytes(length);
-        assembly {
-            calldatacopy(add(decryptedResult, 0x20), start, length) // Copy the relevant part of calldata to decryptedResult memory
-        }
-        decryptedResult = shiftOffsets(decryptedResult, handlesList);
-        FHEVMConfigStruct storage $ = Impl.getFHEVMConfig();
-        return
-            IKMSVerifier($.KMSVerifierAddress).verifyDecryptionEIP712KMSSignatures(
-                $.ACLAddress,
-                handlesList,
-                decryptedResult,
-                signatures
-            );
-    }
-
-    function getSignedDataLength(uint256[] memory handlesList) private pure returns (uint256) {
-        uint256 handlesListlen = handlesList.length;
-        uint256 signedDataLength;
-        for (uint256 i = 0; i < handlesListlen; i++) {
-            uint8 typeCt = uint8(handlesList[i] >> 8);
-            if (typeCt < 9) {
-                signedDataLength += 32;
-            } else if (typeCt == 9) {
-                //ebytes64
-                signedDataLength += 128;
-            } else if (typeCt == 10) {
-                //ebytes128
-                signedDataLength += 192;
-            } else if (typeCt == 11) {
-                //ebytes256
-                signedDataLength += 320;
-            } else {
-                revert("Unsupported handle type");
-            }
-        }
-        signedDataLength += 32; // add offset of signatures
-        return signedDataLength;
-    }
-
-    function shiftOffsets(bytes memory input, uint256[] memory handlesList) private pure returns (bytes memory) {
-        uint256 numArgs = handlesList.length;
-        for (uint256 i = 0; i < numArgs; i++) {
-            uint8 typeCt = uint8(handlesList[i] >> 8);
-            if (typeCt >= 9) {
-                input = subToBytes32Slice(input, 32 * i); // because we append the signatures, all bytes offsets are shifted by 0x20
-            }
-        }
-        input = remove32Slice(input, 32 * numArgs);
-        return input;
-    }
-
-    function subToBytes32Slice(bytes memory data, uint256 offset) private pure returns (bytes memory) {
-        // @note: data is assumed to be more than 32+offset bytes long
-        assembly {
-            let ptr := add(add(data, 0x20), offset)
-            let val := mload(ptr)
-            val := sub(val, 0x20)
-            mstore(ptr, val)
-        }
-        return data;
-    }
-
-    function remove32Slice(bytes memory input, uint256 start) private pure returns (bytes memory) {
-        // @note we assume start+32 is less than input.length
-        bytes memory result = new bytes(input.length - 32);
-
-        for (uint256 i = 0; i < start; i++) {
-            result[i] = input[i];
-        }
-
-        for (uint256 i = start + 32; i < input.length; i++) {
-            result[i - 32] = input[i];
-        }
-
-        return result;
-    }
-}
diff --git a/hardhat.config.ts b/hardhat.config.ts
index 8aa07169..d25aee5b 100644
--- a/hardhat.config.ts
+++ b/hardhat.config.ts
@@ -14,13 +14,12 @@ import CustomProvider from './CustomProvider';
 // Adjust the import path as needed
 import './tasks/accounts';
 import './tasks/getEthereumAddress';
+import './tasks/taskDecryptionOracleRelayer';
 import './tasks/taskDeploy';
-import './tasks/taskGatewayRelayer';
 import './tasks/taskTFHE';
 
-extendProvider(async (provider, _config, _network) => {
-  const newProvider = new CustomProvider(provider);
-  return newProvider;
+extendProvider((provider) => {
+  return new CustomProvider(provider);
 });
 
 task('compile:specific', 'Compiles only the specified contract')
@@ -70,6 +69,9 @@ function getChainConfig(chain: keyof typeof chainIds): NetworkUserConfig {
       break;
     case 'sepolia':
       jsonRpcUrl = process.env.SEPOLIA_RPC_URL!;
+      break;
+    default:
+      throw new Error(`Unsupported chain: ${chain}`);
   }
   return {
     accounts: {
@@ -93,12 +95,12 @@ task('test', async (_taskArgs, hre, runSuper) => {
   // Run modified test task
   if (hre.network.name === 'hardhat') {
     // in fhevm mode all this block is done when launching the node via `pnmp fhevm:start`
-    const privKeyGatewayDeployer = process.env.PRIVATE_KEY_GATEWAY_DEPLOYER;
+    const privKeyDecryptionOracleDeployer = process.env.PRIVATE_KEY_DECRYPTION_ORACLE_DEPLOYER;
     const privKeyFhevmDeployer = process.env.PRIVATE_KEY_FHEVM_DEPLOYER;
     if (!fs.existsSync('node_modules/fhevm-core-contracts/addresses')) {
       fs.mkdirSync('node_modules/fhevm-core-contracts/addresses');
     }
-    await hre.run('task:computeGatewayAddress', { privateKey: privKeyGatewayDeployer });
+    await hre.run('task:computeDecryptionOracleAddress', { privateKey: privKeyDecryptionOracleDeployer });
     await hre.run('task:computeACLAddress', { privateKey: privKeyFhevmDeployer });
     await hre.run('task:computeTFHEExecutorAddress', { privateKey: privKeyFhevmDeployer });
     await hre.run('task:computeKMSVerifierAddress', { privateKey: privKeyFhevmDeployer });
@@ -110,14 +112,13 @@ task('test', async (_taskArgs, hre, runSuper) => {
     const sourceDir2 = path.resolve(__dirname, 'node_modules/fhevm-core-contracts/addresses');
     const destinationDir2 = path.resolve(__dirname, 'fhevmTemp/addresses');
     fs.copySync(sourceDir2, destinationDir2, { dereference: true });
-    const sourceDir3 = path.resolve(__dirname, 'node_modules/fhevm-core-contracts/gateway');
-    const destinationDir3 = path.resolve(__dirname, 'fhevmTemp/gateway');
+    const sourceDir3 = path.resolve(__dirname, 'node_modules/fhevm-core-contracts/decryptionOracle');
+    const destinationDir3 = path.resolve(__dirname, 'fhevmTemp/decryptionOracle');
     fs.copySync(sourceDir3, destinationDir3, { dereference: true });
     await hre.run('compile:specific', { contract: 'fhevmTemp/contracts' });
-    await hre.run('compile:specific', { contract: 'fhevmTemp/gateway' });
+    await hre.run('compile:specific', { contract: 'fhevmTemp/decryptionOracle' });
     await hre.run('compile:specific', { contract: 'lib' });
-    await hre.run('compile:specific', { contract: 'gateway' });
-    await hre.run('compile:specific', { contract: 'payment' });
+    await hre.run('compile:specific', { contract: 'decryption' });
     await hre.run('task:faucetToPrivate', { privateKey: privKeyFhevmDeployer });
     await hre.run('task:deployACL', { privateKey: privKeyFhevmDeployer });
     await hre.run('task:deployTFHEExecutor', { privateKey: privKeyFhevmDeployer });
@@ -185,6 +186,7 @@ const config: HardhatUserConfig = {
         enabled: true,
         runs: 800,
       },
+      viaIR: true,
       evmVersion: 'cancun',
     },
   },
diff --git a/package-lock.json b/package-lock.json
index f82cbecb..e1888b27 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -42,7 +42,7 @@
         "eslint": "^8.28.0",
         "eslint-config-prettier": "^8.5.0",
         "ethers": "^6.8.0",
-        "fhevm-core-contracts": "0.7.0-0",
+        "fhevm-core-contracts": "0.7.0-1",
         "fhevmjs": "^0.6.0-8",
         "hardhat": "^2.22.10",
         "hardhat-deploy": "^0.11.29",
@@ -54,11 +54,13 @@
         "prettier": "^3.4.2",
         "prettier-plugin-solidity": "^1.1.3",
         "rimraf": "^4.1.2",
+        "sha3": "^2.1.4",
         "solidity-coverage": "0.8.12",
         "ts-generator": "^0.1.1",
         "ts-node": "^10.9.2",
         "typechain": "^8.2.0",
-        "typescript": "^5.1.6"
+        "typescript": "^5.1.6",
+        "web3-validator": "^2.0.6"
       },
       "engines": {
         "node": ">=20.0.0"
@@ -93,12 +95,12 @@
       }
     },
     "node_modules/@aws-sdk/types": {
-      "version": "3.667.0",
-      "resolved": "https://registry.npmjs.org/@aws-sdk/types/-/types-3.667.0.tgz",
-      "integrity": "sha512-gYq0xCsqFfQaSL/yT1Gl1vIUjtsg7d7RhnUfsXaHt8xTxOKRTdH9GjbesBjXOzgOvB0W0vfssfreSNGFlOOMJg==",
+      "version": "3.714.0",
+      "resolved": "https://registry.npmjs.org/@aws-sdk/types/-/types-3.714.0.tgz",
+      "integrity": "sha512-ZjpP2gYbSFlxxaUDa1Il5AVvfggvUPbjzzB/l3q0gIE5Thd6xKW+yzEpt2mLZ5s5UaYSABZbF94g8NUOF4CVGA==",
       "dev": true,
       "dependencies": {
-        "@smithy/types": "^3.5.0",
+        "@smithy/types": "^3.7.2",
         "tslib": "^2.6.2"
       },
       "engines": {
@@ -106,9 +108,9 @@
       }
     },
     "node_modules/@aws-sdk/types/node_modules/tslib": {
-      "version": "2.7.0",
-      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.7.0.tgz",
-      "integrity": "sha512-gLXCKdN1/j47AiHiOkJN69hJmcbGTHI0ImLmbYLHykhgeN0jVGola9yVjFgzCUklsZQMW55o+dW7IXv3RCXDzA==",
+      "version": "2.8.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
       "dev": true
     },
     "node_modules/@aws-sdk/util-utf8-browser": {
@@ -121,18 +123,19 @@
       }
     },
     "node_modules/@aws-sdk/util-utf8-browser/node_modules/tslib": {
-      "version": "2.7.0",
-      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.7.0.tgz",
-      "integrity": "sha512-gLXCKdN1/j47AiHiOkJN69hJmcbGTHI0ImLmbYLHykhgeN0jVGola9yVjFgzCUklsZQMW55o+dW7IXv3RCXDzA==",
+      "version": "2.8.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
       "dev": true
     },
     "node_modules/@babel/code-frame": {
-      "version": "7.25.7",
-      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.25.7.tgz",
-      "integrity": "sha512-0xZJFNE5XMpENsgfHYTw8FbX4kv53mFLn2i3XPoq69LyhYSCBJtitaHx9QnsVTrsogI4Z3+HtEfZ2/GFPOtf5g==",
+      "version": "7.26.2",
+      "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.26.2.tgz",
+      "integrity": "sha512-RJlIHRueQgwWitWgF8OdFYGZX328Ax5BCemNGlqHfplnRT9ESi8JkFlvaVYbS+UubVY6dpv87Fs2u5M29iNFVQ==",
       "dev": true,
       "dependencies": {
-        "@babel/highlight": "^7.25.7",
+        "@babel/helper-validator-identifier": "^7.25.9",
+        "js-tokens": "^4.0.0",
         "picocolors": "^1.0.0"
       },
       "engines": {
@@ -166,14 +169,13 @@
       }
     },
     "node_modules/@babel/helper-environment-visitor/node_modules/@babel/types": {
-      "version": "7.25.7",
-      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.25.7.tgz",
-      "integrity": "sha512-vwIVdXG+j+FOpkwqHRcBgHLYNL7XMkufrlaFvL9o6Ai9sJn9+PdyIL5qa0XzTZw084c+u9LOls53eoZWP/W5WQ==",
+      "version": "7.26.3",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.26.3.tgz",
+      "integrity": "sha512-vN5p+1kl59GVKMvTHt55NzzmYVxprfJD+ql7U9NFIfKCBkYE55LYtS+WtPlaYOyzydrKI8Nezd+aZextrd+FMA==",
       "dev": true,
       "dependencies": {
-        "@babel/helper-string-parser": "^7.25.7",
-        "@babel/helper-validator-identifier": "^7.25.7",
-        "to-fast-properties": "^2.0.0"
+        "@babel/helper-string-parser": "^7.25.9",
+        "@babel/helper-validator-identifier": "^7.25.9"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -193,14 +195,13 @@
       }
     },
     "node_modules/@babel/helper-function-name/node_modules/@babel/types": {
-      "version": "7.25.7",
-      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.25.7.tgz",
-      "integrity": "sha512-vwIVdXG+j+FOpkwqHRcBgHLYNL7XMkufrlaFvL9o6Ai9sJn9+PdyIL5qa0XzTZw084c+u9LOls53eoZWP/W5WQ==",
+      "version": "7.26.3",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.26.3.tgz",
+      "integrity": "sha512-vN5p+1kl59GVKMvTHt55NzzmYVxprfJD+ql7U9NFIfKCBkYE55LYtS+WtPlaYOyzydrKI8Nezd+aZextrd+FMA==",
       "dev": true,
       "dependencies": {
-        "@babel/helper-string-parser": "^7.25.7",
-        "@babel/helper-validator-identifier": "^7.25.7",
-        "to-fast-properties": "^2.0.0"
+        "@babel/helper-string-parser": "^7.25.9",
+        "@babel/helper-validator-identifier": "^7.25.9"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -219,14 +220,13 @@
       }
     },
     "node_modules/@babel/helper-hoist-variables/node_modules/@babel/types": {
-      "version": "7.25.7",
-      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.25.7.tgz",
-      "integrity": "sha512-vwIVdXG+j+FOpkwqHRcBgHLYNL7XMkufrlaFvL9o6Ai9sJn9+PdyIL5qa0XzTZw084c+u9LOls53eoZWP/W5WQ==",
+      "version": "7.26.3",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.26.3.tgz",
+      "integrity": "sha512-vN5p+1kl59GVKMvTHt55NzzmYVxprfJD+ql7U9NFIfKCBkYE55LYtS+WtPlaYOyzydrKI8Nezd+aZextrd+FMA==",
       "dev": true,
       "dependencies": {
-        "@babel/helper-string-parser": "^7.25.7",
-        "@babel/helper-validator-identifier": "^7.25.7",
-        "to-fast-properties": "^2.0.0"
+        "@babel/helper-string-parser": "^7.25.9",
+        "@babel/helper-validator-identifier": "^7.25.9"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -245,130 +245,43 @@
       }
     },
     "node_modules/@babel/helper-split-export-declaration/node_modules/@babel/types": {
-      "version": "7.25.7",
-      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.25.7.tgz",
-      "integrity": "sha512-vwIVdXG+j+FOpkwqHRcBgHLYNL7XMkufrlaFvL9o6Ai9sJn9+PdyIL5qa0XzTZw084c+u9LOls53eoZWP/W5WQ==",
+      "version": "7.26.3",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.26.3.tgz",
+      "integrity": "sha512-vN5p+1kl59GVKMvTHt55NzzmYVxprfJD+ql7U9NFIfKCBkYE55LYtS+WtPlaYOyzydrKI8Nezd+aZextrd+FMA==",
       "dev": true,
       "dependencies": {
-        "@babel/helper-string-parser": "^7.25.7",
-        "@babel/helper-validator-identifier": "^7.25.7",
-        "to-fast-properties": "^2.0.0"
+        "@babel/helper-string-parser": "^7.25.9",
+        "@babel/helper-validator-identifier": "^7.25.9"
       },
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/helper-string-parser": {
-      "version": "7.25.7",
-      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.25.7.tgz",
-      "integrity": "sha512-CbkjYdsJNHFk8uqpEkpCvRs3YRp9tY6FmFY7wLMSYuGYkrdUi7r2lc4/wqsvlHoMznX3WJ9IP8giGPq68T/Y6g==",
+      "version": "7.25.9",
+      "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.25.9.tgz",
+      "integrity": "sha512-4A/SCr/2KLd5jrtOMFzaKjVtAei3+2r/NChoBNoZ3EyP/+GlhoaEGoWOZUmFmoITP7zOJyHIMm+DYRd8o3PvHA==",
       "dev": true,
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/helper-validator-identifier": {
-      "version": "7.25.7",
-      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.25.7.tgz",
-      "integrity": "sha512-AM6TzwYqGChO45oiuPqwL2t20/HdMC1rTPAesnBCgPCSF1x3oN9MVUwQV2iyz4xqWrctwK5RNC8LV22kaQCNYg==",
+      "version": "7.25.9",
+      "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.25.9.tgz",
+      "integrity": "sha512-Ed61U6XJc3CVRfkERJWDz4dJwKe7iLmmJsbOGu9wSloNSFttHV0I8g6UAgb7qnK5ly5bGLPd4oXZlxCdANBOWQ==",
       "dev": true,
       "engines": {
         "node": ">=6.9.0"
       }
     },
-    "node_modules/@babel/highlight": {
-      "version": "7.25.7",
-      "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.25.7.tgz",
-      "integrity": "sha512-iYyACpW3iW8Fw+ZybQK+drQre+ns/tKpXbNESfrhNnPLIklLbXr7MYJ6gPEd0iETGLOK+SxMjVvKb/ffmk+FEw==",
-      "dev": true,
-      "dependencies": {
-        "@babel/helper-validator-identifier": "^7.25.7",
-        "chalk": "^2.4.2",
-        "js-tokens": "^4.0.0",
-        "picocolors": "^1.0.0"
-      },
-      "engines": {
-        "node": ">=6.9.0"
-      }
-    },
-    "node_modules/@babel/highlight/node_modules/ansi-styles": {
-      "version": "3.2.1",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz",
-      "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==",
-      "dev": true,
-      "dependencies": {
-        "color-convert": "^1.9.0"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/@babel/highlight/node_modules/chalk": {
-      "version": "2.4.2",
-      "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz",
-      "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==",
-      "dev": true,
-      "dependencies": {
-        "ansi-styles": "^3.2.1",
-        "escape-string-regexp": "^1.0.5",
-        "supports-color": "^5.3.0"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/@babel/highlight/node_modules/color-convert": {
-      "version": "1.9.3",
-      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz",
-      "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==",
-      "dev": true,
-      "dependencies": {
-        "color-name": "1.1.3"
-      }
-    },
-    "node_modules/@babel/highlight/node_modules/color-name": {
-      "version": "1.1.3",
-      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz",
-      "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==",
-      "dev": true
-    },
-    "node_modules/@babel/highlight/node_modules/escape-string-regexp": {
-      "version": "1.0.5",
-      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz",
-      "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==",
-      "dev": true,
-      "engines": {
-        "node": ">=0.8.0"
-      }
-    },
-    "node_modules/@babel/highlight/node_modules/has-flag": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
-      "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==",
-      "dev": true,
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/@babel/highlight/node_modules/supports-color": {
-      "version": "5.5.0",
-      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz",
-      "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==",
-      "dev": true,
-      "dependencies": {
-        "has-flag": "^3.0.0"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
     "node_modules/@babel/parser": {
-      "version": "7.25.7",
-      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.25.7.tgz",
-      "integrity": "sha512-aZn7ETtQsjjGG5HruveUK06cU3Hljuhd9Iojm4M8WWv3wLE6OkE5PWbDUkItmMgegmccaITudyuW5RPYrYlgWw==",
+      "version": "7.26.3",
+      "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.26.3.tgz",
+      "integrity": "sha512-WJ/CvmY8Mea8iDXo6a7RK2wbmJITT5fN3BEkRuFlxVyNx8jOKIIhmC4fSkTcPcf8JyavbBwIe6OpiCOBXt/IcA==",
       "dev": true,
       "dependencies": {
-        "@babel/types": "^7.25.7"
+        "@babel/types": "^7.26.3"
       },
       "bin": {
         "parser": "bin/babel-parser.js"
@@ -378,42 +291,40 @@
       }
     },
     "node_modules/@babel/parser/node_modules/@babel/types": {
-      "version": "7.25.7",
-      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.25.7.tgz",
-      "integrity": "sha512-vwIVdXG+j+FOpkwqHRcBgHLYNL7XMkufrlaFvL9o6Ai9sJn9+PdyIL5qa0XzTZw084c+u9LOls53eoZWP/W5WQ==",
+      "version": "7.26.3",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.26.3.tgz",
+      "integrity": "sha512-vN5p+1kl59GVKMvTHt55NzzmYVxprfJD+ql7U9NFIfKCBkYE55LYtS+WtPlaYOyzydrKI8Nezd+aZextrd+FMA==",
       "dev": true,
       "dependencies": {
-        "@babel/helper-string-parser": "^7.25.7",
-        "@babel/helper-validator-identifier": "^7.25.7",
-        "to-fast-properties": "^2.0.0"
+        "@babel/helper-string-parser": "^7.25.9",
+        "@babel/helper-validator-identifier": "^7.25.9"
       },
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/template": {
-      "version": "7.25.7",
-      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.25.7.tgz",
-      "integrity": "sha512-wRwtAgI3bAS+JGU2upWNL9lSlDcRCqD05BZ1n3X2ONLH1WilFP6O1otQjeMK/1g0pvYcXC7b/qVUB1keofjtZA==",
+      "version": "7.25.9",
+      "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.25.9.tgz",
+      "integrity": "sha512-9DGttpmPvIxBb/2uwpVo3dqJ+O6RooAFOS+lB+xDqoE2PVCE8nfoHMdZLpfCQRLwvohzXISPZcgxt80xLfsuwg==",
       "dev": true,
       "dependencies": {
-        "@babel/code-frame": "^7.25.7",
-        "@babel/parser": "^7.25.7",
-        "@babel/types": "^7.25.7"
+        "@babel/code-frame": "^7.25.9",
+        "@babel/parser": "^7.25.9",
+        "@babel/types": "^7.25.9"
       },
       "engines": {
         "node": ">=6.9.0"
       }
     },
     "node_modules/@babel/template/node_modules/@babel/types": {
-      "version": "7.25.7",
-      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.25.7.tgz",
-      "integrity": "sha512-vwIVdXG+j+FOpkwqHRcBgHLYNL7XMkufrlaFvL9o6Ai9sJn9+PdyIL5qa0XzTZw084c+u9LOls53eoZWP/W5WQ==",
+      "version": "7.26.3",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.26.3.tgz",
+      "integrity": "sha512-vN5p+1kl59GVKMvTHt55NzzmYVxprfJD+ql7U9NFIfKCBkYE55LYtS+WtPlaYOyzydrKI8Nezd+aZextrd+FMA==",
       "dev": true,
       "dependencies": {
-        "@babel/helper-string-parser": "^7.25.7",
-        "@babel/helper-validator-identifier": "^7.25.7",
-        "to-fast-properties": "^2.0.0"
+        "@babel/helper-string-parser": "^7.25.9",
+        "@babel/helper-validator-identifier": "^7.25.9"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -441,12 +352,13 @@
       }
     },
     "node_modules/@babel/traverse/node_modules/@babel/generator": {
-      "version": "7.25.7",
-      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.25.7.tgz",
-      "integrity": "sha512-5Dqpl5fyV9pIAD62yK9P7fcA768uVPUyrQmqpqstHWgMma4feF1x/oFysBCVZLY5wJ2GkMUCdsNDnGZrPoR6rA==",
+      "version": "7.26.3",
+      "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.26.3.tgz",
+      "integrity": "sha512-6FF/urZvD0sTeO7k6/B15pMLC4CHUv1426lzr3N01aHJTl046uCAh9LXW/fzeXXjPNCJ6iABW5XaWOsIZB93aQ==",
       "dev": true,
       "dependencies": {
-        "@babel/types": "^7.25.7",
+        "@babel/parser": "^7.26.3",
+        "@babel/types": "^7.26.3",
         "@jridgewell/gen-mapping": "^0.3.5",
         "@jridgewell/trace-mapping": "^0.3.25",
         "jsesc": "^3.0.2"
@@ -456,14 +368,13 @@
       }
     },
     "node_modules/@babel/traverse/node_modules/@babel/types": {
-      "version": "7.25.7",
-      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.25.7.tgz",
-      "integrity": "sha512-vwIVdXG+j+FOpkwqHRcBgHLYNL7XMkufrlaFvL9o6Ai9sJn9+PdyIL5qa0XzTZw084c+u9LOls53eoZWP/W5WQ==",
+      "version": "7.26.3",
+      "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.26.3.tgz",
+      "integrity": "sha512-vN5p+1kl59GVKMvTHt55NzzmYVxprfJD+ql7U9NFIfKCBkYE55LYtS+WtPlaYOyzydrKI8Nezd+aZextrd+FMA==",
       "dev": true,
       "dependencies": {
-        "@babel/helper-string-parser": "^7.25.7",
-        "@babel/helper-validator-identifier": "^7.25.7",
-        "to-fast-properties": "^2.0.0"
+        "@babel/helper-string-parser": "^7.25.9",
+        "@babel/helper-validator-identifier": "^7.25.9"
       },
       "engines": {
         "node": ">=6.9.0"
@@ -480,9 +391,9 @@
       }
     },
     "node_modules/@babel/traverse/node_modules/jsesc": {
-      "version": "3.0.2",
-      "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.0.2.tgz",
-      "integrity": "sha512-xKqzzWXDttJuOcawBt4KnKHHIf5oQ/Cxax+0PWFG+DFDgHNAdi+TXECADI+RYiFUMmx8792xsMbbgXj4CwnP4g==",
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz",
+      "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==",
       "dev": true,
       "bin": {
         "jsesc": "bin/jsesc"
@@ -504,16 +415,21 @@
         "node": ">=6.9.0"
       }
     },
+    "node_modules/@bytecodealliance/preview2-shim": {
+      "version": "0.17.0",
+      "resolved": "https://registry.npmjs.org/@bytecodealliance/preview2-shim/-/preview2-shim-0.17.0.tgz",
+      "integrity": "sha512-JorcEwe4ud0x5BS/Ar2aQWOQoFzjq/7jcnxYXCvSMh0oRm0dQXzOA+hqLDBnOMks1LLBA7dmiLLsEBl09Yd6iQ==",
+      "dev": true
+    },
     "node_modules/@commitlint/cli": {
-      "version": "19.6.0",
-      "resolved": "https://registry.npmjs.org/@commitlint/cli/-/cli-19.6.0.tgz",
-      "integrity": "sha512-v17BgGD9w5KnthaKxXnEg6KLq6DYiAxyiN44TpiRtqyW8NSq+Kx99mkEG8Qo6uu6cI5eMzMojW2muJxjmPnF8w==",
+      "version": "19.6.1",
+      "resolved": "https://registry.npmjs.org/@commitlint/cli/-/cli-19.6.1.tgz",
+      "integrity": "sha512-8hcyA6ZoHwWXC76BoC8qVOSr8xHy00LZhZpauiD0iO0VYbVhMnED0da85lTfIULxl7Lj4c6vZgF0Wu/ed1+jlQ==",
       "dev": true,
-      "license": "MIT",
       "dependencies": {
         "@commitlint/format": "^19.5.0",
         "@commitlint/lint": "^19.6.0",
-        "@commitlint/load": "^19.5.0",
+        "@commitlint/load": "^19.6.1",
         "@commitlint/read": "^19.5.0",
         "@commitlint/types": "^19.5.0",
         "tinyexec": "^0.3.0",
@@ -526,56 +442,11 @@
         "node": ">=v18"
       }
     },
-    "node_modules/@commitlint/cli/node_modules/cliui": {
-      "version": "8.0.1",
-      "resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz",
-      "integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==",
-      "dev": true,
-      "license": "ISC",
-      "dependencies": {
-        "string-width": "^4.2.0",
-        "strip-ansi": "^6.0.1",
-        "wrap-ansi": "^7.0.0"
-      },
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@commitlint/cli/node_modules/yargs": {
-      "version": "17.7.2",
-      "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz",
-      "integrity": "sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "cliui": "^8.0.1",
-        "escalade": "^3.1.1",
-        "get-caller-file": "^2.0.5",
-        "require-directory": "^2.1.1",
-        "string-width": "^4.2.3",
-        "y18n": "^5.0.5",
-        "yargs-parser": "^21.1.1"
-      },
-      "engines": {
-        "node": ">=12"
-      }
-    },
-    "node_modules/@commitlint/cli/node_modules/yargs-parser": {
-      "version": "21.1.1",
-      "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz",
-      "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==",
-      "dev": true,
-      "license": "ISC",
-      "engines": {
-        "node": ">=12"
-      }
-    },
     "node_modules/@commitlint/config-conventional": {
       "version": "19.6.0",
       "resolved": "https://registry.npmjs.org/@commitlint/config-conventional/-/config-conventional-19.6.0.tgz",
       "integrity": "sha512-DJT40iMnTYtBtUfw9ApbsLZFke1zKh6llITVJ+x9mtpHD08gsNXaIRqHTmwTZL3dNX5+WoyK7pCN/5zswvkBCQ==",
       "dev": true,
-      "license": "MIT",
       "dependencies": {
         "@commitlint/types": "^19.5.0",
         "conventional-changelog-conventionalcommits": "^7.0.2"
@@ -589,7 +460,6 @@
       "resolved": "https://registry.npmjs.org/@commitlint/config-validator/-/config-validator-19.5.0.tgz",
       "integrity": "sha512-CHtj92H5rdhKt17RmgALhfQt95VayrUo2tSqY9g2w+laAXyk7K/Ef6uPm9tn5qSIwSmrLjKaXK9eiNuxmQrDBw==",
       "dev": true,
-      "license": "MIT",
       "dependencies": {
         "@commitlint/types": "^19.5.0",
         "ajv": "^8.11.0"
@@ -598,36 +468,11 @@
         "node": ">=v18"
       }
     },
-    "node_modules/@commitlint/config-validator/node_modules/ajv": {
-      "version": "8.17.1",
-      "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.17.1.tgz",
-      "integrity": "sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "fast-deep-equal": "^3.1.3",
-        "fast-uri": "^3.0.1",
-        "json-schema-traverse": "^1.0.0",
-        "require-from-string": "^2.0.2"
-      },
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/epoberezkin"
-      }
-    },
-    "node_modules/@commitlint/config-validator/node_modules/json-schema-traverse": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz",
-      "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==",
-      "dev": true,
-      "license": "MIT"
-    },
     "node_modules/@commitlint/ensure": {
       "version": "19.5.0",
       "resolved": "https://registry.npmjs.org/@commitlint/ensure/-/ensure-19.5.0.tgz",
       "integrity": "sha512-Kv0pYZeMrdg48bHFEU5KKcccRfKmISSm9MvgIgkpI6m+ohFTB55qZlBW6eYqh/XDfRuIO0x4zSmvBjmOwWTwkg==",
       "dev": true,
-      "license": "MIT",
       "dependencies": {
         "@commitlint/types": "^19.5.0",
         "lodash.camelcase": "^4.3.0",
@@ -645,7 +490,6 @@
       "resolved": "https://registry.npmjs.org/@commitlint/execute-rule/-/execute-rule-19.5.0.tgz",
       "integrity": "sha512-aqyGgytXhl2ejlk+/rfgtwpPexYyri4t8/n4ku6rRJoRhGZpLFMqrZ+YaubeGysCP6oz4mMA34YSTaSOKEeNrg==",
       "dev": true,
-      "license": "MIT",
       "engines": {
         "node": ">=v18"
       }
@@ -655,7 +499,6 @@
       "resolved": "https://registry.npmjs.org/@commitlint/format/-/format-19.5.0.tgz",
       "integrity": "sha512-yNy088miE52stCI3dhG/vvxFo9e4jFkU1Mj3xECfzp/bIS/JUay4491huAlVcffOoMK1cd296q0W92NlER6r3A==",
       "dev": true,
-      "license": "MIT",
       "dependencies": {
         "@commitlint/types": "^19.5.0",
         "chalk": "^5.3.0"
@@ -665,11 +508,10 @@
       }
     },
     "node_modules/@commitlint/format/node_modules/chalk": {
-      "version": "5.3.0",
-      "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.3.0.tgz",
-      "integrity": "sha512-dLitG79d+GV1Nb/VYcCDFivJeK1hiukt9QjRNVOsUtTy1rR1YJsmpGGTZ3qJos+uw7WmWF4wUwBd9jxjocFC2w==",
+      "version": "5.4.1",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.4.1.tgz",
+      "integrity": "sha512-zgVZuo2WcZgfUEmsn6eO3kINexW8RAE4maiQ8QNs8CtpPCSyMiYsULR3HQYkm3w8FIA3SberyMJMSldGsW+U3w==",
       "dev": true,
-      "license": "MIT",
       "engines": {
         "node": "^12.17.0 || ^14.13 || >=16.0.0"
       },
@@ -682,7 +524,6 @@
       "resolved": "https://registry.npmjs.org/@commitlint/is-ignored/-/is-ignored-19.6.0.tgz",
       "integrity": "sha512-Ov6iBgxJQFR9koOupDPHvcHU9keFupDgtB3lObdEZDroiG4jj1rzky60fbQozFKVYRTUdrBGICHG0YVmRuAJmw==",
       "dev": true,
-      "license": "MIT",
       "dependencies": {
         "@commitlint/types": "^19.5.0",
         "semver": "^7.6.0"
@@ -691,25 +532,11 @@
         "node": ">=v18"
       }
     },
-    "node_modules/@commitlint/is-ignored/node_modules/semver": {
-      "version": "7.6.3",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-7.6.3.tgz",
-      "integrity": "sha512-oVekP1cKtI+CTDvHWYFUcMtsK/00wmAEfyqKfNdARm8u1wNVhSgaX7A8d4UuIlUI5e84iEwOhs7ZPYRmzU9U6A==",
-      "dev": true,
-      "license": "ISC",
-      "bin": {
-        "semver": "bin/semver.js"
-      },
-      "engines": {
-        "node": ">=10"
-      }
-    },
     "node_modules/@commitlint/lint": {
       "version": "19.6.0",
       "resolved": "https://registry.npmjs.org/@commitlint/lint/-/lint-19.6.0.tgz",
       "integrity": "sha512-LRo7zDkXtcIrpco9RnfhOKeg8PAnE3oDDoalnrVU/EVaKHYBWYL1DlRR7+3AWn0JiBqD8yKOfetVxJGdEtZ0tg==",
       "dev": true,
-      "license": "MIT",
       "dependencies": {
         "@commitlint/is-ignored": "^19.6.0",
         "@commitlint/parse": "^19.5.0",
@@ -721,11 +548,10 @@
       }
     },
     "node_modules/@commitlint/load": {
-      "version": "19.5.0",
-      "resolved": "https://registry.npmjs.org/@commitlint/load/-/load-19.5.0.tgz",
-      "integrity": "sha512-INOUhkL/qaKqwcTUvCE8iIUf5XHsEPCLY9looJ/ipzi7jtGhgmtH7OOFiNvwYgH7mA8osUWOUDV8t4E2HAi4xA==",
+      "version": "19.6.1",
+      "resolved": "https://registry.npmjs.org/@commitlint/load/-/load-19.6.1.tgz",
+      "integrity": "sha512-kE4mRKWWNju2QpsCWt428XBvUH55OET2N4QKQ0bF85qS/XbsRGG1MiTByDNlEVpEPceMkDr46LNH95DtRwcsfA==",
       "dev": true,
-      "license": "MIT",
       "dependencies": {
         "@commitlint/config-validator": "^19.5.0",
         "@commitlint/execute-rule": "^19.5.0",
@@ -733,7 +559,7 @@
         "@commitlint/types": "^19.5.0",
         "chalk": "^5.3.0",
         "cosmiconfig": "^9.0.0",
-        "cosmiconfig-typescript-loader": "^5.0.0",
+        "cosmiconfig-typescript-loader": "^6.1.0",
         "lodash.isplainobject": "^4.0.6",
         "lodash.merge": "^4.6.2",
         "lodash.uniq": "^4.5.0"
@@ -743,11 +569,10 @@
       }
     },
     "node_modules/@commitlint/load/node_modules/chalk": {
-      "version": "5.3.0",
-      "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.3.0.tgz",
-      "integrity": "sha512-dLitG79d+GV1Nb/VYcCDFivJeK1hiukt9QjRNVOsUtTy1rR1YJsmpGGTZ3qJos+uw7WmWF4wUwBd9jxjocFC2w==",
+      "version": "5.4.1",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.4.1.tgz",
+      "integrity": "sha512-zgVZuo2WcZgfUEmsn6eO3kINexW8RAE4maiQ8QNs8CtpPCSyMiYsULR3HQYkm3w8FIA3SberyMJMSldGsW+U3w==",
       "dev": true,
-      "license": "MIT",
       "engines": {
         "node": "^12.17.0 || ^14.13 || >=16.0.0"
       },
@@ -760,7 +585,6 @@
       "resolved": "https://registry.npmjs.org/@commitlint/message/-/message-19.5.0.tgz",
       "integrity": "sha512-R7AM4YnbxN1Joj1tMfCyBryOC5aNJBdxadTZkuqtWi3Xj0kMdutq16XQwuoGbIzL2Pk62TALV1fZDCv36+JhTQ==",
       "dev": true,
-      "license": "MIT",
       "engines": {
         "node": ">=v18"
       }
@@ -770,7 +594,6 @@
       "resolved": "https://registry.npmjs.org/@commitlint/parse/-/parse-19.5.0.tgz",
       "integrity": "sha512-cZ/IxfAlfWYhAQV0TwcbdR1Oc0/r0Ik1GEessDJ3Lbuma/MRO8FRQX76eurcXtmhJC//rj52ZSZuXUg0oIX0Fw==",
       "dev": true,
-      "license": "MIT",
       "dependencies": {
         "@commitlint/types": "^19.5.0",
         "conventional-changelog-angular": "^7.0.0",
@@ -785,7 +608,6 @@
       "resolved": "https://registry.npmjs.org/@commitlint/read/-/read-19.5.0.tgz",
       "integrity": "sha512-TjS3HLPsLsxFPQj6jou8/CZFAmOP2y+6V4PGYt3ihbQKTY1Jnv0QG28WRKl/d1ha6zLODPZqsxLEov52dhR9BQ==",
       "dev": true,
-      "license": "MIT",
       "dependencies": {
         "@commitlint/top-level": "^19.5.0",
         "@commitlint/types": "^19.5.0",
@@ -802,7 +624,6 @@
       "resolved": "https://registry.npmjs.org/@commitlint/resolve-extends/-/resolve-extends-19.5.0.tgz",
       "integrity": "sha512-CU/GscZhCUsJwcKTJS9Ndh3AKGZTNFIOoQB2n8CmFnizE0VnEuJoum+COW+C1lNABEeqk6ssfc1Kkalm4bDklA==",
       "dev": true,
-      "license": "MIT",
       "dependencies": {
         "@commitlint/config-validator": "^19.5.0",
         "@commitlint/types": "^19.5.0",
@@ -815,22 +636,11 @@
         "node": ">=v18"
       }
     },
-    "node_modules/@commitlint/resolve-extends/node_modules/resolve-from": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-5.0.0.tgz",
-      "integrity": "sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=8"
-      }
-    },
     "node_modules/@commitlint/rules": {
       "version": "19.6.0",
       "resolved": "https://registry.npmjs.org/@commitlint/rules/-/rules-19.6.0.tgz",
       "integrity": "sha512-1f2reW7lbrI0X0ozZMesS/WZxgPa4/wi56vFuJENBmed6mWq5KsheN/nxqnl/C23ioxpPO/PL6tXpiiFy5Bhjw==",
       "dev": true,
-      "license": "MIT",
       "dependencies": {
         "@commitlint/ensure": "^19.5.0",
         "@commitlint/message": "^19.5.0",
@@ -846,7 +656,6 @@
       "resolved": "https://registry.npmjs.org/@commitlint/to-lines/-/to-lines-19.5.0.tgz",
       "integrity": "sha512-R772oj3NHPkodOSRZ9bBVNq224DOxQtNef5Pl8l2M8ZnkkzQfeSTr4uxawV2Sd3ui05dUVzvLNnzenDBO1KBeQ==",
       "dev": true,
-      "license": "MIT",
       "engines": {
         "node": ">=v18"
       }
@@ -856,7 +665,6 @@
       "resolved": "https://registry.npmjs.org/@commitlint/top-level/-/top-level-19.5.0.tgz",
       "integrity": "sha512-IP1YLmGAk0yWrImPRRc578I3dDUI5A2UBJx9FbSOjxe9sTlzFiwVJ+zeMLgAtHMtGZsC8LUnzmW1qRemkFU4ng==",
       "dev": true,
-      "license": "MIT",
       "dependencies": {
         "find-up": "^7.0.0"
       },
@@ -864,101 +672,11 @@
         "node": ">=v18"
       }
     },
-    "node_modules/@commitlint/top-level/node_modules/find-up": {
-      "version": "7.0.0",
-      "resolved": "https://registry.npmjs.org/find-up/-/find-up-7.0.0.tgz",
-      "integrity": "sha512-YyZM99iHrqLKjmt4LJDj58KI+fYyufRLBSYcqycxf//KpBk9FoewoGX0450m9nB44qrZnovzC2oeP5hUibxc/g==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "locate-path": "^7.2.0",
-        "path-exists": "^5.0.0",
-        "unicorn-magic": "^0.1.0"
-      },
-      "engines": {
-        "node": ">=18"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/@commitlint/top-level/node_modules/locate-path": {
-      "version": "7.2.0",
-      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-7.2.0.tgz",
-      "integrity": "sha512-gvVijfZvn7R+2qyPX8mAuKcFGDf6Nc61GdvGafQsHL0sBIxfKzA+usWn4GFC/bk+QdwPUD4kWFJLhElipq+0VA==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "p-locate": "^6.0.0"
-      },
-      "engines": {
-        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/@commitlint/top-level/node_modules/p-limit": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-4.0.0.tgz",
-      "integrity": "sha512-5b0R4txpzjPWVw/cXXUResoD4hb6U/x9BH08L7nw+GN1sezDzPdxeRvpc9c433fZhBan/wusjbCsqwqm4EIBIQ==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "yocto-queue": "^1.0.0"
-      },
-      "engines": {
-        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/@commitlint/top-level/node_modules/p-locate": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-6.0.0.tgz",
-      "integrity": "sha512-wPrq66Llhl7/4AGC6I+cqxT07LhXvWL08LNXz1fENOw0Ap4sRZZ/gZpTTJ5jpurzzzfS2W/Ge9BY3LgLjCShcw==",
-      "dev": true,
-      "license": "MIT",
-      "dependencies": {
-        "p-limit": "^4.0.0"
-      },
-      "engines": {
-        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
-    "node_modules/@commitlint/top-level/node_modules/path-exists": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-5.0.0.tgz",
-      "integrity": "sha512-RjhtfwJOxzcFmNOi6ltcbcu4Iu+FL3zEj83dk4kAS+fVpTxXLO1b38RvJgT/0QwvV/L3aY9TAnyv0EOqW4GoMQ==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
-      }
-    },
-    "node_modules/@commitlint/top-level/node_modules/yocto-queue": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-1.1.1.tgz",
-      "integrity": "sha512-b4JR1PFR10y1mKjhHY9LaGo6tmrgjit7hxVIeAmyMw3jegXR4dhYqLaQF5zMXZxY7tLpMyJeLjr1C4rLmkVe8g==",
-      "dev": true,
-      "license": "MIT",
-      "engines": {
-        "node": ">=12.20"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/sindresorhus"
-      }
-    },
     "node_modules/@commitlint/types": {
       "version": "19.5.0",
       "resolved": "https://registry.npmjs.org/@commitlint/types/-/types-19.5.0.tgz",
       "integrity": "sha512-DSHae2obMSMkAtTBSOulg5X7/z+rGLxcXQIkg3OmWvY6wifojge5uVMydfhUvs7yQj+V7jNmRZ2Xzl8GJyqRgg==",
       "dev": true,
-      "license": "MIT",
       "dependencies": {
         "@types/conventional-commits-parser": "^5.0.0",
         "chalk": "^5.3.0"
@@ -968,11 +686,10 @@
       }
     },
     "node_modules/@commitlint/types/node_modules/chalk": {
-      "version": "5.3.0",
-      "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.3.0.tgz",
-      "integrity": "sha512-dLitG79d+GV1Nb/VYcCDFivJeK1hiukt9QjRNVOsUtTy1rR1YJsmpGGTZ3qJos+uw7WmWF4wUwBd9jxjocFC2w==",
+      "version": "5.4.1",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.4.1.tgz",
+      "integrity": "sha512-zgVZuo2WcZgfUEmsn6eO3kINexW8RAE4maiQ8QNs8CtpPCSyMiYsULR3HQYkm3w8FIA3SberyMJMSldGsW+U3w==",
       "dev": true,
-      "license": "MIT",
       "engines": {
         "node": "^12.17.0 || ^14.13 || >=16.0.0"
       },
@@ -993,24 +710,27 @@
       }
     },
     "node_modules/@eslint-community/eslint-utils": {
-      "version": "4.4.0",
-      "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.4.0.tgz",
-      "integrity": "sha512-1/sA4dwrzBAyeUoQ6oxahHKmrZvsnLCg4RfxW3ZFGGmQkSNQPFNLV9CUEFQP1x9EYXHTo5p6xdhZM1Ne9p/AfA==",
+      "version": "4.4.1",
+      "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.4.1.tgz",
+      "integrity": "sha512-s3O3waFUrMV8P/XaF/+ZTp1X9XBZW1a4B97ZnjQF2KYWaFD2A8KyFBsrsfSjEmjn3RGWAIuvlneuZm3CUK3jbA==",
       "dev": true,
       "dependencies": {
-        "eslint-visitor-keys": "^3.3.0"
+        "eslint-visitor-keys": "^3.4.3"
       },
       "engines": {
         "node": "^12.22.0 || ^14.17.0 || >=16.0.0"
       },
+      "funding": {
+        "url": "https://opencollective.com/eslint"
+      },
       "peerDependencies": {
         "eslint": "^6.0.0 || ^7.0.0 || >=8.0.0"
       }
     },
     "node_modules/@eslint-community/regexpp": {
-      "version": "4.11.1",
-      "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.11.1.tgz",
-      "integrity": "sha512-m4DVN9ZqskZoLU5GlWZadwDnYo3vAEydiUayB9widCl9ffWx2IvPnp6n3on5rJmziJSw9Bv+Z3ChDVdMwXCY8Q==",
+      "version": "4.12.1",
+      "resolved": "https://registry.npmjs.org/@eslint-community/regexpp/-/regexpp-4.12.1.tgz",
+      "integrity": "sha512-CCZCDJuduB9OUkFkY2IgppNZMi2lBQgD2qzwXkEia16cge2pijY/aXi96CJMquDMn3nJdlPV1A5KrJEXwfLNzQ==",
       "dev": true,
       "engines": {
         "node": "^12.0.0 || ^14.0.0 || >=16.0.0"
@@ -1039,6 +759,22 @@
         "url": "https://opencollective.com/eslint"
       }
     },
+    "node_modules/@eslint/eslintrc/node_modules/ajv": {
+      "version": "6.12.6",
+      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
+      "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",
+      "dev": true,
+      "dependencies": {
+        "fast-deep-equal": "^3.1.1",
+        "fast-json-stable-stringify": "^2.0.0",
+        "json-schema-traverse": "^0.4.1",
+        "uri-js": "^4.2.2"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/epoberezkin"
+      }
+    },
     "node_modules/@eslint/eslintrc/node_modules/brace-expansion": {
       "version": "1.1.11",
       "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
@@ -1064,6 +800,12 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/@eslint/eslintrc/node_modules/json-schema-traverse": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
+      "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",
+      "dev": true
+    },
     "node_modules/@eslint/eslintrc/node_modules/minimatch": {
       "version": "3.1.2",
       "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
@@ -1960,9 +1702,9 @@
       "dev": true
     },
     "node_modules/@jridgewell/gen-mapping": {
-      "version": "0.3.5",
-      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.5.tgz",
-      "integrity": "sha512-IzL8ZoEDIBRWEzlCcRhOaCupYyN5gdIK+Q6fbFdPDg6HqX6jpkItn7DFIpW9LQzXG6Df9sA7+OKnq0qlz/GaQg==",
+      "version": "0.3.8",
+      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.8.tgz",
+      "integrity": "sha512-imAbBGkb+ebQyxKgzv5Hu2nmROxoDOXHh80evxdoXNOrvAnVx7zimzc1Oo5h9RlfV4vPXaE2iM5pOFbvOCClWA==",
       "dev": true,
       "dependencies": {
         "@jridgewell/set-array": "^1.2.1",
@@ -2043,9 +1785,9 @@
       }
     },
     "node_modules/@metamask/eth-sig-util/node_modules/bn.js": {
-      "version": "4.12.0",
-      "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.0.tgz",
-      "integrity": "sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==",
+      "version": "4.12.1",
+      "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.1.tgz",
+      "integrity": "sha512-k8TVBiPkPJT9uHLdOKfFpqcfprwBFOAAXXozRubr7R7PfIuKvQlzcI4M0pALeqXN09vdaMbUdUj+pass+uULAg==",
       "dev": true
     },
     "node_modules/@metamask/eth-sig-util/node_modules/ethereumjs-util": {
@@ -2135,81 +1877,81 @@
       }
     },
     "node_modules/@nomicfoundation/edr": {
-      "version": "0.6.3",
-      "resolved": "https://registry.npmjs.org/@nomicfoundation/edr/-/edr-0.6.3.tgz",
-      "integrity": "sha512-hThe5ORR75WFYTXKL0K2AyLDxkTMrG+VQ1yL9BhQYsuh3OIH+3yNDxMz2LjfvrpOrMmJ4kk5NKdFewpqDojjXQ==",
+      "version": "0.6.5",
+      "resolved": "https://registry.npmjs.org/@nomicfoundation/edr/-/edr-0.6.5.tgz",
+      "integrity": "sha512-tAqMslLP+/2b2sZP4qe9AuGxG3OkQ5gGgHE4isUuq6dUVjwCRPFhAOhpdFl+OjY5P3yEv3hmq9HjUGRa2VNjng==",
       "dev": true,
       "dependencies": {
-        "@nomicfoundation/edr-darwin-arm64": "0.6.3",
-        "@nomicfoundation/edr-darwin-x64": "0.6.3",
-        "@nomicfoundation/edr-linux-arm64-gnu": "0.6.3",
-        "@nomicfoundation/edr-linux-arm64-musl": "0.6.3",
-        "@nomicfoundation/edr-linux-x64-gnu": "0.6.3",
-        "@nomicfoundation/edr-linux-x64-musl": "0.6.3",
-        "@nomicfoundation/edr-win32-x64-msvc": "0.6.3"
+        "@nomicfoundation/edr-darwin-arm64": "0.6.5",
+        "@nomicfoundation/edr-darwin-x64": "0.6.5",
+        "@nomicfoundation/edr-linux-arm64-gnu": "0.6.5",
+        "@nomicfoundation/edr-linux-arm64-musl": "0.6.5",
+        "@nomicfoundation/edr-linux-x64-gnu": "0.6.5",
+        "@nomicfoundation/edr-linux-x64-musl": "0.6.5",
+        "@nomicfoundation/edr-win32-x64-msvc": "0.6.5"
       },
       "engines": {
         "node": ">= 18"
       }
     },
     "node_modules/@nomicfoundation/edr-darwin-arm64": {
-      "version": "0.6.3",
-      "resolved": "https://registry.npmjs.org/@nomicfoundation/edr-darwin-arm64/-/edr-darwin-arm64-0.6.3.tgz",
-      "integrity": "sha512-hqtI7tYDqKG5PDmZ//Z65EH5cgH8VL/SAAu50rpHP7WAVfJWkOCcYbecywwF6nhHdonJbRTDGAeG1/+VOy6zew==",
+      "version": "0.6.5",
+      "resolved": "https://registry.npmjs.org/@nomicfoundation/edr-darwin-arm64/-/edr-darwin-arm64-0.6.5.tgz",
+      "integrity": "sha512-A9zCCbbNxBpLgjS1kEJSpqxIvGGAX4cYbpDYCU2f3jVqOwaZ/NU761y1SvuCRVpOwhoCXqByN9b7HPpHi0L4hw==",
       "dev": true,
       "engines": {
         "node": ">= 18"
       }
     },
     "node_modules/@nomicfoundation/edr-darwin-x64": {
-      "version": "0.6.3",
-      "resolved": "https://registry.npmjs.org/@nomicfoundation/edr-darwin-x64/-/edr-darwin-x64-0.6.3.tgz",
-      "integrity": "sha512-4fGi79/lyOlRUORhCYsYb3sWqRHuHT7qqzyZfZuNOn8llaxmT1k36xNmvpyg37R8SzjnhT/DzoukSJrs23Ip9Q==",
+      "version": "0.6.5",
+      "resolved": "https://registry.npmjs.org/@nomicfoundation/edr-darwin-x64/-/edr-darwin-x64-0.6.5.tgz",
+      "integrity": "sha512-x3zBY/v3R0modR5CzlL6qMfFMdgwd6oHrWpTkuuXnPFOX8SU31qq87/230f4szM+ukGK8Hi+mNq7Ro2VF4Fj+w==",
       "dev": true,
       "engines": {
         "node": ">= 18"
       }
     },
     "node_modules/@nomicfoundation/edr-linux-arm64-gnu": {
-      "version": "0.6.3",
-      "resolved": "https://registry.npmjs.org/@nomicfoundation/edr-linux-arm64-gnu/-/edr-linux-arm64-gnu-0.6.3.tgz",
-      "integrity": "sha512-yFFTvGFMhfAvQ1Z2itUh1jpoUA+mVROyVELcaxjIq8fyg602lQmbS+NXkhQ+oaeDgJ+06mSENrHBg4fcfRf9cw==",
+      "version": "0.6.5",
+      "resolved": "https://registry.npmjs.org/@nomicfoundation/edr-linux-arm64-gnu/-/edr-linux-arm64-gnu-0.6.5.tgz",
+      "integrity": "sha512-HGpB8f1h8ogqPHTyUpyPRKZxUk2lu061g97dOQ/W4CxevI0s/qiw5DB3U3smLvSnBHKOzYS1jkxlMeGN01ky7A==",
       "dev": true,
       "engines": {
         "node": ">= 18"
       }
     },
     "node_modules/@nomicfoundation/edr-linux-arm64-musl": {
-      "version": "0.6.3",
-      "resolved": "https://registry.npmjs.org/@nomicfoundation/edr-linux-arm64-musl/-/edr-linux-arm64-musl-0.6.3.tgz",
-      "integrity": "sha512-pOKmd0Fa3a6BHg5qbjbl/jMRELVi9oazbfiuU7Bvgn/dpTK+ID3jwT0SXiuC2zxjmPByWgXL6G9XRf5BPAM2rQ==",
+      "version": "0.6.5",
+      "resolved": "https://registry.npmjs.org/@nomicfoundation/edr-linux-arm64-musl/-/edr-linux-arm64-musl-0.6.5.tgz",
+      "integrity": "sha512-ESvJM5Y9XC03fZg9KaQg3Hl+mbx7dsSkTIAndoJS7X2SyakpL9KZpOSYrDk135o8s9P9lYJdPOyiq+Sh+XoCbQ==",
       "dev": true,
       "engines": {
         "node": ">= 18"
       }
     },
     "node_modules/@nomicfoundation/edr-linux-x64-gnu": {
-      "version": "0.6.3",
-      "resolved": "https://registry.npmjs.org/@nomicfoundation/edr-linux-x64-gnu/-/edr-linux-x64-gnu-0.6.3.tgz",
-      "integrity": "sha512-3AUferhkLIXtLV63w5GjpHttzdxZ36i656XMy+pkBZbbiqnzIVeKWg6DJv1A94fQY16gB4gqj9CLq4CWvbNN6w==",
+      "version": "0.6.5",
+      "resolved": "https://registry.npmjs.org/@nomicfoundation/edr-linux-x64-gnu/-/edr-linux-x64-gnu-0.6.5.tgz",
+      "integrity": "sha512-HCM1usyAR1Ew6RYf5AkMYGvHBy64cPA5NMbaeY72r0mpKaH3txiMyydcHibByOGdQ8iFLWpyUdpl1egotw+Tgg==",
       "dev": true,
       "engines": {
         "node": ">= 18"
       }
     },
     "node_modules/@nomicfoundation/edr-linux-x64-musl": {
-      "version": "0.6.3",
-      "resolved": "https://registry.npmjs.org/@nomicfoundation/edr-linux-x64-musl/-/edr-linux-x64-musl-0.6.3.tgz",
-      "integrity": "sha512-fr6bD872WIBXe9YnTDi0CzYepMcYRgSnkVqn0yK4wRnIvKrloWhxXNVY45GVIl51aNZguBnvoA4WEt6HIazs3A==",
+      "version": "0.6.5",
+      "resolved": "https://registry.npmjs.org/@nomicfoundation/edr-linux-x64-musl/-/edr-linux-x64-musl-0.6.5.tgz",
+      "integrity": "sha512-nB2uFRyczhAvWUH7NjCsIO6rHnQrof3xcCe6Mpmnzfl2PYcGyxN7iO4ZMmRcQS7R1Y670VH6+8ZBiRn8k43m7A==",
       "dev": true,
       "engines": {
         "node": ">= 18"
       }
     },
     "node_modules/@nomicfoundation/edr-win32-x64-msvc": {
-      "version": "0.6.3",
-      "resolved": "https://registry.npmjs.org/@nomicfoundation/edr-win32-x64-msvc/-/edr-win32-x64-msvc-0.6.3.tgz",
-      "integrity": "sha512-sn34MvN1ajw2Oq1+Drpxej78Z0HfIzI4p4WlolupAV9dOZKzp2JAIQeLVfZpjIFbF3zuyxLPP4dUBrQoFPEqhA==",
+      "version": "0.6.5",
+      "resolved": "https://registry.npmjs.org/@nomicfoundation/edr-win32-x64-msvc/-/edr-win32-x64-msvc-0.6.5.tgz",
+      "integrity": "sha512-B9QD/4DSSCFtWicO8A3BrsnitO1FPv7axB62wq5Q+qeJ50yJlTmyeGY3cw62gWItdvy2mh3fRM6L1LpnHiB77A==",
       "dev": true,
       "engines": {
         "node": ">= 18"
@@ -2313,14 +2055,14 @@
       }
     },
     "node_modules/@nomicfoundation/hardhat-ignition": {
-      "version": "0.15.6",
-      "resolved": "https://registry.npmjs.org/@nomicfoundation/hardhat-ignition/-/hardhat-ignition-0.15.6.tgz",
-      "integrity": "sha512-PcMf4xlYvwHYej2jcuOd/rBNNMM5FO11vh9c+MF8+m7NxV4b6NOameL3uscoD7ghg0H2GNgnGXgQ67ryRqtdIQ==",
+      "version": "0.15.9",
+      "resolved": "https://registry.npmjs.org/@nomicfoundation/hardhat-ignition/-/hardhat-ignition-0.15.9.tgz",
+      "integrity": "sha512-lSWqhaDOBt6gsqMadkRLvH6HdoFV1v8/bx7z+12cghaOloVwwn48CPoTH2iXXnkqilPGw8rdH5eVTE6UM+2v6Q==",
       "dev": true,
       "peer": true,
       "dependencies": {
-        "@nomicfoundation/ignition-core": "^0.15.6",
-        "@nomicfoundation/ignition-ui": "^0.15.6",
+        "@nomicfoundation/ignition-core": "^0.15.9",
+        "@nomicfoundation/ignition-ui": "^0.15.9",
         "chalk": "^4.0.0",
         "debug": "^4.3.2",
         "fs-extra": "^10.0.0",
@@ -2333,15 +2075,15 @@
       }
     },
     "node_modules/@nomicfoundation/hardhat-ignition-ethers": {
-      "version": "0.15.6",
-      "resolved": "https://registry.npmjs.org/@nomicfoundation/hardhat-ignition-ethers/-/hardhat-ignition-ethers-0.15.6.tgz",
-      "integrity": "sha512-+jXDGWdfkuIGm0W+aFEZ9SLQz2MIj7Cf4j7ANTXUIIbK8sUkvnVOhTTAQEdqa0KgGEb45XS88BPg0w8fixwrXQ==",
+      "version": "0.15.9",
+      "resolved": "https://registry.npmjs.org/@nomicfoundation/hardhat-ignition-ethers/-/hardhat-ignition-ethers-0.15.9.tgz",
+      "integrity": "sha512-9PwwgLv3z2ec3B26mK0IjiFezHFFBcBcs1qKaRu8SanARE4b7RvrfiLIy8ZXE7HaxgPt32kSsQzehhzAwAIj1Q==",
       "dev": true,
       "peer": true,
       "peerDependencies": {
         "@nomicfoundation/hardhat-ethers": "^3.0.4",
-        "@nomicfoundation/hardhat-ignition": "^0.15.6",
-        "@nomicfoundation/ignition-core": "^0.15.6",
+        "@nomicfoundation/hardhat-ignition": "^0.15.9",
+        "@nomicfoundation/ignition-core": "^0.15.9",
         "ethers": "^6.7.0",
         "hardhat": "^2.18.0"
       }
@@ -2385,17 +2127,17 @@
       }
     },
     "node_modules/@nomicfoundation/hardhat-verify": {
-      "version": "2.0.11",
-      "resolved": "https://registry.npmjs.org/@nomicfoundation/hardhat-verify/-/hardhat-verify-2.0.11.tgz",
-      "integrity": "sha512-lGIo4dNjVQFdsiEgZp3KP6ntLiF7xJEJsbNHfSyIiFCyI0Yv0518ElsFtMC5uCuHEChiBBMrib9jWQvHHT+X3Q==",
+      "version": "2.0.12",
+      "resolved": "https://registry.npmjs.org/@nomicfoundation/hardhat-verify/-/hardhat-verify-2.0.12.tgz",
+      "integrity": "sha512-Lg3Nu7DCXASQRVI/YysjuAX2z8jwOCbS0w5tz2HalWGSTZThqA0v9N0v0psHbKNqzPJa8bNOeapIVSziyJTnAg==",
       "dev": true,
       "dependencies": {
         "@ethersproject/abi": "^5.1.2",
         "@ethersproject/address": "^5.0.2",
         "cbor": "^8.1.0",
-        "chalk": "^2.4.2",
         "debug": "^4.1.1",
         "lodash.clonedeep": "^4.5.0",
+        "picocolors": "^1.1.0",
         "semver": "^6.3.0",
         "table": "^6.8.0",
         "undici": "^5.14.0"
@@ -2404,81 +2146,19 @@
         "hardhat": "^2.0.4"
       }
     },
-    "node_modules/@nomicfoundation/hardhat-verify/node_modules/ansi-styles": {
-      "version": "3.2.1",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz",
-      "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==",
-      "dev": true,
-      "dependencies": {
-        "color-convert": "^1.9.0"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/@nomicfoundation/hardhat-verify/node_modules/chalk": {
-      "version": "2.4.2",
-      "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz",
-      "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==",
-      "dev": true,
-      "dependencies": {
-        "ansi-styles": "^3.2.1",
-        "escape-string-regexp": "^1.0.5",
-        "supports-color": "^5.3.0"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/@nomicfoundation/hardhat-verify/node_modules/color-convert": {
-      "version": "1.9.3",
-      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz",
-      "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==",
-      "dev": true,
-      "dependencies": {
-        "color-name": "1.1.3"
-      }
-    },
-    "node_modules/@nomicfoundation/hardhat-verify/node_modules/color-name": {
-      "version": "1.1.3",
-      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz",
-      "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==",
-      "dev": true
-    },
-    "node_modules/@nomicfoundation/hardhat-verify/node_modules/escape-string-regexp": {
-      "version": "1.0.5",
-      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz",
-      "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==",
-      "dev": true,
-      "engines": {
-        "node": ">=0.8.0"
-      }
-    },
-    "node_modules/@nomicfoundation/hardhat-verify/node_modules/has-flag": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
-      "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==",
-      "dev": true,
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/@nomicfoundation/hardhat-verify/node_modules/supports-color": {
-      "version": "5.5.0",
-      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz",
-      "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==",
+    "node_modules/@nomicfoundation/hardhat-verify/node_modules/semver": {
+      "version": "6.3.1",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
+      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
       "dev": true,
-      "dependencies": {
-        "has-flag": "^3.0.0"
-      },
-      "engines": {
-        "node": ">=4"
+      "bin": {
+        "semver": "bin/semver.js"
       }
     },
     "node_modules/@nomicfoundation/ignition-core": {
-      "version": "0.15.6",
-      "resolved": "https://registry.npmjs.org/@nomicfoundation/ignition-core/-/ignition-core-0.15.6.tgz",
-      "integrity": "sha512-9eD1NJ2G4vh7IleRNmCz/3bGVoNEPYrRVPqx0uvWzG2xD226GGQcTgtK+NovyxsQOE/AcLF1xjX3/+8kNc1sSg==",
+      "version": "0.15.9",
+      "resolved": "https://registry.npmjs.org/@nomicfoundation/ignition-core/-/ignition-core-0.15.9.tgz",
+      "integrity": "sha512-X8W+7UP/UQPorpHUnGvA1OdsEr/edGi8tDpNwEqzaLm83FMZVbRWdOsr3vNICHN2XMzNY/xIm18Cx7xGKL2PQw==",
       "dev": true,
       "peer": true,
       "dependencies": {
@@ -2531,111 +2211,19 @@
       }
     },
     "node_modules/@nomicfoundation/ignition-ui": {
-      "version": "0.15.6",
-      "resolved": "https://registry.npmjs.org/@nomicfoundation/ignition-ui/-/ignition-ui-0.15.6.tgz",
-      "integrity": "sha512-CW14g/BVcGZtBSF1K4eZSCjyvtz1fr9yppkFKC+Z0+sm/lXFWpwcwaVN+UiugQ/9wz9HAfSk4Y0gagdAMiSs0w==",
+      "version": "0.15.9",
+      "resolved": "https://registry.npmjs.org/@nomicfoundation/ignition-ui/-/ignition-ui-0.15.9.tgz",
+      "integrity": "sha512-8lzbT7gpJ5PoowPQDQilkwdyqBviUKDMoHp/5rhgnwG1bDslnCS+Lxuo6s9R2akWu9LtEL14dNyqQb6WsURTag==",
       "dev": true,
       "peer": true
     },
     "node_modules/@nomicfoundation/slang": {
-      "version": "0.17.0",
-      "resolved": "https://registry.npmjs.org/@nomicfoundation/slang/-/slang-0.17.0.tgz",
-      "integrity": "sha512-1GlkGRcGpVnjFw9Z1vvDKOKo2mzparFt7qrl2pDxWp+jrVtlvej98yCMX52pVyrYE7ZeOSZFnx/DtsSgoukStQ==",
-      "dev": true,
-      "dependencies": {
-        "@nomicfoundation/slang-darwin-arm64": "0.17.0",
-        "@nomicfoundation/slang-darwin-x64": "0.17.0",
-        "@nomicfoundation/slang-linux-arm64-gnu": "0.17.0",
-        "@nomicfoundation/slang-linux-arm64-musl": "0.17.0",
-        "@nomicfoundation/slang-linux-x64-gnu": "0.17.0",
-        "@nomicfoundation/slang-linux-x64-musl": "0.17.0",
-        "@nomicfoundation/slang-win32-arm64-msvc": "0.17.0",
-        "@nomicfoundation/slang-win32-ia32-msvc": "0.17.0",
-        "@nomicfoundation/slang-win32-x64-msvc": "0.17.0"
-      },
-      "engines": {
-        "node": ">= 10"
-      }
-    },
-    "node_modules/@nomicfoundation/slang-darwin-arm64": {
-      "version": "0.17.0",
-      "resolved": "https://registry.npmjs.org/@nomicfoundation/slang-darwin-arm64/-/slang-darwin-arm64-0.17.0.tgz",
-      "integrity": "sha512-O0q94EUtoWy9A5kOTOa9/khtxXDYnLqmuda9pQELurSiwbQEVCPQL8kb34VbOW+ifdre66JM/05Xw9JWhIZ9sA==",
-      "dev": true,
-      "engines": {
-        "node": ">= 10"
-      }
-    },
-    "node_modules/@nomicfoundation/slang-darwin-x64": {
-      "version": "0.17.0",
-      "resolved": "https://registry.npmjs.org/@nomicfoundation/slang-darwin-x64/-/slang-darwin-x64-0.17.0.tgz",
-      "integrity": "sha512-IaDbHzvT08sBK2HyGzonWhq1uu8IxdjmTqAWHr25Oh/PYnamdi8u4qchZXXYKz/DHLoYN3vIpBXoqLQIomhD/g==",
-      "dev": true,
-      "engines": {
-        "node": ">= 10"
-      }
-    },
-    "node_modules/@nomicfoundation/slang-linux-arm64-gnu": {
-      "version": "0.17.0",
-      "resolved": "https://registry.npmjs.org/@nomicfoundation/slang-linux-arm64-gnu/-/slang-linux-arm64-gnu-0.17.0.tgz",
-      "integrity": "sha512-Lj4anvOsQZxs1SycG8VyT2Rl2oqIhyLSUCgGepTt3CiJ/bM+8r8bLJIgh8vKkki4BWz49YsYIgaJB2IPv8FFTw==",
-      "dev": true,
-      "engines": {
-        "node": ">= 10"
-      }
-    },
-    "node_modules/@nomicfoundation/slang-linux-arm64-musl": {
-      "version": "0.17.0",
-      "resolved": "https://registry.npmjs.org/@nomicfoundation/slang-linux-arm64-musl/-/slang-linux-arm64-musl-0.17.0.tgz",
-      "integrity": "sha512-/xkTCa9d5SIWUBQE3BmLqDFfJRr4yUBwbl4ynPiGUpRXrD69cs6pWKkwjwz/FdBpXqVo36I+zY95qzoTj/YhOA==",
-      "dev": true,
-      "engines": {
-        "node": ">= 10"
-      }
-    },
-    "node_modules/@nomicfoundation/slang-linux-x64-gnu": {
-      "version": "0.17.0",
-      "resolved": "https://registry.npmjs.org/@nomicfoundation/slang-linux-x64-gnu/-/slang-linux-x64-gnu-0.17.0.tgz",
-      "integrity": "sha512-oe5IO5vntOqYvTd67deCHPIWuSuWm6aYtT2/0Kqz2/VLtGz4ClEulBSRwfnNzBVtw2nksWipE1w8BzhImI7Syg==",
-      "dev": true,
-      "engines": {
-        "node": ">= 10"
-      }
-    },
-    "node_modules/@nomicfoundation/slang-linux-x64-musl": {
-      "version": "0.17.0",
-      "resolved": "https://registry.npmjs.org/@nomicfoundation/slang-linux-x64-musl/-/slang-linux-x64-musl-0.17.0.tgz",
-      "integrity": "sha512-PpYCI5K/kgLAMXaPY0V4VST5gCDprEOh7z/47tbI8kJQumI5odjsj/Cs8MpTo7/uRH6flKYbVNgUzcocWVYrAQ==",
-      "dev": true,
-      "engines": {
-        "node": ">= 10"
-      }
-    },
-    "node_modules/@nomicfoundation/slang-win32-arm64-msvc": {
-      "version": "0.17.0",
-      "resolved": "https://registry.npmjs.org/@nomicfoundation/slang-win32-arm64-msvc/-/slang-win32-arm64-msvc-0.17.0.tgz",
-      "integrity": "sha512-u/Mkf7OjokdBilP7QOJj6QYJU4/mjkbKnTX21wLyCIzeVWS7yafRPYpBycKIBj2pRRZ6ceAY5EqRpb0aiCq+0Q==",
-      "dev": true,
-      "engines": {
-        "node": ">= 10"
-      }
-    },
-    "node_modules/@nomicfoundation/slang-win32-ia32-msvc": {
-      "version": "0.17.0",
-      "resolved": "https://registry.npmjs.org/@nomicfoundation/slang-win32-ia32-msvc/-/slang-win32-ia32-msvc-0.17.0.tgz",
-      "integrity": "sha512-XJBVQfNnZQUv0tP2JSJ573S+pmgrLWgqSZOGaMllnB/TL1gRci4Z7dYRJUF2s82GlRJE+FHSI2Ro6JISKmlXCg==",
-      "dev": true,
-      "engines": {
-        "node": ">= 10"
-      }
-    },
-    "node_modules/@nomicfoundation/slang-win32-x64-msvc": {
-      "version": "0.17.0",
-      "resolved": "https://registry.npmjs.org/@nomicfoundation/slang-win32-x64-msvc/-/slang-win32-x64-msvc-0.17.0.tgz",
-      "integrity": "sha512-zPGsAeiTfqfPNYHD8BfrahQmYzA78ZraoHKTGraq/1xwJwzBK4bu/NtvVA4pJjBV+B4L6DCxVhSbpn40q26JQA==",
-      "dev": true,
-      "engines": {
-        "node": ">= 10"
+      "version": "0.18.3",
+      "resolved": "https://registry.npmjs.org/@nomicfoundation/slang/-/slang-0.18.3.tgz",
+      "integrity": "sha512-YqAWgckqbHM0/CZxi9Nlf4hjk9wUNLC9ngWCWBiqMxPIZmzsVKYuChdlrfeBPQyvQQBoOhbx+7C1005kLVQDZQ==",
+      "dev": true,
+      "dependencies": {
+        "@bytecodealliance/preview2-shim": "0.17.0"
       }
     },
     "node_modules/@nomicfoundation/solidity-analyzer": {
@@ -2736,18 +2324,6 @@
         "semver": "^7.3.5"
       }
     },
-    "node_modules/@npmcli/fs/node_modules/semver": {
-      "version": "7.6.3",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-7.6.3.tgz",
-      "integrity": "sha512-oVekP1cKtI+CTDvHWYFUcMtsK/00wmAEfyqKfNdARm8u1wNVhSgaX7A8d4UuIlUI5e84iEwOhs7ZPYRmzU9U6A==",
-      "optional": true,
-      "bin": {
-        "semver": "bin/semver.js"
-      },
-      "engines": {
-        "node": ">=10"
-      }
-    },
     "node_modules/@npmcli/move-file": {
       "version": "1.1.2",
       "resolved": "https://registry.npmjs.org/@npmcli/move-file/-/move-file-1.1.2.tgz",
@@ -2762,6 +2338,49 @@
         "node": ">=10"
       }
     },
+    "node_modules/@npmcli/move-file/node_modules/brace-expansion": {
+      "version": "1.1.11",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
+      "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
+      "optional": true,
+      "dependencies": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "node_modules/@npmcli/move-file/node_modules/glob": {
+      "version": "7.2.3",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz",
+      "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==",
+      "deprecated": "Glob versions prior to v9 are no longer supported",
+      "optional": true,
+      "dependencies": {
+        "fs.realpath": "^1.0.0",
+        "inflight": "^1.0.4",
+        "inherits": "2",
+        "minimatch": "^3.1.1",
+        "once": "^1.3.0",
+        "path-is-absolute": "^1.0.0"
+      },
+      "engines": {
+        "node": "*"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/@npmcli/move-file/node_modules/minimatch": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
+      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+      "optional": true,
+      "dependencies": {
+        "brace-expansion": "^1.1.7"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
     "node_modules/@npmcli/move-file/node_modules/mkdirp": {
       "version": "1.0.4",
       "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-1.0.4.tgz",
@@ -2805,9 +2424,9 @@
       }
     },
     "node_modules/@openzeppelin/defender-sdk-base-client": {
-      "version": "1.15.0",
-      "resolved": "https://registry.npmjs.org/@openzeppelin/defender-sdk-base-client/-/defender-sdk-base-client-1.15.0.tgz",
-      "integrity": "sha512-nuf/xegMIuKCO0hMrxI1KQKTzQw1iCl/9kew2nJM9MrFIohhfEXItc5rbJRoV/jehmK/Jhi9ATF9OHH09StEsQ==",
+      "version": "1.15.2",
+      "resolved": "https://registry.npmjs.org/@openzeppelin/defender-sdk-base-client/-/defender-sdk-base-client-1.15.2.tgz",
+      "integrity": "sha512-N3ZTeH8TXyklL7yNPMLUv0dxQwT78DTkOEDhzMS2/QE2FxbXrclSseoeeXxl6UYI61RBtZKn+okbSsbwiB5QWQ==",
       "dev": true,
       "dependencies": {
         "amazon-cognito-identity-js": "^6.3.6",
@@ -2815,23 +2434,23 @@
       }
     },
     "node_modules/@openzeppelin/defender-sdk-deploy-client": {
-      "version": "1.15.0",
-      "resolved": "https://registry.npmjs.org/@openzeppelin/defender-sdk-deploy-client/-/defender-sdk-deploy-client-1.15.0.tgz",
-      "integrity": "sha512-2ODMN4j5pPYWyIOvA/zRQmJ0tJyqi6NV3S/PyvufBXa3oj/MDnVO5bMGSQFH0M2VE3bg+i/rcUb0hdbX9Rtm5Q==",
+      "version": "1.15.2",
+      "resolved": "https://registry.npmjs.org/@openzeppelin/defender-sdk-deploy-client/-/defender-sdk-deploy-client-1.15.2.tgz",
+      "integrity": "sha512-zspzMqh+OC8arXAkgBqTUDVO+NfCkt54UrsmQHbA3UAjr5TiDXKycBKU5ORb01hE+2gAmoPwEpDW9uS2VLg33A==",
       "dev": true,
       "dependencies": {
-        "@openzeppelin/defender-sdk-base-client": "^1.15.0",
+        "@openzeppelin/defender-sdk-base-client": "^1.15.2",
         "axios": "^1.7.2",
         "lodash": "^4.17.21"
       }
     },
     "node_modules/@openzeppelin/defender-sdk-network-client": {
-      "version": "1.15.0",
-      "resolved": "https://registry.npmjs.org/@openzeppelin/defender-sdk-network-client/-/defender-sdk-network-client-1.15.0.tgz",
-      "integrity": "sha512-tNynCqFB1XYancq/8yGuj0HCSIyNLSRSuH53Hp2Tl+DpM7W5vIkzSRfvJJxC+8Sld83bVavyNJzTN9xid992Ag==",
+      "version": "1.15.2",
+      "resolved": "https://registry.npmjs.org/@openzeppelin/defender-sdk-network-client/-/defender-sdk-network-client-1.15.2.tgz",
+      "integrity": "sha512-9r9pegc1aR7xzP9fmj1zvkk0OXMRJE10JabxxiJzAQQgmNXDeTGI6W5bFgrNJfxzcImNGqddJ3K4weKdLyL21A==",
       "dev": true,
       "dependencies": {
-        "@openzeppelin/defender-sdk-base-client": "^1.15.0",
+        "@openzeppelin/defender-sdk-base-client": "^1.15.2",
         "axios": "^1.7.2",
         "lodash": "^4.17.21"
       }
@@ -2841,7 +2460,6 @@
       "resolved": "https://registry.npmjs.org/@openzeppelin/hardhat-upgrades/-/hardhat-upgrades-3.3.0.tgz",
       "integrity": "sha512-0RwCpkBKWViG0nIERk8tV5E71DCtZ6PXgsjoCYg+Bi2IWYgD8Skt4Q8b6QqE7tuWsFCK5yVQIVfCFL99JKMK5A==",
       "dev": true,
-      "license": "MIT",
       "dependencies": {
         "@openzeppelin/defender-sdk-base-client": "^1.14.4",
         "@openzeppelin/defender-sdk-deploy-client": "^1.14.4",
@@ -2869,21 +2487,21 @@
       }
     },
     "node_modules/@openzeppelin/hardhat-upgrades/node_modules/undici": {
-      "version": "6.20.0",
-      "resolved": "https://registry.npmjs.org/undici/-/undici-6.20.0.tgz",
-      "integrity": "sha512-AITZfPuxubm31Sx0vr8bteSalEbs9wQb/BOBi9FPlD9Qpd6HxZ4Q0+hI742jBhkPb4RT2v5MQzaW5VhRVyj+9A==",
+      "version": "6.21.0",
+      "resolved": "https://registry.npmjs.org/undici/-/undici-6.21.0.tgz",
+      "integrity": "sha512-BUgJXc752Kou3oOIuU1i+yZZypyZRqNPW0vqoMPl8VaoalSfeR0D8/t4iAS3yirs79SSMTxTag+ZC86uswv+Cw==",
       "dev": true,
       "engines": {
         "node": ">=18.17"
       }
     },
     "node_modules/@openzeppelin/upgrades-core": {
-      "version": "1.39.0",
-      "resolved": "https://registry.npmjs.org/@openzeppelin/upgrades-core/-/upgrades-core-1.39.0.tgz",
-      "integrity": "sha512-TJ1kMeyp7yD4aDR2bFDK+9m5JVe/ObFDck3erVm2WcBKPtRsmFOP6b0QO1DM6w0HOOIiu8VKfrFDqZ6NyJcUyw==",
+      "version": "1.41.0",
+      "resolved": "https://registry.npmjs.org/@openzeppelin/upgrades-core/-/upgrades-core-1.41.0.tgz",
+      "integrity": "sha512-+oryinqZnxkiZvg7bWqWX4Ki/CNwVUZEqC6Elpi5PQoahpL3/6Sq9xjIozD5AiI2O61h8JHQ+A//5NtczyavJw==",
       "dev": true,
       "dependencies": {
-        "@nomicfoundation/slang": "^0.17.0",
+        "@nomicfoundation/slang": "^0.18.3",
         "cbor": "^9.0.0",
         "chalk": "^4.1.0",
         "compare-versions": "^6.0.0",
@@ -3085,9 +2703,9 @@
       }
     },
     "node_modules/@smithy/types": {
-      "version": "3.5.0",
-      "resolved": "https://registry.npmjs.org/@smithy/types/-/types-3.5.0.tgz",
-      "integrity": "sha512-QN0twHNfe8mNJdH9unwsCK13GURU7oEAZqkBI+rsvpv1jrmserO+WnLE7jidR9W/1dxwZ0u/CB01mV2Gms/K2Q==",
+      "version": "3.7.2",
+      "resolved": "https://registry.npmjs.org/@smithy/types/-/types-3.7.2.tgz",
+      "integrity": "sha512-bNwBYYmN8Eh9RyjS1p2gW6MIhSO2rl7X9QeLM8iTdcGRP+eDiIWDt66c9IysCc22gefKszZv+ubV9qZc7hdESg==",
       "dev": true,
       "dependencies": {
         "tslib": "^2.6.2"
@@ -3097,9 +2715,9 @@
       }
     },
     "node_modules/@smithy/types/node_modules/tslib": {
-      "version": "2.7.0",
-      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.7.0.tgz",
-      "integrity": "sha512-gLXCKdN1/j47AiHiOkJN69hJmcbGTHI0ImLmbYLHykhgeN0jVGola9yVjFgzCUklsZQMW55o+dW7IXv3RCXDzA==",
+      "version": "2.8.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
       "dev": true
     },
     "node_modules/@solidity-parser/parser": {
@@ -3250,7 +2868,6 @@
       "resolved": "https://registry.npmjs.org/@types/conventional-commits-parser/-/conventional-commits-parser-5.0.1.tgz",
       "integrity": "sha512-7uz5EHdzz2TqoMfV7ee61Egf5y6NkcO4FB/1iCCQnbeiI1F3xzv3vK5dBCXUCLQgGYS+mUeigK1iKQzvED+QnQ==",
       "dev": true,
-      "license": "MIT",
       "dependencies": {
         "@types/node": "*"
       }
@@ -3295,15 +2912,6 @@
       "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==",
       "dev": true
     },
-    "node_modules/@types/keccak": {
-      "version": "3.0.5",
-      "resolved": "https://registry.npmjs.org/@types/keccak/-/keccak-3.0.5.tgz",
-      "integrity": "sha512-Mvu4StIJ9KyfPXDVRv3h0fWNBAjHPBQZ8EPcxhqA8FG6pLzxtytVXU5owB6J2/8xZ+ZspWTXJEUjAHt0pk0I1Q==",
-      "dev": true,
-      "dependencies": {
-        "@types/node": "*"
-      }
-    },
     "node_modules/@types/lru-cache": {
       "version": "5.1.1",
       "resolved": "https://registry.npmjs.org/@types/lru-cache/-/lru-cache-5.1.1.tgz",
@@ -3326,15 +2934,15 @@
       }
     },
     "node_modules/@types/mocha": {
-      "version": "10.0.9",
-      "resolved": "https://registry.npmjs.org/@types/mocha/-/mocha-10.0.9.tgz",
-      "integrity": "sha512-sicdRoWtYevwxjOHNMPTl3vSfJM6oyW8o1wXeI7uww6b6xHg8eBznQDNSGBCDJmsE8UMxP05JgZRtsKbTqt//Q==",
+      "version": "10.0.10",
+      "resolved": "https://registry.npmjs.org/@types/mocha/-/mocha-10.0.10.tgz",
+      "integrity": "sha512-xPyYSz1cMPnJQhl0CLMH68j3gprKZaTjG3s5Vi+fDgx+uhG9NOXwbVt52eFS8ECyXhyKcjDLCBEqBExKuiZb7Q==",
       "dev": true
     },
     "node_modules/@types/node": {
-      "version": "20.16.11",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.16.11.tgz",
-      "integrity": "sha512-y+cTCACu92FyA5fgQSAI8A1H429g7aSK2HsO7K4XYUWc4dY5IUz55JSDIYT6/VsOLfGy8vmvQYC2hfb0iF16Uw==",
+      "version": "20.17.10",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-20.17.10.tgz",
+      "integrity": "sha512-/jrvh5h6NXhEauFFexRin69nA0uHJ5gwk4iDivp/DeoEua3uwCUto6PC86IpRITBOs4+6i2I56K5x5b6WYGXHA==",
       "dev": true,
       "dependencies": {
         "undici-types": "~6.19.2"
@@ -3356,9 +2964,9 @@
       "dev": true
     },
     "node_modules/@types/qs": {
-      "version": "6.9.16",
-      "resolved": "https://registry.npmjs.org/@types/qs/-/qs-6.9.16.tgz",
-      "integrity": "sha512-7i+zxXdPD0T4cKDuxCUXJ4wHcsJLwENa6Z3dCu8cfCK743OGy5Nu1RmAGqDPsoTDINVEcdXKRvR/zre+P2Ku1A==",
+      "version": "6.9.17",
+      "resolved": "https://registry.npmjs.org/@types/qs/-/qs-6.9.17.tgz",
+      "integrity": "sha512-rX4/bPcfmvxHDv0XjfJELTTr+iB+tn032nPILqHm5wbthUUUuVtNGGqzhya9XUxjTP8Fpr0qYgSZZKxGY++svQ==",
       "dev": true
     },
     "node_modules/@types/resolve": {
@@ -3419,18 +3027,6 @@
         }
       }
     },
-    "node_modules/@typescript-eslint/eslint-plugin/node_modules/semver": {
-      "version": "7.6.3",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-7.6.3.tgz",
-      "integrity": "sha512-oVekP1cKtI+CTDvHWYFUcMtsK/00wmAEfyqKfNdARm8u1wNVhSgaX7A8d4UuIlUI5e84iEwOhs7ZPYRmzU9U6A==",
-      "dev": true,
-      "bin": {
-        "semver": "bin/semver.js"
-      },
-      "engines": {
-        "node": ">=10"
-      }
-    },
     "node_modules/@typescript-eslint/parser": {
       "version": "5.62.0",
       "resolved": "https://registry.npmjs.org/@typescript-eslint/parser/-/parser-5.62.0.tgz",
@@ -3542,18 +3138,6 @@
         }
       }
     },
-    "node_modules/@typescript-eslint/typescript-estree/node_modules/semver": {
-      "version": "7.6.3",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-7.6.3.tgz",
-      "integrity": "sha512-oVekP1cKtI+CTDvHWYFUcMtsK/00wmAEfyqKfNdARm8u1wNVhSgaX7A8d4UuIlUI5e84iEwOhs7ZPYRmzU9U6A==",
-      "dev": true,
-      "bin": {
-        "semver": "bin/semver.js"
-      },
-      "engines": {
-        "node": ">=10"
-      }
-    },
     "node_modules/@typescript-eslint/utils": {
       "version": "5.62.0",
       "resolved": "https://registry.npmjs.org/@typescript-eslint/utils/-/utils-5.62.0.tgz",
@@ -3580,18 +3164,6 @@
         "eslint": "^6.0.0 || ^7.0.0 || ^8.0.0"
       }
     },
-    "node_modules/@typescript-eslint/utils/node_modules/semver": {
-      "version": "7.6.3",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-7.6.3.tgz",
-      "integrity": "sha512-oVekP1cKtI+CTDvHWYFUcMtsK/00wmAEfyqKfNdARm8u1wNVhSgaX7A8d4UuIlUI5e84iEwOhs7ZPYRmzU9U6A==",
-      "dev": true,
-      "bin": {
-        "semver": "bin/semver.js"
-      },
-      "engines": {
-        "node": ">=10"
-      }
-    },
     "node_modules/@typescript-eslint/visitor-keys": {
       "version": "5.62.0",
       "resolved": "https://registry.npmjs.org/@typescript-eslint/visitor-keys/-/visitor-keys-5.62.0.tgz",
@@ -3610,9 +3182,9 @@
       }
     },
     "node_modules/@ungap/structured-clone": {
-      "version": "1.2.0",
-      "resolved": "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.2.0.tgz",
-      "integrity": "sha512-zuVdFrMJiuCDQUMCzQaD6KL28MjnqqN8XnAqiEq9PNm/hCPTSGfrXCOfwj1ow4LFb/tNymJPwsNbVePc1xFqrQ==",
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.2.1.tgz",
+      "integrity": "sha512-fEzPV3hSkSMltkw152tJKNARhOupqbH96MZWyRjNaYZOMIzbrTeQDG+MTc6Mr2pgzFQzFxAfmhGDNP5QK++2ZA==",
       "dev": true
     },
     "node_modules/abbrev": {
@@ -3622,9 +3194,9 @@
       "devOptional": true
     },
     "node_modules/acorn": {
-      "version": "8.12.1",
-      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.12.1.tgz",
-      "integrity": "sha512-tcpGyI9zbizT9JbV6oYE477V6mTlXvvi0T0G3SNIYE2apm/G5huBa1+K89VGeovbg+jycCrfhl3ADxErOuO6Jg==",
+      "version": "8.14.0",
+      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.14.0.tgz",
+      "integrity": "sha512-cl669nCJTZBsL97OF4kUQm5g5hC2uihk0NxY3WENAC0TYdILVkAyHymAntgxGkl7K+t0cXIrH5siy5S4XkFycA==",
       "dev": true,
       "bin": {
         "acorn": "bin/acorn"
@@ -3707,15 +3279,15 @@
       }
     },
     "node_modules/ajv": {
-      "version": "6.12.6",
-      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
-      "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",
+      "version": "8.17.1",
+      "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.17.1.tgz",
+      "integrity": "sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==",
       "dev": true,
       "dependencies": {
-        "fast-deep-equal": "^3.1.1",
-        "fast-json-stable-stringify": "^2.0.0",
-        "json-schema-traverse": "^0.4.1",
-        "uri-js": "^4.2.2"
+        "fast-deep-equal": "^3.1.3",
+        "fast-uri": "^3.0.1",
+        "json-schema-traverse": "^1.0.0",
+        "require-from-string": "^2.0.2"
       },
       "funding": {
         "type": "github",
@@ -3956,9 +3528,9 @@
       }
     },
     "node_modules/axios": {
-      "version": "1.7.7",
-      "resolved": "https://registry.npmjs.org/axios/-/axios-1.7.7.tgz",
-      "integrity": "sha512-S4kL7XrjgBmvdGut0sN3yJxqYzrDOnivkBiN0OFs6hLiUam3UPvswUo0kqGyhqUZGEOytHyumEdXsAkgCOUf3Q==",
+      "version": "1.7.9",
+      "resolved": "https://registry.npmjs.org/axios/-/axios-1.7.9.tgz",
+      "integrity": "sha512-LhLcE7Hbiryz8oMDdDptSrWowmB4Bl6RCt6sIJKpRB4XtVf0iEgewX3au/pJqm+Py1kCASkb/FFKjxQaLtxJvw==",
       "dev": true,
       "dependencies": {
         "follow-redirects": "^1.15.6",
@@ -4246,6 +3818,49 @@
         "node": ">= 10"
       }
     },
+    "node_modules/cacache/node_modules/brace-expansion": {
+      "version": "1.1.11",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
+      "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
+      "optional": true,
+      "dependencies": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "node_modules/cacache/node_modules/glob": {
+      "version": "7.2.3",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz",
+      "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==",
+      "deprecated": "Glob versions prior to v9 are no longer supported",
+      "optional": true,
+      "dependencies": {
+        "fs.realpath": "^1.0.0",
+        "inflight": "^1.0.4",
+        "inherits": "2",
+        "minimatch": "^3.1.1",
+        "once": "^1.3.0",
+        "path-is-absolute": "^1.0.0"
+      },
+      "engines": {
+        "node": "*"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/cacache/node_modules/minimatch": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
+      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+      "optional": true,
+      "dependencies": {
+        "brace-expansion": "^1.1.7"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
     "node_modules/cacache/node_modules/mkdirp": {
       "version": "1.0.4",
       "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-1.0.4.tgz",
@@ -4275,16 +3890,44 @@
       }
     },
     "node_modules/call-bind": {
-      "version": "1.0.7",
-      "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.7.tgz",
-      "integrity": "sha512-GHTSNSYICQ7scH7sZ+M2rFopRoLh8t2bLSW6BbgrtLsahOIB5iyAVJf9GjWK3cYTDaMj4XdBpM1cA6pIS0Kv2w==",
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.8.tgz",
+      "integrity": "sha512-oKlSFMcMwpUg2ednkhQ454wfWiU/ul3CkJe/PEHcTKuiX6RpbehUiFMXu13HalGZxfUwCQzZG747YXBn1im9ww==",
       "dev": true,
       "dependencies": {
+        "call-bind-apply-helpers": "^1.0.0",
         "es-define-property": "^1.0.0",
-        "es-errors": "^1.3.0",
-        "function-bind": "^1.1.2",
         "get-intrinsic": "^1.2.4",
-        "set-function-length": "^1.2.1"
+        "set-function-length": "^1.2.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/call-bind-apply-helpers": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.1.tgz",
+      "integrity": "sha512-BhYE+WDaywFg2TBWYNXAE+8B1ATnThNBqXHP5nQu0jWJdVvY2hvkpyB3qOmtmDePiS5/BDQ8wASEWGMWRG148g==",
+      "dev": true,
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/call-bound": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.3.tgz",
+      "integrity": "sha512-YTd+6wGlNlPxSuri7Y6X8tY2dmm12UMH66RpKMhiX6rsk5wXXnYgbUcOt8kiS31/AjfoTOvCsE+w8nZQLQnzHA==",
+      "dev": true,
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.1",
+        "get-intrinsic": "^1.2.6"
       },
       "engines": {
         "node": ">= 0.4"
@@ -4400,9 +4043,9 @@
       }
     },
     "node_modules/chokidar": {
-      "version": "4.0.1",
-      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-4.0.1.tgz",
-      "integrity": "sha512-n8enUVCED/KVRQlab1hr3MVpcVMvxtZjmEa956u+4YijlmQED223XMSYj2tLuKvr4jcCTzNNMpQDUer72MMmzA==",
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-4.0.3.tgz",
+      "integrity": "sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA==",
       "dev": true,
       "dependencies": {
         "readdirp": "^4.0.1"
@@ -4429,13 +4072,16 @@
       "dev": true
     },
     "node_modules/cipher-base": {
-      "version": "1.0.4",
-      "resolved": "https://registry.npmjs.org/cipher-base/-/cipher-base-1.0.4.tgz",
-      "integrity": "sha512-Kkht5ye6ZGmwv40uUDZztayT2ThLQGfnj/T71N/XzeZeo3nf8foyW7zGTsPYkEya3m5f3cAypH+qe7YOrM1U2Q==",
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/cipher-base/-/cipher-base-1.0.6.tgz",
+      "integrity": "sha512-3Ek9H3X6pj5TgenXYtNWdaBon1tgYCaebd+XPg0keyjEbEfkD4KkmAxkQ/i1vYvxdcT5nscLBfq9VJRmCBcFSw==",
       "dev": true,
       "dependencies": {
-        "inherits": "^2.0.1",
-        "safe-buffer": "^5.0.1"
+        "inherits": "^2.0.4",
+        "safe-buffer": "^5.2.1"
+      },
+      "engines": {
+        "node": ">= 0.10"
       }
     },
     "node_modules/clean-stack": {
@@ -4519,14 +4165,17 @@
       }
     },
     "node_modules/cliui": {
-      "version": "7.0.4",
-      "resolved": "https://registry.npmjs.org/cliui/-/cliui-7.0.4.tgz",
-      "integrity": "sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ==",
+      "version": "8.0.1",
+      "resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz",
+      "integrity": "sha512-BSeNnyus75C4//NQ9gQt1/csTXyo/8Sb+afLAkzAptFuMsod9HFokGNudZpi/oQV73hnVK+sR+5PVRMd+Dr7YQ==",
       "dev": true,
       "dependencies": {
         "string-width": "^4.2.0",
-        "strip-ansi": "^6.0.0",
+        "strip-ansi": "^6.0.1",
         "wrap-ansi": "^7.0.0"
+      },
+      "engines": {
+        "node": ">=12"
       }
     },
     "node_modules/color-convert": {
@@ -4789,7 +4438,6 @@
       "resolved": "https://registry.npmjs.org/conventional-changelog-angular/-/conventional-changelog-angular-7.0.0.tgz",
       "integrity": "sha512-ROjNchA9LgfNMTTFSIWPzebCwOGFdgkEq45EnvvrmSLvCtAw0HSmrCs7/ty+wAeYUZyNay0YMUNYFTRL72PkBQ==",
       "dev": true,
-      "license": "ISC",
       "dependencies": {
         "compare-func": "^2.0.0"
       },
@@ -4823,7 +4471,6 @@
       "resolved": "https://registry.npmjs.org/conventional-commits-parser/-/conventional-commits-parser-5.0.0.tgz",
       "integrity": "sha512-ZPMl0ZJbw74iS9LuX9YIAiW8pfM5p3yh2o/NbXHbkFuZzY5jvdi5jFycEOkmBW5H5I7nA+D6f3UcsCLP2vvSEA==",
       "dev": true,
-      "license": "MIT",
       "dependencies": {
         "is-text-path": "^2.0.0",
         "JSONStream": "^1.3.5",
@@ -4837,16 +4484,6 @@
         "node": ">=16"
       }
     },
-    "node_modules/conventional-commits-parser/node_modules/split2": {
-      "version": "4.2.0",
-      "resolved": "https://registry.npmjs.org/split2/-/split2-4.2.0.tgz",
-      "integrity": "sha512-UcjcJOWknrNkF6PLX83qcHM6KHgVKNkV62Y8a5uYDVv9ydGQVwAHMKqHdJje1VTWpljG0WYpCDhrCdAOYH4TWg==",
-      "dev": true,
-      "license": "ISC",
-      "engines": {
-        "node": ">= 10.x"
-      }
-    },
     "node_modules/cookie": {
       "version": "0.4.2",
       "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.4.2.tgz",
@@ -4867,7 +4504,6 @@
       "resolved": "https://registry.npmjs.org/cosmiconfig/-/cosmiconfig-9.0.0.tgz",
       "integrity": "sha512-itvL5h8RETACmOTFc4UfIyB2RfEHi71Ax6E/PivVxq9NseKbOWpeyHEOIbmAw1rs8Ak0VursQNww7lf7YtUwzg==",
       "dev": true,
-      "license": "MIT",
       "dependencies": {
         "env-paths": "^2.2.1",
         "import-fresh": "^3.3.0",
@@ -4890,21 +4526,20 @@
       }
     },
     "node_modules/cosmiconfig-typescript-loader": {
-      "version": "5.1.0",
-      "resolved": "https://registry.npmjs.org/cosmiconfig-typescript-loader/-/cosmiconfig-typescript-loader-5.1.0.tgz",
-      "integrity": "sha512-7PtBB+6FdsOvZyJtlF3hEPpACq7RQX6BVGsgC7/lfVXnKMvNCu/XY3ykreqG5w/rBNdu2z8LCIKoF3kpHHdHlA==",
+      "version": "6.1.0",
+      "resolved": "https://registry.npmjs.org/cosmiconfig-typescript-loader/-/cosmiconfig-typescript-loader-6.1.0.tgz",
+      "integrity": "sha512-tJ1w35ZRUiM5FeTzT7DtYWAFFv37ZLqSRkGi2oeCK1gPhvaWjkAtfXvLmvE1pRfxxp9aQo6ba/Pvg1dKj05D4g==",
       "dev": true,
-      "license": "MIT",
       "dependencies": {
-        "jiti": "^1.21.6"
+        "jiti": "^2.4.1"
       },
       "engines": {
-        "node": ">=v16"
+        "node": ">=v18"
       },
       "peerDependencies": {
         "@types/node": "*",
-        "cosmiconfig": ">=8.2",
-        "typescript": ">=4"
+        "cosmiconfig": ">=9",
+        "typescript": ">=5"
       }
     },
     "node_modules/create-hash": {
@@ -4959,9 +4594,9 @@
       }
     },
     "node_modules/cross-spawn": {
-      "version": "7.0.3",
-      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.3.tgz",
-      "integrity": "sha512-iRDPJKUPVEND7dHPO8rkbOnPpyDygcDFtWjpeWNCgy8WP2rXcxXL8TskReQl6OrB2G7+UJrags1q15Fudc7G6w==",
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
+      "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
       "dev": true,
       "dependencies": {
         "path-key": "^3.1.0",
@@ -4986,7 +4621,6 @@
       "resolved": "https://registry.npmjs.org/dargs/-/dargs-8.1.0.tgz",
       "integrity": "sha512-wAV9QHOsNbwnWdNW2FYvE1P56wtgSbM+3SZcdGiWQILwVjACCXDCI3Ai8QlCjMDB8YK5zySiXZYBiwGmNY3lnw==",
       "dev": true,
-      "license": "MIT",
       "engines": {
         "node": ">=12"
       },
@@ -5001,9 +4635,9 @@
       "dev": true
     },
     "node_modules/debug": {
-      "version": "4.3.7",
-      "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.7.tgz",
-      "integrity": "sha512-Er2nc/H7RrMXZBFCEim6TCmMk02Z8vLC2Rbi1KEBggpo0fS6l0S1nnapwmIi3yW/+GOJap1Krg4w0Hg80oCqgQ==",
+      "version": "4.4.0",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.0.tgz",
+      "integrity": "sha512-6WTZ/IxCY/T6BALoZHaE4ctp9xm+Z5kY/pzYaCHRFeyVhojxlrm+46y68HA6hr0TcwEssoxNiDEUJQjfPZ/RYA==",
       "devOptional": true,
       "dependencies": {
         "ms": "^2.1.3"
@@ -5185,9 +4819,9 @@
       }
     },
     "node_modules/dotenv": {
-      "version": "16.4.5",
-      "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-16.4.5.tgz",
-      "integrity": "sha512-ZmdL2rui+eB2YwhsWzjInR8LldtZHGDoQ1ugH85ppHKwpUHL7j7rN0Ti9NCnGiQbhaZ11FpR+7ao1dNsmduNUg==",
+      "version": "16.4.7",
+      "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-16.4.7.tgz",
+      "integrity": "sha512-47qPchRCykZC03FhkYAhrvwU4xDBFIj1QPqaarj6mdM/hgUzfPHcpkHJOn3mJAufFeeAxAzeGsr5X0M4k6fLZQ==",
       "dev": true,
       "engines": {
         "node": ">=12"
@@ -5196,6 +4830,20 @@
         "url": "https://dotenvx.com"
       }
     },
+    "node_modules/dunder-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
+      "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
+      "dev": true,
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "gopd": "^1.2.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
     "node_modules/elliptic": {
       "version": "6.5.4",
       "resolved": "https://registry.npmjs.org/elliptic/-/elliptic-6.5.4.tgz",
@@ -5212,9 +4860,9 @@
       }
     },
     "node_modules/elliptic/node_modules/bn.js": {
-      "version": "4.12.0",
-      "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.0.tgz",
-      "integrity": "sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==",
+      "version": "4.12.1",
+      "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.1.tgz",
+      "integrity": "sha512-k8TVBiPkPJT9uHLdOKfFpqcfprwBFOAAXXozRubr7R7PfIuKvQlzcI4M0pALeqXN09vdaMbUdUj+pass+uULAg==",
       "dev": true
     },
     "node_modules/emoji-regex": {
@@ -5291,19 +4939,15 @@
       "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.2.tgz",
       "integrity": "sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==",
       "dev": true,
-      "license": "MIT",
       "dependencies": {
         "is-arrayish": "^0.2.1"
       }
     },
     "node_modules/es-define-property": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.0.tgz",
-      "integrity": "sha512-jxayLKShrEqqzJ0eumQbVhTYQM27CfT1T35+gCgDFoL82JLsXqTJ76zv6A0YLOgEnLUMvLzsDsGIrl8NFpT2gQ==",
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
+      "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
       "dev": true,
-      "dependencies": {
-        "get-intrinsic": "^1.2.4"
-      },
       "engines": {
         "node": ">= 0.4"
       }
@@ -5317,6 +4961,18 @@
         "node": ">= 0.4"
       }
     },
+    "node_modules/es-object-atoms": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.0.0.tgz",
+      "integrity": "sha512-MZ4iQ6JwHOBQjahnjwaC1ZtIBH+2ohjamzAO3oaHcXYup7qxjF2fixyH+Q71voWHeOkI2q/TnJao/KfXYIZWbw==",
+      "dev": true,
+      "dependencies": {
+        "es-errors": "^1.3.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
     "node_modules/escalade": {
       "version": "3.2.0",
       "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
@@ -5526,6 +5182,22 @@
         "url": "https://opencollective.com/eslint"
       }
     },
+    "node_modules/eslint/node_modules/ajv": {
+      "version": "6.12.6",
+      "resolved": "https://registry.npmjs.org/ajv/-/ajv-6.12.6.tgz",
+      "integrity": "sha512-j3fVLgvTo527anyYyJOGTYJbG+vnnQYvE0m5mmkc1TK+nxAppkCLMIL0aZ4dblVCNoGShhm+kzE4ZUykBoMg4g==",
+      "dev": true,
+      "dependencies": {
+        "fast-deep-equal": "^3.1.1",
+        "fast-json-stable-stringify": "^2.0.0",
+        "json-schema-traverse": "^0.4.1",
+        "uri-js": "^4.2.2"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/epoberezkin"
+      }
+    },
     "node_modules/eslint/node_modules/brace-expansion": {
       "version": "1.1.11",
       "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
@@ -5561,6 +5233,22 @@
         "node": ">=4.0"
       }
     },
+    "node_modules/eslint/node_modules/find-up": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz",
+      "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==",
+      "dev": true,
+      "dependencies": {
+        "locate-path": "^6.0.0",
+        "path-exists": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/eslint/node_modules/globals": {
       "version": "13.24.0",
       "resolved": "https://registry.npmjs.org/globals/-/globals-13.24.0.tgz",
@@ -5576,6 +5264,27 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/eslint/node_modules/json-schema-traverse": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
+      "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",
+      "dev": true
+    },
+    "node_modules/eslint/node_modules/locate-path": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz",
+      "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==",
+      "dev": true,
+      "dependencies": {
+        "p-locate": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/eslint/node_modules/minimatch": {
       "version": "3.1.2",
       "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
@@ -5588,6 +5297,45 @@
         "node": "*"
       }
     },
+    "node_modules/eslint/node_modules/p-limit": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz",
+      "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==",
+      "dev": true,
+      "dependencies": {
+        "yocto-queue": "^0.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/eslint/node_modules/p-locate": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz",
+      "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==",
+      "dev": true,
+      "dependencies": {
+        "p-limit": "^3.0.2"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/eslint/node_modules/path-exists": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
+      "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==",
+      "dev": true,
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/eslint/node_modules/type-fest": {
       "version": "0.20.2",
       "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.20.2.tgz",
@@ -5600,6 +5348,18 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/eslint/node_modules/yocto-queue": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz",
+      "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==",
+      "dev": true,
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/espree": {
       "version": "9.6.1",
       "resolved": "https://registry.npmjs.org/espree/-/espree-9.6.1.tgz",
@@ -5834,9 +5594,9 @@
       }
     },
     "node_modules/ethereum-bloom-filters/node_modules/@noble/hashes": {
-      "version": "1.5.0",
-      "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-1.5.0.tgz",
-      "integrity": "sha512-1j6kQFb7QRru7eKN3ZDvRcP13rugwdxZqCjbiAVZfIJwgj2A65UmT4TgARXGlXgnRkORLTDTrO19ZErt7+QXgA==",
+      "version": "1.6.1",
+      "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-1.6.1.tgz",
+      "integrity": "sha512-pq5D8h10hHBjyqX+cfBm0i8JUXJ0UhczFc4r74zbuT9XgewFo2E3J1cOaGtdZynILNmQ685YWGzGE1Zv6io50w==",
       "dev": true,
       "engines": {
         "node": "^14.21.3 || >=16"
@@ -5872,6 +5632,7 @@
       "version": "0.6.8",
       "resolved": "https://registry.npmjs.org/ethereumjs-abi/-/ethereumjs-abi-0.6.8.tgz",
       "integrity": "sha512-Tx0r/iXI6r+lRsdvkFDlut0N08jWMnKRZ6Gkq+Nmw75lZe4e6o3EkSnkaBP5NF6+m5PTGAr9JP43N3LyeoglsA==",
+      "deprecated": "This library has been deprecated and usage is discouraged.",
       "dev": true,
       "dependencies": {
         "bn.js": "^4.11.8",
@@ -5888,9 +5649,9 @@
       }
     },
     "node_modules/ethereumjs-abi/node_modules/bn.js": {
-      "version": "4.12.0",
-      "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.0.tgz",
-      "integrity": "sha512-c98Bf3tPniI+scsdk237ku1Dc3ujXQTSgyiPUDEOe7tRkhrqridvh8klBv0HCEso1OLOYcHuCv/cS6DNxKH+ZA==",
+      "version": "4.12.1",
+      "resolved": "https://registry.npmjs.org/bn.js/-/bn.js-4.12.1.tgz",
+      "integrity": "sha512-k8TVBiPkPJT9uHLdOKfFpqcfprwBFOAAXXozRubr7R7PfIuKvQlzcI4M0pALeqXN09vdaMbUdUj+pass+uULAg==",
       "dev": true
     },
     "node_modules/ethereumjs-abi/node_modules/ethereumjs-util": {
@@ -5925,9 +5686,9 @@
       }
     },
     "node_modules/ethers": {
-      "version": "6.13.3",
-      "resolved": "https://registry.npmjs.org/ethers/-/ethers-6.13.3.tgz",
-      "integrity": "sha512-/DzbZOLVtoO4fKvvQwpEucHAQgIwBGWuRvBdwE/lMXgXvvHHTSkn7XqAQ2b+gjJzZDJjWA9OD05bVceVOsBHbg==",
+      "version": "6.13.4",
+      "resolved": "https://registry.npmjs.org/ethers/-/ethers-6.13.4.tgz",
+      "integrity": "sha512-21YtnZVg4/zKkCQPjrDj38B1r4nQvTZLopUGMLQ1ePU2zV/joCfDC3t3iKQjWRzjjjbzR+mdAIoikeBRNkdllA==",
       "dev": true,
       "funding": [
         {
@@ -5943,9 +5704,9 @@
         "@adraffy/ens-normalize": "1.10.1",
         "@noble/curves": "1.2.0",
         "@noble/hashes": "1.3.2",
-        "@types/node": "18.15.13",
+        "@types/node": "22.7.5",
         "aes-js": "4.0.0-beta.5",
-        "tslib": "2.4.0",
+        "tslib": "2.7.0",
         "ws": "8.17.1"
       },
       "engines": {
@@ -5953,15 +5714,18 @@
       }
     },
     "node_modules/ethers/node_modules/@types/node": {
-      "version": "18.15.13",
-      "resolved": "https://registry.npmjs.org/@types/node/-/node-18.15.13.tgz",
-      "integrity": "sha512-N+0kuo9KgrUQ1Sn/ifDXsvg0TTleP7rIy4zOBGECxAljqvqfqpTfzx0Q1NUedOixRMBfe2Whhb056a42cWs26Q==",
-      "dev": true
+      "version": "22.7.5",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-22.7.5.tgz",
+      "integrity": "sha512-jML7s2NAzMWc//QSJ1a3prpk78cOPchGvXJsC3C6R6PSMoooztvRVQEz89gmBTBY1SPMaqo5teB4uNHPdetShQ==",
+      "dev": true,
+      "dependencies": {
+        "undici-types": "~6.19.2"
+      }
     },
     "node_modules/ethers/node_modules/tslib": {
-      "version": "2.4.0",
-      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.4.0.tgz",
-      "integrity": "sha512-d6xOpEDfsi2CZVlPQzGeux8XMwLT9hssAsaPYExaQMuYskwb+x1x7J371tWlbBdWHroy99KnVB6qIkUbs5X3UQ==",
+      "version": "2.7.0",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.7.0.tgz",
+      "integrity": "sha512-gLXCKdN1/j47AiHiOkJN69hJmcbGTHI0ImLmbYLHykhgeN0jVGola9yVjFgzCUklsZQMW55o+dW7IXv3RCXDzA==",
       "dev": true
     },
     "node_modules/ethjs-unit": {
@@ -6074,15 +5838,15 @@
       "dev": true
     },
     "node_modules/fast-uri": {
-      "version": "3.0.2",
-      "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.0.2.tgz",
-      "integrity": "sha512-GR6f0hD7XXyNJa25Tb9BuIdN0tdr+0BMi6/CJPH3wJO1JjNG3n/VsSw38AwRdKZABm8lGbPfakLRkYzx2V9row==",
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.0.3.tgz",
+      "integrity": "sha512-aLrHthzCjH5He4Z2H9YZ+v6Ujb9ocRuW6ZzkJQOrTxleEijANq4v1TsaPaVG1PZcuurEzrLcWRyYBYXD5cEiaw==",
       "dev": true
     },
     "node_modules/fastq": {
-      "version": "1.17.1",
-      "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.17.1.tgz",
-      "integrity": "sha512-sRVD3lWVIXWg6By68ZN7vho9a1pQcN/WBFaAAsDDFzlJjvoGx0P8z7V1t72grFJfJhu3YPZBuu25f7Kaw2jN1w==",
+      "version": "1.18.0",
+      "resolved": "https://registry.npmjs.org/fastq/-/fastq-1.18.0.tgz",
+      "integrity": "sha512-QKHXPW0hD8g4UET03SdOdunzSouc9N4AuHdsX8XNcTsuz+yYFILVNIX4l9yHABMhiEI9Db0JTTIpu0wB+Y1QQw==",
       "dev": true,
       "dependencies": {
         "reusify": "^1.0.4"
@@ -6110,28 +5874,26 @@
       }
     },
     "node_modules/fhevm-core-contracts": {
-      "version": "0.7.0-0",
-      "resolved": "https://registry.npmjs.org/fhevm-core-contracts/-/fhevm-core-contracts-0.7.0-0.tgz",
-      "integrity": "sha512-iVQi1phRoX9Ht3NE7T+fcZ/N/sASuqsTWa25pKBSbzCIzZ6Reajp+t5/B1tmAsf+MIsaI/zFAv/79W3XlfybmA==",
+      "version": "0.7.0-1",
+      "resolved": "https://registry.npmjs.org/fhevm-core-contracts/-/fhevm-core-contracts-0.7.0-1.tgz",
+      "integrity": "sha512-+F//WJdIAu79plRfEmYBu0s+3acAo5+0wYpJacDgzFuC128TdccmTh/nlU5FvsvI8lVMPBO297RCElt0v0qRbQ==",
       "dev": true
     },
     "node_modules/fhevmjs": {
-      "version": "0.6.0-9",
-      "resolved": "https://registry.npmjs.org/fhevmjs/-/fhevmjs-0.6.0-9.tgz",
-      "integrity": "sha512-DUGeX0xk/pQC9gG1byljxwEinLADRaWV4tsp0Crk8sbbCTEGTJ1rr3NSxvMPNggGFIwoaOeKT99KueKGaPn2gg==",
+      "version": "0.6.2",
+      "resolved": "https://registry.npmjs.org/fhevmjs/-/fhevmjs-0.6.2.tgz",
+      "integrity": "sha512-Kiq59DiqusavaCft8AzSVF2G92ZrNyf3u2dmu3zqlOxK5TGXAIY7PNICrV4xvT+pVxiAF88auNP+tH/dFqx1iA==",
       "dev": true,
       "dependencies": {
-        "@types/keccak": "^3.0.4",
         "bigint-buffer": "^1.1.5",
         "commander": "^11.0.0",
         "fetch-mock": "^11.1.3",
+        "keccak": "^3.0.4",
         "node-tfhe": "^0.9.1",
-        "node-tkms": "0.9.0-rc27",
-        "sha3": "^2.1.4",
+        "node-tkms": "^0.9.0",
         "tfhe": "^0.9.1",
-        "tkms": "0.9.0-rc27",
-        "url": "^0.11.3",
-        "web3-validator": "^2.0.6"
+        "tkms": "^0.9.0",
+        "wasm-feature-detect": "^1.8.0"
       },
       "bin": {
         "fhevm": "bin/fhevm.js"
@@ -6182,16 +5944,17 @@
       }
     },
     "node_modules/find-up": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz",
-      "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==",
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/find-up/-/find-up-7.0.0.tgz",
+      "integrity": "sha512-YyZM99iHrqLKjmt4LJDj58KI+fYyufRLBSYcqycxf//KpBk9FoewoGX0450m9nB44qrZnovzC2oeP5hUibxc/g==",
       "dev": true,
       "dependencies": {
-        "locate-path": "^6.0.0",
-        "path-exists": "^4.0.0"
+        "locate-path": "^7.2.0",
+        "path-exists": "^5.0.0",
+        "unicorn-magic": "^0.1.0"
       },
       "engines": {
-        "node": ">=10"
+        "node": ">=18"
       },
       "funding": {
         "url": "https://github.com/sponsors/sindresorhus"
@@ -6220,6 +5983,49 @@
         "node": "^10.12.0 || >=12.0.0"
       }
     },
+    "node_modules/flat-cache/node_modules/brace-expansion": {
+      "version": "1.1.11",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
+      "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
+      "dev": true,
+      "dependencies": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "node_modules/flat-cache/node_modules/glob": {
+      "version": "7.2.3",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz",
+      "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==",
+      "deprecated": "Glob versions prior to v9 are no longer supported",
+      "dev": true,
+      "dependencies": {
+        "fs.realpath": "^1.0.0",
+        "inflight": "^1.0.4",
+        "inherits": "2",
+        "minimatch": "^3.1.1",
+        "once": "^1.3.0",
+        "path-is-absolute": "^1.0.0"
+      },
+      "engines": {
+        "node": "*"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/flat-cache/node_modules/minimatch": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
+      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+      "dev": true,
+      "dependencies": {
+        "brace-expansion": "^1.1.7"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
     "node_modules/flat-cache/node_modules/rimraf": {
       "version": "3.0.2",
       "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-3.0.2.tgz",
@@ -6237,9 +6043,9 @@
       }
     },
     "node_modules/flatted": {
-      "version": "3.3.1",
-      "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.3.1.tgz",
-      "integrity": "sha512-X8cqMLLie7KsNUDSdzeN8FYK9rEt4Dt67OsG/DNGnYTSDBG4uFAJFBnUeiV+zCVAvwFy56IjM9sH51jVaEhNxw==",
+      "version": "3.3.2",
+      "resolved": "https://registry.npmjs.org/flatted/-/flatted-3.3.2.tgz",
+      "integrity": "sha512-AiwGJM8YcNOaobumgtng+6NHuOqC3A7MixFeDafM3X9cIUM+xUXoS5Vfgf+OihAYe20fxqNM9yPBXJzRtZ/4eA==",
       "dev": true
     },
     "node_modules/fmix": {
@@ -6281,9 +6087,9 @@
       }
     },
     "node_modules/form-data": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.0.tgz",
-      "integrity": "sha512-ETEklSGi5t0QMZuiXoA/Q6vcnxcLQP5vdugSpuAyi6SVGi2clPPp+xgEhuMaHC+zGgn31Kd235W35f7Hykkaww==",
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.1.tgz",
+      "integrity": "sha512-tzN8e4TX8+kkxGPK8D5u0FNmjPUjw3lwC9lSLxxoB/+GtsJG91CO8bSWy73APlgAZzZbXEYZJuxjkHH2w+Ezhw==",
       "dev": true,
       "dependencies": {
         "asynckit": "^0.4.0",
@@ -6404,16 +6210,21 @@
       }
     },
     "node_modules/get-intrinsic": {
-      "version": "1.2.4",
-      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.4.tgz",
-      "integrity": "sha512-5uYhsJH8VJBTv7oslg4BznJYhDoRI6waYCxMmCdnTrcCrHA/fCFKoTFz2JKKE0HdDFUF7/oQuhzumXJK7paBRQ==",
+      "version": "1.2.6",
+      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.6.tgz",
+      "integrity": "sha512-qxsEs+9A+u85HhllWJJFicJfPDhRmjzoYdl64aMWW9yRIJmSyxdn8IEkuIM530/7T+lv0TIHd8L6Q/ra0tEoeA==",
       "dev": true,
       "dependencies": {
+        "call-bind-apply-helpers": "^1.0.1",
+        "dunder-proto": "^1.0.0",
+        "es-define-property": "^1.0.1",
         "es-errors": "^1.3.0",
+        "es-object-atoms": "^1.0.0",
         "function-bind": "^1.1.2",
-        "has-proto": "^1.0.1",
-        "has-symbols": "^1.0.3",
-        "hasown": "^2.0.0"
+        "gopd": "^1.2.0",
+        "has-symbols": "^1.1.0",
+        "hasown": "^2.0.2",
+        "math-intrinsics": "^1.0.0"
       },
       "engines": {
         "node": ">= 0.4"
@@ -6520,7 +6331,6 @@
       "resolved": "https://registry.npmjs.org/git-raw-commits/-/git-raw-commits-4.0.0.tgz",
       "integrity": "sha512-ICsMM1Wk8xSGMowkOmPrzo2Fgmfo4bMHLNX6ytHjajRJUqvHOw/TFapQ+QG75c3X/tTDDhOSRPGC52dDbNM8FQ==",
       "dev": true,
-      "license": "MIT",
       "dependencies": {
         "dargs": "^8.0.0",
         "meow": "^12.0.1",
@@ -6533,37 +6343,26 @@
         "node": ">=16"
       }
     },
-    "node_modules/git-raw-commits/node_modules/split2": {
-      "version": "4.2.0",
-      "resolved": "https://registry.npmjs.org/split2/-/split2-4.2.0.tgz",
-      "integrity": "sha512-UcjcJOWknrNkF6PLX83qcHM6KHgVKNkV62Y8a5uYDVv9ydGQVwAHMKqHdJje1VTWpljG0WYpCDhrCdAOYH4TWg==",
-      "dev": true,
-      "license": "ISC",
-      "engines": {
-        "node": ">= 10.x"
-      }
-    },
     "node_modules/github-from-package": {
       "version": "0.0.0",
       "resolved": "https://registry.npmjs.org/github-from-package/-/github-from-package-0.0.0.tgz",
       "integrity": "sha512-SyHy3T1v2NUXn29OsWdxmK6RwHD+vkj3v8en8AOBZ1wBQ/hCAQ5bAQTD02kW4W9tUp/3Qh6J8r9EvntiyCmOOw=="
     },
     "node_modules/glob": {
-      "version": "7.2.0",
-      "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.0.tgz",
-      "integrity": "sha512-lmLf6gtyrPq8tTjSmrO94wBeQbFR3HbLHbuyD69wuyQkImp2hWqMGB47OX65FBkPffO641IP9jWa1z4ivqG26Q==",
+      "version": "8.1.0",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-8.1.0.tgz",
+      "integrity": "sha512-r8hpEjiQEYlF2QU0df3dS+nxxSIreXQS1qRhMJM0Q5NDdR386C7jb7Hwwod8Fgiuex+k0GFjgft18yvxm5XoCQ==",
       "deprecated": "Glob versions prior to v9 are no longer supported",
-      "devOptional": true,
+      "dev": true,
       "dependencies": {
         "fs.realpath": "^1.0.0",
         "inflight": "^1.0.4",
         "inherits": "2",
-        "minimatch": "^3.0.4",
-        "once": "^1.3.0",
-        "path-is-absolute": "^1.0.0"
+        "minimatch": "^5.0.1",
+        "once": "^1.3.0"
       },
       "engines": {
-        "node": "*"
+        "node": ">=12"
       },
       "funding": {
         "url": "https://github.com/sponsors/isaacs"
@@ -6587,26 +6386,16 @@
       "integrity": "sha512-lkX1HJXwyMcprw/5YUZc2s7DrpAiHB21/V+E1rHUrVNokkvB6bqMzT0VfV6/86ZNabt1k14YOIaT7nDvOX3Iiw==",
       "dev": true
     },
-    "node_modules/glob/node_modules/brace-expansion": {
-      "version": "1.1.11",
-      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
-      "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
-      "devOptional": true,
-      "dependencies": {
-        "balanced-match": "^1.0.0",
-        "concat-map": "0.0.1"
-      }
-    },
     "node_modules/glob/node_modules/minimatch": {
-      "version": "3.1.2",
-      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
-      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
-      "devOptional": true,
+      "version": "5.1.6",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.6.tgz",
+      "integrity": "sha512-lKwV/1brpG6mBUFHtb7NUmtABCb2WZZmm2wNiOA5hAb8VdCS4B3dtMWyvcoViccwAW/COERjXLt0zP1zXUN26g==",
+      "dev": true,
       "dependencies": {
-        "brace-expansion": "^1.1.7"
+        "brace-expansion": "^2.0.1"
       },
       "engines": {
-        "node": "*"
+        "node": ">=10"
       }
     },
     "node_modules/global-directory": {
@@ -6614,7 +6403,6 @@
       "resolved": "https://registry.npmjs.org/global-directory/-/global-directory-4.0.1.tgz",
       "integrity": "sha512-wHTUcDUoZ1H5/0iVqEudYW4/kAlN5cZ3j/bXn0Dpbizl9iaUVeWSHqiOjsgk6OW2bkLclbBjzewBz6weQ1zA2Q==",
       "dev": true,
-      "license": "MIT",
       "dependencies": {
         "ini": "4.1.1"
       },
@@ -6625,16 +6413,6 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/global-directory/node_modules/ini": {
-      "version": "4.1.1",
-      "resolved": "https://registry.npmjs.org/ini/-/ini-4.1.1.tgz",
-      "integrity": "sha512-QQnnxNyfvmHFIsj7gkPcYymR8Jdw/o7mp5ZFihxn6h8Ci6fh3Dx4E1gPjpQEpIuPo9XVNY/ZUwh4BPMjGyL01g==",
-      "dev": true,
-      "license": "ISC",
-      "engines": {
-        "node": "^14.17.0 || ^16.13.0 || >=18.0.0"
-      }
-    },
     "node_modules/global-modules": {
       "version": "2.0.0",
       "resolved": "https://registry.npmjs.org/global-modules/-/global-modules-2.0.0.tgz",
@@ -6661,6 +6439,12 @@
         "node": ">=6"
       }
     },
+    "node_modules/global-prefix/node_modules/ini": {
+      "version": "1.3.8",
+      "resolved": "https://registry.npmjs.org/ini/-/ini-1.3.8.tgz",
+      "integrity": "sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew==",
+      "dev": true
+    },
     "node_modules/global-prefix/node_modules/which": {
       "version": "1.3.1",
       "resolved": "https://registry.npmjs.org/which/-/which-1.3.1.tgz",
@@ -6703,12 +6487,12 @@
       }
     },
     "node_modules/gopd": {
-      "version": "1.0.1",
-      "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.0.1.tgz",
-      "integrity": "sha512-d65bNlIadxvpb/A2abVdlqKqV563juRnZ1Wtk6s1sIR8uNsXR70xqIzVqxVf1eTqDunwT2MkczEeaezCKTZhwA==",
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
+      "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
       "dev": true,
-      "dependencies": {
-        "get-intrinsic": "^1.1.3"
+      "engines": {
+        "node": ">= 0.4"
       },
       "funding": {
         "url": "https://github.com/sponsors/ljharb"
@@ -6757,14 +6541,14 @@
       }
     },
     "node_modules/hardhat": {
-      "version": "2.22.13",
-      "resolved": "https://registry.npmjs.org/hardhat/-/hardhat-2.22.13.tgz",
-      "integrity": "sha512-psVJX4FSXDpSXwsU8OcKTJN04pQEj9cFBMX5OPko+OFwbIoiOpvRmafa954/UaA1934npTj8sV3gaTSdx9bPbA==",
+      "version": "2.22.17",
+      "resolved": "https://registry.npmjs.org/hardhat/-/hardhat-2.22.17.tgz",
+      "integrity": "sha512-tDlI475ccz4d/dajnADUTRc1OJ3H8fpP9sWhXhBPpYsQOg8JHq5xrDimo53UhWPl7KJmAeDCm1bFG74xvpGRpg==",
       "dev": true,
       "dependencies": {
         "@ethersproject/abi": "^5.1.2",
         "@metamask/eth-sig-util": "^4.0.0",
-        "@nomicfoundation/edr": "^0.6.3",
+        "@nomicfoundation/edr": "^0.6.5",
         "@nomicfoundation/ethereumjs-common": "4.0.4",
         "@nomicfoundation/ethereumjs-tx": "5.0.4",
         "@nomicfoundation/ethereumjs-util": "9.0.4",
@@ -6776,7 +6560,6 @@
         "aggregate-error": "^3.0.0",
         "ansi-escapes": "^4.3.0",
         "boxen": "^5.1.2",
-        "chalk": "^2.4.2",
         "chokidar": "^4.0.0",
         "ci-info": "^2.0.0",
         "debug": "^4.1.1",
@@ -6784,10 +6567,9 @@
         "env-paths": "^2.2.0",
         "ethereum-cryptography": "^1.0.3",
         "ethereumjs-abi": "^0.6.8",
-        "find-up": "^2.1.0",
+        "find-up": "^5.0.0",
         "fp-ts": "1.19.3",
         "fs-extra": "^7.0.1",
-        "glob": "7.2.0",
         "immutable": "^4.0.0-rc.12",
         "io-ts": "1.10.4",
         "json-stream-stringify": "^3.1.4",
@@ -6796,12 +6578,14 @@
         "mnemonist": "^0.38.0",
         "mocha": "^10.0.0",
         "p-map": "^4.0.0",
+        "picocolors": "^1.1.0",
         "raw-body": "^2.4.1",
         "resolve": "1.17.0",
         "semver": "^6.3.0",
         "solc": "0.8.26",
         "source-map-support": "^0.5.13",
         "stacktrace-parser": "^0.1.10",
+        "tinyglobby": "^0.2.6",
         "tsort": "0.0.1",
         "undici": "^5.14.0",
         "uuid": "^8.3.2",
@@ -6985,9 +6769,9 @@
       }
     },
     "node_modules/hardhat-ignore-warnings": {
-      "version": "0.2.11",
-      "resolved": "https://registry.npmjs.org/hardhat-ignore-warnings/-/hardhat-ignore-warnings-0.2.11.tgz",
-      "integrity": "sha512-+nHnRbP6COFZaXE7HAY7TZNE3au5vHe5dkcnyq0XaP07ikT2fJ3NhFY0vn7Deh4Qbz0Z/9Xpnj2ki6Ktgk61pg==",
+      "version": "0.2.12",
+      "resolved": "https://registry.npmjs.org/hardhat-ignore-warnings/-/hardhat-ignore-warnings-0.2.12.tgz",
+      "integrity": "sha512-SaxCLKzYBMk3Rd1275TnanUmmxwgU+bu4Ekf2MKcqXxxt6xTGcPTtTaM+USrLgmejZHC4Itg/PaWITlOp4RL3g==",
       "dev": true,
       "dependencies": {
         "minimatch": "^5.1.0",
@@ -7032,74 +6816,24 @@
       ],
       "dependencies": {
         "@noble/hashes": "~1.2.0",
-        "@noble/secp256k1": "~1.7.0",
-        "@scure/base": "~1.1.0"
-      }
-    },
-    "node_modules/hardhat/node_modules/@scure/bip39": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/@scure/bip39/-/bip39-1.1.1.tgz",
-      "integrity": "sha512-t+wDck2rVkh65Hmv280fYdVdY25J9YeEUIgn2LG1WM6gxFkGzcksoDiUkWVpVp3Oex9xGC68JU2dSbUfwZ2jPg==",
-      "dev": true,
-      "funding": [
-        {
-          "type": "individual",
-          "url": "https://paulmillr.com/funding/"
-        }
-      ],
-      "dependencies": {
-        "@noble/hashes": "~1.2.0",
-        "@scure/base": "~1.1.0"
-      }
-    },
-    "node_modules/hardhat/node_modules/ansi-styles": {
-      "version": "3.2.1",
-      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz",
-      "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==",
-      "dev": true,
-      "dependencies": {
-        "color-convert": "^1.9.0"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/hardhat/node_modules/chalk": {
-      "version": "2.4.2",
-      "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz",
-      "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==",
-      "dev": true,
-      "dependencies": {
-        "ansi-styles": "^3.2.1",
-        "escape-string-regexp": "^1.0.5",
-        "supports-color": "^5.3.0"
-      },
-      "engines": {
-        "node": ">=4"
-      }
-    },
-    "node_modules/hardhat/node_modules/color-convert": {
-      "version": "1.9.3",
-      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz",
-      "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==",
-      "dev": true,
-      "dependencies": {
-        "color-name": "1.1.3"
-      }
-    },
-    "node_modules/hardhat/node_modules/color-name": {
-      "version": "1.1.3",
-      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz",
-      "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==",
-      "dev": true
+        "@noble/secp256k1": "~1.7.0",
+        "@scure/base": "~1.1.0"
+      }
     },
-    "node_modules/hardhat/node_modules/escape-string-regexp": {
-      "version": "1.0.5",
-      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz",
-      "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==",
+    "node_modules/hardhat/node_modules/@scure/bip39": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/@scure/bip39/-/bip39-1.1.1.tgz",
+      "integrity": "sha512-t+wDck2rVkh65Hmv280fYdVdY25J9YeEUIgn2LG1WM6gxFkGzcksoDiUkWVpVp3Oex9xGC68JU2dSbUfwZ2jPg==",
       "dev": true,
-      "engines": {
-        "node": ">=0.8.0"
+      "funding": [
+        {
+          "type": "individual",
+          "url": "https://paulmillr.com/funding/"
+        }
+      ],
+      "dependencies": {
+        "@noble/hashes": "~1.2.0",
+        "@scure/base": "~1.1.0"
       }
     },
     "node_modules/hardhat/node_modules/ethereum-cryptography": {
@@ -7115,15 +6849,19 @@
       }
     },
     "node_modules/hardhat/node_modules/find-up": {
-      "version": "2.1.0",
-      "resolved": "https://registry.npmjs.org/find-up/-/find-up-2.1.0.tgz",
-      "integrity": "sha512-NWzkk0jSJtTt08+FBFMvXoeZnOJD+jTtsRmBYbAIzJdX6l7dLgR7CTubCM5/eDdPUBvLCeVasP1brfVR/9/EZQ==",
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz",
+      "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==",
       "dev": true,
       "dependencies": {
-        "locate-path": "^2.0.0"
+        "locate-path": "^6.0.0",
+        "path-exists": "^4.0.0"
       },
       "engines": {
-        "node": ">=4"
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
     "node_modules/hardhat/node_modules/fs-extra": {
@@ -7140,15 +6878,6 @@
         "node": ">=6 <7 || >=8"
       }
     },
-    "node_modules/hardhat/node_modules/has-flag": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
-      "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==",
-      "dev": true,
-      "engines": {
-        "node": ">=4"
-      }
-    },
     "node_modules/hardhat/node_modules/jsonfile": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-4.0.0.tgz",
@@ -7159,61 +6888,66 @@
       }
     },
     "node_modules/hardhat/node_modules/locate-path": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-2.0.0.tgz",
-      "integrity": "sha512-NCI2kiDkyR7VeEKm27Kda/iQHyKJe1Bu0FlTbYp3CqJu+9IFe9bLyAjMxf5ZDDbEg+iMPzB5zYyUTSm8wVTKmA==",
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz",
+      "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==",
       "dev": true,
       "dependencies": {
-        "p-locate": "^2.0.0",
-        "path-exists": "^3.0.0"
+        "p-locate": "^5.0.0"
       },
       "engines": {
-        "node": ">=4"
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
     "node_modules/hardhat/node_modules/p-limit": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-1.3.0.tgz",
-      "integrity": "sha512-vvcXsLAJ9Dr5rQOPk7toZQZJApBl2K4J6dANSsEuh6QI41JYcsS/qhTGa9ErIUUgK3WNQoJYvylxvjqmiqEA9Q==",
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz",
+      "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==",
       "dev": true,
       "dependencies": {
-        "p-try": "^1.0.0"
+        "yocto-queue": "^0.1.0"
       },
       "engines": {
-        "node": ">=4"
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
     "node_modules/hardhat/node_modules/p-locate": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-2.0.0.tgz",
-      "integrity": "sha512-nQja7m7gSKuewoVRen45CtVfODR3crN3goVQ0DDZ9N3yHxgpkuBhZqsaiotSQRrADUrne346peY7kT3TSACykg==",
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz",
+      "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==",
       "dev": true,
       "dependencies": {
-        "p-limit": "^1.1.0"
+        "p-limit": "^3.0.2"
       },
       "engines": {
-        "node": ">=4"
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
     "node_modules/hardhat/node_modules/path-exists": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-3.0.0.tgz",
-      "integrity": "sha512-bpC7GYwiDYQ4wYLe+FA8lhRjhQCMcQGuSgGGqDkg/QerRWw9CmGRT0iSOVRSZJ29NMLZgIzqaljJ63oaL4NIJQ==",
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
+      "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==",
       "dev": true,
       "engines": {
-        "node": ">=4"
+        "node": ">=8"
       }
     },
-    "node_modules/hardhat/node_modules/supports-color": {
-      "version": "5.5.0",
-      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz",
-      "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==",
+    "node_modules/hardhat/node_modules/semver": {
+      "version": "6.3.1",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
+      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
       "dev": true,
-      "dependencies": {
-        "has-flag": "^3.0.0"
-      },
-      "engines": {
-        "node": ">=4"
+      "bin": {
+        "semver": "bin/semver.js"
       }
     },
     "node_modules/hardhat/node_modules/universalify": {
@@ -7246,6 +6980,18 @@
         }
       }
     },
+    "node_modules/hardhat/node_modules/yocto-queue": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz",
+      "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==",
+      "dev": true,
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/has-flag": {
       "version": "4.0.0",
       "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
@@ -7267,22 +7013,10 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/has-proto": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/has-proto/-/has-proto-1.0.3.tgz",
-      "integrity": "sha512-SJ1amZAJUiZS+PhsVLf5tGydlaVB8EdFpaSO4gmiUKUOxk8qzn5AIy4ZeJUmh22znIdk/uMAUT2pl3FxzVUH+Q==",
-      "dev": true,
-      "engines": {
-        "node": ">= 0.4"
-      },
-      "funding": {
-        "url": "https://github.com/sponsors/ljharb"
-      }
-    },
     "node_modules/has-symbols": {
-      "version": "1.0.3",
-      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.0.3.tgz",
-      "integrity": "sha512-l3LCuF6MgDNwTDKkdYGEihYjt5pRPbEg46rtlmnSPlUbgmB8LOIrKJbYYFBSbnPaJexMKtiPO8hmeRjRz2Td+A==",
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
+      "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
       "dev": true,
       "engines": {
         "node": ">= 0.4"
@@ -7467,7 +7201,6 @@
       "resolved": "https://registry.npmjs.org/husky/-/husky-9.1.7.tgz",
       "integrity": "sha512-5gs5ytaNjBrh5Ow3zrvdUUY+0VxIuWVL4i9irt6friV+BqdCfmV11CQTWMiBYWHbXhco+J1kHfTOUkePhCDvMA==",
       "dev": true,
-      "license": "MIT",
       "bin": {
         "husky": "bin.js"
       },
@@ -7551,12 +7284,20 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/import-fresh/node_modules/resolve-from": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz",
+      "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==",
+      "dev": true,
+      "engines": {
+        "node": ">=4"
+      }
+    },
     "node_modules/import-meta-resolve": {
       "version": "4.1.0",
       "resolved": "https://registry.npmjs.org/import-meta-resolve/-/import-meta-resolve-4.1.0.tgz",
       "integrity": "sha512-I6fiaX09Xivtk+THaMfAwnA3MVA5Big1WHF1Dfx9hFuvNIWpXnorlkzhcQf6ehrqQiiZECRt1poOAkPmer3ruw==",
       "dev": true,
-      "license": "MIT",
       "funding": {
         "type": "github",
         "url": "https://github.com/sponsors/wooorm"
@@ -7612,9 +7353,13 @@
       "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="
     },
     "node_modules/ini": {
-      "version": "1.3.8",
-      "resolved": "https://registry.npmjs.org/ini/-/ini-1.3.8.tgz",
-      "integrity": "sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew=="
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/ini/-/ini-4.1.1.tgz",
+      "integrity": "sha512-QQnnxNyfvmHFIsj7gkPcYymR8Jdw/o7mp5ZFihxn6h8Ci6fh3Dx4E1gPjpQEpIuPo9XVNY/ZUwh4BPMjGyL01g==",
+      "dev": true,
+      "engines": {
+        "node": "^14.17.0 || ^16.13.0 || >=18.0.0"
+      }
     },
     "node_modules/interpret": {
       "version": "1.4.0",
@@ -7648,13 +7393,13 @@
       }
     },
     "node_modules/is-arguments": {
-      "version": "1.1.1",
-      "resolved": "https://registry.npmjs.org/is-arguments/-/is-arguments-1.1.1.tgz",
-      "integrity": "sha512-8Q7EARjzEnKpt/PCD7e1cgUS0a6X8u5tdSiMqXhojOdoV9TsMsiO+9VLC5vAmO8N7/GmXn7yjR8qnA6bVAEzfA==",
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/is-arguments/-/is-arguments-1.2.0.tgz",
+      "integrity": "sha512-7bVbi0huj/wrIAOzb8U1aszg9kdi3KN/CyU19CTI7tAoZYEZoL9yCDXpbXN+uPsuWnP02cyug1gleqq+TU+YCA==",
       "dev": true,
       "dependencies": {
-        "call-bind": "^1.0.2",
-        "has-tostringtag": "^1.0.0"
+        "call-bound": "^1.0.2",
+        "has-tostringtag": "^1.0.2"
       },
       "engines": {
         "node": ">= 0.4"
@@ -7667,8 +7412,7 @@
       "version": "0.2.1",
       "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz",
       "integrity": "sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==",
-      "dev": true,
-      "license": "MIT"
+      "dev": true
     },
     "node_modules/is-binary-path": {
       "version": "2.1.0",
@@ -7802,7 +7546,6 @@
       "resolved": "https://registry.npmjs.org/is-text-path/-/is-text-path-2.0.0.tgz",
       "integrity": "sha512-+oDTluR6WEjdXEJMnC2z6A4FRwFoYuvShVVEGsS7ewc0UTi2QtAKMDJuL4BDEVt+5T7MjFo12RP8ghOM75oKJw==",
       "dev": true,
-      "license": "MIT",
       "dependencies": {
         "text-extensions": "^2.0.0"
       },
@@ -7811,12 +7554,12 @@
       }
     },
     "node_modules/is-typed-array": {
-      "version": "1.1.13",
-      "resolved": "https://registry.npmjs.org/is-typed-array/-/is-typed-array-1.1.13.tgz",
-      "integrity": "sha512-uZ25/bUAlUY5fR4OKT4rZQEBrzQWYV9ZJYGGsUmEJ6thodVJ1HX64ePQ6Z0qPWP+m+Uq6e9UugrE38jeYsDSMw==",
+      "version": "1.1.15",
+      "resolved": "https://registry.npmjs.org/is-typed-array/-/is-typed-array-1.1.15.tgz",
+      "integrity": "sha512-p3EcsicXjit7SaskXHs1hA91QxgTw46Fv6EFKKGS5DRFLD8yKnohjF3hxoju94b/OcMZoQukzpPpBE9uLVKzgQ==",
       "dev": true,
       "dependencies": {
-        "which-typed-array": "^1.1.14"
+        "which-typed-array": "^1.1.16"
       },
       "engines": {
         "node": ">= 0.4"
@@ -7866,13 +7609,12 @@
       "dev": true
     },
     "node_modules/jiti": {
-      "version": "1.21.6",
-      "resolved": "https://registry.npmjs.org/jiti/-/jiti-1.21.6.tgz",
-      "integrity": "sha512-2yTgeWTWzMWkHu6Jp9NKgePDaYHbntiwvYuuJLbbN9vl7DC9DvXKOB2BC3ZZ92D3cvV/aflH0osDfwpHepQ53w==",
+      "version": "2.4.2",
+      "resolved": "https://registry.npmjs.org/jiti/-/jiti-2.4.2.tgz",
+      "integrity": "sha512-rg9zJN+G4n2nfJl5MW3BMygZX56zKPNVEYYqq7adpmMh4Jn2QNEwhvQlFy6jPVdcod7txZtKHWnyZiA3a0zP7A==",
       "dev": true,
-      "license": "MIT",
       "bin": {
-        "jiti": "bin/jiti.js"
+        "jiti": "lib/jiti-cli.mjs"
       }
     },
     "node_modules/js-cookie": {
@@ -7933,13 +7675,12 @@
       "version": "2.3.1",
       "resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz",
       "integrity": "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==",
-      "dev": true,
-      "license": "MIT"
+      "dev": true
     },
     "node_modules/json-schema-traverse": {
-      "version": "0.4.1",
-      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-0.4.1.tgz",
-      "integrity": "sha512-xbbCH5dCYU5T8LcEhhuh7HJ88HXuW3qsI3Y0zOZFKfZEHcpWiHU/Jxzk629Brsab/mMiHQti9wMP+845RPe3Vg==",
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz",
+      "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==",
       "dev": true
     },
     "node_modules/json-stable-stringify-without-jsonify": {
@@ -7996,8 +7737,7 @@
       "dev": true,
       "engines": [
         "node >= 0.2.0"
-      ],
-      "license": "MIT"
+      ]
     },
     "node_modules/jsonschema": {
       "version": "1.4.1",
@@ -8013,7 +7753,6 @@
       "resolved": "https://registry.npmjs.org/JSONStream/-/JSONStream-1.3.5.tgz",
       "integrity": "sha512-E+iruNOY8VV9s4JEbe1aNEm6MiszPRr/UfcHMz0TQh1BXSxHK+ASV1R6W4HpjBhSeS+54PIsAMCBmwD06LLsqQ==",
       "dev": true,
-      "license": "(MIT OR Apache-2.0)",
       "dependencies": {
         "jsonparse": "^1.2.0",
         "through": ">=2.2.7 <3"
@@ -8085,19 +7824,18 @@
       "version": "1.2.4",
       "resolved": "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.2.4.tgz",
       "integrity": "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==",
-      "dev": true,
-      "license": "MIT"
+      "dev": true
     },
     "node_modules/locate-path": {
-      "version": "6.0.0",
-      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz",
-      "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==",
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-7.2.0.tgz",
+      "integrity": "sha512-gvVijfZvn7R+2qyPX8mAuKcFGDf6Nc61GdvGafQsHL0sBIxfKzA+usWn4GFC/bk+QdwPUD4kWFJLhElipq+0VA==",
       "dev": true,
       "dependencies": {
-        "p-locate": "^5.0.0"
+        "p-locate": "^6.0.0"
       },
       "engines": {
-        "node": ">=10"
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
       },
       "funding": {
         "url": "https://github.com/sponsors/sindresorhus"
@@ -8131,15 +7869,13 @@
       "version": "4.0.6",
       "resolved": "https://registry.npmjs.org/lodash.isplainobject/-/lodash.isplainobject-4.0.6.tgz",
       "integrity": "sha512-oSXzaWypCMHkPC3NvBEaPHf0KsA5mvPrOPgQWDsbg8n7orZ290M0BmC/jgRZ4vcJ6DTAhjrsSYgdsW/F+MFOBA==",
-      "dev": true,
-      "license": "MIT"
+      "dev": true
     },
     "node_modules/lodash.kebabcase": {
       "version": "4.1.1",
       "resolved": "https://registry.npmjs.org/lodash.kebabcase/-/lodash.kebabcase-4.1.1.tgz",
       "integrity": "sha512-N8XRTIMMqqDgSy4VLKPnJ/+hpGZN+PHQiJnSenYqPaVV/NCqEogTnAdZLQiGKhxX+JCs8waWq2t1XHWKOmlY8g==",
-      "dev": true,
-      "license": "MIT"
+      "dev": true
     },
     "node_modules/lodash.merge": {
       "version": "4.6.2",
@@ -8151,22 +7887,19 @@
       "version": "4.6.2",
       "resolved": "https://registry.npmjs.org/lodash.mergewith/-/lodash.mergewith-4.6.2.tgz",
       "integrity": "sha512-GK3g5RPZWTRSeLSpgP8Xhra+pnjBC56q9FZYe1d5RN3TJ35dbkGy3YqBSMbyCrlbi+CM9Z3Jk5yTL7RCsqboyQ==",
-      "dev": true,
-      "license": "MIT"
+      "dev": true
     },
     "node_modules/lodash.snakecase": {
       "version": "4.1.1",
       "resolved": "https://registry.npmjs.org/lodash.snakecase/-/lodash.snakecase-4.1.1.tgz",
       "integrity": "sha512-QZ1d4xoBHYUeuouhEq3lk3Uq7ldgyFXGBhg04+oRLnIz8o9T65Eh+8YdroUwn846zchkA9yDsDl5CVVaV2nqYw==",
-      "dev": true,
-      "license": "MIT"
+      "dev": true
     },
     "node_modules/lodash.startcase": {
       "version": "4.4.0",
       "resolved": "https://registry.npmjs.org/lodash.startcase/-/lodash.startcase-4.4.0.tgz",
       "integrity": "sha512-+WKqsK294HMSc2jEbNgpHpd0JfIBhp7rEV4aqXWqFr6AlXov+SlcgB1Fv01y2kGe3Gc8nMW7VA0SrGuSkRfIEg==",
-      "dev": true,
-      "license": "MIT"
+      "dev": true
     },
     "node_modules/lodash.truncate": {
       "version": "4.4.2",
@@ -8178,15 +7911,13 @@
       "version": "4.5.0",
       "resolved": "https://registry.npmjs.org/lodash.uniq/-/lodash.uniq-4.5.0.tgz",
       "integrity": "sha512-xfBaXQd9ryd9dlSDvnvI0lvxfLJlYAZzXomUYzLKtUeOQvOP5piqAWuGtrhWeqaXK9hhoM/iyJc5AV+XfsX3HQ==",
-      "dev": true,
-      "license": "MIT"
+      "dev": true
     },
     "node_modules/lodash.upperfirst": {
       "version": "4.3.1",
       "resolved": "https://registry.npmjs.org/lodash.upperfirst/-/lodash.upperfirst-4.3.1.tgz",
       "integrity": "sha512-sReKOYJIJf74dhJONhU4e0/shzi1trVbSWDOhKYE5XV2O+H7Sb2Dihwuc7xWxVl+DgFPyTqIN3zMfT9cq5iWDg==",
-      "dev": true,
-      "license": "MIT"
+      "dev": true
     },
     "node_modules/log-symbols": {
       "version": "4.1.0",
@@ -8276,6 +8007,15 @@
       "integrity": "sha512-0EESkXiTkWzrQQntBu2uzKvLu6vVkUGz40nGPbSZuegcfE5UuSzNjLaIu76zJWuaT/2I3Z/8M06OlUOZLGwLlQ==",
       "dev": true
     },
+    "node_modules/math-intrinsics": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
+      "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
+      "dev": true,
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
     "node_modules/md5.js": {
       "version": "1.3.5",
       "resolved": "https://registry.npmjs.org/md5.js/-/md5.js-1.3.5.tgz",
@@ -8301,7 +8041,6 @@
       "resolved": "https://registry.npmjs.org/meow/-/meow-12.1.1.tgz",
       "integrity": "sha512-BhXM0Au22RwUneMPwSCnyhTOizdWoIEPU9sp0Aqa1PnDMR5Wv2FGXYDjuzJEIX+Eo2Rb8xuYe5jrnm5QowQFkw==",
       "dev": true,
-      "license": "MIT",
       "engines": {
         "node": ">=16.10"
       },
@@ -8519,9 +8258,9 @@
       }
     },
     "node_modules/mocha": {
-      "version": "10.7.3",
-      "resolved": "https://registry.npmjs.org/mocha/-/mocha-10.7.3.tgz",
-      "integrity": "sha512-uQWxAu44wwiACGqjbPYmjo7Lg8sFrS3dQe7PP2FQI+woptP4vZXSMcfMyFL/e1yFEeEpV4RtyTpZROOKmxis+A==",
+      "version": "10.8.2",
+      "resolved": "https://registry.npmjs.org/mocha/-/mocha-10.8.2.tgz",
+      "integrity": "sha512-VZlYo/WE8t1tstuRmqgeyBgCbJc/lEdopaa+axcKzTBJ+UIdlAB9XnmvTCAH4pwR4ElNInaedhEBmZD8iCSVEg==",
       "dev": true,
       "dependencies": {
         "ansi-colors": "^4.1.3",
@@ -8577,24 +8316,31 @@
         "fsevents": "~2.3.2"
       }
     },
-    "node_modules/mocha/node_modules/glob": {
-      "version": "8.1.0",
-      "resolved": "https://registry.npmjs.org/glob/-/glob-8.1.0.tgz",
-      "integrity": "sha512-r8hpEjiQEYlF2QU0df3dS+nxxSIreXQS1qRhMJM0Q5NDdR386C7jb7Hwwod8Fgiuex+k0GFjgft18yvxm5XoCQ==",
-      "deprecated": "Glob versions prior to v9 are no longer supported",
+    "node_modules/mocha/node_modules/cliui": {
+      "version": "7.0.4",
+      "resolved": "https://registry.npmjs.org/cliui/-/cliui-7.0.4.tgz",
+      "integrity": "sha512-OcRE68cOsVMXp1Yvonl/fzkQOyjLSu/8bhPDfQt0e0/Eb283TKP20Fs2MqoPsr9SwA595rRCA+QMzYc9nBP+JQ==",
       "dev": true,
       "dependencies": {
-        "fs.realpath": "^1.0.0",
-        "inflight": "^1.0.4",
-        "inherits": "2",
-        "minimatch": "^5.0.1",
-        "once": "^1.3.0"
+        "string-width": "^4.2.0",
+        "strip-ansi": "^6.0.0",
+        "wrap-ansi": "^7.0.0"
+      }
+    },
+    "node_modules/mocha/node_modules/find-up": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz",
+      "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==",
+      "dev": true,
+      "dependencies": {
+        "locate-path": "^6.0.0",
+        "path-exists": "^4.0.0"
       },
       "engines": {
-        "node": ">=12"
+        "node": ">=10"
       },
       "funding": {
-        "url": "https://github.com/sponsors/isaacs"
+        "url": "https://github.com/sponsors/sindresorhus"
       }
     },
     "node_modules/mocha/node_modules/glob-parent": {
@@ -8609,6 +8355,21 @@
         "node": ">= 6"
       }
     },
+    "node_modules/mocha/node_modules/locate-path": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz",
+      "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==",
+      "dev": true,
+      "dependencies": {
+        "p-locate": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/mocha/node_modules/minimatch": {
       "version": "5.1.6",
       "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.6.tgz",
@@ -8618,7 +8379,46 @@
         "brace-expansion": "^2.0.1"
       },
       "engines": {
-        "node": ">=10"
+        "node": ">=10"
+      }
+    },
+    "node_modules/mocha/node_modules/p-limit": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz",
+      "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==",
+      "dev": true,
+      "dependencies": {
+        "yocto-queue": "^0.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/mocha/node_modules/p-locate": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz",
+      "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==",
+      "dev": true,
+      "dependencies": {
+        "p-limit": "^3.0.2"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/mocha/node_modules/path-exists": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
+      "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==",
+      "dev": true,
+      "engines": {
+        "node": ">=8"
       }
     },
     "node_modules/mocha/node_modules/readdirp": {
@@ -8648,6 +8448,36 @@
         "url": "https://github.com/chalk/supports-color?sponsor=1"
       }
     },
+    "node_modules/mocha/node_modules/yargs": {
+      "version": "16.2.0",
+      "resolved": "https://registry.npmjs.org/yargs/-/yargs-16.2.0.tgz",
+      "integrity": "sha512-D1mvvtDG0L5ft/jGWkLpG1+m0eQxOfaBvTNELraWj22wSVUMWxZUvYgJYcKh6jGGIkJFhH4IZPQhR4TKpc8mBw==",
+      "dev": true,
+      "dependencies": {
+        "cliui": "^7.0.2",
+        "escalade": "^3.1.1",
+        "get-caller-file": "^2.0.5",
+        "require-directory": "^2.1.1",
+        "string-width": "^4.2.0",
+        "y18n": "^5.0.5",
+        "yargs-parser": "^20.2.2"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/mocha/node_modules/yocto-queue": {
+      "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz",
+      "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==",
+      "dev": true,
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/ms": {
       "version": "2.1.3",
       "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
@@ -8702,10 +8532,20 @@
         "node": ">=10"
       }
     },
+    "node_modules/ndjson/node_modules/split2": {
+      "version": "3.2.2",
+      "resolved": "https://registry.npmjs.org/split2/-/split2-3.2.2.tgz",
+      "integrity": "sha512-9NThjpgZnifTkJpzTZ7Eue85S49QwpNhZTq6GRJwObb6jnLFNGB7Qm73V5HewTROPyxD0C29xqmaI68bQtV+hg==",
+      "dev": true,
+      "peer": true,
+      "dependencies": {
+        "readable-stream": "^3.0.0"
+      }
+    },
     "node_modules/negotiator": {
-      "version": "0.6.3",
-      "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.3.tgz",
-      "integrity": "sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==",
+      "version": "0.6.4",
+      "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.4.tgz",
+      "integrity": "sha512-myRT3DiWPHqho5PrJaIRyaMv2kgYf0mUVgBNOYMuCH5Ki1yEiQaf/ZJuQ62nvpc44wL5WDbTX7yGJi1Neevw8w==",
       "optional": true,
       "engines": {
         "node": ">= 0.6"
@@ -8718,9 +8558,9 @@
       "dev": true
     },
     "node_modules/node-abi": {
-      "version": "3.68.0",
-      "resolved": "https://registry.npmjs.org/node-abi/-/node-abi-3.68.0.tgz",
-      "integrity": "sha512-7vbj10trelExNjFSBm5kTvZXXa7pZyKWx9RCKIyqe6I9Ev3IzGpQoqBP3a+cOdxY+pWj6VkP28n/2wWysBHD/A==",
+      "version": "3.71.0",
+      "resolved": "https://registry.npmjs.org/node-abi/-/node-abi-3.71.0.tgz",
+      "integrity": "sha512-SZ40vRiy/+wRTf21hxkkEjPJZpARzUMVcJoQse2EF8qkUWbbO2z7vd5oA/H6bVH6SZQ5STGcu0KRDS7biNRfxw==",
       "dependencies": {
         "semver": "^7.3.5"
       },
@@ -8728,17 +8568,6 @@
         "node": ">=10"
       }
     },
-    "node_modules/node-abi/node_modules/semver": {
-      "version": "7.6.3",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-7.6.3.tgz",
-      "integrity": "sha512-oVekP1cKtI+CTDvHWYFUcMtsK/00wmAEfyqKfNdARm8u1wNVhSgaX7A8d4UuIlUI5e84iEwOhs7ZPYRmzU9U6A==",
-      "bin": {
-        "semver": "bin/semver.js"
-      },
-      "engines": {
-        "node": ">=10"
-      }
-    },
     "node_modules/node-addon-api": {
       "version": "2.0.2",
       "resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-2.0.2.tgz",
@@ -8799,9 +8628,9 @@
       }
     },
     "node_modules/node-gyp-build": {
-      "version": "4.8.2",
-      "resolved": "https://registry.npmjs.org/node-gyp-build/-/node-gyp-build-4.8.2.tgz",
-      "integrity": "sha512-IRUxE4BVsHWXkV/SFOut4qTlagw2aM8T5/vnTsmrHJvVoKueJHRc/JaFND7QDDc61kLYUJ6qlZM3sqTSyx2dTw==",
+      "version": "4.8.4",
+      "resolved": "https://registry.npmjs.org/node-gyp-build/-/node-gyp-build-4.8.4.tgz",
+      "integrity": "sha512-LA4ZjwlnUblHVgq0oBF3Jl/6h/Nvs5fzBLwdEF4nuxnFdsfajde4WfxtJr3CaiH+F6ewcIB/q4jQ4UzPyid+CQ==",
       "dev": true,
       "bin": {
         "node-gyp-build": "bin.js",
@@ -8809,6 +8638,49 @@
         "node-gyp-build-test": "build-test.js"
       }
     },
+    "node_modules/node-gyp/node_modules/brace-expansion": {
+      "version": "1.1.11",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
+      "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
+      "optional": true,
+      "dependencies": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "node_modules/node-gyp/node_modules/glob": {
+      "version": "7.2.3",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz",
+      "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==",
+      "deprecated": "Glob versions prior to v9 are no longer supported",
+      "optional": true,
+      "dependencies": {
+        "fs.realpath": "^1.0.0",
+        "inflight": "^1.0.4",
+        "inherits": "2",
+        "minimatch": "^3.1.1",
+        "once": "^1.3.0",
+        "path-is-absolute": "^1.0.0"
+      },
+      "engines": {
+        "node": "*"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/node-gyp/node_modules/minimatch": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
+      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+      "optional": true,
+      "dependencies": {
+        "brace-expansion": "^1.1.7"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
     "node_modules/node-gyp/node_modules/nopt": {
       "version": "5.0.0",
       "resolved": "https://registry.npmjs.org/nopt/-/nopt-5.0.0.tgz",
@@ -8840,18 +8712,6 @@
         "url": "https://github.com/sponsors/isaacs"
       }
     },
-    "node_modules/node-gyp/node_modules/semver": {
-      "version": "7.6.3",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-7.6.3.tgz",
-      "integrity": "sha512-oVekP1cKtI+CTDvHWYFUcMtsK/00wmAEfyqKfNdARm8u1wNVhSgaX7A8d4UuIlUI5e84iEwOhs7ZPYRmzU9U6A==",
-      "optional": true,
-      "bin": {
-        "semver": "bin/semver.js"
-      },
-      "engines": {
-        "node": ">=10"
-      }
-    },
     "node_modules/node-interval-tree": {
       "version": "2.1.2",
       "resolved": "https://registry.npmjs.org/node-interval-tree/-/node-interval-tree-2.1.2.tgz",
@@ -8871,9 +8731,9 @@
       "dev": true
     },
     "node_modules/node-tkms": {
-      "version": "0.9.0-rc27",
-      "resolved": "https://registry.npmjs.org/node-tkms/-/node-tkms-0.9.0-rc27.tgz",
-      "integrity": "sha512-lRCgH5pHewK5IRkczX1zpDpU0BidGHKDtaN812Yh9fhR97aqKVDWdSidQrOqX7RSstDkHeJ1dDyN6fx2wkQ+4Q==",
+      "version": "0.9.0",
+      "resolved": "https://registry.npmjs.org/node-tkms/-/node-tkms-0.9.0.tgz",
+      "integrity": "sha512-ulhV23okeMW3WYnxzhvf9u87tcXqe64JqUFlvdgu64uKteG8re+zwOjzkOdxvF0xSWQbMtEU96dvcrvQM10PEg==",
       "dev": true
     },
     "node_modules/nofilter": {
@@ -8952,9 +8812,9 @@
       }
     },
     "node_modules/object-inspect": {
-      "version": "1.13.2",
-      "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.2.tgz",
-      "integrity": "sha512-IRZSRuzJiynemAXPYtPe5BoI/RESNYR7TYm50MC5Mqbd3Jmw5y790sErYw3V6SryFJD64b74qQQs9wn5Bg/k3g==",
+      "version": "1.13.3",
+      "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.3.tgz",
+      "integrity": "sha512-kDCGIbxkDSXE3euJZZXzc6to7fCrKHNI/hSRQnRuQ+BWjFNzZwiFF8fj/6o2t2G9/jTj8PSIYTfCLelLZEeRpA==",
       "dev": true,
       "engines": {
         "node": ">= 0.4"
@@ -9010,30 +8870,30 @@
       }
     },
     "node_modules/p-limit": {
-      "version": "3.1.0",
-      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz",
-      "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==",
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-4.0.0.tgz",
+      "integrity": "sha512-5b0R4txpzjPWVw/cXXUResoD4hb6U/x9BH08L7nw+GN1sezDzPdxeRvpc9c433fZhBan/wusjbCsqwqm4EIBIQ==",
       "dev": true,
       "dependencies": {
-        "yocto-queue": "^0.1.0"
+        "yocto-queue": "^1.0.0"
       },
       "engines": {
-        "node": ">=10"
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
       },
       "funding": {
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
     "node_modules/p-locate": {
-      "version": "5.0.0",
-      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz",
-      "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==",
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-6.0.0.tgz",
+      "integrity": "sha512-wPrq66Llhl7/4AGC6I+cqxT07LhXvWL08LNXz1fENOw0Ap4sRZZ/gZpTTJ5jpurzzzfS2W/Ge9BY3LgLjCShcw==",
       "dev": true,
       "dependencies": {
-        "p-limit": "^3.0.2"
+        "p-limit": "^4.0.0"
       },
       "engines": {
-        "node": ">=10"
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
       },
       "funding": {
         "url": "https://github.com/sponsors/sindresorhus"
@@ -9054,15 +8914,6 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
-    "node_modules/p-try": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/p-try/-/p-try-1.0.0.tgz",
-      "integrity": "sha512-U1etNYuMJoIz3ZXSrrySFjsXQTWOx2/jdi86L+2pRvph/qMKL6sbcCYdH23fqsbm8TH2Gn0OybpT4eSFlCVHww==",
-      "dev": true,
-      "engines": {
-        "node": ">=4"
-      }
-    },
     "node_modules/parent-module": {
       "version": "1.0.1",
       "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz",
@@ -9086,7 +8937,6 @@
       "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-5.2.0.tgz",
       "integrity": "sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==",
       "dev": true,
-      "license": "MIT",
       "dependencies": {
         "@babel/code-frame": "^7.0.0",
         "error-ex": "^1.3.1",
@@ -9101,12 +8951,12 @@
       }
     },
     "node_modules/path-exists": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz",
-      "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==",
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-5.0.0.tgz",
+      "integrity": "sha512-RjhtfwJOxzcFmNOi6ltcbcu4Iu+FL3zEj83dk4kAS+fVpTxXLO1b38RvJgT/0QwvV/L3aY9TAnyv0EOqW4GoMQ==",
       "dev": true,
       "engines": {
-        "node": ">=8"
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
       }
     },
     "node_modules/path-is-absolute": {
@@ -9199,9 +9049,9 @@
       }
     },
     "node_modules/picocolors": {
-      "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.0.tgz",
-      "integrity": "sha512-TQ92mBOW0l3LeMeyLV6mzy/kWr8lkd/hp3mTg7wYK7zJhuBStmGMBG0BdeDZS/dZx1IukaX6Bk11zcln25o1Aw==",
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
       "dev": true
     },
     "node_modules/picomatch": {
@@ -9273,7 +9123,6 @@
       "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.4.2.tgz",
       "integrity": "sha512-e9MewbtFo+Fevyuxn/4rrcDAaq0IYxPGLvObpQjiZBMAzB9IGmzlnG9RZy3FFas+eBMu2vA0CszMeduow5dIuQ==",
       "dev": true,
-      "license": "MIT",
       "bin": {
         "prettier": "bin/prettier.cjs"
       },
@@ -9306,18 +9155,6 @@
       "integrity": "sha512-yfORGUIPgLck41qyN7nbwJRAx17/jAIXCTanHOJZhB6PJ1iAk/84b/xlsVKFSyNyLXIj0dhppoE0+CRws7wlzA==",
       "dev": true
     },
-    "node_modules/prettier-plugin-solidity/node_modules/semver": {
-      "version": "7.6.3",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-7.6.3.tgz",
-      "integrity": "sha512-oVekP1cKtI+CTDvHWYFUcMtsK/00wmAEfyqKfNdARm8u1wNVhSgaX7A8d4UuIlUI5e84iEwOhs7ZPYRmzU9U6A==",
-      "dev": true,
-      "bin": {
-        "semver": "bin/semver.js"
-      },
-      "engines": {
-        "node": ">=10"
-      }
-    },
     "node_modules/process-nextick-args": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/process-nextick-args/-/process-nextick-args-2.0.1.tgz",
@@ -9420,9 +9257,9 @@
       }
     },
     "node_modules/qs": {
-      "version": "6.13.0",
-      "resolved": "https://registry.npmjs.org/qs/-/qs-6.13.0.tgz",
-      "integrity": "sha512-+38qI9SOr8tfZ4QmJNplMUxqjbe7LKvvZgWdExBOmd+egZTtjLB67Gu0HRX3u/XOq7UU2Nx6nsjvS16Z9uwfpg==",
+      "version": "6.13.1",
+      "resolved": "https://registry.npmjs.org/qs/-/qs-6.13.1.tgz",
+      "integrity": "sha512-EJPeIn0CYrGu+hli1xilKAPXODtJ12T0sP63Ijx2/khC2JtuaN3JyNIpvmnkmaEtha9ocbG4A4cMcr+TvqvwQg==",
       "dev": true,
       "dependencies": {
         "side-channel": "^1.0.6"
@@ -9492,6 +9329,11 @@
         "rc": "cli.js"
       }
     },
+    "node_modules/rc/node_modules/ini": {
+      "version": "1.3.8",
+      "resolved": "https://registry.npmjs.org/ini/-/ini-1.3.8.tgz",
+      "integrity": "sha512-JV/yugV2uzW5iMRSiZAyDtQd+nxtUnjeLt0acNdw98kKLrvuRVyB80tsREOE7yvGVgalhZ6RNXCmEHkUKBKxew=="
+    },
     "node_modules/rc/node_modules/strip-json-comments": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/strip-json-comments/-/strip-json-comments-2.0.1.tgz",
@@ -9654,12 +9496,12 @@
       }
     },
     "node_modules/resolve-from": {
-      "version": "4.0.0",
-      "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz",
-      "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==",
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-5.0.0.tgz",
+      "integrity": "sha512-qYg9KP24dD5qka9J47d0aVky0N+b4fTU89LN9iDnjB5waksiC49rvMB0PrUJQGoTmH50XPiqOvAjDfaijGxYZw==",
       "dev": true,
       "engines": {
-        "node": ">=4"
+        "node": ">=8"
       }
     },
     "node_modules/retry": {
@@ -10004,12 +9846,14 @@
       "dev": true
     },
     "node_modules/semver": {
-      "version": "6.3.1",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",
-      "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",
-      "dev": true,
+      "version": "7.6.3",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.6.3.tgz",
+      "integrity": "sha512-oVekP1cKtI+CTDvHWYFUcMtsK/00wmAEfyqKfNdARm8u1wNVhSgaX7A8d4UuIlUI5e84iEwOhs7ZPYRmzU9U6A==",
       "bin": {
         "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
       }
     },
     "node_modules/serialize-javascript": {
@@ -10096,79 +9940,176 @@
       "resolved": "https://registry.npmjs.org/buffer/-/buffer-6.0.3.tgz",
       "integrity": "sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA==",
       "dev": true,
-      "funding": [
-        {
-          "type": "github",
-          "url": "https://github.com/sponsors/feross"
-        },
-        {
-          "type": "patreon",
-          "url": "https://www.patreon.com/feross"
-        },
-        {
-          "type": "consulting",
-          "url": "https://feross.org/support"
-        }
-      ],
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "dependencies": {
+        "base64-js": "^1.3.1",
+        "ieee754": "^1.2.1"
+      }
+    },
+    "node_modules/shallowequal": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/shallowequal/-/shallowequal-1.1.0.tgz",
+      "integrity": "sha512-y0m1JoUZSlPAjXVtPPW70aZWfIL/dSP7AFkRnniLCrK/8MDKog3TySTBmckD+RObVxH0v4Tox67+F14PdED2oQ==",
+      "dev": true
+    },
+    "node_modules/shebang-command": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
+      "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
+      "dev": true,
+      "dependencies": {
+        "shebang-regex": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/shebang-regex": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
+      "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
+      "dev": true,
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/shelljs": {
+      "version": "0.8.5",
+      "resolved": "https://registry.npmjs.org/shelljs/-/shelljs-0.8.5.tgz",
+      "integrity": "sha512-TiwcRcrkhHvbrZbnRcFYMLl30Dfov3HKqzp5tO5b4pt6G/SezKcYhmDg15zXVBswHmctSAQKznqNW2LO5tTDow==",
+      "dev": true,
+      "dependencies": {
+        "glob": "^7.0.0",
+        "interpret": "^1.0.0",
+        "rechoir": "^0.6.2"
+      },
+      "bin": {
+        "shjs": "bin/shjs"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/shelljs/node_modules/brace-expansion": {
+      "version": "1.1.11",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
+      "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
+      "dev": true,
+      "dependencies": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
+    "node_modules/shelljs/node_modules/glob": {
+      "version": "7.2.3",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz",
+      "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==",
+      "deprecated": "Glob versions prior to v9 are no longer supported",
+      "dev": true,
+      "dependencies": {
+        "fs.realpath": "^1.0.0",
+        "inflight": "^1.0.4",
+        "inherits": "2",
+        "minimatch": "^3.1.1",
+        "once": "^1.3.0",
+        "path-is-absolute": "^1.0.0"
+      },
+      "engines": {
+        "node": "*"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/shelljs/node_modules/minimatch": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
+      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+      "dev": true,
       "dependencies": {
-        "base64-js": "^1.3.1",
-        "ieee754": "^1.2.1"
+        "brace-expansion": "^1.1.7"
+      },
+      "engines": {
+        "node": "*"
       }
     },
-    "node_modules/shallowequal": {
+    "node_modules/side-channel": {
       "version": "1.1.0",
-      "resolved": "https://registry.npmjs.org/shallowequal/-/shallowequal-1.1.0.tgz",
-      "integrity": "sha512-y0m1JoUZSlPAjXVtPPW70aZWfIL/dSP7AFkRnniLCrK/8MDKog3TySTBmckD+RObVxH0v4Tox67+F14PdED2oQ==",
-      "dev": true
-    },
-    "node_modules/shebang-command": {
-      "version": "2.0.0",
-      "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
-      "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
+      "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.0.tgz",
+      "integrity": "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==",
       "dev": true,
       "dependencies": {
-        "shebang-regex": "^3.0.0"
+        "es-errors": "^1.3.0",
+        "object-inspect": "^1.13.3",
+        "side-channel-list": "^1.0.0",
+        "side-channel-map": "^1.0.1",
+        "side-channel-weakmap": "^1.0.2"
       },
       "engines": {
-        "node": ">=8"
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/shebang-regex": {
-      "version": "3.0.0",
-      "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
-      "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
+    "node_modules/side-channel-list": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.0.tgz",
+      "integrity": "sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==",
       "dev": true,
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "object-inspect": "^1.13.3"
+      },
       "engines": {
-        "node": ">=8"
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/shelljs": {
-      "version": "0.8.5",
-      "resolved": "https://registry.npmjs.org/shelljs/-/shelljs-0.8.5.tgz",
-      "integrity": "sha512-TiwcRcrkhHvbrZbnRcFYMLl30Dfov3HKqzp5tO5b4pt6G/SezKcYhmDg15zXVBswHmctSAQKznqNW2LO5tTDow==",
+    "node_modules/side-channel-map": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz",
+      "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==",
       "dev": true,
       "dependencies": {
-        "glob": "^7.0.0",
-        "interpret": "^1.0.0",
-        "rechoir": "^0.6.2"
-      },
-      "bin": {
-        "shjs": "bin/shjs"
+        "call-bound": "^1.0.2",
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.5",
+        "object-inspect": "^1.13.3"
       },
       "engines": {
-        "node": ">=4"
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
       }
     },
-    "node_modules/side-channel": {
-      "version": "1.0.6",
-      "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.0.6.tgz",
-      "integrity": "sha512-fDW/EZ6Q9RiO8eFG8Hj+7u/oW+XrPTIChwCOM2+th2A6OblDtYYIpve9m+KvI9Z4C9qSEXlaGR6bTEYHReuglA==",
+    "node_modules/side-channel-weakmap": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz",
+      "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==",
       "dev": true,
       "dependencies": {
-        "call-bind": "^1.0.7",
+        "call-bound": "^1.0.2",
         "es-errors": "^1.3.0",
-        "get-intrinsic": "^1.2.4",
-        "object-inspect": "^1.13.1"
+        "get-intrinsic": "^1.2.5",
+        "object-inspect": "^1.13.3",
+        "side-channel-map": "^1.0.1"
       },
       "engines": {
         "node": ">= 0.4"
@@ -10574,6 +10515,16 @@
         "node": ">=4"
       }
     },
+    "node_modules/solidity-coverage/node_modules/brace-expansion": {
+      "version": "1.1.11",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
+      "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
+      "dev": true,
+      "dependencies": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
     "node_modules/solidity-coverage/node_modules/chalk": {
       "version": "2.4.2",
       "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz",
@@ -10626,6 +10577,27 @@
         "node": ">=6 <7 || >=8"
       }
     },
+    "node_modules/solidity-coverage/node_modules/glob": {
+      "version": "7.2.3",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz",
+      "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==",
+      "deprecated": "Glob versions prior to v9 are no longer supported",
+      "dev": true,
+      "dependencies": {
+        "fs.realpath": "^1.0.0",
+        "inflight": "^1.0.4",
+        "inherits": "2",
+        "minimatch": "^3.1.1",
+        "once": "^1.3.0",
+        "path-is-absolute": "^1.0.0"
+      },
+      "engines": {
+        "node": "*"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
     "node_modules/solidity-coverage/node_modules/globby": {
       "version": "10.0.2",
       "resolved": "https://registry.npmjs.org/globby/-/globby-10.0.2.tgz",
@@ -10663,16 +10635,16 @@
         "graceful-fs": "^4.1.6"
       }
     },
-    "node_modules/solidity-coverage/node_modules/semver": {
-      "version": "7.6.3",
-      "resolved": "https://registry.npmjs.org/semver/-/semver-7.6.3.tgz",
-      "integrity": "sha512-oVekP1cKtI+CTDvHWYFUcMtsK/00wmAEfyqKfNdARm8u1wNVhSgaX7A8d4UuIlUI5e84iEwOhs7ZPYRmzU9U6A==",
+    "node_modules/solidity-coverage/node_modules/minimatch": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
+      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
       "dev": true,
-      "bin": {
-        "semver": "bin/semver.js"
+      "dependencies": {
+        "brace-expansion": "^1.1.7"
       },
       "engines": {
-        "node": ">=10"
+        "node": "*"
       }
     },
     "node_modules/solidity-coverage/node_modules/supports-color": {
@@ -10725,13 +10697,12 @@
       }
     },
     "node_modules/split2": {
-      "version": "3.2.2",
-      "resolved": "https://registry.npmjs.org/split2/-/split2-3.2.2.tgz",
-      "integrity": "sha512-9NThjpgZnifTkJpzTZ7Eue85S49QwpNhZTq6GRJwObb6jnLFNGB7Qm73V5HewTROPyxD0C29xqmaI68bQtV+hg==",
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/split2/-/split2-4.2.0.tgz",
+      "integrity": "sha512-UcjcJOWknrNkF6PLX83qcHM6KHgVKNkV62Y8a5uYDVv9ydGQVwAHMKqHdJje1VTWpljG0WYpCDhrCdAOYH4TWg==",
       "dev": true,
-      "peer": true,
-      "dependencies": {
-        "readable-stream": "^3.0.0"
+      "engines": {
+        "node": ">= 10.x"
       }
     },
     "node_modules/sprintf-js": {
@@ -10911,9 +10882,9 @@
       }
     },
     "node_modules/table": {
-      "version": "6.8.2",
-      "resolved": "https://registry.npmjs.org/table/-/table-6.8.2.tgz",
-      "integrity": "sha512-w2sfv80nrAh2VCbqR5AK27wswXhqcck2AhfnNW76beQXskGZ1V12GwS//yYVa3d3fcvAip2OUnbDAjW2k3v9fA==",
+      "version": "6.9.0",
+      "resolved": "https://registry.npmjs.org/table/-/table-6.9.0.tgz",
+      "integrity": "sha512-9kY+CygyYM6j02t5YFHbNz2FN5QmYGv9zAjVp4lCDjlCw7amdckXlEt/bjMhUIfj4ThGRE4gCUH5+yGnNuPo5A==",
       "dev": true,
       "dependencies": {
         "ajv": "^8.0.1",
@@ -10959,28 +10930,6 @@
         "node": ">=8"
       }
     },
-    "node_modules/table/node_modules/ajv": {
-      "version": "8.17.1",
-      "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.17.1.tgz",
-      "integrity": "sha512-B/gBuNg5SiMTrPkC+A2+cW0RszwxYmn6VYxB/inlBStS5nx6xHIt/ehKRhIMhqusl7a8LjQoZnjCs5vhwxOQ1g==",
-      "dev": true,
-      "dependencies": {
-        "fast-deep-equal": "^3.1.3",
-        "fast-uri": "^3.0.1",
-        "json-schema-traverse": "^1.0.0",
-        "require-from-string": "^2.0.2"
-      },
-      "funding": {
-        "type": "github",
-        "url": "https://github.com/sponsors/epoberezkin"
-      }
-    },
-    "node_modules/table/node_modules/json-schema-traverse": {
-      "version": "1.0.0",
-      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz",
-      "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==",
-      "dev": true
-    },
     "node_modules/tar": {
       "version": "6.2.1",
       "resolved": "https://registry.npmjs.org/tar/-/tar-6.2.1.tgz",
@@ -11052,7 +11001,6 @@
       "resolved": "https://registry.npmjs.org/text-extensions/-/text-extensions-2.4.0.tgz",
       "integrity": "sha512-te/NtwBwfiNRLf9Ijqx3T0nlqZiQ2XrrtBvu+cLL8ZRrGkO0NHTug8MYFKyoSrv/sHTaSKfilUkizV6XhxMJ3g==",
       "dev": true,
-      "license": "MIT",
       "engines": {
         "node": ">=8"
       },
@@ -11101,14 +11049,15 @@
       "dev": true
     },
     "node_modules/then-request/node_modules/form-data": {
-      "version": "2.5.1",
-      "resolved": "https://registry.npmjs.org/form-data/-/form-data-2.5.1.tgz",
-      "integrity": "sha512-m21N3WOmEEURgk6B9GLOE4RuWOFf28Lhh9qGYeNlGq4VDXUlJy2th2slBNU8Gp8EzloYZOibZJ7t5ecIrFSjVA==",
+      "version": "2.5.2",
+      "resolved": "https://registry.npmjs.org/form-data/-/form-data-2.5.2.tgz",
+      "integrity": "sha512-GgwY0PS7DbXqajuGf4OYlsrIu3zgxD6Vvql43IBhm6MahqA5SK/7mwhtNj2AdH2z35YR34ujJ7BN+3fFC3jP5Q==",
       "dev": true,
       "dependencies": {
         "asynckit": "^0.4.0",
         "combined-stream": "^1.0.6",
-        "mime-types": "^2.1.12"
+        "mime-types": "^2.1.12",
+        "safe-buffer": "^5.2.1"
       },
       "engines": {
         "node": ">= 0.12"
@@ -11118,8 +11067,7 @@
       "version": "2.3.8",
       "resolved": "https://registry.npmjs.org/through/-/through-2.3.8.tgz",
       "integrity": "sha512-w89qg7PI8wAdvX60bMDP+bFoD5Dvhm9oLheFp5O4a2QF0cSBGsBX4qZmadPMvVqlLJBBci+WqGGOAPvcDeNSVg==",
-      "dev": true,
-      "license": "MIT"
+      "dev": true
     },
     "node_modules/through2": {
       "version": "4.0.2",
@@ -11135,13 +11083,51 @@
       "version": "0.3.1",
       "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-0.3.1.tgz",
       "integrity": "sha512-WiCJLEECkO18gwqIp6+hJg0//p23HXp4S+gGtAKu3mI2F2/sXC4FvHvXvB0zJVVaTPhx1/tOwdbRsa1sOBIKqQ==",
+      "dev": true
+    },
+    "node_modules/tinyglobby": {
+      "version": "0.2.10",
+      "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.10.tgz",
+      "integrity": "sha512-Zc+8eJlFMvgatPZTl6A9L/yht8QqdmUNtURHaKZLmKBE12hNPSrqNkUp2cs3M/UKmNVVAMFQYSjYIVHDjW5zew==",
+      "dev": true,
+      "dependencies": {
+        "fdir": "^6.4.2",
+        "picomatch": "^4.0.2"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      }
+    },
+    "node_modules/tinyglobby/node_modules/fdir": {
+      "version": "6.4.2",
+      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.4.2.tgz",
+      "integrity": "sha512-KnhMXsKSPZlAhp7+IjUkRZKPb4fUyccpDrdFXbi4QL1qkmFh9kVY09Yox+n4MaOb3lHZ1Tv829C3oaaXoMYPDQ==",
+      "dev": true,
+      "peerDependencies": {
+        "picomatch": "^3 || ^4"
+      },
+      "peerDependenciesMeta": {
+        "picomatch": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/tinyglobby/node_modules/picomatch": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.2.tgz",
+      "integrity": "sha512-M7BAV6Rlcy5u+m6oPhAPFgJTzAioX/6B0DxyvDlo9l8+T3nLKbrczg2WLUyzd45L8RqfUMyGPzekbMvX2Ldkwg==",
       "dev": true,
-      "license": "MIT"
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/jonschlinkert"
+      }
     },
     "node_modules/tkms": {
-      "version": "0.9.0-rc27",
-      "resolved": "https://registry.npmjs.org/tkms/-/tkms-0.9.0-rc27.tgz",
-      "integrity": "sha512-sSO1jb4/gw0FjS+AubW35/KnJfx1qBp2EuIb0gLg7247DS2VlsBh2iNlBtHKKBevhkgfvjdOt0YZT1J0y9Bv/Q==",
+      "version": "0.9.0",
+      "resolved": "https://registry.npmjs.org/tkms/-/tkms-0.9.0.tgz",
+      "integrity": "sha512-dSzorTHvIXTYZtn6ACV/iz0GhO/kMRjqGbo3o7JJ3GNbFhsPzbIEtAQ/x+h9nJdwn//VRdsStnOAE0fxUVIGrQ==",
       "dev": true
     },
     "node_modules/tmp": {
@@ -11248,6 +11234,16 @@
         "node": ">=4"
       }
     },
+    "node_modules/ts-generator/node_modules/brace-expansion": {
+      "version": "1.1.11",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.11.tgz",
+      "integrity": "sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==",
+      "dev": true,
+      "dependencies": {
+        "balanced-match": "^1.0.0",
+        "concat-map": "0.0.1"
+      }
+    },
     "node_modules/ts-generator/node_modules/chalk": {
       "version": "2.4.2",
       "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz",
@@ -11286,6 +11282,27 @@
         "node": ">=0.8.0"
       }
     },
+    "node_modules/ts-generator/node_modules/glob": {
+      "version": "7.2.3",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz",
+      "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==",
+      "deprecated": "Glob versions prior to v9 are no longer supported",
+      "dev": true,
+      "dependencies": {
+        "fs.realpath": "^1.0.0",
+        "inflight": "^1.0.4",
+        "inherits": "2",
+        "minimatch": "^3.1.1",
+        "once": "^1.3.0",
+        "path-is-absolute": "^1.0.0"
+      },
+      "engines": {
+        "node": "*"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
     "node_modules/ts-generator/node_modules/has-flag": {
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
@@ -11295,6 +11312,18 @@
         "node": ">=4"
       }
     },
+    "node_modules/ts-generator/node_modules/minimatch": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
+      "integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
+      "dev": true,
+      "dependencies": {
+        "brace-expansion": "^1.1.7"
+      },
+      "engines": {
+        "node": "*"
+      }
+    },
     "node_modules/ts-generator/node_modules/prettier": {
       "version": "2.8.8",
       "resolved": "https://registry.npmjs.org/prettier/-/prettier-2.8.8.tgz",
@@ -11596,9 +11625,9 @@
       "dev": true
     },
     "node_modules/typescript": {
-      "version": "5.6.3",
-      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.6.3.tgz",
-      "integrity": "sha512-hjcS1mhfuyi4WW8IWtjP7brDrG2cuDZukyrYrSauoXGNgx0S7zceP07adYkJycEr56BOUTNPzbInooiN3fn1qw==",
+      "version": "5.7.2",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.7.2.tgz",
+      "integrity": "sha512-i5t66RHxDvVN40HfDd1PsEThGNnlMCMT3jMUuoh9/0TaqWevNontacunWyN02LA9/fIbEWlcHZcgTKb9QoaLfg==",
       "dev": true,
       "bin": {
         "tsc": "bin/tsc",
@@ -11659,7 +11688,6 @@
       "resolved": "https://registry.npmjs.org/unicorn-magic/-/unicorn-magic-0.1.0.tgz",
       "integrity": "sha512-lRfVq8fE8gz6QMBuDM6a+LO3IAzTi05H6gCVaUpir2E1Rwpo4ZUog45KpNXKC/Mn3Yb9UDuHumeFTo9iV/D9FQ==",
       "dev": true,
-      "license": "MIT",
       "engines": {
         "node": ">=18"
       },
@@ -11712,25 +11740,6 @@
         "punycode": "^2.1.0"
       }
     },
-    "node_modules/url": {
-      "version": "0.11.4",
-      "resolved": "https://registry.npmjs.org/url/-/url-0.11.4.tgz",
-      "integrity": "sha512-oCwdVC7mTuWiPyjLUz/COz5TLk6wgp0RCsN+wHZ2Ekneac9w8uuV0njcbbie2ME+Vs+d6duwmYuR3HgQXs1fOg==",
-      "dev": true,
-      "dependencies": {
-        "punycode": "^1.4.1",
-        "qs": "^6.12.3"
-      },
-      "engines": {
-        "node": ">= 0.4"
-      }
-    },
-    "node_modules/url/node_modules/punycode": {
-      "version": "1.4.1",
-      "resolved": "https://registry.npmjs.org/punycode/-/punycode-1.4.1.tgz",
-      "integrity": "sha512-jmYNElW7yvO7TV33CjSmvSiE2yco3bV2czu/OzDKdMNVZQWfxCblURLhf+47syQRBntjfLdd/H0egrzIG+oaFQ==",
-      "dev": true
-    },
     "node_modules/utf8": {
       "version": "3.0.0",
       "resolved": "https://registry.npmjs.org/utf8/-/utf8-3.0.0.tgz",
@@ -11770,13 +11779,19 @@
       "integrity": "sha512-wa7YjyUGfNZngI/vtK0UHAN+lgDCxBPCylVXGp0zu59Fz5aiGtNXaq3DhIov063MorB+VfufLh3JlF2KdTK3xg==",
       "dev": true
     },
+    "node_modules/wasm-feature-detect": {
+      "version": "1.8.0",
+      "resolved": "https://registry.npmjs.org/wasm-feature-detect/-/wasm-feature-detect-1.8.0.tgz",
+      "integrity": "sha512-zksaLKM2fVlnB5jQQDqKXXwYHLQUVH9es+5TOOHwGOVJOCeRBCiPjwSg+3tN2AdTCzjgli4jijCH290kXb/zWQ==",
+      "dev": true
+    },
     "node_modules/web3-errors": {
-      "version": "1.3.0",
-      "resolved": "https://registry.npmjs.org/web3-errors/-/web3-errors-1.3.0.tgz",
-      "integrity": "sha512-j5JkAKCtuVMbY3F5PYXBqg1vWrtF4jcyyMY1rlw8a4PV67AkqlepjGgpzWJZd56Mt+TvHy6DA1F/3Id8LatDSQ==",
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/web3-errors/-/web3-errors-1.3.1.tgz",
+      "integrity": "sha512-w3NMJujH+ZSW4ltIZZKtdbkbyQEvBzyp3JRn59Ckli0Nz4VMsVq8aF1bLWM7A2kuQ+yVEm3ySeNU+7mSRwx7RQ==",
       "dev": true,
       "dependencies": {
-        "web3-types": "^1.7.0"
+        "web3-types": "^1.10.0"
       },
       "engines": {
         "node": ">=14",
@@ -11784,9 +11799,9 @@
       }
     },
     "node_modules/web3-types": {
-      "version": "1.8.0",
-      "resolved": "https://registry.npmjs.org/web3-types/-/web3-types-1.8.0.tgz",
-      "integrity": "sha512-Z51wFLPGhZM/1uDxrxE8gzju3t2aEdRGn+YmLX463id5UjTuMEmP/9in1GFjqrsPB3m86czs8RnGBUt3ovueMw==",
+      "version": "1.10.0",
+      "resolved": "https://registry.npmjs.org/web3-types/-/web3-types-1.10.0.tgz",
+      "integrity": "sha512-0IXoaAFtFc8Yin7cCdQfB9ZmjafrbP6BO0f0KT/khMhXKUpoJ6yShrVhiNpyRBo8QQjuOagsWzwSK2H49I7sbw==",
       "dev": true,
       "engines": {
         "node": ">=14",
@@ -11933,15 +11948,16 @@
       }
     },
     "node_modules/which-typed-array": {
-      "version": "1.1.15",
-      "resolved": "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.15.tgz",
-      "integrity": "sha512-oV0jmFtUky6CXfkqehVvBP/LSWJ2sy4vWMioiENyJLePrBO/yKyV9OyJySfAKosh+RYkIl5zJCNZ8/4JncrpdA==",
+      "version": "1.1.18",
+      "resolved": "https://registry.npmjs.org/which-typed-array/-/which-typed-array-1.1.18.tgz",
+      "integrity": "sha512-qEcY+KJYlWyLH9vNbsr6/5j59AXk5ni5aakf8ldzBvGde6Iz4sxZGkJyWSAueTG7QhOvNRYb1lDdFmL5Td0QKA==",
       "dev": true,
       "dependencies": {
         "available-typed-arrays": "^1.0.7",
-        "call-bind": "^1.0.7",
+        "call-bind": "^1.0.8",
+        "call-bound": "^1.0.3",
         "for-each": "^0.3.3",
-        "gopd": "^1.0.1",
+        "gopd": "^1.2.0",
         "has-tostringtag": "^1.0.2"
       },
       "engines": {
@@ -12073,21 +12089,21 @@
       "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A=="
     },
     "node_modules/yargs": {
-      "version": "16.2.0",
-      "resolved": "https://registry.npmjs.org/yargs/-/yargs-16.2.0.tgz",
-      "integrity": "sha512-D1mvvtDG0L5ft/jGWkLpG1+m0eQxOfaBvTNELraWj22wSVUMWxZUvYgJYcKh6jGGIkJFhH4IZPQhR4TKpc8mBw==",
+      "version": "17.7.2",
+      "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz",
+      "integrity": "sha512-7dSzzRQ++CKnNI/krKnYRV7JKKPUXMEh61soaHKg9mrWEhzFWhFnxPxGl+69cD1Ou63C13NUPCnmIcrvqCuM6w==",
       "dev": true,
       "dependencies": {
-        "cliui": "^7.0.2",
+        "cliui": "^8.0.1",
         "escalade": "^3.1.1",
         "get-caller-file": "^2.0.5",
         "require-directory": "^2.1.1",
-        "string-width": "^4.2.0",
+        "string-width": "^4.2.3",
         "y18n": "^5.0.5",
-        "yargs-parser": "^20.2.2"
+        "yargs-parser": "^21.1.1"
       },
       "engines": {
-        "node": ">=10"
+        "node": ">=12"
       }
     },
     "node_modules/yargs-parser": {
@@ -12114,6 +12130,15 @@
         "node": ">=10"
       }
     },
+    "node_modules/yargs/node_modules/yargs-parser": {
+      "version": "21.1.1",
+      "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-21.1.1.tgz",
+      "integrity": "sha512-tVpsJW7DdjecAiFpbIB1e3qxIQsE6NoPc5/eTdrbbIC4h0LVsWhnoa3g+m2HclBIujHzsxZ4VJVA+GUuc2/LBw==",
+      "dev": true,
+      "engines": {
+        "node": ">=12"
+      }
+    },
     "node_modules/yn": {
       "version": "3.1.1",
       "resolved": "https://registry.npmjs.org/yn/-/yn-3.1.1.tgz",
@@ -12124,21 +12149,21 @@
       }
     },
     "node_modules/yocto-queue": {
-      "version": "0.1.0",
-      "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz",
-      "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==",
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-1.1.1.tgz",
+      "integrity": "sha512-b4JR1PFR10y1mKjhHY9LaGo6tmrgjit7hxVIeAmyMw3jegXR4dhYqLaQF5zMXZxY7tLpMyJeLjr1C4rLmkVe8g==",
       "dev": true,
       "engines": {
-        "node": ">=10"
+        "node": ">=12.20"
       },
       "funding": {
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
     "node_modules/zod": {
-      "version": "3.23.8",
-      "resolved": "https://registry.npmjs.org/zod/-/zod-3.23.8.tgz",
-      "integrity": "sha512-XBx9AXhXktjUqnepgTiE5flcKIYWi/rme0Eaj+5Y0lftuGBq+jyRu/md4WnuxqgP1ubdpNCsYEYPxrzVHD8d6g==",
+      "version": "3.24.1",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-3.24.1.tgz",
+      "integrity": "sha512-muH7gBL9sI1nciMZV67X5fTKKBLtwpZ5VBp1vsOQzj1MhrBZ4wlVCm3gedKZWLp0Oyel8sIGfeiz54Su+OVT+A==",
       "dev": true,
       "funding": {
         "url": "https://github.com/sponsors/colinhacks"
diff --git a/package.json b/package.json
index a717fe6b..0533a754 100644
--- a/package.json
+++ b/package.json
@@ -72,8 +72,8 @@
     "eslint": "^8.28.0",
     "eslint-config-prettier": "^8.5.0",
     "ethers": "^6.8.0",
+    "fhevm-core-contracts": "0.7.0-1",
     "fhevmjs": "^0.6.0-8",
-    "fhevm-core-contracts": "0.7.0-0",
     "hardhat": "^2.22.10",
     "hardhat-deploy": "^0.11.29",
     "hardhat-gas-reporter": "^1.0.2",
@@ -84,11 +84,13 @@
     "prettier": "^3.4.2",
     "prettier-plugin-solidity": "^1.1.3",
     "rimraf": "^4.1.2",
+    "sha3": "^2.1.4",
     "solidity-coverage": "0.8.12",
     "ts-generator": "^0.1.1",
     "ts-node": "^10.9.2",
     "typechain": "^8.2.0",
-    "typescript": "^5.1.6"
+    "typescript": "^5.1.6",
+    "web3-validator": "^2.0.6"
   },
   "dependencies": {
     "@openzeppelin/contracts": "^5.0.1",
diff --git a/tasks/taskGatewayRelayer.ts b/tasks/taskDecryptionOracleRelayer.ts
similarity index 52%
rename from tasks/taskGatewayRelayer.ts
rename to tasks/taskDecryptionOracleRelayer.ts
index b5ebe644..2eef61c9 100644
--- a/tasks/taskGatewayRelayer.ts
+++ b/tasks/taskDecryptionOracleRelayer.ts
@@ -15,97 +15,62 @@ const getCoin = async (address: string) => {
   if (res.raw_log.match('account sequence mismatch')) await getCoin(address);
 };
 
-task('task:computeGatewayAddress')
+task('task:computeDecryptionOracleAddress')
   .addParam('privateKey', 'The deployer private key')
   .setAction(async function (taskArguments: TaskArguments, { ethers }) {
     const deployerAddress = new ethers.Wallet(taskArguments.privateKey).address;
-    const gatewayContractAddressPrecomputed = ethers.getCreateAddress({
+    const decryptionoracleAddressPrecomputed = ethers.getCreateAddress({
       from: deployerAddress,
       nonce: 1, // deployer is supposed to have nonce 0 when deploying GatewayContract (0 nonce for implementation, +1 for UUPS)
     });
-    const envFilePath = path.join(__dirname, '../node_modules/fhevm-core-contracts/addresses/.env.gateway');
-    const content = `GATEWAY_CONTRACT_PREDEPLOY_ADDRESS=${gatewayContractAddressPrecomputed}`;
+    const envFilePath = path.join(__dirname, '../node_modules/fhevm-core-contracts/addresses/.env.decryptionoracle');
+    const content = `DECRYPTION_ORACLE_ADDRESS=${decryptionoracleAddressPrecomputed}`;
     try {
       fs.writeFileSync(envFilePath, content, { flag: 'w' });
       console.log(
-        'gatewayContractAddress written to node_modules/fhevm-core-contracts/addresses/.env.gateway successfully!',
+        'decryptionOracleAddress written to node_modules/fhevm-core-contracts/addresses/.env.decryptionoracle successfully!',
       );
     } catch (err) {
-      console.error('Failed to write to node_modules/fhevm-core-contracts/addresses/.env.gateway:', err);
+      console.error('Failed to write to node_modules/fhevm-core-contracts/addresses/.env.decryptionoracle:', err);
     }
 
     const solidityTemplate = `// SPDX-License-Identifier: BSD-3-Clause-Clear
 
 pragma solidity ^0.8.24;
 
-address constant GATEWAY_CONTRACT_PREDEPLOY_ADDRESS = ${gatewayContractAddressPrecomputed};
+address constant DECRYPTION_ORACLE_ADDRESS = ${decryptionoracleAddressPrecomputed};
 `;
 
     try {
-      fs.writeFileSync('node_modules/fhevm-core-contracts/addresses/GatewayContractAddress.sol', solidityTemplate, {
+      fs.writeFileSync('node_modules/fhevm-core-contracts/addresses/DecryptionOracleAddress.sol', solidityTemplate, {
         encoding: 'utf8',
         flag: 'w',
       });
       console.log(
-        'node_modules/fhevm-core-contracts/addresses/GatewayContractAddress.sol file has been generated successfully.',
+        'node_modules/fhevm-core-contracts/addresses/DecryptionOracleAddress.sol file has been generated successfully.',
       );
     } catch (error) {
-      console.error('Failed to write node_modules/fhevm-core-contracts/addresses/GatewayContractAddress.sol', error);
-    }
-  });
-
-task('task:addRelayer')
-  .addParam('privateKey', 'The owner private key')
-  .addParam('gatewayAddress', 'The GatewayContract address')
-  .addParam('relayerAddress', 'The relayer address')
-  .setAction(async function (taskArguments: TaskArguments, { ethers }) {
-    const codeAtAddress = await ethers.provider.getCode(taskArguments.gatewayAddress);
-    if (codeAtAddress === '0x') {
-      throw Error(`${taskArguments.gatewayAddress} is not a smart contract`);
-    }
-    const owner = new ethers.Wallet(taskArguments.privateKey).connect(ethers.provider);
-    const gateway = await ethers.getContractAt('GatewayContract', taskArguments.gatewayAddress, owner);
-    const tx = await gateway.addRelayer(taskArguments.relayerAddress);
-    const rcpt = await tx.wait();
-    if (rcpt!.status === 1) {
-      console.log(`Account ${taskArguments.relayerAddress} was succesfully added as an gateway relayer`);
-    } else {
-      console.log('Adding relayer failed');
-    }
-  });
-
-task('task:removeRelayer')
-  .addParam('privateKey', 'The owner private key')
-  .addParam('gatewayAddress', 'The GatewayContract address')
-  .addParam('relayerAddress', 'The relayer address')
-  .setAction(async function (taskArguments: TaskArguments, { ethers }) {
-    const codeAtAddress = await ethers.provider.getCode(taskArguments.gatewayAddress);
-    if (codeAtAddress === '0x') {
-      throw Error(`${taskArguments.gatewayAddress} is not a smart contract`);
-    }
-    const owner = new ethers.Wallet(taskArguments.privateKey).connect(ethers.provider);
-    const gateway = await ethers.getContractAt('GatewayContract', taskArguments.gatewayAddress, owner);
-    const tx = await gateway.removeRelayer(taskArguments.relayerAddress);
-    const rcpt = await tx.wait();
-    if (rcpt!.status === 1) {
-      console.log(`Account ${taskArguments.relayerAddress} was succesfully removed from authorized relayers`);
-    } else {
-      console.log('Removing relayer failed');
+      console.error('Failed to write node_modules/fhevm-core-contracts/addresses/DecryptionOracleAddress.sol', error);
     }
   });
 
 task('task:launchFhevm')
   .addOptionalParam('skipGetCoin', 'Skip calling getCoin()', false, types.boolean)
-  .addOptionalParam('useAddress', 'Use address instead of privte key for the Gateway Relayer', false, types.boolean)
+  .addOptionalParam(
+    'useAddress',
+    'Use address instead of privte key for the Decryption Oracle Relayer',
+    false,
+    types.boolean,
+  )
   .setAction(async function (taskArgs, hre) {
-    const privKeyDeployer = process.env.PRIVATE_KEY_GATEWAY_DEPLOYER;
+    const privKeyDeployer = process.env.PRIVATE_KEY_DECRYPTION_ORACLE_DEPLOYER;
     const deployerAddress = new hre.ethers.Wallet(privKeyDeployer!).address;
     let relayerAddress;
     if (!taskArgs.useAddress) {
-      const privKeyRelayer = process.env.PRIVATE_KEY_GATEWAY_RELAYER;
+      const privKeyRelayer = process.env.PRIVATE_KEY_DECRYPTION_ORACLE_RELAYER;
       relayerAddress = new hre.ethers.Wallet(privKeyRelayer!).address;
     } else {
-      relayerAddress = process.env.ADDRESS_GATEWAY_RELAYER;
+      relayerAddress = process.env.ADDRESS_DECRYPTION_ORACLE_RELAYER;
     }
     if (!taskArgs.skipGetCoin) {
       if (hre.network.name === 'hardhat') {
@@ -120,21 +85,12 @@ task('task:launchFhevm')
         await new Promise((res) => setTimeout(res, 5000)); // wait 5 seconds
       }
     }
-    await hre.run('task:deployGateway', { privateKey: privKeyDeployer, ownerAddress: deployerAddress });
-
-    const parsedEnv = dotenv.parse(fs.readFileSync('node_modules/fhevm-core-contracts/addresses/.env.gateway'));
-    const gatewayContractAddress = parsedEnv.GATEWAY_CONTRACT_PREDEPLOY_ADDRESS;
-
-    await hre.run('task:addRelayer', {
-      privateKey: privKeyDeployer,
-      gatewayAddress: gatewayContractAddress,
-      relayerAddress: relayerAddress,
-    });
+    await hre.run('task:deployDecryptionOracle', { privateKey: privKeyDeployer, ownerAddress: deployerAddress });
   });
 
 task('task:getBalances').setAction(async function (taskArgs, hre) {
-  const privKeyDeployer = process.env.PRIVATE_KEY_GATEWAY_DEPLOYER;
-  const privKeyRelayer = process.env.PRIVATE_KEY_GATEWAY_RELAYER;
+  const privKeyDeployer = process.env.PRIVATE_KEY_DECRYPTION_ORACLE_DEPLOYER;
+  const privKeyRelayer = process.env.PRIVATE_KEY_DECRYPTION_ORACLE_RELAYER;
   const deployerAddress = new hre.ethers.Wallet(privKeyDeployer!).address;
   const relayerAddress = new hre.ethers.Wallet(privKeyRelayer!).address;
   console.log(await hre.ethers.provider.getBalance(deployerAddress));
diff --git a/tasks/taskDeploy.ts b/tasks/taskDeploy.ts
index d35faa7f..44291c33 100644
--- a/tasks/taskDeploy.ts
+++ b/tasks/taskDeploy.ts
@@ -5,25 +5,27 @@ import type { TaskArguments } from 'hardhat/types';
 
 import { KMSVerifier } from '../types';
 
-task('task:deployGateway')
+task('task:deployDecryptionOracle')
   .addParam('privateKey', 'The deployer private key')
   .addParam('ownerAddress', 'The owner address')
   .setAction(async function (taskArguments: TaskArguments, { ethers, upgrades }) {
     const deployer = new ethers.Wallet(taskArguments.privateKey).connect(ethers.provider);
-    const factory = await ethers.getContractFactory('GatewayContract', deployer);
-    const Gateway = await upgrades.deployProxy(factory, [taskArguments.ownerAddress], {
+    const factory = await ethers.getContractFactory('DecryptionOracle', deployer);
+    const DecryptionOracle = await upgrades.deployProxy(factory, [taskArguments.ownerAddress], {
       initializer: 'initialize',
       kind: 'uups',
     });
-    await Gateway.waitForDeployment();
-    const GatewayContractAddress = await Gateway.getAddress();
-    const envConfig = dotenv.parse(fs.readFileSync('node_modules/fhevm-core-contracts/addresses/.env.gateway'));
-    if (GatewayContractAddress !== envConfig.GATEWAY_CONTRACT_PREDEPLOY_ADDRESS) {
+    await DecryptionOracle.waitForDeployment();
+    const DecryptionOracleAddress = await DecryptionOracle.getAddress();
+    const envConfig = dotenv.parse(
+      fs.readFileSync('node_modules/fhevm-core-contracts/addresses/.env.decryptionoracle'),
+    );
+    if (DecryptionOracleAddress !== envConfig.DECRYPTION_ORACLE_ADDRESS) {
       throw new Error(
         `The nonce of the deployer account is not null. Please use another deployer private key or relaunch a clean instance of the fhEVM`,
       );
     }
-    console.log('GatewayContract was deployed at address: ', GatewayContractAddress);
+    console.log('DecryptionOracle was deployed at address: ', DecryptionOracleAddress);
   });
 
 task('task:deployACL')
@@ -122,7 +124,7 @@ task('task:deployFHEGasLimit')
     await payment.waitForDeployment();
     const address = await payment.getAddress();
     const envConfig = dotenv.parse(fs.readFileSync('node_modules/fhevm-core-contracts/addresses/.env.fhegaslimit'));
-    if (address !== envConfig.FHE_PAYMENT_CONTRACT_ADDRESS) {
+    if (address !== envConfig.FHE_GASLIMIT_CONTRACT_ADDRESS) {
       throw new Error(
         `The nonce of the deployer account is not correct. Please relaunch a clean instance of the fhEVM`,
       );
diff --git a/tasks/taskTFHE.ts b/tasks/taskTFHE.ts
index 16f1de25..9fad579f 100644
--- a/tasks/taskTFHE.ts
+++ b/tasks/taskTFHE.ts
@@ -188,7 +188,7 @@ task('task:computeFHEGasLimitAddress')
       nonce: 9, // using nonce of 9 for the FHEGasLimit contract (8 for original implementation, +1 for proxy)
     });
     const envFilePath = path.join(__dirname, '../node_modules/fhevm-core-contracts/addresses/.env.fhegaslimit');
-    const content = `FHE_PAYMENT_CONTRACT_ADDRESS=${fheGasLimitAddress}\n`;
+    const content = `FHE_GASLIMIT_CONTRACT_ADDRESS=${fheGasLimitAddress}\n`;
     try {
       fs.writeFileSync(envFilePath, content, { flag: 'w' });
       console.log(`FHEGasLimit address ${fheGasLimitAddress} written successfully!`);
diff --git a/test/asyncDecrypt.ts b/test/asyncDecrypt.ts
index 74fa92cf..aa4ba7f3 100644
--- a/test/asyncDecrypt.ts
+++ b/test/asyncDecrypt.ts
@@ -3,9 +3,8 @@ import { Wallet } from 'ethers';
 import fs from 'fs';
 import { ethers, network } from 'hardhat';
 
-import { GatewayContract } from '../types';
+import { DecryptionOracle } from '../types';
 import { awaitCoprocessor, getClearText } from './coprocessorUtils';
-import { waitNBlocks } from './utils';
 
 const networkName = network.name;
 
@@ -27,52 +26,43 @@ const CiphertextType = {
   11: 'bytes',
 };
 
+let toSkip: BigInt[] = [];
+
 const currentTime = (): string => {
   const now = new Date();
   return now.toLocaleTimeString('en-US', { hour12: true, hour: 'numeric', minute: 'numeric', second: 'numeric' });
 };
 
-const parsedEnv = dotenv.parse(fs.readFileSync('node_modules/fhevm-core-contracts/addresses/.env.gateway'));
+const parsedEnv = dotenv.parse(fs.readFileSync('node_modules/fhevm-core-contracts/addresses/.env.decryptionoracle'));
 let relayer: Wallet;
 if (networkName === 'hardhat') {
-  const privKeyRelayer = process.env.PRIVATE_KEY_GATEWAY_RELAYER;
+  const privKeyRelayer = process.env.PRIVATE_KEY_DECRYPTION_ORACLE_RELAYER;
   relayer = new ethers.Wallet(privKeyRelayer!, ethers.provider);
 }
 
-const argEvents =
-  '(uint256 indexed requestID, uint256[] cts, address contractCaller, bytes4 callbackSelector, uint256 msgValue, uint256 maxTimestamp, bool passSignaturesToCaller)';
-const ifaceEventDecryption = new ethers.Interface(['event EventDecryption' + argEvents]);
-
-const argEvents2 = '(uint256 indexed requestID, bool success, bytes result)';
-const ifaceResultCallback = new ethers.Interface(['event ResultCallback' + argEvents2]);
+const argEvents = '(uint256 indexed requestID, uint256[] cts, address contractCaller, bytes4 callbackSelector)';
+const ifaceEventDecryption = new ethers.Interface(['event DecryptionRequest' + argEvents]);
 
-let gateway: GatewayContract;
+let decryptionOracle: DecryptionOracle;
 let firstBlockListening: number;
 let lastBlockSnapshotForDecrypt: number;
 
-export const initGateway = async (): Promise<void> => {
+export const initDecryptionOracle = async (): Promise<void> => {
   firstBlockListening = await ethers.provider.getBlockNumber();
   if (networkName === 'hardhat' && hre.__SOLIDITY_COVERAGE_RUNNING !== true) {
     // evm_snapshot is not supported in coverage mode
     await ethers.provider.send('set_lastBlockSnapshotForDecrypt', [firstBlockListening]);
   }
   // this function will emit logs for every request and fulfilment of a decryption
-  gateway = await ethers.getContractAt('GatewayContract', parsedEnv.GATEWAY_CONTRACT_PREDEPLOY_ADDRESS);
-  await gateway.on(
-    'EventDecryption',
-    async (requestID, _cts, _contractCaller, _callbackSelector, _msgValue, _maxTimestamp, eventData) => {
-      const blockNumber = eventData.log.blockNumber;
-      console.log(`${currentTime()} - Requested decrypt on block ${blockNumber} (requestID ${requestID})`);
-    },
-  );
-  await gateway.on('ResultCallback', async (requestID, _success, _result, eventData) => {
+  decryptionOracle = await ethers.getContractAt('DecryptionOracle', parsedEnv.DECRYPTION_ORACLE_ADDRESS);
+  decryptionOracle.on('DecryptionRequest', async (requestID, cts, contractCaller, callbackSelector, eventData) => {
     const blockNumber = eventData.log.blockNumber;
-    console.log(`${currentTime()} - Fulfilled decrypt on block ${blockNumber} (requestID ${requestID})`);
+    console.log(`${await currentTime()} - Requested decrypt on block ${blockNumber} (requestID ${requestID})`);
   });
 };
 
 export const awaitAllDecryptionResults = async (): Promise<void> => {
-  gateway = await ethers.getContractAt('GatewayContract', parsedEnv.GATEWAY_CONTRACT_PREDEPLOY_ADDRESS);
+  decryptionOracle = await ethers.getContractAt('DecryptionOracle', parsedEnv.DECRYPTION_ORACLE_ADDRESS);
   const provider = ethers.provider;
   if (networkName === 'hardhat' && hre.__SOLIDITY_COVERAGE_RUNNING !== true) {
     // evm_snapshot is not supported in coverage mode
@@ -89,28 +79,12 @@ export const awaitAllDecryptionResults = async (): Promise<void> => {
   }
 };
 
-const getAlreadyFulfilledDecryptions = async (): Promise<[bigint]> => {
-  let results = [];
-  const eventDecryptionResult = await gateway.filters.ResultCallback().getTopicFilter();
-  const filterDecryptionResult = {
-    address: parsedEnv.GATEWAY_CONTRACT_PREDEPLOY_ADDRESS,
-    fromBlock: firstBlockListening,
-    toBlock: 'latest',
-    topics: eventDecryptionResult,
-  };
-  const pastResults = await ethers.provider.getLogs(filterDecryptionResult);
-  results = results.concat(pastResults.map((result) => ifaceResultCallback.parseLog(result).args[0]));
-
-  return results;
-};
-
 const allTrue = (arr: boolean[], fn = Boolean) => arr.every(fn);
 
 const fulfillAllPastRequestsIds = async (mocked: boolean) => {
-  const eventDecryption = await gateway.filters.EventDecryption().getTopicFilter();
-  const results = await getAlreadyFulfilledDecryptions();
+  const eventDecryption = await decryptionOracle.filters.DecryptionRequest().getTopicFilter();
   const filterDecryption = {
-    address: parsedEnv.GATEWAY_CONTRACT_PREDEPLOY_ADDRESS,
+    address: parsedEnv.DECRYPTION_ORACLE_ADDRESS,
     fromBlock: firstBlockListening,
     toBlock: 'latest',
     topics: eventDecryption,
@@ -120,54 +94,64 @@ const fulfillAllPastRequestsIds = async (mocked: boolean) => {
     const event = ifaceEventDecryption.parseLog(request);
     const requestID = event.args[0];
     const handles = event.args[1];
+    const contractCaller = event.args[2];
+    const callbackSelector = event.args[3];
     const typesList = handles.map((handle) => parseInt(handle.toString(16).slice(-4, -2), 16));
-    const msgValue = event.args[4];
-
-    if (!results.includes(requestID)) {
-      // if request is not already fulfilled
-      if (mocked) {
-        // in mocked mode, we trigger the decryption fulfillment manually
-        await awaitCoprocessor();
-
-        // first check tat all handles are allowed for decryption
-        const aclFactory = await ethers.getContractFactory('fhevmTemp/contracts/ACL.sol:ACL');
-        const acl = aclFactory.attach(aclAdd);
-        const isAllowedForDec = await Promise.all(handles.map(async (handle) => acl.isAllowedForDecryption(handle)));
-        if (!allTrue(isAllowedForDec)) {
-          throw new Error('Some handle is not authorized for decryption');
-        }
-        const types = typesList.map((num) => CiphertextType[num]);
-        const values = await Promise.all(handles.map(async (handle) => BigInt(await getClearText(handle))));
-        const valuesFormatted = values.map((value, index) =>
-          types[index] === 'address' ? '0x' + value.toString(16).padStart(40, '0') : value,
-        );
-        const valuesFormatted2 = valuesFormatted.map((value, index) =>
-          typesList[index] === 9 ? '0x' + value.toString(16).padStart(128, '0') : value,
-        );
-        const valuesFormatted3 = valuesFormatted2.map((value, index) =>
-          typesList[index] === 10 ? '0x' + value.toString(16).padStart(256, '0') : value,
-        );
-        const valuesFormatted4 = valuesFormatted3.map((value, index) =>
-          typesList[index] === 11 ? '0x' + value.toString(16).padStart(512, '0') : value,
-        );
-
-        const abiCoder = new ethers.AbiCoder();
-        let encodedData;
-        let calldata;
-
-        encodedData = abiCoder.encode(['uint256', ...types], [31, ...valuesFormatted4]); // 31 is just a dummy uint256 requestID to get correct abi encoding for the remaining arguments (i.e everything except the requestID)
-        calldata = '0x' + encodedData.slice(66); // we just pop the dummy requestID to get the correct value to pass for `decryptedCts`
-
-        const numSigners = +process.env.NUM_KMS_SIGNERS!;
-        const decryptResultsEIP712signatures = await computeDecryptSignatures(handles, calldata, numSigners);
-        const tx = await gateway
-          .connect(relayer)
-          .fulfillRequest(requestID, calldata, decryptResultsEIP712signatures, { value: msgValue });
+    // if request is not already fulfilled
+    if (mocked && !toSkip.includes(requestID)) {
+      // in mocked mode, we trigger the decryption fulfillment manually
+      await awaitCoprocessor();
+
+      // first check tat all handles are allowed for decryption
+      const aclFactory = await ethers.getContractFactory('ACL');
+      const acl = aclFactory.attach(aclAdd);
+      const isAllowedForDec = await Promise.all(handles.map(async (handle) => acl.isAllowedForDecryption(handle)));
+      if (!allTrue(isAllowedForDec)) {
+        throw new Error('Some handle is not authorized for decryption');
+      }
+      const types = typesList.map((num) => CiphertextType[num]);
+      const values = await Promise.all(handles.map(async (handle) => BigInt(await getClearText(handle))));
+      const valuesFormatted = values.map((value, index) =>
+        types[index] === 'address' ? '0x' + value.toString(16).padStart(40, '0') : value,
+      );
+      const valuesFormatted2 = valuesFormatted.map((value, index) =>
+        typesList[index] === 9 ? '0x' + value.toString(16).padStart(128, '0') : value,
+      );
+      const valuesFormatted3 = valuesFormatted2.map((value, index) =>
+        typesList[index] === 10 ? '0x' + value.toString(16).padStart(256, '0') : value,
+      );
+      const valuesFormatted4 = valuesFormatted3.map((value, index) =>
+        typesList[index] === 11 ? '0x' + value.toString(16).padStart(512, '0') : value,
+      );
+
+      const abiCoder = new ethers.AbiCoder();
+      let encodedData;
+      let decryptedResult;
+
+      encodedData = abiCoder.encode(['uint256', ...types, 'bytes[]'], [31, ...valuesFormatted4, []]); // 31 is just a dummy uint256 requestID to get correct abi encoding for the remaining arguments (i.e everything except the requestID)
+      // + adding also a dummy empty array of bytes for correct abi-encoding when used with signatures
+      decryptedResult = '0x' + encodedData.slice(66).slice(0, -64); // we pop the dummy requestID to get the correct value to pass for `decryptedCts` + we also pop the last 32 bytes (empty bytes[])
+
+      const numSigners = +process.env.NUM_KMS_SIGNERS!;
+      const decryptResultsEIP712signatures = await computeDecryptSignatures(handles, decryptedResult, numSigners);
+
+      const calldata =
+        callbackSelector +
+        abiCoder
+          .encode(['uint256', ...types, 'bytes[]'], [requestID, ...valuesFormatted4, decryptResultsEIP712signatures])
+          .slice(2);
+
+      const txData = {
+        to: contractCaller,
+        data: calldata,
+      };
+      try {
+        const tx = await relayer.sendTransaction(txData);
         await tx.wait();
-      } else {
-        // in fhEVM mode we must wait until the gateway service relayer submits the decryption fulfillment tx
-        await waitNBlocks(1);
-        await fulfillAllPastRequestsIds(mocked);
+      } catch (error) {
+        console.log('Gateway fulfillment tx failed with the following error:', error.message);
+        toSkip.push(requestID);
+        throw error;
       }
     }
   }
diff --git a/test/gatewayDecrypt/testAsyncDecrypt.ts b/test/gatewayDecrypt/testAsyncDecrypt.ts
index 99b0c99f..2dfb08fc 100644
--- a/test/gatewayDecrypt/testAsyncDecrypt.ts
+++ b/test/gatewayDecrypt/testAsyncDecrypt.ts
@@ -1,10 +1,10 @@
 import { expect } from 'chai';
 import { ethers, network } from 'hardhat';
 
-import { awaitAllDecryptionResults, initGateway } from '../asyncDecrypt';
+import { awaitAllDecryptionResults, initDecryptionOracle } from '../asyncDecrypt';
 import { createInstances } from '../instance';
 import { getSigners, initSigners } from '../signers';
-import { bigIntToBytes64, bigIntToBytes128, bigIntToBytes256, waitNBlocks } from '../utils';
+import { bigIntToBytes64, bigIntToBytes128, bigIntToBytes256 } from '../utils';
 
 describe('TestAsyncDecrypt', function () {
   before(async function () {
@@ -12,7 +12,7 @@ describe('TestAsyncDecrypt', function () {
     this.signers = await getSigners();
     this.relayerAddress = '0x97F272ccfef4026A1F3f0e0E879d514627B84E69';
     this.instances = await createInstances(this.signers);
-    await initGateway();
+    await initDecryptionOracle();
   });
 
   beforeEach(async function () {
@@ -26,7 +26,7 @@ describe('TestAsyncDecrypt', function () {
   it.skip('test async decrypt bool infinite loop', async function () {
     const balanceBeforeR = await ethers.provider.getBalance(this.relayerAddress);
     const balanceBeforeU = await ethers.provider.getBalance(this.signers.carol.address);
-    const tx = await this.contract.connect(this.signers.carol).requestBoolInfinite({ gasLimit: 5_000_000 });
+    const tx = await this.contract.connect(this.signers.carol).requestBoolInfinite();
     await tx.wait();
     const balanceAfterU = await ethers.provider.getBalance(this.signers.carol.address);
     await awaitAllDecryptionResults();
@@ -37,34 +37,10 @@ describe('TestAsyncDecrypt', function () {
     console.log('gas paid by user (request tx) : ', balanceBeforeU - balanceAfterU);
   });
 
-  it.skip('test async decrypt bool would fail if maxTimestamp is above 1 day', async function () {
-    if (network.name === 'hardhat') {
-      // mocked mode
-      await expect(this.contract.connect(this.signers.carol).requestBoolAboveDelay()).to.be.revertedWith(
-        'maxTimestamp exceeded MAX_DELAY',
-      );
-    } else {
-      // fhevm-mode
-      const txObject = await this.contract.requestBoolAboveDelay.populateTransaction({ gasLimit: 5_000_000 });
-      const tx = await this.signers.carol.sendTransaction(txObject);
-      let receipt = null;
-      let waitTime = 0;
-      while (receipt === null && waitTime < 15000) {
-        receipt = await ethers.provider.getTransactionReceipt(tx.hash);
-        if (receipt === null) {
-          console.log('Trying again to fetch txn receipt....');
-          await new Promise((resolve) => setTimeout(resolve, 5000)); // Wait for 5 seconds
-          waitTime += 5000;
-        }
-      }
-      receipt === null ? expect(waitTime >= 15000).to.be.true : expect(receipt!.status).to.equal(0);
-    }
-  });
-
   it('test async decrypt bool', async function () {
     const balanceBeforeR = await ethers.provider.getBalance(this.relayerAddress);
     const balanceBeforeU = await ethers.provider.getBalance(this.signers.carol.address);
-    const tx2 = await this.contract.connect(this.signers.carol).requestBool({ gasLimit: 5_000_000 });
+    const tx2 = await this.contract.connect(this.signers.carol).requestBool();
     await tx2.wait();
     const balanceAfterU = await ethers.provider.getBalance(this.signers.carol.address);
     await awaitAllDecryptionResults();
@@ -75,21 +51,10 @@ describe('TestAsyncDecrypt', function () {
     console.log('gas paid by user (request tx) : ', balanceBeforeU - balanceAfterU);
   });
 
-  it('test async decrypt bool trustless', async function () {
-    const contractFactory = await ethers.getContractFactory('TestAsyncDecrypt');
-    const contract2 = await contractFactory.connect(this.signers.alice).deploy();
-    await contract2.waitForDeployment();
-    const tx2 = await contract2.requestBoolTrustless({ gasLimit: 5_000_000 });
-    await tx2.wait();
-    await awaitAllDecryptionResults();
-    const y = await contract2.yBool();
-    expect(y).to.equal(true);
-  });
-
   it.skip('test async decrypt FAKE bool', async function () {
     if (network.name !== 'hardhat') {
       // only in fhevm mode
-      const txObject = await this.contract.requestFakeBool.populateTransaction({ gasLimit: 5_000_000 });
+      const txObject = await this.contract.requestFakeBool.populateTransaction();
       const tx = await this.signers.carol.sendTransaction(txObject);
       let receipt = null;
       let waitTime = 0;
@@ -107,7 +72,7 @@ describe('TestAsyncDecrypt', function () {
 
   it('test async decrypt uint4', async function () {
     const balanceBefore = await ethers.provider.getBalance(this.relayerAddress);
-    const tx2 = await this.contract.connect(this.signers.carol).requestUint4({ gasLimit: 5_000_000 });
+    const tx2 = await this.contract.connect(this.signers.carol).requestUint4();
     await tx2.wait();
     await awaitAllDecryptionResults();
     const y = await this.contract.yUint4();
@@ -119,7 +84,7 @@ describe('TestAsyncDecrypt', function () {
   it.skip('test async decrypt FAKE uint4', async function () {
     if (network.name !== 'hardhat') {
       // only in fhevm mode
-      const txObject = await this.contract.requestFakeUint4.populateTransaction({ gasLimit: 5_000_000 });
+      const txObject = await this.contract.requestFakeUint4.populateTransaction();
       const tx = await this.signers.carol.sendTransaction(txObject);
       let receipt = null;
       let waitTime = 0;
@@ -136,7 +101,7 @@ describe('TestAsyncDecrypt', function () {
   });
 
   it('test async decrypt uint8', async function () {
-    const tx2 = await this.contract.connect(this.signers.carol).requestUint8({ gasLimit: 5_000_000 });
+    const tx2 = await this.contract.connect(this.signers.carol).requestUint8();
     await tx2.wait();
     await awaitAllDecryptionResults();
     const y = await this.contract.yUint8();
@@ -146,7 +111,7 @@ describe('TestAsyncDecrypt', function () {
   it.skip('test async decrypt FAKE uint8', async function () {
     if (network.name !== 'hardhat') {
       // only in fhevm mode
-      const txObject = await this.contract.requestFakeUint8.populateTransaction({ gasLimit: 5_000_000 });
+      const txObject = await this.contract.requestFakeUint8.populateTransaction();
       const tx = await this.signers.carol.sendTransaction(txObject);
       let receipt = null;
       let waitTime = 0;
@@ -163,7 +128,7 @@ describe('TestAsyncDecrypt', function () {
   });
 
   it('test async decrypt uint16', async function () {
-    const tx2 = await this.contract.connect(this.signers.carol).requestUint16({ gasLimit: 5_000_000 });
+    const tx2 = await this.contract.connect(this.signers.carol).requestUint16();
     await tx2.wait();
     await awaitAllDecryptionResults();
     const y = await this.contract.yUint16();
@@ -173,7 +138,7 @@ describe('TestAsyncDecrypt', function () {
   it.skip('test async decrypt FAKE uint16', async function () {
     if (network.name !== 'hardhat') {
       // only in fhevm mode
-      const txObject = await this.contract.requestFakeUint16.populateTransaction({ gasLimit: 5_000_000 });
+      const txObject = await this.contract.requestFakeUint16.populateTransaction();
       const tx = await this.signers.carol.sendTransaction(txObject);
       let receipt = null;
       let waitTime = 0;
@@ -190,7 +155,7 @@ describe('TestAsyncDecrypt', function () {
   });
 
   it('test async decrypt uint32', async function () {
-    const tx2 = await this.contract.connect(this.signers.carol).requestUint32(5, 15, { gasLimit: 5_000_000 });
+    const tx2 = await this.contract.connect(this.signers.carol).requestUint32(5, 15);
     await tx2.wait();
     await awaitAllDecryptionResults();
     const y = await this.contract.yUint32();
@@ -200,7 +165,7 @@ describe('TestAsyncDecrypt', function () {
   it.skip('test async decrypt FAKE uint32', async function () {
     if (network.name !== 'hardhat') {
       // only in fhevm mode
-      const txObject = await this.contract.requestFakeUint32.populateTransaction({ gasLimit: 5_000_000 });
+      const txObject = await this.contract.requestFakeUint32.populateTransaction();
       const tx = await this.signers.carol.sendTransaction(txObject);
       let receipt = null;
       let waitTime = 0;
@@ -217,7 +182,7 @@ describe('TestAsyncDecrypt', function () {
   });
 
   it('test async decrypt uint64', async function () {
-    const tx2 = await this.contract.connect(this.signers.carol).requestUint64({ gasLimit: 5_000_000 });
+    const tx2 = await this.contract.connect(this.signers.carol).requestUint64();
     await tx2.wait();
     await awaitAllDecryptionResults();
     const y = await this.contract.yUint64();
@@ -225,7 +190,7 @@ describe('TestAsyncDecrypt', function () {
   });
 
   it('test async decrypt uint128', async function () {
-    const tx2 = await this.contract.connect(this.signers.carol).requestUint128({ gasLimit: 5_000_000 });
+    const tx2 = await this.contract.connect(this.signers.carol).requestUint128();
     await tx2.wait();
     await awaitAllDecryptionResults();
     const y = await this.contract.yUint128();
@@ -236,9 +201,7 @@ describe('TestAsyncDecrypt', function () {
     const inputAlice = this.instances.alice.createEncryptedInput(this.contractAddress, this.signers.alice.address);
     inputAlice.add128(184467440737095500429401496n);
     const encryptedAmount = await inputAlice.encrypt();
-    const tx = await this.contract.requestUint128NonTrivial(encryptedAmount.handles[0], encryptedAmount.inputProof, {
-      gasLimit: 5_000_000,
-    });
+    const tx = await this.contract.requestUint128NonTrivial(encryptedAmount.handles[0], encryptedAmount.inputProof);
     await tx.wait();
     await awaitAllDecryptionResults();
     const y = await this.contract.yUint128();
@@ -246,7 +209,7 @@ describe('TestAsyncDecrypt', function () {
   });
 
   it('test async decrypt uint256', async function () {
-    const tx2 = await this.contract.connect(this.signers.carol).requestUint256({ gasLimit: 5_000_000 });
+    const tx2 = await this.contract.connect(this.signers.carol).requestUint256();
     await tx2.wait();
     await awaitAllDecryptionResults();
     const y = await this.contract.yUint256();
@@ -257,9 +220,7 @@ describe('TestAsyncDecrypt', function () {
     const inputAlice = this.instances.alice.createEncryptedInput(this.contractAddress, this.signers.alice.address);
     inputAlice.add256(6985387162255149739023449108101809804435888681546n);
     const encryptedAmount = await inputAlice.encrypt();
-    const tx = await this.contract.requestUint256NonTrivial(encryptedAmount.handles[0], encryptedAmount.inputProof, {
-      gasLimit: 5_000_000,
-    });
+    const tx = await this.contract.requestUint256NonTrivial(encryptedAmount.handles[0], encryptedAmount.inputProof);
     await tx.wait();
     await awaitAllDecryptionResults();
     const y = await this.contract.yUint256();
@@ -269,7 +230,7 @@ describe('TestAsyncDecrypt', function () {
   it.skip('test async decrypt FAKE uint64', async function () {
     if (network.name !== 'hardhat') {
       // only in fhevm mode
-      const txObject = await this.contract.requestFakeUint64.populateTransaction({ gasLimit: 5_000_000 });
+      const txObject = await this.contract.requestFakeUint64.populateTransaction();
       const tx = await this.signers.carol.sendTransaction(txObject);
       let receipt = null;
       let waitTime = 0;
@@ -286,7 +247,7 @@ describe('TestAsyncDecrypt', function () {
   });
 
   it('test async decrypt address', async function () {
-    const tx2 = await this.contract.connect(this.signers.carol).requestAddress({ gasLimit: 5_000_000 });
+    const tx2 = await this.contract.connect(this.signers.carol).requestAddress();
     await tx2.wait();
     await awaitAllDecryptionResults();
     const y = await this.contract.yAddress();
@@ -294,7 +255,7 @@ describe('TestAsyncDecrypt', function () {
   });
 
   it('test async decrypt several addresses', async function () {
-    const tx2 = await this.contract.connect(this.signers.carol).requestSeveralAddresses({ gasLimit: 5_000_000 });
+    const tx2 = await this.contract.connect(this.signers.carol).requestSeveralAddresses();
     await tx2.wait();
     await awaitAllDecryptionResults();
     const y = await this.contract.yAddress();
@@ -306,7 +267,7 @@ describe('TestAsyncDecrypt', function () {
   it.skip('test async decrypt FAKE address', async function () {
     if (network.name !== 'hardhat') {
       // only in fhevm mode
-      const txObject = await this.contract.requestFakeAddress.populateTransaction({ gasLimit: 5_000_000 });
+      const txObject = await this.contract.requestFakeAddress.populateTransaction();
       const tx = await this.signers.carol.sendTransaction(txObject);
       let receipt = null;
       let waitTime = 0;
@@ -323,10 +284,10 @@ describe('TestAsyncDecrypt', function () {
   });
 
   it('test async decrypt mixed', async function () {
-    const tx2 = await this.contract.connect(this.signers.carol).requestMixed(5, 15, { gasLimit: 5_000_000 });
+    const tx2 = await this.contract.connect(this.signers.carol).requestMixed(5, 15);
     await tx2.wait();
     await awaitAllDecryptionResults();
-    const yB = await this.contract.yBool();
+    let yB = await this.contract.yBool();
     expect(yB).to.equal(true);
     let y = await this.contract.yUint4();
     expect(y).to.equal(4);
@@ -334,7 +295,7 @@ describe('TestAsyncDecrypt', function () {
     expect(y).to.equal(42);
     y = await this.contract.yUint16();
     expect(y).to.equal(16);
-    const yAdd = await this.contract.yAddress();
+    let yAdd = await this.contract.yAddress();
     expect(yAdd).to.equal('0x8ba1f109551bD432803012645Ac136ddd64DBA72');
     y = await this.contract.yUint32();
     expect(y).to.equal(52); // 5+15+32
@@ -346,9 +307,7 @@ describe('TestAsyncDecrypt', function () {
     const inputAlice = this.instances.alice.createEncryptedInput(this.contractAddress, this.signers.alice.address);
     inputAlice.add64(18446744073709550042n);
     const encryptedAmount = await inputAlice.encrypt();
-    const tx = await this.contract.requestUint64NonTrivial(encryptedAmount.handles[0], encryptedAmount.inputProof, {
-      gasLimit: 5_000_000,
-    });
+    const tx = await this.contract.requestUint64NonTrivial(encryptedAmount.handles[0], encryptedAmount.inputProof);
     await tx.wait();
     await awaitAllDecryptionResults();
     const y = await this.contract.yUint64();
@@ -369,9 +328,7 @@ describe('TestAsyncDecrypt', function () {
       bigIntToBytes64(98870780878070870878787887072921111299111111000000292928818818818818221112111n),
     );
     const encryptedAmount = await inputAlice.encrypt();
-    const tx = await this.contract.requestEbytes64NonTrivial(encryptedAmount.handles[0], encryptedAmount.inputProof, {
-      gasLimit: 5_000_000,
-    });
+    const tx = await this.contract.requestEbytes64NonTrivial(encryptedAmount.handles[0], encryptedAmount.inputProof);
     await tx.wait();
     await awaitAllDecryptionResults();
     const y = await this.contract.yBytes64();
@@ -405,9 +362,7 @@ describe('TestAsyncDecrypt', function () {
       ),
     );
     const encryptedAmount = await inputAlice.encrypt();
-    const tx = await this.contract.requestEbytes128NonTrivial(encryptedAmount.handles[0], encryptedAmount.inputProof, {
-      gasLimit: 5_000_000,
-    });
+    const tx = await this.contract.requestEbytes128NonTrivial(encryptedAmount.handles[0], encryptedAmount.inputProof);
     await tx.wait();
     await awaitAllDecryptionResults();
     const y = await this.contract.yBytes128();
@@ -431,9 +386,7 @@ describe('TestAsyncDecrypt', function () {
     const inputAlice = this.instances.alice.createEncryptedInput(this.contractAddress, this.signers.alice.address);
     inputAlice.addBytes256(bigIntToBytes256(18446744073709550022n));
     const encryptedAmount = await inputAlice.encrypt();
-    const tx = await this.contract.requestEbytes256NonTrivial(encryptedAmount.handles[0], encryptedAmount.inputProof, {
-      gasLimit: 5_000_000,
-    });
+    const tx = await this.contract.requestEbytes256NonTrivial(encryptedAmount.handles[0], encryptedAmount.inputProof);
     await tx.wait();
     await awaitAllDecryptionResults();
     const y = await this.contract.yBytes256();
@@ -446,11 +399,7 @@ describe('TestAsyncDecrypt', function () {
       const inputAlice = this.instances.alice.createEncryptedInput(this.contractAddress, this.signers.alice.address);
       inputAlice.addBytes256(bigIntToBytes256(18446744073709550022n));
       const encryptedAmount = await inputAlice.encrypt();
-      const tx = await this.contract.requestEbytes256NonTrivial(
-        encryptedAmount.handles[0],
-        encryptedAmount.inputProof,
-        { gasLimit: 5_000_000 },
-      );
+      const tx = await this.contract.requestEbytes256NonTrivial(encryptedAmount.handles[0], encryptedAmount.inputProof);
       await tx.wait();
       await awaitAllDecryptionResults();
       const y = await this.contract.yBytes256();
@@ -463,7 +412,6 @@ describe('TestAsyncDecrypt', function () {
       const tx2 = await this.contract.requestEbytes256NonTrivial(
         encryptedAmount2.handles[0],
         encryptedAmount2.inputProof,
-        { gasLimit: 5_000_000 },
       );
       await tx2.wait();
       await awaitAllDecryptionResults();
@@ -476,9 +424,7 @@ describe('TestAsyncDecrypt', function () {
     const inputAlice = this.instances.alice.createEncryptedInput(this.contractAddress, this.signers.alice.address);
     inputAlice.addBytes256(bigIntToBytes256(18446744073709550032n));
     const encryptedAmount = await inputAlice.encrypt();
-    const tx = await this.contract.requestMixedBytes256(encryptedAmount.handles[0], encryptedAmount.inputProof, {
-      gasLimit: 5_000_000,
-    });
+    const tx = await this.contract.requestMixedBytes256(encryptedAmount.handles[0], encryptedAmount.inputProof);
     await tx.wait();
     await awaitAllDecryptionResults();
     const y = await this.contract.yBytes256();
@@ -490,48 +436,4 @@ describe('TestAsyncDecrypt', function () {
     const yAdd = await this.contract.yAddress();
     expect(yAdd).to.equal('0x8ba1f109551bD432803012645Ac136ddd64DBA72');
   });
-
-  it('test async decrypt ebytes256 non-trivial trustless', async function () {
-    const contractFactory = await ethers.getContractFactory('TestAsyncDecrypt');
-    const contract2 = await contractFactory.connect(this.signers.alice).deploy();
-    await contract2.waitForDeployment();
-    const inputAlice = this.instances.alice.createEncryptedInput(
-      await contract2.getAddress(),
-      this.signers.alice.address,
-    );
-    inputAlice.addBytes256(bigIntToBytes256(18446744073709550022n));
-    const encryptedAmount = await inputAlice.encrypt();
-    const tx = await contract2.requestEbytes256NonTrivialTrustless(
-      encryptedAmount.handles[0],
-      encryptedAmount.inputProof,
-      { gasLimit: 5_000_000 },
-    );
-    await tx.wait();
-    await awaitAllDecryptionResults();
-    const y = await contract2.yBytes256();
-    expect(y).to.equal(ethers.toBeHex(18446744073709550022n, 256));
-  });
-
-  it('test async decrypt mixed with ebytes256 trustless', async function () {
-    const contractFactory = await ethers.getContractFactory('TestAsyncDecrypt');
-    const contract2 = await contractFactory.connect(this.signers.alice).deploy();
-    await contract2.waitForDeployment();
-    const inputAlice = this.instances.alice.createEncryptedInput(
-      await contract2.getAddress(),
-      this.signers.alice.address,
-    );
-    inputAlice.addBytes256(bigIntToBytes256(18446744073709550032n));
-    const encryptedAmount = await inputAlice.encrypt();
-    const tx = await contract2.requestMixedBytes256Trustless(encryptedAmount.handles[0], encryptedAmount.inputProof, {
-      gasLimit: 5_000_000,
-    });
-    await tx.wait();
-    await awaitAllDecryptionResults();
-    const y = await contract2.yBytes256();
-    expect(y).to.equal(ethers.toBeHex(18446744073709550032n, 256));
-    const yb = await contract2.yBool();
-    expect(yb).to.equal(true);
-    const yAdd = await contract2.yAddress();
-    expect(yAdd).to.equal('0x8ba1f109551bD432803012645Ac136ddd64DBA72');
-  });
 });
diff --git a/test/instance.ts b/test/instance.ts
index 261e528f..4b98abda 100644
--- a/test/instance.ts
+++ b/test/instance.ts
@@ -89,7 +89,7 @@ const getDecryptor = () => {
  * @debug
  * This function is intended for debugging purposes only.
  * It cannot be used in production code, since it requires the FHE private key for decryption.
- * In production, decryption is only possible via an asyncronous on-chain call to the Gateway.
+ * In production, decryption is only possible via an asyncronous on-chain call to the Decryption Oracle.
  *
  * @param {bigint} a handle to decrypt
  * @returns {bool}
@@ -107,7 +107,7 @@ export const decryptBool = async (handle: bigint): Promise<boolean> => {
  * @debug
  * This function is intended for debugging purposes only.
  * It cannot be used in production code, since it requires the FHE private key for decryption.
- * In production, decryption is only possible via an asyncronous on-chain call to the Gateway.
+ * In production, decryption is only possible via an asyncronous on-chain call to the Decryption Oracle.
  *
  * @param {bigint} a handle to decrypt
  * @returns {bigint}
@@ -125,7 +125,7 @@ export const decrypt4 = async (handle: bigint): Promise<bigint> => {
  * @debug
  * This function is intended for debugging purposes only.
  * It cannot be used in production code, since it requires the FHE private key for decryption.
- * In production, decryption is only possible via an asyncronous on-chain call to the Gateway.
+ * In production, decryption is only possible via an asyncronous on-chain call to the Decryption Oracle.
  *
  * @param {bigint} a handle to decrypt
  * @returns {bigint}
@@ -143,7 +143,7 @@ export const decrypt8 = async (handle: bigint): Promise<bigint> => {
  * @debug
  * This function is intended for debugging purposes only.
  * It cannot be used in production code, since it requires the FHE private key for decryption.
- * In production, decryption is only possible via an asyncronous on-chain call to the Gateway.
+ * In production, decryption is only possible via an asyncronous on-chain call to the Decryption Oracle.
  *
  * @param {bigint} a handle to decrypt
  * @returns {bigint}
@@ -161,7 +161,7 @@ export const decrypt16 = async (handle: bigint): Promise<bigint> => {
  * @debug
  * This function is intended for debugging purposes only.
  * It cannot be used in production code, since it requires the FHE private key for decryption.
- * In production, decryption is only possible via an asyncronous on-chain call to the Gateway.
+ * In production, decryption is only possible via an asyncronous on-chain call to the Decryption Oracle.
  *
  * @param {bigint} a handle to decrypt
  * @returns {bigint}
@@ -179,7 +179,7 @@ export const decrypt32 = async (handle: bigint): Promise<bigint> => {
  * @debug
  * This function is intended for debugging purposes only.
  * It cannot be used in production code, since it requires the FHE private key for decryption.
- * In production, decryption is only possible via an asyncronous on-chain call to the Gateway.
+ * In production, decryption is only possible via an asyncronous on-chain call to the Decryption Oracle.
  *
  * @param {bigint} a handle to decrypt
  * @returns {bigint}
@@ -197,7 +197,7 @@ export const decrypt64 = async (handle: bigint): Promise<bigint> => {
  * @debug
  * This function is intended for debugging purposes only.
  * It cannot be used in production code, since it requires the FHE private key for decryption.
- * In production, decryption is only possible via an asyncronous on-chain call to the Gateway.
+ * In production, decryption is only possible via an asyncronous on-chain call to the Decryption Oracle.
  *
  * @param {bigint} a handle to decrypt
  * @returns {bigint}
@@ -215,7 +215,7 @@ export const decrypt128 = async (handle: bigint): Promise<bigint> => {
  * @debug
  * This function is intended for debugging purposes only.
  * It cannot be used in production code, since it requires the FHE private key for decryption.
- * In production, decryption is only possible via an asyncronous on-chain call to the Gateway.
+ * In production, decryption is only possible via an asyncronous on-chain call to the Decryption Oracle.
  *
  * @param {bigint} a handle to decrypt
  * @returns {bigint}
@@ -233,7 +233,7 @@ export const decrypt256 = async (handle: bigint): Promise<bigint> => {
  * @debug
  * This function is intended for debugging purposes only.
  * It cannot be used in production code, since it requires the FHE private key for decryption.
- * In production, decryption is only possible via an asyncronous on-chain call to the Gateway.
+ * In production, decryption is only possible via an asyncronous on-chain call to the Decryption Oracle.
  *
  * @param {bigint} a handle to decrypt
  * @returns {string}
@@ -253,7 +253,7 @@ export const decryptAddress = async (handle: bigint): Promise<string> => {
  * @debug
  * This function is intended for debugging purposes only.
  * It cannot be used in production code, since it requires the FHE private key for decryption.
- * In production, decryption is only possible via an asyncronous on-chain call to the Gateway.
+ * In production, decryption is only possible via an asyncronous on-chain call to the Decryption Oracle.
  *
  * @param {bigint} a handle to decrypt
  * @returns {bigint}
@@ -271,7 +271,7 @@ export const decryptEbytes64 = async (handle: bigint): Promise<bigint> => {
  * @debug
  * This function is intended for debugging purposes only.
  * It cannot be used in production code, since it requires the FHE private key for decryption.
- * In production, decryption is only possible via an asyncronous on-chain call to the Gateway.
+ * In production, decryption is only possible via an asyncronous on-chain call to the Decryption Oracle.
  *
  * @param {bigint} a handle to decrypt
  * @returns {bigint}
@@ -289,7 +289,7 @@ export const decryptEbytes128 = async (handle: bigint): Promise<bigint> => {
  * @debug
  * This function is intended for debugging purposes only.
  * It cannot be used in production code, since it requires the FHE private key for decryption.
- * In production, decryption is only possible via an asyncronous on-chain call to the Gateway.
+ * In production, decryption is only possible via an asyncronous on-chain call to the Decryption Oracle.
  *
  * @param {bigint} a handle to decrypt
  * @returns {bigint}
diff --git a/test/kmsVerifier/kmsVerifier.ts b/test/kmsVerifier/kmsVerifier.ts
index 2e998b83..deaa24f6 100644
--- a/test/kmsVerifier/kmsVerifier.ts
+++ b/test/kmsVerifier/kmsVerifier.ts
@@ -3,7 +3,7 @@ import dotenv from 'dotenv';
 import fs from 'fs';
 import { ethers } from 'hardhat';
 
-import { awaitAllDecryptionResults, initGateway } from '../asyncDecrypt';
+import { awaitAllDecryptionResults, initDecryptionOracle } from '../asyncDecrypt';
 import { createInstances } from '../instance';
 import { getSigners, initSigners } from '../signers';
 import { bigIntToBytes256 } from '../utils';
@@ -13,8 +13,8 @@ describe('KMSVerifier', function () {
     await initSigners(2);
     this.signers = await getSigners();
     this.instances = await createInstances(this.signers);
-    this.kmsFactory = await ethers.getContractFactory('fhevmTemp/contracts/KMSVerifier.sol:KMSVerifier');
-    await initGateway();
+    this.kmsFactory = await ethers.getContractFactory('KMSVerifier');
+    await initDecryptionOracle();
   });
 
   it('original owner adds one signer, then adds two more signers, then removes one signer', async function () {
@@ -37,7 +37,7 @@ describe('KMSVerifier', function () {
 
       const contractFactory = await ethers.getContractFactory('TestAsyncDecrypt');
       const contract = await contractFactory.connect(this.signers.alice).deploy();
-      const tx2 = await contract.requestBool({ gasLimit: 5_000_000 });
+      const tx2 = await contract.requestBool();
       await tx2.wait();
       await awaitAllDecryptionResults();
       const y = await contract.yBool();
@@ -60,7 +60,7 @@ describe('KMSVerifier', function () {
       await tx4.wait();
       expect((await kmsVerifier.getSigners()).length).to.equal(4); // 3rd and 4th signer has been added successfully
 
-      const tx5 = await contract.requestUint4({ gasLimit: 5_000_000 });
+      const tx5 = await contract.requestUint4();
       await tx5.wait();
       await expect(awaitAllDecryptionResults())
         .to.revertedWithCustomError(kmsVerifier, 'KMSSignatureThresholdNotReached')
@@ -68,13 +68,15 @@ describe('KMSVerifier', function () {
       const y2 = await contract.yUint4();
       expect(y2).to.equal(0);
 
+      const tx5Bis = await contract.requestUint4();
+      await tx5Bis.wait();
       process.env.NUM_KMS_SIGNERS = '2';
       await awaitAllDecryptionResults();
       const y3 = await contract.yUint4();
       expect(y3).to.equal(4); // with 2 signatures decryption should now succeed
 
       process.env.NUM_KMS_SIGNERS = '4';
-      const tx6 = await contract.requestUint8({ gasLimit: 5_000_000 });
+      const tx6 = await contract.requestUint8();
       await tx6.wait();
       await awaitAllDecryptionResults();
       const y4 = await contract.yUint8();
@@ -89,33 +91,21 @@ describe('KMSVerifier', function () {
 
       process.env.NUM_KMS_SIGNERS = '1';
       const encryptedAmount2 = await inputAlice.encrypt();
-      await expect(
-        contract2.requestMixedBytes256Trustless(encryptedAmount2.handles[0], encryptedAmount2.inputProof, {
-          gasLimit: 5_000_000,
-        }),
-      )
+      await expect(contract2.requestMixedBytes256(encryptedAmount2.handles[0], encryptedAmount2.inputProof))
         .to.revertedWithCustomError(kmsVerifier, 'KMSSignatureThresholdNotReached')
-        .withArgs(1n); // this should fail because in this case the InputVerifier received only one KMS signature (instead of at least 2);
+        .withArgs(1n); // should revert because now we are below the threshold! (we receive only 1 signature but threshold is 2)
 
       if (process.env.IS_COPROCESSOR === 'true') {
         // different format of inputProof for native
         const cheatInputProof = encryptedAmount2.inputProof + encryptedAmount2.inputProof.slice(-130); // trying to cheat by repeating the first kms signer signature
         const cheat = cheatInputProof.slice(0, 5) + '2' + cheatInputProof.slice(6);
-        await expect(
-          contract2.requestMixedBytes256Trustless(encryptedAmount2.handles[0], cheat, {
-            gasLimit: 5_000_000,
-          }),
-        ).to.revertedWith('Not enough unique KMS input signatures'); // this should fail because in this case the InputVerifier received only one KMS signature (instead of at least 2)
+        await expect(contract2.requestMixedBytes256(encryptedAmount2.handles[0], cheat)).to.revertedWith(
+          'Not enough unique KMS input signatures',
+        ); // this should fail because in this case the InputVerifier received only one KMS signature (instead of at least 2)
       }
       process.env.NUM_KMS_SIGNERS = '4';
       const encryptedAmount = await inputAlice.encrypt();
-      const tx6bis = await contract2.requestMixedBytes256Trustless(
-        encryptedAmount.handles[0],
-        encryptedAmount.inputProof,
-        {
-          gasLimit: 5_000_000,
-        },
-      );
+      const tx6bis = await contract2.requestMixedBytes256(encryptedAmount.handles[0], encryptedAmount.inputProof);
       await tx6bis.wait();
       await awaitAllDecryptionResults();
       const ybis = await contract2.yBytes256();
@@ -127,15 +117,17 @@ describe('KMSVerifier', function () {
 
       process.env.NUM_KMS_SIGNERS = '2';
       process.env.PRIVATE_KEY_KMS_SIGNER_1 = process.env.PRIVATE_KEY_KMS_SIGNER_0;
-      const tx7 = await contract.requestUint16({ gasLimit: 5_000_000 });
+      const tx7 = await contract.requestUint16();
       await tx7.wait();
-      await expect(awaitAllDecryptionResults()).to.revertedWith('KMS signature verification failed'); // cannot use duplicated signatures if threshold is 2
+      await expect(awaitAllDecryptionResults()).to.revertedWithCustomError(contract, 'InvalidKMSSignatures'); // cannot use duplicated signatures if threshold is 2
       const y5 = await contract.yUint16();
       expect(y5).to.equal(0);
 
       process.env.NUM_KMS_SIGNERS = '1';
       const tx8 = await kmsVerifier.connect(deployer).removeSigner(kmsSigner2.address);
       await tx8.wait();
+      const tx7Bis = await contract.requestUint16();
+      await tx7Bis.wait();
       await awaitAllDecryptionResults();
       const y6 = await contract.yUint16();
       expect(y6).to.equal(16); // after removing one of the 4 signers, one signature is enough for decryption
diff --git a/test/paymentUtils.ts b/test/paymentUtils.ts
index 66d7023a..3cfd5a2a 100644
--- a/test/paymentUtils.ts
+++ b/test/paymentUtils.ts
@@ -7,7 +7,7 @@ export async function initializeFHEGasLimit() {
   const parsedFHEGasLimit = dotenv.parse(
     fs.readFileSync('node_modules/fhevm-core-contracts/addresses/.env.fhegaslimit'),
   );
-  const fheGasLimit = fheGasLimitFactory.attach(parsedFHEGasLimit.FHE_PAYMENT_CONTRACT_ADDRESS);
+  const fheGasLimit = fheGasLimitFactory.attach(parsedFHEGasLimit.FHE_GASLIMIT_CONTRACT_ADDRESS);
   return fheGasLimit;
 }