Account Abstraction

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;

struct UserOperation {
    address sender;                 // the Smart Contract Account
    uint256 nonce;                  // anti-replay value, managed by EntryPoint
    bytes   initCode;               // factory + calldata to deploy the SCA (first tx only)
    bytes   callData;               // the call the SCA will execute
    uint256 callGasLimit;           // gas for the execution phase
    uint256 verificationGasLimit;   // gas for the validation phase
    uint256 preVerificationGas;     // gas to compensate the bundler for calldata/overhead
    uint256 maxFeePerGas;           // EIP-1559 style fee cap
    uint256 maxPriorityFeePerGas;   // EIP-1559 style priority fee
    bytes   paymasterAndData;       // paymaster address + data (empty = self-pay)
    bytes   signature;              // SCA-verified signature over the whole UserOp
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;

interface IAccount {
    function validateUserOp(
        UserOperation calldata userOp,
        bytes32 userOpHash,
        uint256 missingAccountFunds
    ) external returns (uint256 validationData);
}

contract EntryPointLike {
    // Bundler calls this with a batch of UserOperations
    function handleOps(UserOperation[] calldata ops, address payable beneficiary) external {
        uint256 opsLen = ops.length;

        // ---- Phase 1: validation loop ----
        for (uint256 i = 0; i < opsLen; i++) {
            UserOperation calldata op = ops[i];
            bytes32 opHash = getUserOpHash(op);
            uint256 missingFunds = _requiredPrefund(op); // top-up the SCA must cover

            // The SCA decides if the signature/nonce/limits are valid
            uint256 validationData = IAccount(op.sender).validateUserOp(op, opHash, missingFunds);
            require(validationData == 0, "AA: signature/validation error");
        }

        // ---- Phase 2: execution loop ----
        for (uint256 i = 0; i < opsLen; i++) {
            UserOperation calldata op = ops[i];
            (bool ok, ) = op.sender.call{gas: op.callGasLimit}(op.callData);
            // failures are recorded but do not revert the whole bundle
            emit UserOperationEvent(getUserOpHash(op), op.sender, ok);
            _compensateBundler(op, beneficiary);
        }
    }

    function getUserOpHash(UserOperation calldata) public view returns (bytes32) { /* ... */ }
    function _requiredPrefund(UserOperation calldata) internal pure returns (uint256) { /* ... */ }
    function _compensateBundler(UserOperation calldata, address payable) internal { /* ... */ }

    event UserOperationEvent(bytes32 indexed userOpHash, address indexed sender, bool success);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;

interface IPaymaster {
    function validatePaymasterUserOp(
        UserOperation calldata userOp,
        bytes32 userOpHash,
        uint256 maxCost
    ) external returns (bytes memory context, uint256 validationData);

    function postOp(uint8 mode, bytes calldata context, uint256 actualGasCost) external;
}

contract SponsorPaymaster is IPaymaster {
    address public immutable entryPoint;
    address public owner;
    mapping(address => bool) public sponsored; // dApp whitelists SCAs

    constructor(address _entryPoint) {
        entryPoint = _entryPoint;
        owner = msg.sender;
    }

    // Called by the EntryPoint during validation
    function validatePaymasterUserOp(
        UserOperation calldata userOp,
        bytes32,
        uint256
    ) external view returns (bytes memory context, uint256 validationData) {
        require(msg.sender == entryPoint, "only EntryPoint");
        require(sponsored[userOp.sender], "sender not sponsored");
        // returning 0 means "valid, no time bounds"
        return (abi.encode(userOp.sender), 0);
    }

    // Called after execution so the paymaster can do accounting / charge in ERC-20
    function postOp(uint8, bytes calldata context, uint256 actualGasCost) external {
        require(msg.sender == entryPoint, "only EntryPoint");
        address account = abi.decode(context, (address));
        emit GasSponsored(account, actualGasCost);
    }

    function setSponsored(address account, bool ok) external {
        require(msg.sender == owner, "not owner");
        sponsored[account] = ok;
    }

    event GasSponsored(address indexed account, uint256 cost);
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;

contract LimitedAccount {
    address public owner;
    uint256 public dailyLimit;       // max wei spendable per day
    uint256 public spentToday;
    uint256 public windowStart;

    constructor(address _owner, uint256 _dailyLimit) {
        owner = _owner;
        dailyLimit = _dailyLimit;
        windowStart = block.timestamp;
    }

    modifier withinLimit(uint256 amount) {
        // reset the rolling 24h window
        if (block.timestamp >= windowStart + 1 days) {
            windowStart = block.timestamp;
            spentToday = 0;
        }
        require(spentToday + amount <= dailyLimit, "daily limit exceeded");
        spentToday += amount;
        _;
    }

    // The SCA exposes execute(); EntryPoint reaches it via callData
    function execute(address to, uint256 value, bytes calldata data)
        external
        withinLimit(value)
        returns (bytes memory)
    {
        require(msg.sender == owner || msg.sender == address(this), "not authorized");
        (bool ok, bytes memory ret) = to.call{value: value}(data);
        require(ok, "call failed");
        return ret;
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;

contract PullPaymentModule {
    struct Subscription {
        address payee;      // who may pull
        uint256 amount;     // max per period
        uint256 period;     // seconds between pulls
        uint256 lastPull;   // timestamp of last successful pull
        bool    active;
    }

    // account => payee => subscription
    mapping(address => mapping(address => Subscription)) public subs;

    function approveSubscription(address payee, uint256 amount, uint256 period) external {
        subs[msg.sender][payee] =
            Subscription(payee, amount, period, 0, true);
        emit Approved(msg.sender, payee, amount, period);
    }

    // Called by the payee to pull the recurring amount
    function pull(address account) external {
        Subscription storage s = subs[account][msg.sender];
        require(s.active, "no subscription");
        require(block.timestamp >= s.lastPull + s.period, "too early");
        s.lastPull = block.timestamp;

        // the account contract must implement payOut()
        ILimited(account).payOut(s.payee, s.amount);
        emit Pulled(account, s.payee, s.amount);
    }

    function cancel(address payee) external {
        subs[msg.sender][payee].active = false;
    }

    event Approved(address indexed account, address indexed payee, uint256 amount, uint256 period);
    event Pulled(address indexed account, address indexed payee, uint256 amount);
}

interface ILimited { function payOut(address to, uint256 amount) external; }

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;

contract BatchAccount {
    address public owner;

    constructor(address _owner) { owner = _owner; }

    struct Call { address to; uint256 value; bytes data; }

    // One UserOp, many calls — approve + swap in a single atomic execution
    function executeBatch(Call[] calldata calls) external {
        require(msg.sender == owner || msg.sender == address(this), "not authorized");
        for (uint256 i = 0; i < calls.length; i++) {
            (bool ok, ) = calls[i].to.call{value: calls[i].value}(calls[i].data);
            require(ok, "batch call failed");
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;

contract SocialRecovery {
    address public owner;
    address[] public guardians;
    uint256 public threshold;          // how many guardians must approve

    address public proposedOwner;
    uint256 public approvals;
    mapping(address => bool) public hasApproved;

    constructor(address[] memory _guardians, uint256 _threshold) {
        guardians = _guardians;
        threshold = _threshold;
        owner = msg.sender;
    }

    modifier onlyGuardian() {
        bool ok;
        for (uint256 i; i < guardians.length; i++) if (guardians[i] == msg.sender) ok = true;
        require(ok, "not a guardian");
        _;
    }

    function proposeRecovery(address newOwner) external onlyGuardian {
        proposedOwner = newOwner;
        approvals = 0;
        // reset prior approvals
        for (uint256 i; i < guardians.length; i++) hasApproved[guardians[i]] = false;
        emit RecoveryProposed(newOwner);
    }

    function approveRecovery() external onlyGuardian {
        require(!hasApproved[msg.sender], "already approved");
        hasApproved[msg.sender] = true;
        approvals++;
        if (approvals >= threshold) {
            owner = proposedOwner;          // rotate the key
            emit RecoveryExecuted(owner);
        }
    }

    event RecoveryProposed(address indexed newOwner);
    event RecoveryExecuted(address indexed newOwner);
}

Traditional EOA                         │  Account Abstraction (ERC-4337)
────────────────────────────────────────┼──────────────────────────────────────────────
basic unit = transaction                 │  basic unit = user operation (userOp)
signed with the end user's private key   │  signed by the user with any SCA-supported method
sent to an Ethereum node via RPC         │  sent to a bundler via RPC
packaged into a block, added to chain    │  enters userOp mempool, picked up by a bundler,
                                         │    sent to the EntryPoint for processing
calldata processed by target contract    │  calldata processed by the SCA, which usually
                                         │    then calls a function on a target contract

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;

import {SimpleAccount} from "./SimpleAccount.sol";

contract AccountFactory {
    address public immutable entryPoint;

    constructor(address _entryPoint) { entryPoint = _entryPoint; }

    // EntryPoint calls this through initCode on the very first UserOp
    function createAccount(address owner, uint256 salt) external returns (address) {
        address predicted = getAddress(owner, salt);

        // if already deployed, just return it (idempotent)
        if (predicted.code.length > 0) {
            return predicted;
        }

        // deterministic deploy: same owner+salt => same address on any chain
        SimpleAccount account =
            new SimpleAccount{salt: bytes32(salt)}(entryPoint, owner);
        return address(account);
    }

    // Counterfactual address — known before deployment, so funds can be sent first
    function getAddress(address owner, uint256 salt) public view returns (address) {
        bytes32 hash = keccak256(
            abi.encodePacked(
                bytes1(0xff),
                address(this),
                bytes32(salt),
                keccak256(abi.encodePacked(
                    type(SimpleAccount).creationCode,
                    abi.encode(entryPoint, owner)
                ))
            )
        );
        return address(uint160(uint256(hash)));
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.23;

import {ECDSA} from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";

contract SimpleAccount {
    using ECDSA for bytes32;

    address public immutable entryPoint;
    address public owner;

    uint256 internal constant SIG_VALIDATION_FAILED = 1;

    constructor(address _entryPoint, address _owner) {
        entryPoint = _entryPoint;
        owner = _owner;
    }

    modifier onlyEntryPoint() {
        require(msg.sender == entryPoint, "account: not from EntryPoint");
        _;
    }

    // Phase 1: the EntryPoint asks the account to validate the signature
    function validateUserOp(
        UserOperation calldata userOp,
        bytes32 userOpHash,
        uint256 missingAccountFunds
    ) external onlyEntryPoint returns (uint256 validationData) {
        // recover the signer from the userOp hash
        address recovered = userOpHash.toEthSignedMessageHash().recover(userOp.signature);
        if (recovered != owner) {
            return SIG_VALIDATION_FAILED;   // non-zero => EntryPoint rejects
        }

        // pre-fund the EntryPoint for the gas it will spend on us
        if (missingAccountFunds > 0) {
            (bool ok, ) = payable(entryPoint).call{value: missingAccountFunds}("");
            (ok);   // ignore failure here; EntryPoint re-checks
        }
        return 0;   // 0 => valid, no time bounds
    }

    // Phase 2: the EntryPoint executes the intended call
    function execute(address to, uint256 value, bytes calldata data)
        external
        onlyEntryPoint
        returns (bytes memory)
    {
        (bool ok, bytes memory ret) = to.call{value: value}(data);
        require(ok, "account: call reverted");
        return ret;
    }

    receive() external payable {}
}

import { ethers } from "ethers";

// 1) derive the counterfactual SCA address from the factory
const sender = await factory.getAddress(ownerAddress, salt);

// 2) encode the call the SCA should perform (transfer 1 token)
const callData = accountIface.encodeFunctionData("execute", [
  tokenAddress,
  0,
  tokenIface.encodeFunctionData("transfer", [recipient, amount]),
]);

// 3) assemble the UserOperation
const userOp = {
  sender,
  nonce: await entryPoint.getNonce(sender, 0),
  initCode: isDeployed ? "0x" : factoryInitCode, // factory + createAccount(owner, salt)
  callData,
  callGasLimit: 200_000n,
  verificationGasLimit: 150_000n,
  preVerificationGas: 50_000n,
  maxFeePerGas: ethers.parseUnits("30", "gwei"),
  maxPriorityFeePerGas: ethers.parseUnits("2", "gwei"),
  paymasterAndData: "0x",                          // self-pay; or paymaster addr + data
  signature: "0x",
};

// 4) hash + sign with the owner key
const userOpHash = await entryPoint.getUserOpHash(userOp);
userOp.signature = await ownerWallet.signMessage(ethers.getBytes(userOpHash));

// 5) ship it to the bundler RPC, not a normal node
await bundlerProvider.send("eth_sendUserOperation", [userOp, entryPointAddress]);