@diwantanushh/rapiddex-contracts 1.0.0

package/lib/openzeppelin-contracts-master/contracts/utils/Create3.sol

@@ -0,0 +1,134 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import {Create2} from "./Create2.sol";
+import {Errors} from "./Errors.sol";
+import {LowLevelCall} from "./LowLevelCall.sol";
+
+/**
+ * @dev Helper to deploy contracts using the `CREATE3` approach.
+ * `CREATE3` combines both `CREATE2` and `CREATE` opcodes to deploy arbitrary bytecode at an address that only depends
+ * on the provided salt and the address of the contract using this library. At a high level, it behaves like a `CREATE2`
+ * operation that would not use the bytecodehash to generate the contract address.
+ *
+ * CREATE3 can be used to compute in advance the address where a smart contract will be deployed, even if the bytecode
+ * is subject to change.
+ *
+ * NOTE: To get the same deployment address on multiple chains, the deployer contract must live at the same address on
+ * each chain.
+ *
+ * See {Create2} for counterfactual deployments that include the bytecodehash in the computation of the address.
+ */
+library Create3 {
+    /**
+     * ===================================[ PROXY CODE ]===================================
+     * Offset | Opcode      | Mnemonic         | Stack           | Memory
+     * -------|-------------|------------------|-----------------|-------------------------
+     * 0x00   | 36          | CALLDATASIZE     | cds             |
+     * 0x01   | 5F          | PUSH0            | 0 cds           |
+     * 0x02   | 5F          | PUSH0            | 0 0 cds         |
+     * 0x03   | 37          | CALLDATACOPY     |                 | [0..cds): calldata
+     * 0x04   | 36          | CALLDATASIZE     | cds             | [0..cds): calldata
+     * 0x05   | 5F          | PUSH0            | 0 cds           | [0..cds): calldata
+     * 0x06   | 34          | CALLVALUE        | value 0 cds     | [0..cds): calldata
+     * 0x07   | f0          | CREATE           | addr            | [0..cds): calldata
+     * 0x08   | 3D          | RETURNDATASIZE   | rds addr        |
+     * 0x09   | 5F          | PUSH0            | 0 rds addr      |
+     * 0x0A   | 5F          | PUSH0            | 0 0 rds addr    |
+     * 0x0B   | 3E          | RETURNDATACOPY   | addr            | [0..rds): returndata
+     * 0x0C   | 5F          | PUSH0            | 0 addr          | [0..rds): returndata
+     * 0x0D   | 3D          | RETURNDATASIZE   | rds 0 addr      | [0..rds): returndata
+     * 0x0E   | 91          | SWAP2            | addr 0 rds      | [0..rds): returndata
+     * 0x0F   | 6013        | PUSH1 0x13       | 0x13 addr 0 rds | [0..rds): returndata
+     * 0x11   | 57          | JUMPI            | 0 rds           | [0..rds): returndata
+     * 0x12   | FD          | REVERT           |                 |
+     * 0x13   | 5b          | JUMPDEST         | 0 rds           | [0..rds): returndata
+     * 0x14   | f3          | RETURN           |                 |
+     *
+     * ================================[ DEPLOYMENT CODE ]=================================
+     * Offset | Opcode      | Mnemonic         | Stack           | Memory
+     * -------|-------------|------------------|-----------------|-------------------------
+     * 0x00   | 74 bytecode | PUSH21 bytecode  | bytecode        |
+     * 0x16   | 5F          | PUSH0            | 0 bytecode      |
+     * 0x17   | 52          | MSTORE           |                 | [0x0B..0x20): bytecode
+     * 0x18   | 6015        | PUSH1 0x15       | 0x15            | [0x0B..0x20): bytecode
+     * 0x1A   | 600B        | PUSH1 0x0B       | 0x0B 0x15       | [0x0B..0x20): bytecode
+     * 0x1C   | f3          | RETURN           |                 | [0x0B..0x20): bytecode
+     */
+
+    /// @dev The proxy initialization code.
+    bytes29 private constant PROXY_INITCODE = 0x74365F5F37365F34f03D5F5F3E5F3D91601357FD5bf35F526015600Bf3;
+
+    /// @dev Hash of the `PROXY_INITCODE`.
+    /// Equivalent to `keccak256(hex"74365F5F37365F34f03D5F5F3E5F3D91601357FD5bf35F526015600Bf3")`.
+    bytes32 internal constant PROXY_INITCODE_HASH = 0xd61bbde0460e6c48ddd99fb8b7e1ad36529d2ec79cbac1db0300b3d26ddcdc2a;
+
+    /**
+     * @dev There's no code to deploy.
+     */
+    error Create3EmptyBytecode();
+
+    /**
+     * @dev Deploys a contract using the `CREATE3` mechanism. The address where the contract
+     * will be deployed can be known in advance via {computeAddress}, and only depends on the salt.
+     * The bytecode that is deployed DOES NOT affect the location at which it is deployed.
+     *
+     * The bytecode for a contract can be obtained from Solidity with
+     * `type(contractName).creationCode`.
+     *
+     * Requirements:
+     *
+     * - `bytecode` must not be empty.
+     * - `salt` must not have been used already.
+     * - the factory must have a balance of at least `amount`.
+     * - if `amount` is non-zero, `bytecode` must have a `payable` constructor.
+     */
+    function deploy(uint256 amount, bytes32 salt, bytes memory bytecode) internal returns (address) {
+        if (address(this).balance < amount) {
+            revert Errors.InsufficientBalance(address(this).balance, amount);
+        }
+        if (bytecode.length == 0) {
+            revert Create3EmptyBytecode();
+        }
+        // This fails if the salt was already used. Will never return address(0).
+        address proxy = Create2.deploy(0, salt, abi.encodePacked(PROXY_INITCODE));
+        // Perform the actual deployment (create on the proxy with nonce 1).
+        bool success = LowLevelCall.callNoReturn(proxy, amount, bytecode);
+        if (!success) {
+            if (LowLevelCall.returnDataSize() == 0) {
+                revert Errors.FailedDeployment();
+            } else {
+                LowLevelCall.bubbleRevert();
+            }
+        }
+
+        return _computeCreateAddress(proxy);
+    }
+
+    /**
+     * @dev Returns the address where a contract will be stored if deployed via {deploy}. Any change in the
+     * `salt` will result in a new destination address.
+     */
+    function computeAddress(bytes32 salt) internal view returns (address) {
+        return computeAddress(salt, address(this));
+    }
+
+    /**
+     * @dev Returns the address where a contract will be stored if deployed via {deploy} from a contract located at
+     * `deployer`. If `deployer` is this contract's address, returns the same value as {computeAddress}.
+     */
+    function computeAddress(bytes32 salt, address deployer) internal pure returns (address) {
+        return _computeCreateAddress(Create2.computeAddress(salt, PROXY_INITCODE_HASH, deployer));
+    }
+
+    /// @dev Compute the address of the first contract that `creator` would deployed using CREATE (nonce 1).
+    function _computeCreateAddress(address creator) private pure returns (address addr) {
+        assembly ("memory-safe") {
+            mstore(0x15, 0x01)
+            mstore(0x14, creator)
+            mstore(0x00, 0xd694)
+            addr := and(keccak256(0x1e, 0x17), 0xffffffffffffffffffffffffffffffffffffffff)
+        }
+    }
+}

package/lib/openzeppelin-contracts-master/contracts/utils/ERC6372Utils.sol

@@ -0,0 +1,52 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.24;
+
+import {IERC6372} from "../interfaces/IERC6372.sol";
+import {Time} from "./types/Time.sol";
+
+/**
+ * @dev Utility library for the ERC-6372 clock standard.
+ */
+library ERC6372Utils {
+    /// @dev The clock was incorrectly modified.
+    error ERC6372InconsistentClock();
+
+    /// @dev Variant of {blockNumberClockMode-uint48-} that checks against an IERC6372 instance
+    function blockNumberClockMode(IERC6372 instance) internal view returns (string memory) {
+        return blockNumberClockMode(instance.clock());
+    }
+
+    /// @dev Variant of {blockNumberClockMode-uint48-} that checks against the clock function.
+    function blockNumberClockMode(function() view returns (uint48) clock) internal view returns (string memory) {
+        return blockNumberClockMode(clock());
+    }
+
+    /// @dev Block number clock mode. Checks that the current `clock` was not modified.
+    function blockNumberClockMode(uint48 clock) internal view returns (string memory) {
+        // Check that the clock was not modified
+        if (clock != Time.blockNumber()) {
+            revert ERC6372InconsistentClock();
+        }
+        return "mode=blocknumber&from=default";
+    }
+
+    /// @dev Variant of {timestampClockMode-uint48-} that checks against an IERC6372 instance
+    function timestampClockMode(IERC6372 instance) internal view returns (string memory) {
+        return timestampClockMode(instance.clock());
+    }
+
+    /// @dev Variant of {timestampClockMode-uint48-} that checks against the clock function.
+    function timestampClockMode(function() view returns (uint48) clock) internal view returns (string memory) {
+        return timestampClockMode(clock());
+    }
+
+    /// @dev Timestamp clock mode. Checks that the current `clock` was not modified.
+    function timestampClockMode(uint48 clock) internal view returns (string memory) {
+        // Check that the clock was not modified
+        if (clock != Time.timestamp()) {
+            revert ERC6372InconsistentClock();
+        }
+        return "mode=timestamp";
+    }
+}

package/lib/openzeppelin-contracts-master/contracts/utils/Errors.sol

@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v5.1.0) (utils/Errors.sol)
+
+pragma solidity ^0.8.20;
+
+/**
+ * @dev Collection of common custom errors used in multiple contracts
+ *
+ * IMPORTANT: Backwards compatibility is not guaranteed in future versions of the library.
+ * It is recommended to avoid relying on the error API for critical functionality.
+ *
+ * _Available since v5.1._
+ */
+library Errors {
+    /**
+     * @dev The ETH balance of the account is not enough to perform the operation.
+     */
+    error InsufficientBalance(uint256 balance, uint256 needed);
+
+    /**
+     * @dev A call to an address target failed. The target may have reverted.
+     */
+    error FailedCall();
+
+    /**
+     * @dev The deployment failed.
+     */
+    error FailedDeployment();
+
+    /**
+     * @dev A necessary precompile is missing.
+     */
+    error MissingPrecompile(address);
+}

package/lib/openzeppelin-contracts-master/contracts/utils/LowLevelCall.sol

@@ -0,0 +1,127 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v5.6.0) (utils/LowLevelCall.sol)
+
+pragma solidity ^0.8.20;
+
+/**
+ * @dev Library of low level call functions that implement different calling strategies to deal with the return data.
+ *
+ * WARNING: Using this library requires an advanced understanding of Solidity and how the EVM works. It is recommended
+ * to use the {Address} library instead.
+ */
+library LowLevelCall {
+    /// @dev Performs a Solidity function call using a low level `call` and ignoring the return data.
+    function callNoReturn(address target, bytes memory data) internal returns (bool success) {
+        return callNoReturn(target, 0, data);
+    }
+
+    /// @dev Same as {callNoReturn-address-bytes}, but allows specifying the value to be sent in the call.
+    function callNoReturn(address target, uint256 value, bytes memory data) internal returns (bool success) {
+        assembly ("memory-safe") {
+            success := call(gas(), target, value, add(data, 0x20), mload(data), 0x00, 0x00)
+        }
+    }
+
+    /// @dev Performs a Solidity function call using a low level `call` and returns the first 64 bytes of the result
+    /// in the scratch space of memory. Useful for functions that return a tuple with two single-word values.
+    ///
+    /// WARNING: Do not assume that the results are zero if `success` is false. Memory can be already allocated
+    /// and this function doesn't zero it out.
+    function callReturn64Bytes(
+        address target,
+        bytes memory data
+    ) internal returns (bool success, bytes32 result1, bytes32 result2) {
+        return callReturn64Bytes(target, 0, data);
+    }
+
+    /// @dev Same as {callReturn64Bytes-address-bytes}, but allows specifying the value to be sent in the call.
+    function callReturn64Bytes(
+        address target,
+        uint256 value,
+        bytes memory data
+    ) internal returns (bool success, bytes32 result1, bytes32 result2) {
+        assembly ("memory-safe") {
+            success := call(gas(), target, value, add(data, 0x20), mload(data), 0x00, 0x40)
+            result1 := mload(0x00)
+            result2 := mload(0x20)
+        }
+    }
+
+    /// @dev Performs a Solidity function call using a low level `staticcall` and ignoring the return data.
+    function staticcallNoReturn(address target, bytes memory data) internal view returns (bool success) {
+        assembly ("memory-safe") {
+            success := staticcall(gas(), target, add(data, 0x20), mload(data), 0x00, 0x00)
+        }
+    }
+
+    /// @dev Performs a Solidity function call using a low level `staticcall` and returns the first 64 bytes of the result
+    /// in the scratch space of memory. Useful for functions that return a tuple with two single-word values.
+    ///
+    /// WARNING: Do not assume that the results are zero if `success` is false. Memory can be already allocated
+    /// and this function doesn't zero it out.
+    function staticcallReturn64Bytes(
+        address target,
+        bytes memory data
+    ) internal view returns (bool success, bytes32 result1, bytes32 result2) {
+        assembly ("memory-safe") {
+            success := staticcall(gas(), target, add(data, 0x20), mload(data), 0x00, 0x40)
+            result1 := mload(0x00)
+            result2 := mload(0x20)
+        }
+    }
+
+    /// @dev Performs a Solidity function call using a low level `delegatecall` and ignoring the return data.
+    function delegatecallNoReturn(address target, bytes memory data) internal returns (bool success) {
+        assembly ("memory-safe") {
+            success := delegatecall(gas(), target, add(data, 0x20), mload(data), 0x00, 0x00)
+        }
+    }
+
+    /// @dev Performs a Solidity function call using a low level `delegatecall` and returns the first 64 bytes of the result
+    /// in the scratch space of memory. Useful for functions that return a tuple with two single-word values.
+    ///
+    /// WARNING: Do not assume that the results are zero if `success` is false. Memory can be already allocated
+    /// and this function doesn't zero it out.
+    function delegatecallReturn64Bytes(
+        address target,
+        bytes memory data
+    ) internal returns (bool success, bytes32 result1, bytes32 result2) {
+        assembly ("memory-safe") {
+            success := delegatecall(gas(), target, add(data, 0x20), mload(data), 0x00, 0x40)
+            result1 := mload(0x00)
+            result2 := mload(0x20)
+        }
+    }
+
+    /// @dev Returns the size of the return data buffer.
+    function returnDataSize() internal pure returns (uint256 size) {
+        assembly ("memory-safe") {
+            size := returndatasize()
+        }
+    }
+
+    /// @dev Returns a buffer containing the return data from the last call.
+    function returnData() internal pure returns (bytes memory result) {
+        assembly ("memory-safe") {
+            result := mload(0x40)
+            mstore(result, returndatasize())
+            returndatacopy(add(result, 0x20), 0x00, returndatasize())
+            mstore(0x40, add(result, add(0x20, returndatasize())))
+        }
+    }
+
+    /// @dev Revert with the return data from the last call.
+    function bubbleRevert() internal pure {
+        assembly ("memory-safe") {
+            let fmp := mload(0x40)
+            returndatacopy(fmp, 0x00, returndatasize())
+            revert(fmp, returndatasize())
+        }
+    }
+
+    function bubbleRevert(bytes memory returndata) internal pure {
+        assembly ("memory-safe") {
+            revert(add(returndata, 0x20), mload(returndata))
+        }
+    }
+}

package/lib/openzeppelin-contracts-master/contracts/utils/Memory.sol

@@ -0,0 +1,149 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v5.6.0) (utils/Memory.sol)
+
+pragma solidity ^0.8.24;
+
+import {Panic} from "./Panic.sol";
+import {Math} from "./math/Math.sol";
+
+/**
+ * @dev Utilities to manipulate memory.
+ *
+ * Memory is a contiguous and dynamic byte array in which Solidity stores non-primitive types.
+ * This library provides functions to manipulate pointers to this dynamic array and work with slices of it.
+ *
+ * Slices provide a view into a portion of memory without copying data, enabling efficient substring operations.
+ *
+ * WARNING: When manipulating memory pointers or slices, make sure to follow the Solidity documentation
+ * guidelines for https://docs.soliditylang.org/en/v0.8.20/assembly.html#memory-safety[Memory Safety].
+ */
+library Memory {
+    type Pointer is bytes32;
+
+    /// @dev Returns a `Pointer` to the current free `Pointer`.
+    function getFreeMemoryPointer() internal pure returns (Pointer ptr) {
+        assembly ("memory-safe") {
+            ptr := mload(0x40)
+        }
+    }
+
+    /**
+     * @dev Sets the free `Pointer` to a specific value.
+     *
+     * The solidity memory layout requires that the FMP is never set to a value lower than 0x80. Setting the
+     * FMP to a value lower than 0x80 may cause unexpected behavior. Deallocating all memory can be achieved by
+     * setting the FMP to 0x80.
+     *
+     * WARNING: Everything after the pointer may be overwritten.
+     **/
+    function unsafeSetFreeMemoryPointer(Pointer ptr) internal pure {
+        assembly ("memory-safe") {
+            mstore(0x40, ptr)
+        }
+    }
+
+    /// @dev Move a pointer forward by a given offset.
+    function forward(Pointer ptr, uint256 offset) internal pure returns (Pointer) {
+        return Pointer.wrap(bytes32(uint256(Pointer.unwrap(ptr)) + offset));
+    }
+
+    /// @dev Equality comparator for memory pointers.
+    function equal(Pointer ptr1, Pointer ptr2) internal pure returns (bool) {
+        return Pointer.unwrap(ptr1) == Pointer.unwrap(ptr2);
+    }
+
+    type Slice is bytes32;
+
+    /// @dev Get a slice representation of a bytes object in memory
+    function asSlice(bytes memory self) internal pure returns (Slice result) {
+        assembly ("memory-safe") {
+            result := or(shl(128, mload(self)), add(self, 0x20))
+        }
+    }
+
+    /// @dev Returns the length of a given slice (equiv to self.length for calldata slices)
+    function length(Slice self) internal pure returns (uint256 result) {
+        assembly ("memory-safe") {
+            result := shr(128, self)
+        }
+    }
+
+    /// @dev Offset a memory slice (equivalent to self[offset:] for calldata slices)
+    function slice(Slice self, uint256 offset) internal pure returns (Slice) {
+        if (offset > length(self)) Panic.panic(Panic.ARRAY_OUT_OF_BOUNDS);
+        return _asSlice(length(self) - offset, forward(_pointer(self), offset));
+    }
+
+    /// @dev Offset and cut a Slice (equivalent to self[offset:offset+len] for calldata slices)
+    function slice(Slice self, uint256 offset, uint256 len) internal pure returns (Slice) {
+        if (offset + len > length(self)) Panic.panic(Panic.ARRAY_OUT_OF_BOUNDS);
+        return _asSlice(len, forward(_pointer(self), offset));
+    }
+
+    /**
+     * @dev Read a bytes32 buffer from a given Slice at a specific offset
+     *
+     * NOTE: If offset > length(slice) - 0x20, part of the return value will be out of bound of the slice. These bytes are zeroed.
+     */
+    function load(Slice self, uint256 offset) internal pure returns (bytes32 value) {
+        uint256 outOfBoundBytes = Math.saturatingSub(0x20 + offset, length(self));
+        if (outOfBoundBytes > 0x1f) Panic.panic(Panic.ARRAY_OUT_OF_BOUNDS);
+
+        assembly ("memory-safe") {
+            value := and(mload(add(and(self, shr(128, not(0))), offset)), shl(mul(8, outOfBoundBytes), not(0)))
+        }
+    }
+
+    /// @dev Extract the data corresponding to a Slice (allocate new memory)
+    function toBytes(Slice self) internal pure returns (bytes memory result) {
+        uint256 len = length(self);
+        Memory.Pointer ptr = _pointer(self);
+        assembly ("memory-safe") {
+            result := mload(0x40)
+            mstore(result, len)
+            mcopy(add(result, 0x20), ptr, len)
+            mstore(0x40, add(add(result, len), 0x20))
+        }
+    }
+
+    /// @dev Returns true if the two slices contain the same data.
+    function equal(Slice a, Slice b) internal pure returns (bool result) {
+        Memory.Pointer ptrA = _pointer(a);
+        Memory.Pointer ptrB = _pointer(b);
+        uint256 lenA = length(a);
+        uint256 lenB = length(b);
+        assembly ("memory-safe") {
+            result := eq(keccak256(ptrA, lenA), keccak256(ptrB, lenB))
+        }
+    }
+
+    /// @dev Returns true if the memory occupied by the slice is reserved (i.e. before the free memory pointer)
+    function isReserved(Slice self) internal pure returns (bool result) {
+        Memory.Pointer fmp = getFreeMemoryPointer();
+        Memory.Pointer end = forward(_pointer(self), length(self));
+        assembly ("memory-safe") {
+            result := iszero(lt(fmp, end)) // end <= fmp
+        }
+    }
+
+    /**
+     * @dev Private helper: create a slice from raw values (length and pointer)
+     *
+     * NOTE: this function MUST NOT be called with `len` or `ptr` that exceed `2**128-1`. This should never be
+     * the case of slices produced by `asSlice(bytes)`, and function that reduce the scope of slices
+     * (`slice(Slice,uint256)` and `slice(Slice,uint256, uint256)`) should not cause this issue if the parent slice is
+     * correct.
+     */
+    function _asSlice(uint256 len, Memory.Pointer ptr) private pure returns (Slice result) {
+        assembly ("memory-safe") {
+            result := or(shl(128, len), ptr)
+        }
+    }
+
+    /// @dev Returns the memory location of a given slice (equiv to self.offset for calldata slices)
+    function _pointer(Slice self) private pure returns (Memory.Pointer result) {
+        assembly ("memory-safe") {
+            result := and(self, shr(128, not(0)))
+        }
+    }
+}

package/lib/openzeppelin-contracts-master/contracts/utils/Multicall.sol

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v5.5.0) (utils/Multicall.sol)
+
+pragma solidity ^0.8.20;
+
+import {Address} from "./Address.sol";
+import {Context} from "./Context.sol";
+
+/**
+ * @dev Provides a function to batch together multiple calls in a single external call.
+ *
+ * Consider any assumption about calldata validation performed by the sender may be violated if it's not especially
+ * careful about sending transactions invoking {multicall}. For example, a relay address that filters function
+ * selectors won't filter calls nested within a {multicall} operation.
+ *
+ * NOTE: Since 5.0.1 and 4.9.4, this contract identifies non-canonical contexts (i.e. `msg.sender` is not {Context-_msgSender}).
+ * If a non-canonical context is identified, the following self `delegatecall` appends the last bytes of `msg.data`
+ * to the subcall. This makes it safe to use with {ERC2771Context}. Contexts that don't affect the resolution of
+ * {Context-_msgSender} are not propagated to subcalls.
+ */
+abstract contract Multicall is Context {
+    /**
+     * @dev Receives and executes a batch of function calls on this contract.
+     * @custom:oz-upgrades-unsafe-allow-reachable delegatecall
+     */
+    function multicall(bytes[] calldata data) public virtual returns (bytes[] memory results) {
+        bytes memory context = msg.sender == _msgSender()
+            ? new bytes(0)
+            : msg.data[msg.data.length - _contextSuffixLength():];
+
+        results = new bytes[](data.length);
+        for (uint256 i = 0; i < data.length; i++) {
+            results[i] = Address.functionDelegateCall(address(this), bytes.concat(data[i], context));
+        }
+        return results;
+    }
+}

package/lib/openzeppelin-contracts-master/contracts/utils/Nonces.sol

@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v5.0.0) (utils/Nonces.sol)
+pragma solidity ^0.8.20;
+
+/**
+ * @dev Provides tracking nonces for addresses. Nonces will only increment.
+ */
+abstract contract Nonces {
+    /**
+     * @dev The nonce used for an `account` is not the expected current nonce.
+     */
+    error InvalidAccountNonce(address account, uint256 currentNonce);
+
+    mapping(address account => uint256) private _nonces;
+
+    /**
+     * @dev Returns the next unused nonce for an address.
+     */
+    function nonces(address owner) public view virtual returns (uint256) {
+        return _nonces[owner];
+    }
+
+    /**
+     * @dev Consumes a nonce.
+     *
+     * Returns the current value and increments nonce.
+     */
+    function _useNonce(address owner) internal virtual returns (uint256) {
+        // For each account, the nonce has an initial value of 0, can only be incremented by one, and cannot be
+        // decremented or reset. This guarantees that the nonce never overflows.
+        unchecked {
+            // It is important to do x++ and not ++x here.
+            return _nonces[owner]++;
+        }
+    }
+
+    /**
+     * @dev Same as {_useNonce} but checking that `nonce` is the next valid for `owner`.
+     */
+    function _useCheckedNonce(address owner, uint256 nonce) internal virtual {
+        uint256 current = _useNonce(owner);
+        if (nonce != current) {
+            revert InvalidAccountNonce(owner, current);
+        }
+    }
+}

package/lib/openzeppelin-contracts-master/contracts/utils/NoncesKeyed.sol

@@ -0,0 +1,74 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v5.2.0) (utils/NoncesKeyed.sol)
+pragma solidity ^0.8.20;
+
+import {Nonces} from "./Nonces.sol";
+
+/**
+ * @dev Alternative to {Nonces}, that supports key-ed nonces.
+ *
+ * Follows the https://eips.ethereum.org/EIPS/eip-4337#semi-abstracted-nonce-support[ERC-4337's semi-abstracted nonce system].
+ *
+ * NOTE: This contract inherits from {Nonces} and reuses its storage for the first nonce key (i.e. `0`). This
+ * makes upgrading from {Nonces} to {NoncesKeyed} safe when using their upgradeable versions (e.g. `NoncesKeyedUpgradeable`).
+ * Doing so will NOT reset the current state of nonces, avoiding replay attacks where a nonce is reused after the upgrade.
+ */
+abstract contract NoncesKeyed is Nonces {
+    mapping(address owner => mapping(uint192 key => uint64)) private _nonces;
+
+    /// @dev Returns the next unused nonce for an address and key. Result contains the key prefix.
+    function nonces(address owner, uint192 key) public view virtual returns (uint256) {
+        return key == 0 ? nonces(owner) : _pack(key, _nonces[owner][key]);
+    }
+
+    /**
+     * @dev Consumes the next unused nonce for an address and key.
+     *
+     * Returns the current value without the key prefix. Consumed nonce is increased, so calling this function twice
+     * with the same arguments will return different (sequential) results.
+     */
+    function _useNonce(address owner, uint192 key) internal virtual returns (uint256) {
+        // For each account, the nonce has an initial value of 0, can only be incremented by one, and cannot be
+        // decremented or reset. This guarantees that the nonce never overflows.
+        unchecked {
+            // It is important to do x++ and not ++x here.
+            return key == 0 ? _useNonce(owner) : _pack(key, _nonces[owner][key]++);
+        }
+    }
+
+    /**
+     * @dev Same as {_useNonce} but checking that `nonce` is the next valid for `owner`.
+     *
+     * This version takes the key and the nonce in a single uint256 parameter:
+     * - use the first 24 bytes for the key
+     * - use the last 8 bytes for the nonce
+     */
+    function _useCheckedNonce(address owner, uint256 keyNonce) internal virtual override {
+        (uint192 key, ) = _unpack(keyNonce);
+        if (key == 0) {
+            super._useCheckedNonce(owner, keyNonce);
+        } else {
+            uint256 current = _useNonce(owner, key);
+            if (keyNonce != current) revert InvalidAccountNonce(owner, current);
+        }
+    }
+
+    /**
+     * @dev Same as {_useNonce} but checking that `nonce` is the next valid for `owner`.
+     *
+     * This version takes the key and the nonce as two different parameters.
+     */
+    function _useCheckedNonce(address owner, uint192 key, uint64 nonce) internal virtual {
+        _useCheckedNonce(owner, _pack(key, nonce));
+    }
+
+    /// @dev Pack key and nonce into a keyNonce
+    function _pack(uint192 key, uint64 nonce) private pure returns (uint256) {
+        return (uint256(key) << 64) | nonce;
+    }
+
+    /// @dev Unpack a keyNonce into its key and nonce components
+    function _unpack(uint256 keyNonce) private pure returns (uint192 key, uint64 nonce) {
+        return (uint192(keyNonce >> 64), uint64(keyNonce));
+    }
+}