Erc7702 Patterns

authorization_list: [{ chain_id, address, nonce, y_parity, r, s }]

struct Authorization {
    uint256 chainId;   // 0 = valid on any chain
    address delegate;  // implementation contract
    uint64 nonce;      // EOA's current nonce
    uint8 yParity;
    bytes32 r;
    bytes32 s;
}

import { createWalletClient, http, parseEther } from 'viem';
import { mainnet } from 'viem/chains';
import { privateKeyToAccount } from 'viem/accounts';
import { eip7702Actions } from 'viem/experimental';

const account = privateKeyToAccount('0x...');
const client = createWalletClient({
  account,
  chain: mainnet,
  transport: http(),
}).extend(eip7702Actions());

const authorization = await client.signAuthorization({
  contractAddress: '0xDelegateContract...',
});

const hash = await client.sendTransaction({
  authorizationList: [authorization],
  to: account.address,
  data: encodeFunctionData({ ... }),
});

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

contract SmartAccount {
    struct Call {
        address target;
        uint256 value;
        bytes data;
    }

    /// @notice Execute a batch of calls from the delegating EOA.
    /// Only the EOA itself can invoke (msg.sender == address(this)).
    function execute(Call[] calldata calls) external payable {
        require(msg.sender == address(this), "Only self");
        for (uint256 i = 0; i < calls.length; i++) {
            (bool ok, bytes memory ret) = calls[i].target.call{value: calls[i].value}(calls[i].data);
            require(ok, string(ret));
        }
    }
}

const calls = [
  { target: tokenAddress, value: 0n, data: approveCalldata },
  { target: routerAddress, value: 0n, data: swapCalldata },
  { target: stakingAddress, value: 0n, data: stakeCalldata },
];

const hash = await client.sendTransaction({
  authorizationList: [authorization],
  to: account.address,
  data: encodeFunctionData({
    abi: smartAccountAbi,
    functionName: 'execute',
    args: [calls],
  }),
});

contract SponsoredAccount {
    mapping(address => bool) public sponsors;

    function executeSponsored(
        Call[] calldata calls,
        address sponsor,
        bytes calldata sponsorSig
    ) external {
        require(sponsors[sponsor] || msg.sender == address(this), "Unauthorized");
        for (uint256 i = 0; i < calls.length; i++) {
            (bool ok,) = calls[i].target.call{value: calls[i].value}(calls[i].data);
            require(ok, "Call failed");
        }
    }
}

contract SessionKeyAccount {
    struct SessionKey {
        address key;
        uint48 validAfter;
        uint48 validUntil;
        address[] allowedTargets;
    }

    mapping(bytes32 => bool) public sessionKeys;

    function addSessionKey(SessionKey calldata sk) external {
        require(msg.sender == address(this), "Only self");
        sessionKeys[keccak256(abi.encode(sk))] = true;
    }

    function executeWithSessionKey(
        Call[] calldata calls,
        SessionKey calldata sk,
        bytes calldata signature
    ) external {
        require(sessionKeys[keccak256(abi.encode(sk))], "Unknown key");
        require(block.timestamp >= sk.validAfter, "Too early");
        require(block.timestamp <= sk.validUntil, "Expired");

        bytes32 digest = keccak256(abi.encode(calls, sk));
        require(ECDSA.recover(digest, signature) == sk.key, "Bad sig");

        for (uint256 i = 0; i < calls.length; i++) {
            _validateTarget(calls[i].target, sk.allowedTargets);
            (bool ok,) = calls[i].target.call{value: calls[i].value}(calls[i].data);
            require(ok, "Call failed");
        }
    }

    function _validateTarget(address target, address[] memory allowed) internal pure {
        for (uint256 i = 0; i < allowed.length; i++) {
            if (target == allowed[i]) return;
        }
        revert("Target not allowed");
    }
}

function test_eip7702_batch() public {
    // Foundry supports EIP-7702 via vm.signAuthorization
    bytes memory auth = vm.signAuthorization(address(smartAccount), eoaPrivateKey);
    vm.attachAuthorization(auth);

    SmartAccount.Call[] memory calls = new SmartAccount.Call[](2);
    calls[0] = SmartAccount.Call(address(token), 0, abi.encodeCall(token.approve, (router, 1e18)));
    calls[1] = SmartAccount.Call(address(router), 0, abi.encodeCall(router.swap, (1e18)));

    vm.prank(eoa);
    SmartAccount(eoa).execute(calls);
}