@erc6900/reference-implementation 0.8.1 → 1.0.0

package/src/interfaces/IERC6900ValidationModule.sol

@@ -1,53 +0,0 @@
-// SPDX-License-Identifier: CC0-1.0
-pragma solidity ^0.8.20;
-
-import {PackedUserOperation} from "@eth-infinitism/account-abstraction/interfaces/PackedUserOperation.sol";
-
-import {IERC6900Module} from "./IERC6900Module.sol";
-
-interface IERC6900ValidationModule is IERC6900Module {
-    /// @notice Run the user operation validation function specified by the `entityId`.
-    /// @param entityId An identifier that routes the call to different internal implementations, should there
-    /// be more than one.
-    /// @param userOp The user operation.
-    /// @param userOpHash The user operation hash.
-    /// @return Packed validation data for validAfter (6 bytes), validUntil (6 bytes), and authorizer (20 bytes).
-    function validateUserOp(uint32 entityId, PackedUserOperation calldata userOp, bytes32 userOpHash)
-        external
-        returns (uint256);
-
-    /// @notice Run the runtime validation function specified by the `entityId`.
-    /// @dev To indicate the entire call should revert, the function MUST revert.
-    /// @param account The account to validate for.
-    /// @param entityId An identifier that routes the call to different internal implementations, should there
-    /// be more than one.
-    /// @param sender The caller address.
-    /// @param value The call value.
-    /// @param data The calldata sent.
-    /// @param authorization Additional data for the validation function to use.
-    function validateRuntime(
-        address account,
-        uint32 entityId,
-        address sender,
-        uint256 value,
-        bytes calldata data,
-        bytes calldata authorization
-    ) external;
-
-    /// @notice Validates a signature using ERC-1271.
-    /// @dev To indicate the entire call should revert, the function MUST revert.
-    /// @param account The account to validate for.
-    /// @param entityId An identifier that routes the call to different internal implementations, should there
-    /// be more than one.
-    /// @param sender The address that sent the ERC-1271 request to the smart account.
-    /// @param hash The hash of the ERC-1271 request.
-    /// @param signature The signature of the ERC-1271 request.
-    /// @return The ERC-1271 `MAGIC_VALUE` if the signature is valid, or 0xFFFFFFFF if invalid.
-    function validateSignature(
-        address account,
-        uint32 entityId,
-        address sender,
-        bytes32 hash,
-        bytes calldata signature
-    ) external view returns (bytes4);
-}

package/src/libraries/HookConfigLib.sol

@@ -1,135 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.20;
-
-import {HookConfig, ModuleEntity} from "../interfaces/IERC6900Account.sol";
-
-// Hook types:
-// Exec hook: bools for hasPre, hasPost
-// Validation hook: no bools
-
-// Hook fields:
-// module address
-// entity ID
-// hook type
-// if exec hook: hasPre, hasPost
-
-// Hook config is a packed representation of a hook function and flags for its configuration.
-// Layout:
-// 0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA________________________ // Address
-// 0x________________________________________BBBBBBBB________________ // Entity ID
-// 0x________________________________________________CC______________ // Hook Flags
-
-// Hook flags layout:
-// 0b00000___ // unused
-// 0b_____A__ // hasPre (exec only)
-// 0b______B_ // hasPost (exec only)
-// 0b_______C // hook type (0 for exec, 1 for validation)
-
-library HookConfigLib {
-    // Hook type constants
-    // Exec has no bits set
-    bytes32 internal constant _HOOK_TYPE_EXEC = bytes32(uint256(0));
-    // Validation has 1 in the 25th byte
-    bytes32 internal constant _HOOK_TYPE_VALIDATION = bytes32(uint256(1) << 56);
-
-    // Exec hook flags constants
-    // Pre hook has 1 in 4's bit in the 25th byte
-    bytes32 internal constant _EXEC_HOOK_HAS_PRE = bytes32(uint256(1) << 58);
-    // Post hook has 1 in 2's bit in the 25th byte
-    bytes32 internal constant _EXEC_HOOK_HAS_POST = bytes32(uint256(1) << 57);
-
-    function packValidationHook(ModuleEntity _hookFunction) internal pure returns (HookConfig) {
-        return
-            HookConfig.wrap(bytes25(bytes25(ModuleEntity.unwrap(_hookFunction)) | bytes25(_HOOK_TYPE_VALIDATION)));
-    }
-
-    function packValidationHook(address _module, uint32 _entityId) internal pure returns (HookConfig) {
-        return HookConfig.wrap(
-            bytes25(
-                // module address stored in the first 20 bytes
-                bytes25(bytes20(_module))
-                // entityId stored in the 21st - 24th byte
-                | bytes25(bytes24(uint192(_entityId))) | bytes25(_HOOK_TYPE_VALIDATION)
-            )
-        );
-    }
-
-    function packExecHook(ModuleEntity _hookFunction, bool _hasPre, bool _hasPost)
-        internal
-        pure
-        returns (HookConfig)
-    {
-        return HookConfig.wrap(
-            bytes25(
-                bytes25(ModuleEntity.unwrap(_hookFunction))
-                // | bytes25(_HOOK_TYPE_EXEC) // Can omit because exec type is 0
-                | bytes25(_hasPre ? _EXEC_HOOK_HAS_PRE : bytes32(0))
-                    | bytes25(_hasPost ? _EXEC_HOOK_HAS_POST : bytes32(0))
-            )
-        );
-    }
-
-    function packExecHook(address _module, uint32 _entityId, bool _hasPre, bool _hasPost)
-        internal
-        pure
-        returns (HookConfig)
-    {
-        return HookConfig.wrap(
-            bytes25(
-                // module address stored in the first 20 bytes
-                bytes25(bytes20(_module))
-                // entityId stored in the 21st - 24th byte
-                | bytes25(bytes24(uint192(_entityId)))
-                // | bytes25(_HOOK_TYPE_EXEC) // Can omit because exec type is 0
-                | bytes25(_hasPre ? _EXEC_HOOK_HAS_PRE : bytes32(0))
-                    | bytes25(_hasPost ? _EXEC_HOOK_HAS_POST : bytes32(0))
-            )
-        );
-    }
-
-    function unpackValidationHook(HookConfig _config) internal pure returns (ModuleEntity _hookFunction) {
-        bytes25 configBytes = HookConfig.unwrap(_config);
-        _hookFunction = ModuleEntity.wrap(bytes24(configBytes));
-    }
-
-    function unpackExecHook(HookConfig _config)
-        internal
-        pure
-        returns (ModuleEntity _hookFunction, bool _hasPre, bool _hasPost)
-    {
-        bytes25 configBytes = HookConfig.unwrap(_config);
-        _hookFunction = ModuleEntity.wrap(bytes24(configBytes));
-        _hasPre = configBytes & _EXEC_HOOK_HAS_PRE != 0;
-        _hasPost = configBytes & _EXEC_HOOK_HAS_POST != 0;
-    }
-
-    function module(HookConfig _config) internal pure returns (address) {
-        return address(bytes20(HookConfig.unwrap(_config)));
-    }
-
-    function entityId(HookConfig _config) internal pure returns (uint32) {
-        return uint32(bytes4(HookConfig.unwrap(_config) << 160));
-    }
-
-    function moduleEntity(HookConfig _config) internal pure returns (ModuleEntity) {
-        return ModuleEntity.wrap(bytes24(HookConfig.unwrap(_config)));
-    }
-
-    // Check if the hook is a validation hook
-    // If false, it is an exec hook
-    function isValidationHook(HookConfig _config) internal pure returns (bool) {
-        return HookConfig.unwrap(_config) & _HOOK_TYPE_VALIDATION != 0;
-    }
-
-    // Check if the exec hook has a pre hook
-    // Undefined behavior if the hook is not an exec hook
-    function hasPreHook(HookConfig _config) internal pure returns (bool) {
-        return HookConfig.unwrap(_config) & _EXEC_HOOK_HAS_PRE != 0;
-    }
-
-    // Check if the exec hook has a post hook
-    // Undefined behavior if the hook is not an exec hook
-    function hasPostHook(HookConfig _config) internal pure returns (bool) {
-        return HookConfig.unwrap(_config) & _EXEC_HOOK_HAS_POST != 0;
-    }
-}

package/src/libraries/KnownSelectorsLib.sol

@@ -1,65 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.20;
-
-import {IAccount} from "@eth-infinitism/account-abstraction/interfaces/IAccount.sol";
-import {IAggregator} from "@eth-infinitism/account-abstraction/interfaces/IAggregator.sol";
-import {IPaymaster} from "@eth-infinitism/account-abstraction/interfaces/IPaymaster.sol";
-import {UUPSUpgradeable} from "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
-import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
-
-import {IERC6900Account} from "../interfaces/IERC6900Account.sol";
-
-import {IERC6900AccountView} from "../interfaces/IERC6900AccountView.sol";
-
-import {IERC6900ExecutionHookModule} from "../interfaces/IERC6900ExecutionHookModule.sol";
-
-import {IERC6900ExecutionModule} from "../interfaces/IERC6900ExecutionModule.sol";
-import {IERC6900Module} from "../interfaces/IERC6900Module.sol";
-import {IERC6900ValidationHookModule} from "../interfaces/IERC6900ValidationHookModule.sol";
-import {IERC6900ValidationModule} from "../interfaces/IERC6900ValidationModule.sol";
-
-/// @dev Library to help to check if a selector is a know function selector of the modular account or ERC-4337
-/// contract.
-library KnownSelectorsLib {
-    function isNativeFunction(bytes4 selector) internal pure returns (bool) {
-        return
-        // check against IAccount methods
-        selector == IAccount.validateUserOp.selector
-        // check against IERC6900Account methods
-        || selector == IERC6900Account.installExecution.selector
-            || selector == IERC6900Account.uninstallExecution.selector
-            || selector == IERC6900Account.installValidation.selector
-            || selector == IERC6900Account.uninstallValidation.selector || selector == IERC6900Account.execute.selector
-            || selector == IERC6900Account.executeBatch.selector
-            || selector == IERC6900Account.executeWithRuntimeValidation.selector
-            || selector == IERC6900Account.accountId.selector
-        // check against IERC165 methods
-        || selector == IERC165.supportsInterface.selector
-        // check against UUPSUpgradeable methods
-        || selector == UUPSUpgradeable.proxiableUUID.selector
-            || selector == UUPSUpgradeable.upgradeToAndCall.selector
-        // check against IERC6900AccountView methods
-        || selector == IERC6900AccountView.getExecutionData.selector
-            || selector == IERC6900AccountView.getValidationData.selector;
-    }
-
-    function isErc4337Function(bytes4 selector) internal pure returns (bool) {
-        return selector == IAggregator.validateSignatures.selector
-            || selector == IAggregator.validateUserOpSignature.selector
-            || selector == IAggregator.aggregateSignatures.selector
-            || selector == IPaymaster.validatePaymasterUserOp.selector || selector == IPaymaster.postOp.selector;
-    }
-
-    function isIModuleFunction(bytes4 selector) internal pure returns (bool) {
-        return selector == IERC6900Module.onInstall.selector || selector == IERC6900Module.onUninstall.selector
-            || selector == IERC6900Module.moduleId.selector
-            || selector == IERC6900ExecutionModule.executionManifest.selector
-            || selector == IERC6900ExecutionHookModule.preExecutionHook.selector
-            || selector == IERC6900ExecutionHookModule.postExecutionHook.selector
-            || selector == IERC6900ValidationModule.validateUserOp.selector
-            || selector == IERC6900ValidationModule.validateRuntime.selector
-            || selector == IERC6900ValidationModule.validateSignature.selector
-            || selector == IERC6900ValidationHookModule.preUserOpValidationHook.selector
-            || selector == IERC6900ValidationHookModule.preRuntimeValidationHook.selector;
-    }
-}

package/src/libraries/ModuleEntityLib.sol

@@ -1,37 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.20;
-
-import {ModuleEntity} from "../interfaces/IERC6900Account.sol";
-// ModuleEntity is a packed representation of a module function
-// Layout:
-// 0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA________________________ // Address
-// 0x________________________________________BBBBBBBB________________ // Entity ID
-// 0x________________________________________________0000000000000000 // unused
-
-library ModuleEntityLib {
-    function pack(address addr, uint32 entityId) internal pure returns (ModuleEntity) {
-        return ModuleEntity.wrap(bytes24(bytes20(addr)) | bytes24(uint192(entityId)));
-    }
-
-    function unpack(ModuleEntity moduleEntity) internal pure returns (address addr, uint32 entityId) {
-        bytes24 underlying = ModuleEntity.unwrap(moduleEntity);
-        addr = address(bytes20(underlying));
-        entityId = uint32(bytes4(underlying << 160));
-    }
-
-    function isEmpty(ModuleEntity moduleEntity) internal pure returns (bool) {
-        return ModuleEntity.unwrap(moduleEntity) == bytes24(0);
-    }
-
-    function notEmpty(ModuleEntity moduleEntity) internal pure returns (bool) {
-        return ModuleEntity.unwrap(moduleEntity) != bytes24(0);
-    }
-
-    function eq(ModuleEntity a, ModuleEntity b) internal pure returns (bool) {
-        return ModuleEntity.unwrap(a) == ModuleEntity.unwrap(b);
-    }
-
-    function notEq(ModuleEntity a, ModuleEntity b) internal pure returns (bool) {
-        return ModuleEntity.unwrap(a) != ModuleEntity.unwrap(b);
-    }
-}

package/src/libraries/ModuleStorageLib.sol

@@ -1,62 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.20;
-
-type StoragePointer is bytes32;
-
-/// @title Module Storage Library
-/// @notice Library for allocating and accessing ERC-4337 address-associated storage within modules.
-library ModuleStorageLib {
-    /// @notice Allocates a memory buffer for an associated storage key, and sets the associated address and batch
-    /// index.
-    /// @param addr The address to associate with the storage key.
-    /// @param batchIndex The batch index to associate with the storage key.
-    /// @param keySize The size of the key in words, where each word is 32 bytes. Not inclusive of the address and
-    /// batch index.
-    /// @return key The allocated memory buffer.
-    function allocateAssociatedStorageKey(address addr, uint256 batchIndex, uint8 keySize)
-        internal
-        pure
-        returns (bytes memory key)
-    {
-        /// @solidity memory-safe-assembly
-        assembly {
-            // Clear any dirty upper bits of keySize to prevent overflow
-            keySize := and(keySize, 0xff)
-
-            // compute the total size of the buffer, include the address and batch index
-            let totalSize := add(64, mul(32, keySize))
-
-            // Allocate memory for the key
-            key := mload(0x40)
-            mstore(0x40, add(add(key, totalSize), 32))
-            mstore(key, totalSize)
-
-            // Clear any dirty upper bits of address
-            addr := and(addr, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)
-            // Store the address and batch index in the key buffer
-            mstore(add(key, 32), addr)
-            mstore(add(key, 64), batchIndex)
-        }
-    }
-
-    function associatedStorageLookup(bytes memory key, bytes32 input) internal pure returns (StoragePointer ptr) {
-        /// @solidity memory-safe-assembly
-        assembly {
-            mstore(add(key, 96), input)
-            ptr := keccak256(add(key, 32), mload(key))
-        }
-    }
-
-    function associatedStorageLookup(bytes memory key, bytes32 input1, bytes32 input2)
-        internal
-        pure
-        returns (StoragePointer ptr)
-    {
-        /// @solidity memory-safe-assembly
-        assembly {
-            mstore(add(key, 96), input1)
-            mstore(add(key, 128), input2)
-            ptr := keccak256(add(key, 32), mload(key))
-        }
-    }
-}

package/src/libraries/SparseCalldataSegmentLib.sol

@@ -1,95 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.20;
-
-import {RESERVED_VALIDATION_DATA_INDEX} from "../helpers/Constants.sol";
-import {getEmptyCalldataSlice} from "../helpers/EmptyCalldataSlice.sol";
-
-/// @title Sparse Calldata Segment Library
-/// @notice Library for working with sparsely-packed calldata segments, identified with an index.
-/// @dev The first byte of each segment is the index of the segment.
-/// To prevent accidental stack-to-deep errors, the body and index of the segment are extracted separately, rather
-/// than inline as part of the tuple returned by `getNextSegment`.
-library SparseCalldataSegmentLib {
-    error NonCanonicalEncoding();
-    error SegmentOutOfOrder();
-    error ValidationSignatureSegmentMissing();
-
-    /// @notice Splits out a segment of calldata, sparsely-packed.
-    /// The expected format is:
-    /// [uint8(index0), uint32(len(segment0)), segment0, uint8(index1), uint32(len(segment1)), segment1,
-    /// ... uint8(indexN), uint32(len(segmentN)), segmentN]
-    /// @param source The calldata to extract the segment from.
-    /// @return segment The extracted segment. Using the above example, this would be segment0.
-    /// @return remainder The remaining calldata. Using the above example,
-    /// this would start at uint8(index1) and continue to the end at segmentN.
-    function getNextSegment(bytes calldata source)
-        internal
-        pure
-        returns (bytes calldata segment, bytes calldata remainder)
-    {
-        // The first byte of the segment is the index.
-        // The next 4 bytes hold the length of the segment, excluding the index.
-        uint32 length = uint32(bytes4(source[1:5]));
-
-        // The offset of the remainder of the calldata.
-        uint256 remainderOffset = 5 + length;
-
-        // The segment is the next `length` bytes after the first 5 bytes.
-        segment = source[5:remainderOffset];
-
-        // The remainder is the rest of the calldata.
-        remainder = source[remainderOffset:];
-    }
-
-    /// @notice If the index of the next segment in the source equals the provided index, return the next body and
-    /// advance the source by one segment.
-    /// @dev Reverts if the index of the next segment is less than the provided index, or if the extracted segment
-    /// has length 0.
-    /// @param source The calldata to extract the segment from.
-    /// @param index The index of the segment to extract.
-    /// @return A tuple containing the extracted segment's body, or an empty buffer if the index is not found, and
-    /// the remaining calldata.
-    function advanceSegmentIfAtIndex(bytes calldata source, uint8 index)
-        internal
-        pure
-        returns (bytes calldata, bytes calldata)
-    {
-        uint8 nextIndex = getIndex(source);
-
-        if (nextIndex < index) {
-            revert SegmentOutOfOrder();
-        }
-
-        if (nextIndex == index) {
-            (bytes calldata segment, bytes calldata remainder) = getNextSegment(source);
-
-            if (segment.length == 0) {
-                revert NonCanonicalEncoding();
-            }
-
-            return (segment, remainder);
-        }
-
-        return (getEmptyCalldataSlice(), source);
-    }
-
-    /// @notice Extracts the final segment from the source.
-    /// @dev Reverts if the index of the segment is not RESERVED_VALIDATION_DATA_INDEX.
-    /// @param source The calldata to extract the segment from.
-    /// @return The final segment.
-    function getFinalSegment(bytes calldata source) internal pure returns (bytes calldata) {
-        if (getIndex(source) != RESERVED_VALIDATION_DATA_INDEX) {
-            revert ValidationSignatureSegmentMissing();
-        }
-
-        return source[1:];
-    }
-
-    /// @notice Extracts the index from a segment.
-    /// @dev The first byte of the segment is the index.
-    /// @param segment The segment to extract the index from
-    /// @return The index of the segment
-    function getIndex(bytes calldata segment) internal pure returns (uint8) {
-        return uint8(segment[0]);
-    }
-}

package/src/libraries/ValidationConfigLib.sol

@@ -1,119 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.20;
-
-import {ModuleEntity, ValidationConfig, ValidationFlags} from "../interfaces/IERC6900Account.sol";
-
-// Validation config is a packed representation of a validation function and flags for its configuration.
-// Layout:
-// 0xAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA________________________ // Address
-// 0x________________________________________BBBBBBBB________________ // Entity ID
-// 0x________________________________________________CC______________ // ValidationFlags
-// 0x__________________________________________________00000000000000 // unused
-
-// ValidationFlags layout:
-// 0b00000___ // unused
-// 0b_____A__ // isGlobal
-// 0b______B_ // isSignatureValidation
-// 0b_______C // isUserOpValidation
-
-library ValidationConfigLib {
-    // is user op validation flag stored in last bit of the 25th byte
-    bytes32 internal constant _VALIDATION_FLAG_IS_USER_OP = bytes32(uint256(1) << 56);
-    // is signature validation flag stored in second to last bit of the 25th byte
-    bytes32 internal constant _VALIDATION_FLAG_IS_SIGNATURE = bytes32(uint256(1) << 57);
-    // is global flag stored in the third to last bit of the 25th byte
-    bytes32 internal constant _VALIDATION_FLAG_IS_GLOBAL = bytes32(uint256(1) << 58);
-
-    function pack(
-        ModuleEntity _validationFunction,
-        bool _isGlobal,
-        bool _isSignatureValidation,
-        bool _isUserOpValidation
-    ) internal pure returns (ValidationConfig) {
-        return ValidationConfig.wrap(
-            bytes25(
-                bytes25(ModuleEntity.unwrap(_validationFunction))
-                    | bytes25(bytes32(_isGlobal ? _VALIDATION_FLAG_IS_GLOBAL : bytes32(0)))
-                    | bytes25(bytes32(_isSignatureValidation ? _VALIDATION_FLAG_IS_SIGNATURE : bytes32(0)))
-                    | bytes25(bytes32(_isUserOpValidation ? _VALIDATION_FLAG_IS_USER_OP : bytes32(0)))
-            )
-        );
-    }
-
-    function pack(
-        address _module,
-        uint32 _entityId,
-        bool _isGlobal,
-        bool _isSignatureValidation,
-        bool _isUserOpValidation
-    ) internal pure returns (ValidationConfig) {
-        return ValidationConfig.wrap(
-            bytes25(
-                // module address stored in the first 20 bytes
-                bytes25(bytes20(_module))
-                // entityId stored in the 21st - 24th byte
-                | bytes25(bytes24(uint192(_entityId)))
-                    | bytes25(bytes32(_isGlobal ? _VALIDATION_FLAG_IS_GLOBAL : bytes32(0)))
-                    | bytes25(bytes32(_isSignatureValidation ? _VALIDATION_FLAG_IS_SIGNATURE : bytes32(0)))
-                    | bytes25(bytes32(_isUserOpValidation ? _VALIDATION_FLAG_IS_USER_OP : bytes32(0)))
-            )
-        );
-    }
-
-    function unpackUnderlying(ValidationConfig config)
-        internal
-        pure
-        returns (address _module, uint32 _entityId, ValidationFlags flags)
-    {
-        bytes25 configBytes = ValidationConfig.unwrap(config);
-        _module = address(bytes20(configBytes));
-        _entityId = uint32(bytes4(configBytes << 160));
-        flags = ValidationFlags.wrap(uint8(configBytes[24]));
-    }
-
-    function unpack(ValidationConfig config)
-        internal
-        pure
-        returns (ModuleEntity _validationFunction, ValidationFlags flags)
-    {
-        bytes25 configBytes = ValidationConfig.unwrap(config);
-        _validationFunction = ModuleEntity.wrap(bytes24(configBytes));
-        flags = ValidationFlags.wrap(uint8(configBytes[24]));
-    }
-
-    function module(ValidationConfig config) internal pure returns (address) {
-        return address(bytes20(ValidationConfig.unwrap(config)));
-    }
-
-    function entityId(ValidationConfig config) internal pure returns (uint32) {
-        return uint32(bytes4(ValidationConfig.unwrap(config) << 160));
-    }
-
-    function moduleEntity(ValidationConfig config) internal pure returns (ModuleEntity) {
-        return ModuleEntity.wrap(bytes24(ValidationConfig.unwrap(config)));
-    }
-
-    function isGlobal(ValidationConfig config) internal pure returns (bool) {
-        return ValidationConfig.unwrap(config) & _VALIDATION_FLAG_IS_GLOBAL != 0;
-    }
-
-    function isGlobal(ValidationFlags flags) internal pure returns (bool) {
-        return ValidationFlags.unwrap(flags) & 0x04 != 0;
-    }
-
-    function isSignatureValidation(ValidationConfig config) internal pure returns (bool) {
-        return ValidationConfig.unwrap(config) & _VALIDATION_FLAG_IS_SIGNATURE != 0;
-    }
-
-    function isSignatureValidation(ValidationFlags flags) internal pure returns (bool) {
-        return ValidationFlags.unwrap(flags) & 0x02 != 0;
-    }
-
-    function isUserOpValidation(ValidationConfig config) internal pure returns (bool) {
-        return ValidationConfig.unwrap(config) & _VALIDATION_FLAG_IS_USER_OP != 0;
-    }
-
-    function isUserOpValidation(ValidationFlags flags) internal pure returns (bool) {
-        return ValidationFlags.unwrap(flags) & 0x01 != 0;
-    }
-}

package/src/modules/BaseModule.sol

@@ -1,54 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.20;
-
-import {IAccountExecute} from "@eth-infinitism/account-abstraction/interfaces/IAccountExecute.sol";
-import {PackedUserOperation} from "@eth-infinitism/account-abstraction/interfaces/PackedUserOperation.sol";
-import {ERC165, IERC165} from "@openzeppelin/contracts/utils/introspection/ERC165.sol";
-
-import {IERC6900Module} from "../interfaces/IERC6900Module.sol";
-
-/// @title Base contract for modules
-/// @dev Implements ERC-165 to support IERC6900Module's interface, which is a requirement
-/// for module installation. This also ensures that module interactions cannot
-/// happen via the standard execution funtions `execute` and `executeBatch`.
-abstract contract BaseModule is ERC165, IERC6900Module {
-    error NotImplemented();
-
-    /// @dev Returns true if this contract implements the interface defined by
-    /// `interfaceId`. See the corresponding
-    /// https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
-    /// to learn more about how these ids are created.
-    ///
-    /// This function call must use less than 30 000 gas.
-    ///
-    /// Supporting the IERC6900Module interface is a requirement for module installation. This is also used
-    /// by the modular account to prevent standard execution functions `execute` and `executeBatch` from
-    /// making calls to modules.
-    /// @param interfaceId The interface ID to check for support.
-    /// @return True if the contract supports `interfaceId`.
-    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
-        return interfaceId == type(IERC6900Module).interfaceId || super.supportsInterface(interfaceId);
-    }
-
-    function _getSelectorAndCalldata(bytes calldata data) internal pure returns (bytes4, bytes memory) {
-        if (bytes4(data[:4]) == IAccountExecute.executeUserOp.selector) {
-            (PackedUserOperation memory uo,) = abi.decode(data[4:], (PackedUserOperation, bytes32));
-            bytes4 selector;
-            bytes memory callData = uo.callData;
-            // Bytes arr representation: [bytes32(len), bytes4(executeUserOp.selector), bytes4(actualSelector),
-            // bytes(actualCallData)]
-            // 1. Copy actualSelector into a new var
-            // 2. Shorten bytes arry by 8 by: store length - 8 into the new pointer location
-            // 3. Move the callData pointer by 8
-            assembly {
-                selector := mload(add(callData, 36))
-
-                let len := mload(callData)
-                mstore(add(callData, 8), sub(len, 8))
-                callData := add(callData, 8)
-            }
-            return (selector, callData);
-        }
-        return (bytes4(data[:4]), data[4:]);
-    }
-}

package/src/modules/ModuleEIP712.sol

@@ -1,29 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.20;
-
-// A base for modules that use EIP-712 structured data signing.
-//
-// Unlike other EIP712 libraries, this mixin uses the salt field to hold the account address.
-//
-// It omits the name and version from the EIP-712 domain, as modules are intended to be deployed as
-// immutable singletons, thus a different versions and instances would have a different module address.
-//
-// Due to depending on the account address to calculate the domain separator, this abstract contract does not
-// implement EIP-5267, as the domain retrieval function does not provide a parameter to use for the account address
-// (internally the verifyingContract), and the computed `msg.sender` for an `eth_call` without an override is
-// address(0).
-abstract contract ModuleEIP712 {
-    // keccak256(
-    //     "EIP712Domain(uint256 chainId,address verifyingContract,bytes32 salt)"
-    // )
-    bytes32 private constant _DOMAIN_SEPARATOR_TYPEHASH =
-        0x71062c282d40422f744945d587dbf4ecfd4f9cfad1d35d62c944373009d96162;
-
-    function _domainSeparator(address account) internal view returns (bytes32) {
-        return keccak256(
-            abi.encode(
-                _DOMAIN_SEPARATOR_TYPEHASH, block.chainid, address(this), bytes32(uint256(uint160(account)))
-            )
-        );
-    }
-}