web3gbit-cli 1.0.0

package/lib/openzeppelin-contracts/contracts/mocks/SingleInheritanceInitializableMocks.sol

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import {Initializable} from "../proxy/utils/Initializable.sol";
+
+/**
+ * @title MigratableMockV1
+ * @dev This contract is a mock to test initializable functionality through migrations
+ */
+contract MigratableMockV1 is Initializable {
+    uint256 public x;
+
+    function initialize(uint256 value) public payable initializer {
+        x = value;
+    }
+}
+
+/**
+ * @title MigratableMockV2
+ * @dev This contract is a mock to test migratable functionality with params
+ */
+contract MigratableMockV2 is MigratableMockV1 {
+    bool internal _migratedV2;
+    uint256 public y;
+
+    function migrate(uint256 value, uint256 anotherValue) public payable {
+        require(!_migratedV2);
+        x = value;
+        y = anotherValue;
+        _migratedV2 = true;
+    }
+}
+
+/**
+ * @title MigratableMockV3
+ * @dev This contract is a mock to test migratable functionality without params
+ */
+contract MigratableMockV3 is MigratableMockV2 {
+    bool internal _migratedV3;
+
+    function migrate() public payable {
+        require(!_migratedV3);
+        uint256 oldX = x;
+        x = y;
+        y = oldX;
+        _migratedV3 = true;
+    }
+}

package/lib/openzeppelin-contracts/contracts/mocks/Stateless.sol

@@ -0,0 +1,62 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.26;
+
+// We keep these imports and a dummy contract just to we can run the test suite after transpilation.
+
+import {Accumulators} from "../utils/structs/Accumulators.sol";
+import {Address} from "../utils/Address.sol";
+import {Arrays} from "../utils/Arrays.sol";
+import {AuthorityUtils} from "../access/manager/AuthorityUtils.sol";
+import {Base58} from "../utils/Base58.sol";
+import {Base64} from "../utils/Base64.sol";
+import {BitMaps} from "../utils/structs/BitMaps.sol";
+import {Blockhash} from "../utils/Blockhash.sol";
+import {Bytes} from "../utils/Bytes.sol";
+import {CAIP2} from "../utils/CAIP2.sol";
+import {CAIP10} from "../utils/CAIP10.sol";
+import {Checkpoints} from "../utils/structs/Checkpoints.sol";
+import {CircularBuffer} from "../utils/structs/CircularBuffer.sol";
+import {Clones} from "../proxy/Clones.sol";
+import {Create2} from "../utils/Create2.sol";
+import {DoubleEndedQueue} from "../utils/structs/DoubleEndedQueue.sol";
+import {ECDSA} from "../utils/cryptography/ECDSA.sol";
+import {EIP7702Utils} from "../account/utils/EIP7702Utils.sol";
+import {EnumerableMap} from "../utils/structs/EnumerableMap.sol";
+import {EnumerableSet} from "../utils/structs/EnumerableSet.sol";
+import {ERC165} from "../utils/introspection/ERC165.sol";
+import {ERC165Checker} from "../utils/introspection/ERC165Checker.sol";
+import {ERC721Holder} from "../token/ERC721/utils/ERC721Holder.sol";
+import {ERC1155Holder} from "../token/ERC1155/utils/ERC1155Holder.sol";
+import {ERC1967Utils} from "../proxy/ERC1967/ERC1967Utils.sol";
+import {ERC4337Utils} from "../account/utils/draft-ERC4337Utils.sol";
+import {ERC7579Utils} from "../account/utils/draft-ERC7579Utils.sol";
+import {ERC7913P256Verifier} from "../utils/cryptography/verifiers/ERC7913P256Verifier.sol";
+import {ERC7913RSAVerifier} from "../utils/cryptography/verifiers/ERC7913RSAVerifier.sol";
+import {ERC7913WebAuthnVerifier} from "../utils/cryptography/verifiers/ERC7913WebAuthnVerifier.sol";
+import {Heap} from "../utils/structs/Heap.sol";
+import {InteroperableAddress} from "../utils/draft-InteroperableAddress.sol";
+import {LowLevelCall} from "../utils/LowLevelCall.sol";
+import {Math} from "../utils/math/Math.sol";
+import {Memory} from "../utils/Memory.sol";
+import {MerkleProof} from "../utils/cryptography/MerkleProof.sol";
+import {MessageHashUtils} from "../utils/cryptography/MessageHashUtils.sol";
+import {Nonces} from "../utils/Nonces.sol";
+import {NoncesKeyed} from "../utils/NoncesKeyed.sol";
+import {P256} from "../utils/cryptography/P256.sol";
+import {Packing} from "../utils/Packing.sol";
+import {Panic} from "../utils/Panic.sol";
+import {RelayedCall} from "../utils/RelayedCall.sol";
+import {RLP} from "../utils/RLP.sol";
+import {RSA} from "../utils/cryptography/RSA.sol";
+import {SafeCast} from "../utils/math/SafeCast.sol";
+import {SafeERC20} from "../token/ERC20/utils/SafeERC20.sol";
+import {ShortStrings} from "../utils/ShortStrings.sol";
+import {SignatureChecker} from "../utils/cryptography/SignatureChecker.sol";
+import {SignedMath} from "../utils/math/SignedMath.sol";
+import {StorageSlot} from "../utils/StorageSlot.sol";
+import {Strings} from "../utils/Strings.sol";
+import {Time} from "../utils/types/Time.sol";
+import {TrieProof} from "../utils/cryptography/TrieProof.sol";
+
+contract Dummy1234 {}

package/lib/openzeppelin-contracts/contracts/mocks/StorageSlotMock.sol

@@ -0,0 +1,87 @@
+// SPDX-License-Identifier: MIT
+// This file was procedurally generated from scripts/generate/templates/StorageSlotMock.js.
+
+pragma solidity ^0.8.20;
+
+import {Multicall} from "../utils/Multicall.sol";
+import {StorageSlot} from "../utils/StorageSlot.sol";
+
+contract StorageSlotMock is Multicall {
+    using StorageSlot for *;
+
+    function setAddressSlot(bytes32 slot, address value) public {
+        slot.getAddressSlot().value = value;
+    }
+
+    function setBooleanSlot(bytes32 slot, bool value) public {
+        slot.getBooleanSlot().value = value;
+    }
+
+    function setBytes32Slot(bytes32 slot, bytes32 value) public {
+        slot.getBytes32Slot().value = value;
+    }
+
+    function setUint256Slot(bytes32 slot, uint256 value) public {
+        slot.getUint256Slot().value = value;
+    }
+
+    function setInt256Slot(bytes32 slot, int256 value) public {
+        slot.getInt256Slot().value = value;
+    }
+
+    function getAddressSlot(bytes32 slot) public view returns (address) {
+        return slot.getAddressSlot().value;
+    }
+
+    function getBooleanSlot(bytes32 slot) public view returns (bool) {
+        return slot.getBooleanSlot().value;
+    }
+
+    function getBytes32Slot(bytes32 slot) public view returns (bytes32) {
+        return slot.getBytes32Slot().value;
+    }
+
+    function getUint256Slot(bytes32 slot) public view returns (uint256) {
+        return slot.getUint256Slot().value;
+    }
+
+    function getInt256Slot(bytes32 slot) public view returns (int256) {
+        return slot.getInt256Slot().value;
+    }
+
+    mapping(uint256 key => string) public stringMap;
+
+    function setStringSlot(bytes32 slot, string calldata value) public {
+        slot.getStringSlot().value = value;
+    }
+
+    function setStringStorage(uint256 key, string calldata value) public {
+        stringMap[key].getStringSlot().value = value;
+    }
+
+    function getStringSlot(bytes32 slot) public view returns (string memory) {
+        return slot.getStringSlot().value;
+    }
+
+    function getStringStorage(uint256 key) public view returns (string memory) {
+        return stringMap[key].getStringSlot().value;
+    }
+
+    mapping(uint256 key => bytes) public bytesMap;
+
+    function setBytesSlot(bytes32 slot, bytes calldata value) public {
+        slot.getBytesSlot().value = value;
+    }
+
+    function setBytesStorage(uint256 key, bytes calldata value) public {
+        bytesMap[key].getBytesSlot().value = value;
+    }
+
+    function getBytesSlot(bytes32 slot) public view returns (bytes memory) {
+        return slot.getBytesSlot().value;
+    }
+
+    function getBytesStorage(uint256 key) public view returns (bytes memory) {
+        return bytesMap[key].getBytesSlot().value;
+    }
+}

package/lib/openzeppelin-contracts/contracts/mocks/TimelockReentrant.sol

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {Address} from "../utils/Address.sol";
+
+contract TimelockReentrant {
+    address private _reenterTarget;
+    bytes private _reenterData;
+    bool _reentered;
+
+    function disableReentrancy() external {
+        _reentered = true;
+    }
+
+    function enableReentrancy(address target, bytes calldata data) external {
+        _reenterTarget = target;
+        _reenterData = data;
+    }
+
+    function reenter() external {
+        if (!_reentered) {
+            _reentered = true;
+            Address.functionCall(_reenterTarget, _reenterData);
+        }
+    }
+}

package/lib/openzeppelin-contracts/contracts/mocks/TransientSlotMock.sol

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: MIT
+// This file was procedurally generated from scripts/generate/templates/TransientSlotMock.js.
+
+pragma solidity ^0.8.24;
+
+import {Multicall} from "../utils/Multicall.sol";
+import {TransientSlot} from "../utils/TransientSlot.sol";
+
+contract TransientSlotMock is Multicall {
+    using TransientSlot for *;
+
+    event AddressValue(bytes32 slot, address value);
+
+    function tloadAddress(bytes32 slot) public {
+        emit AddressValue(slot, slot.asAddress().tload());
+    }
+
+    function tstore(bytes32 slot, address value) public {
+        slot.asAddress().tstore(value);
+    }
+
+    event BooleanValue(bytes32 slot, bool value);
+
+    function tloadBoolean(bytes32 slot) public {
+        emit BooleanValue(slot, slot.asBoolean().tload());
+    }
+
+    function tstore(bytes32 slot, bool value) public {
+        slot.asBoolean().tstore(value);
+    }
+
+    event Bytes32Value(bytes32 slot, bytes32 value);
+
+    function tloadBytes32(bytes32 slot) public {
+        emit Bytes32Value(slot, slot.asBytes32().tload());
+    }
+
+    function tstore(bytes32 slot, bytes32 value) public {
+        slot.asBytes32().tstore(value);
+    }
+
+    event Uint256Value(bytes32 slot, uint256 value);
+
+    function tloadUint256(bytes32 slot) public {
+        emit Uint256Value(slot, slot.asUint256().tload());
+    }
+
+    function tstore(bytes32 slot, uint256 value) public {
+        slot.asUint256().tstore(value);
+    }
+
+    event Int256Value(bytes32 slot, int256 value);
+
+    function tloadInt256(bytes32 slot) public {
+        emit Int256Value(slot, slot.asInt256().tload());
+    }
+
+    function tstore(bytes32 slot, int256 value) public {
+        slot.asInt256().tstore(value);
+    }
+}

package/lib/openzeppelin-contracts/contracts/mocks/UpgradeableBeaconMock.sol

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {IBeacon} from "../proxy/beacon/IBeacon.sol";
+
+contract UpgradeableBeaconMock is IBeacon {
+    address public implementation;
+
+    constructor(address impl) {
+        implementation = impl;
+    }
+}
+
+interface IProxyExposed {
+    // solhint-disable-next-line func-name-mixedcase
+    function $getBeacon() external view returns (address);
+}
+
+contract UpgradeableBeaconReentrantMock is IBeacon {
+    error BeaconProxyBeaconSlotAddress(address beacon);
+
+    function implementation() external view override returns (address) {
+        // Revert with the beacon seen in the proxy at the moment of calling to check if it's
+        // set before the call.
+        revert BeaconProxyBeaconSlotAddress(IProxyExposed(msg.sender).$getBeacon());
+    }
+}

package/lib/openzeppelin-contracts/contracts/mocks/VotesExtendedMock.sol

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.24;
+
+import {VotesExtended} from "../governance/utils/VotesExtended.sol";
+
+abstract contract VotesExtendedMock is VotesExtended {
+    mapping(address voter => uint256) private _votingUnits;
+
+    function getTotalSupply() public view returns (uint256) {
+        return _getTotalSupply();
+    }
+
+    function delegate(address account, address newDelegation) public {
+        return _delegate(account, newDelegation);
+    }
+
+    function _getVotingUnits(address account) internal view override returns (uint256) {
+        return _votingUnits[account];
+    }
+
+    function _mint(address account, uint256 votes) internal {
+        _votingUnits[account] += votes;
+        _transferVotingUnits(address(0), account, votes);
+    }
+
+    function _burn(address account, uint256 votes) internal {
+        _votingUnits[account] += votes;
+        _transferVotingUnits(account, address(0), votes);
+    }
+}
+
+abstract contract VotesExtendedTimestampMock is VotesExtendedMock {
+    function clock() public view override returns (uint48) {
+        return uint48(block.timestamp);
+    }
+
+    // solhint-disable-next-line func-name-mixedcase
+    function CLOCK_MODE() public view virtual override returns (string memory) {
+        return "mode=timestamp";
+    }
+}

package/lib/openzeppelin-contracts/contracts/mocks/VotesMock.sol

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.24;
+
+import {Votes} from "../governance/utils/Votes.sol";
+
+abstract contract VotesMock is Votes {
+    mapping(address voter => uint256) private _votingUnits;
+
+    function getTotalSupply() public view returns (uint256) {
+        return _getTotalSupply();
+    }
+
+    function delegate(address account, address newDelegation) public {
+        return _delegate(account, newDelegation);
+    }
+
+    function _getVotingUnits(address account) internal view override returns (uint256) {
+        return _votingUnits[account];
+    }
+
+    function _mint(address account, uint256 votes) internal {
+        _votingUnits[account] += votes;
+        _transferVotingUnits(address(0), account, votes);
+    }
+
+    function _burn(address account, uint256 votes) internal {
+        _votingUnits[account] += votes;
+        _transferVotingUnits(account, address(0), votes);
+    }
+}
+
+abstract contract VotesTimestampMock is VotesMock {
+    function clock() public view override returns (uint48) {
+        return uint48(block.timestamp);
+    }
+
+    // solhint-disable-next-line func-name-mixedcase
+    function CLOCK_MODE() public view virtual override returns (string memory) {
+        return "mode=timestamp";
+    }
+}

package/lib/openzeppelin-contracts/contracts/mocks/account/AccountMock.sol

@@ -0,0 +1,181 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.26;
+
+import {Account} from "../../account/Account.sol";
+import {AccountERC7579} from "../../account/extensions/draft-AccountERC7579.sol";
+import {AccountERC7579Hooked} from "../../account/extensions/draft-AccountERC7579Hooked.sol";
+import {ERC721Holder} from "../../token/ERC721/utils/ERC721Holder.sol";
+import {ERC1155Holder} from "../../token/ERC1155/utils/ERC1155Holder.sol";
+import {ERC7739} from "../../utils/cryptography/signers/draft-ERC7739.sol";
+import {ERC7821} from "../../account/extensions/draft-ERC7821.sol";
+import {MODULE_TYPE_VALIDATOR} from "../../interfaces/draft-IERC7579.sol";
+import {PackedUserOperation} from "../../interfaces/draft-IERC4337.sol";
+import {AbstractSigner} from "../../utils/cryptography/signers/AbstractSigner.sol";
+import {SignerECDSA} from "../../utils/cryptography/signers/SignerECDSA.sol";
+import {SignerP256} from "../../utils/cryptography/signers/SignerP256.sol";
+import {SignerRSA} from "../../utils/cryptography/signers/SignerRSA.sol";
+import {SignerWebAuthn} from "../../utils/cryptography/signers/SignerWebAuthn.sol";
+import {SignerEIP7702} from "../../utils/cryptography/signers/SignerEIP7702.sol";
+import {SignerERC7913} from "../../utils/cryptography/signers/SignerERC7913.sol";
+import {MultiSignerERC7913} from "../../utils/cryptography/signers/MultiSignerERC7913.sol";
+import {MultiSignerERC7913Weighted} from "../../utils/cryptography/signers/MultiSignerERC7913Weighted.sol";
+
+abstract contract AccountMock is Account, ERC7739, ERC7821, ERC721Holder, ERC1155Holder {
+    /// Validates a user operation with a boolean signature.
+    function _rawSignatureValidation(bytes32 hash, bytes calldata signature) internal pure override returns (bool) {
+        return signature.length >= 32 && bytes32(signature) == hash;
+    }
+
+    /// @inheritdoc ERC7821
+    function _erc7821AuthorizedExecutor(
+        address caller,
+        bytes32 mode,
+        bytes calldata executionData
+    ) internal view virtual override returns (bool) {
+        return caller == address(entryPoint()) || super._erc7821AuthorizedExecutor(caller, mode, executionData);
+    }
+}
+
+abstract contract AccountECDSAMock is Account, SignerECDSA, ERC7739, ERC7821, ERC721Holder, ERC1155Holder {
+    /// @inheritdoc ERC7821
+    function _erc7821AuthorizedExecutor(
+        address caller,
+        bytes32 mode,
+        bytes calldata executionData
+    ) internal view virtual override returns (bool) {
+        return caller == address(entryPoint()) || super._erc7821AuthorizedExecutor(caller, mode, executionData);
+    }
+}
+
+abstract contract AccountP256Mock is Account, SignerP256, ERC7739, ERC7821, ERC721Holder, ERC1155Holder {
+    /// @inheritdoc ERC7821
+    function _erc7821AuthorizedExecutor(
+        address caller,
+        bytes32 mode,
+        bytes calldata executionData
+    ) internal view virtual override returns (bool) {
+        return caller == address(entryPoint()) || super._erc7821AuthorizedExecutor(caller, mode, executionData);
+    }
+}
+
+abstract contract AccountRSAMock is Account, SignerRSA, ERC7739, ERC7821, ERC721Holder, ERC1155Holder {
+    /// @inheritdoc ERC7821
+    function _erc7821AuthorizedExecutor(
+        address caller,
+        bytes32 mode,
+        bytes calldata executionData
+    ) internal view virtual override returns (bool) {
+        return caller == address(entryPoint()) || super._erc7821AuthorizedExecutor(caller, mode, executionData);
+    }
+}
+
+abstract contract AccountWebAuthnMock is Account, SignerWebAuthn, ERC7739, ERC7821, ERC721Holder, ERC1155Holder {
+    /// @inheritdoc ERC7821
+    function _erc7821AuthorizedExecutor(
+        address caller,
+        bytes32 mode,
+        bytes calldata executionData
+    ) internal view virtual override returns (bool) {
+        return caller == address(entryPoint()) || super._erc7821AuthorizedExecutor(caller, mode, executionData);
+    }
+}
+
+abstract contract AccountEIP7702Mock is Account, SignerEIP7702, ERC7739, ERC7821, ERC721Holder, ERC1155Holder {
+    /// @inheritdoc ERC7821
+    function _erc7821AuthorizedExecutor(
+        address caller,
+        bytes32 mode,
+        bytes calldata executionData
+    ) internal view virtual override returns (bool) {
+        return caller == address(entryPoint()) || super._erc7821AuthorizedExecutor(caller, mode, executionData);
+    }
+}
+
+abstract contract AccountEIP7702WithModulesMock is
+    Account,
+    AccountERC7579,
+    SignerEIP7702,
+    ERC7739,
+    ERC721Holder,
+    ERC1155Holder
+{
+    function _validateUserOp(
+        PackedUserOperation calldata userOp,
+        bytes32 userOpHash,
+        bytes calldata signature
+    ) internal virtual override(Account, AccountERC7579) returns (uint256) {
+        return super._validateUserOp(userOp, userOpHash, signature);
+    }
+
+    /// @dev Resolve implementation of ERC-1271 by both ERC7739 and AccountERC7579 to support both schemes.
+    function isValidSignature(
+        bytes32 hash,
+        bytes calldata signature
+    ) public view virtual override(ERC7739, AccountERC7579) returns (bytes4) {
+        // ERC-7739 can return the fn selector (success), 0xffffffff (invalid) or 0x77390001 (detection).
+        // If the return is 0xffffffff, we fallback to validation using ERC-7579 modules.
+        bytes4 erc7739magic = ERC7739.isValidSignature(hash, signature);
+        return erc7739magic == bytes4(0xffffffff) ? AccountERC7579.isValidSignature(hash, signature) : erc7739magic;
+    }
+
+    /// @dev Enable signature using the EIP-7702 signer.
+    function _rawSignatureValidation(
+        bytes32 hash,
+        bytes calldata signature
+    ) internal view virtual override(AbstractSigner, AccountERC7579, SignerEIP7702) returns (bool) {
+        return SignerEIP7702._rawSignatureValidation(hash, signature);
+    }
+}
+
+abstract contract AccountERC7579Mock is AccountERC7579 {
+    constructor(address validator, bytes memory initData) {
+        _installModule(MODULE_TYPE_VALIDATOR, validator, initData);
+    }
+}
+
+abstract contract AccountERC7579HookedMock is AccountERC7579Hooked {
+    constructor(address validator, bytes memory initData) {
+        _installModule(MODULE_TYPE_VALIDATOR, validator, initData);
+    }
+}
+
+abstract contract AccountERC7913Mock is Account, SignerERC7913, ERC7739, ERC7821, ERC721Holder, ERC1155Holder {
+    /// @inheritdoc ERC7821
+    function _erc7821AuthorizedExecutor(
+        address caller,
+        bytes32 mode,
+        bytes calldata executionData
+    ) internal view virtual override returns (bool) {
+        return caller == address(entryPoint()) || super._erc7821AuthorizedExecutor(caller, mode, executionData);
+    }
+}
+
+abstract contract AccountMultiSignerMock is Account, MultiSignerERC7913, ERC7739, ERC7821, ERC721Holder, ERC1155Holder {
+    /// @inheritdoc ERC7821
+    function _erc7821AuthorizedExecutor(
+        address caller,
+        bytes32 mode,
+        bytes calldata executionData
+    ) internal view virtual override returns (bool) {
+        return caller == address(entryPoint()) || super._erc7821AuthorizedExecutor(caller, mode, executionData);
+    }
+}
+
+abstract contract AccountMultiSignerWeightedMock is
+    Account,
+    MultiSignerERC7913Weighted,
+    ERC7739,
+    ERC7821,
+    ERC721Holder,
+    ERC1155Holder
+{
+    /// @inheritdoc ERC7821
+    function _erc7821AuthorizedExecutor(
+        address caller,
+        bytes32 mode,
+        bytes calldata executionData
+    ) internal view virtual override returns (bool) {
+        return caller == address(entryPoint()) || super._erc7821AuthorizedExecutor(caller, mode, executionData);
+    }
+}