web3gbit-cli 1.0.0

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

@@ -0,0 +1,127 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v5.5.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 of 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 of 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 of 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/contracts/utils/Memory.sol

@@ -0,0 +1,146 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v5.5.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.
+     *
+     * WARNING: Everything after the pointer may be overwritten.
+     **/
+    function setFreeMemoryPointer(Pointer ptr) internal pure {
+        assembly ("memory-safe") {
+            mstore(0x40, ptr)
+        }
+    }
+
+    /// @dev `Pointer` to `bytes32`. Expects a pointer to a properly ABI-encoded `bytes` object.
+    function asBytes32(Pointer ptr) internal pure returns (bytes32) {
+        return Pointer.unwrap(ptr);
+    }
+
+    /// @dev `bytes32` to `Pointer`. Expects a pointer to a properly ABI-encoded `bytes` object.
+    function asPointer(bytes32 value) internal pure returns (Pointer) {
+        return Pointer.wrap(value);
+    }
+
+    /// @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[start:] 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[start:start+length] 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 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/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/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/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));
+    }
+}