Account Abstraction

/**
 * @dev Implementation of ERC-7579 account abstraction
 */
abstract contract AccountERC7579Upgradeable {
    function __AccountERC7579_init(
        bytes[] calldata validators,
        bytes[] calldata executors
    ) internal onlyInitializing;
    
    /**
     * @dev Install a module on the account
     */
    function installModule(
        uint256 moduleTypeId,
        address module,
        bytes calldata initData
    ) external;
    
    /**
     * @dev Uninstall a module from the account
     */
    function uninstallModule(
        uint256 moduleTypeId,
        address module,
        bytes calldata deinitData
    ) external;
    
    /**
     * @dev Check if a module is installed
     */
    function isModuleInstalled(
        uint256 moduleTypeId,
        address module,
        bytes calldata additionalContext
    ) external view returns (bool);
    
    /**
     * @dev Returns true if this contract implements the interface
     */
    function supportsExecutionMode(bytes32 encodedMode) external pure returns (bool);
    
    /**
     * @dev Returns true if the module is supported
     */
    function supportsModule(uint256 moduleTypeId) external pure returns (bool);
    
    /**
     * @dev Execute a single call
     */
    function execute(
        bytes32 mode,
        bytes calldata executionCalldata
    ) external;
    
    /**
     * @dev Execute from an executor module
     */
    function executeFromExecutor(
        bytes32 mode,
        bytes calldata executionCalldata
    ) external returns (bytes[] memory returnData);
}

// Module type constants
uint256 constant MODULE_TYPE_VALIDATOR = 1;
uint256 constant MODULE_TYPE_EXECUTOR = 2;
uint256 constant MODULE_TYPE_FALLBACK = 3;
uint256 constant MODULE_TYPE_HOOK = 4;

/**
 * @dev Extension with hooks support
 */
abstract contract AccountERC7579HookedUpgradeable {
    function __AccountERC7579Hooked_init(
        bytes[] calldata validators,
        bytes[] calldata executors,
        bytes[] calldata hooks
    ) internal onlyInitializing;
    
    /**
     * @dev Install a hook module
     */
    function installHook(
        address hook,
        bytes calldata initData
    ) external;
    
    /**
     * @dev Uninstall a hook module
     */
    function uninstallHook(
        address hook,
        bytes calldata deinitData
    ) external;
    
    // Inherits all AccountERC7579Upgradeable functions
}

import {AccountERC7579Upgradeable} from "@openzeppelin/contracts-upgradeable/account/extensions/draft-AccountERC7579Upgradeable.sol";
import {OwnableUpgradeable} from "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol";

contract MySmartAccount is AccountERC7579Upgradeable, OwnableUpgradeable {
    function initialize(
        address initialOwner,
        bytes[] calldata validators,
        bytes[] calldata executors
    ) initializer public {
        __AccountERC7579_init(validators, executors);
        __Ownable_init(initialOwner);
    }
    
    function executeTransaction(
        address to,
        uint256 value,
        bytes calldata data
    ) external onlyOwner {
        bytes32 mode = bytes32(0); // Single execution mode
        bytes memory executionCalldata = abi.encode(to, value, data);
        execute(mode, executionCalldata);
    }
}

import {AccountERC7579HookedUpgradeable} from "@openzeppelin/contracts-upgradeable/account/extensions/draft-AccountERC7579HookedUpgradeable.sol";

contract HookedSmartAccount is AccountERC7579HookedUpgradeable {
    function initialize(
        bytes[] calldata validators,
        bytes[] calldata executors,
        bytes[] calldata hooks
    ) initializer public {
        __AccountERC7579Hooked_init(validators, executors, hooks);
    }
    
    function addSecurityHook(address hook, bytes calldata initData) external {
        installHook(hook, initData);
    }
}