Eip 7702

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

import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol";

/**
 * @title BatchCallAndSponsor
 * @notice An educational contract that allows batch execution of calls with nonce and signature verification.
 *
 * When an EOA upgrades via EIP‑7702, it delegates to this implementation.
 * Off‑chain, the account signs a message authorizing a batch of calls. The message is the hash of:
 *    keccak256(abi.encodePacked(nonce, calls))
 * The signature must be generated with the EOA’s private key so that, once upgraded, the recovered signer equals the account’s own address (i.e. address(this)).
 *
 * This contract provides two ways to execute a batch:
 * 1. With a signature: Any sponsor can submit the batch if it carries a valid signature.
 * 2. Directly by the smart account: When the account itself (i.e. address(this)) calls the function, no signature is required.
 *
 * Replay protection is achieved by using a nonce that is included in the signed message.
 */
contract BatchCallAndSponsor {
    using ECDSA for bytes32;

    /// @notice A nonce used for replay protection.
    uint256 public nonce;

    /// @notice Represents a single call within a batch.
    struct Call {
        address to;
        uint256 value;
        bytes data;
    }

    /// @notice Emitted for every individual call executed.
    event CallExecuted(address indexed sender, address indexed to, uint256 value, bytes data);
    /// @notice Emitted when a full batch is executed.
    event BatchExecuted(uint256 indexed nonce, Call[] calls);

    /**
     * @notice Executes a batch of calls using an off–chain signature.
     * @param calls An array of Call structs containing destination, ETH value, and calldata.
     * @param signature The ECDSA signature over the current nonce and the call data.
     *
     * The signature must be produced off–chain by signing:
     * The signing key should be the account’s key (which becomes the smart account’s own identity after upgrade).
     */
    function execute(Call[] calldata calls, bytes calldata signature) external payable {
        // Compute the digest that the account was expected to sign.
        bytes memory encodedCalls;
        for (uint256 i = 0; i < calls.length; i++) {
            encodedCalls = abi.encodePacked(encodedCalls, calls[i].to, calls[i].value, calls[i].data);
        }
        bytes32 digest = keccak256(abi.encodePacked(nonce, encodedCalls));

        bytes32 ethSignedMessageHash = MessageHashUtils.toEthSignedMessageHash(digest);

        // Recover the signer from the provided signature.
        address recovered = ECDSA.recover(ethSignedMessageHash, signature);
        require(recovered == address(this), "Invalid signature");

        _executeBatch(calls);
    }

    /**
     * @notice Executes a batch of calls directly.
     * @dev This function is intended for use when the smart account itself (i.e. address(this))
     * calls the contract. It checks that msg.sender is the contract itself.
     * @param calls An array of Call structs containing destination, ETH value, and calldata.
     */
    function execute(Call[] calldata calls) external payable {
        require(msg.sender == address(this), "Invalid authority");
        _executeBatch(calls);
    }

    /**
     * @dev Internal function that handles batch execution and nonce incrementation.
     * @param calls An array of Call structs.
     */
    function _executeBatch(Call[] calldata calls) internal {
        uint256 currentNonce = nonce;
        nonce++; // Increment nonce to protect against replay attacks

        for (uint256 i = 0; i < calls.length; i++) {
            _executeCall(calls[i]);
        }

        emit BatchExecuted(currentNonce, calls);
    }

    /**
     * @dev Internal function to execute a single call.
     * @param callItem The Call struct containing destination, value, and calldata.
     */
    function _executeCall(Call calldata callItem) internal {
        (bool success,) = callItem.to.call{value: callItem.value}(callItem.data);
        require(success, "Call reverted");
        emit CallExecuted(msg.sender, callItem.to, callItem.value, callItem.data);
    }

    // Allow the contract to receive ETH (e.g. from DEX swaps or other transfers).
    fallback() external payable {}
    receive() external payable {}
}

import { createWalletClient, http, encodeFunctionData, parseEther, createPublicClient, erc20Abi, keccak256, encodePacked, toBytes, type Address } from 'viem'
import { privateKeyToAccount, generatePrivateKey } from 'viem/accounts'
import { anvil } from 'viem/chains'

/**
 * EIP-7702 Integration Test: Gasless Token Transfer
 * 
 * Requirements:
 * 1. Anvil running with Prague hardfork: `anvil --hardfork prague`
 * 2. Implementation & Token contracts deployed (see Deploy.s.sol)
 */

// --- CONFIGURATION ---
// Update these addresses after running your deployment script
const IMPLEMENTATION_ADDRESS = '0x5FbDB2315678afecb367f032d93F642f64180aa3' as Address
const TOKEN_ADDRESS = '0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512' as Address

const BATCH_ABI = [
  {
    "type": "function",
    "name": "execute",
    "inputs": [
      {
        "name": "calls",
        "type": "tuple[]",
        "components": [
          { "name": "to", "type": "address" },
          { "name": "value", "type": "uint256" },
          { "name": "data", "type": "bytes" }
        ]
      },
      { "name": "signature", "type": "bytes" }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "nonce",
    "inputs": [],
    "outputs": [{ "name": "", "type": "uint256" }],
    "stateMutability": "view"
  }
] as const

async function main() {
  const publicClient = createPublicClient({ chain: anvil, transport: http() })

  // 1. Setup Accounts
  // Alice: The EOA that will be "upgraded". Starts with 0 ETH.
  const alice = privateKeyToAccount(generatePrivateKey())
  
  // Bob: The Sponsor. Has ETH to pay for gas.
  // (Using default Anvil Account #0 for gas)
  const bob = privateKeyToAccount('0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80')
  const bobClient = createWalletClient({ account: bob, chain: anvil, transport: http() })

  // Charlie: The recipient
  const charlie = privateKeyToAccount(generatePrivateKey())

  console.log(`Alice: ${alice.address} (Upgrading...)`)
  console.log(`Bob:   ${bob.address} (Sponsoring...)`)
  console.log(`Charlie: ${charlie.address} (Recipient)`)

  // 2. Fund Alice with Tokens (Sponsor pays for the minting)
  console.log("Minting 100 tokens to Alice...")
  const mintHash = await bobClient.writeContract({
    address: TOKEN_ADDRESS,
    abi: [{ name: 'mint', type: 'function', inputs: [{type:'address', name:'to'}, {type:'uint256', name:'amount'}], outputs: [], stateMutability: 'nonpayable' }] as const,
    functionName: 'mint',
    args: [alice.address, parseEther('100')]
  })
  await publicClient.waitForTransactionReceipt({ hash: mintHash })

  // 3. Prepare Batch Call (Alice wants to transfer 50 tokens to Charlie)
  const calls = [
    {
      to: TOKEN_ADDRESS,
      value: 0n,
      data: encodeFunctionData({
        abi: erc20Abi,
        functionName: 'transfer',
        args: [charlie.address, parseEther('50')]
      })
    }
  ]

  // 4. Sign Inner Intent (Contract-level authentication)
  // We sign a digest of the calls to satisfy BatchCallAndSponsor's security checks.
  const nonce = 0n // Fresh EOA
  let encodedCalls = '0x' as `0x${string}`
  for (const call of calls) {
     encodedCalls = encodePacked(
        ['bytes', 'address', 'uint256', 'bytes'],
        [encodedCalls, call.to, call.value, call.data]
     )
  }
  const digest = keccak256(encodePacked(['uint256', 'bytes'], [nonce, encodedCalls]))
  
  // IMPORTANT: use message.raw to sign the digest bytes directly
  const innerSignature = await alice.signMessage({
    message: { raw: toBytes(digest) }
  })

  // 5. Sign EIP-7702 Authorization (Protocol-level delegation)
  const authorization = await bobClient.signAuthorization({
    contractAddress: IMPLEMENTATION_ADDRESS,
    account: alice
  })

  // 6. Execute Sponsored Transaction
  // Bob calls Alice's address. The authorizationList upgrades Alice to the implementation.
  console.log("Sending Sponsored EIP-7702 Transaction...")
  const txHash = await bobClient.writeContract({
    abi: BATCH_ABI,
    address: alice.address,
    functionName: 'execute',
    args: [calls, innerSignature],
    authorizationList: [authorization]
  })

  await publicClient.waitForTransactionReceipt({ hash: txHash })
  console.log(`Transaction Successful: ${txHash}`)

  // 7. Verification
  const balance = await publicClient.readContract({
    address: TOKEN_ADDRESS,
    abi: erc20Abi,
    functionName: 'balanceOf',
    args: [charlie.address]
  })
  
  console.log(`Charlie Final Balance: ${balance}`)
  if (balance === parseEther('50')) console.log("SUCCESS: Gasless transfer confirmed.")
}

main().catch(console.error)

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

import "forge-std/Test.sol";
import "../src/BatchCallAndSponsor.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract MockERC20 is ERC20 {
    constructor() ERC20("Mock", "MCK") {}
    function mint(address to, uint256 amount) public {
        _mint(to, amount);
    }
}

contract BatchCallAndSponsorTest is Test {
    BatchCallAndSponsor public implementation;
    MockERC20 public token;

    uint256 internal constant ALICE_PK =
        0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d;
    address payable internal constant ALICE_ADDRESS =
        payable(0x70997970C51812dc3A010C7d01b50e0d17dc79C8);

    uint256 internal constant BOB_PK =
        0x5de4111afa1a4b94908f83103eb1f1706367c2e68ca870fc3fb9a804cdab365a;
    address payable internal constant BOB_ADDRESS =
        payable(0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC);

    function setUp() public {
        implementation = new BatchCallAndSponsor();
        token = new MockERC20();

        // Fund Alice with tokens but NO ETH (to simulate sponsored need)
        token.mint(ALICE_ADDRESS, 1000e18);
        // Bob has ETH to sponsor
        vm.deal(BOB_ADDRESS, 10 ether);
    }

    function testDirectExecution() public {
        // Alice needs some ETH for gas in direct execution
        vm.deal(ALICE_ADDRESS, 1 ether);

        BatchCallAndSponsor.Call[]
            memory calls = new BatchCallAndSponsor.Call[](1);
        calls[0] = BatchCallAndSponsor.Call({
            to: address(token),
            value: 0,
            data: abi.encodeCall(ERC20.transfer, (BOB_ADDRESS, 100e18))
        });

        vm.signAndAttachDelegation(address(implementation), ALICE_PK);

        vm.startPrank(ALICE_ADDRESS);
        BatchCallAndSponsor(ALICE_ADDRESS).execute(calls);
        vm.stopPrank();

        assertEq(token.balanceOf(BOB_ADDRESS), 100e18);
    }

    function testSponsoredExecution() public {
        // Alice has 0 ETH. Bob sponsors.

        BatchCallAndSponsor.Call[]
            memory calls = new BatchCallAndSponsor.Call[](1);
        calls[0] = BatchCallAndSponsor.Call({
            to: address(token),
            value: 0,
            data: abi.encodeCall(ERC20.transfer, (BOB_ADDRESS, 50e18))
        });

        // 1. Prepare signature for the contract logic (replay protection etc)
        // Alice's nonce starts at 0 for a fresh EOA delegation
        uint256 nonce = 0;
        bytes memory encodedCalls;
        for (uint256 i = 0; i < calls.length; i++) {
            encodedCalls = abi.encodePacked(
                encodedCalls,
                calls[i].to,
                calls[i].value,
                calls[i].data
            );
        }
        bytes32 digest = keccak256(abi.encodePacked(nonce, encodedCalls));
        bytes32 ethSignedMessageHash = MessageHashUtils.toEthSignedMessageHash(
            digest
        );
        (uint8 v, bytes32 r, bytes32 s) = vm.sign(
            ALICE_PK,
            ethSignedMessageHash
        );
        bytes memory signature = abi.encodePacked(r, s, v);

        // 2. Prepare EIP-7702 Delegation
        Vm.SignedDelegation memory signedDelegation = vm.signDelegation(
            address(implementation),
            ALICE_PK
        );

        // 3. Bob executes
        vm.startBroadcast(BOB_PK);
        vm.attachDelegation(signedDelegation);

        BatchCallAndSponsor(ALICE_ADDRESS).execute(calls, signature);
        vm.stopBroadcast();

        assertEq(token.balanceOf(BOB_ADDRESS), 50e18);
    }
}