Batch Call & Sponsor

Author: bh2smith

README-Foundry.md

@@ -0,0 +1,66 @@
+## Foundry
+
+**Foundry is a blazing fast, portable and modular toolkit for Ethereum application development written in Rust.**
+
+Foundry consists of:
+
+-   **Forge**: Ethereum testing framework (like Truffle, Hardhat and DappTools).
+-   **Cast**: Swiss army knife for interacting with EVM smart contracts, sending transactions and getting chain data.
+-   **Anvil**: Local Ethereum node, akin to Ganache, Hardhat Network.
+-   **Chisel**: Fast, utilitarian, and verbose solidity REPL.
+
+## Documentation
+
+https://book.getfoundry.sh/
+
+## Usage
+
+### Build
+
+```shell
+$ forge build
+```
+
+### Test
+
+```shell
+$ forge test
+```
+
+### Format
+
+```shell
+$ forge fmt
+```
+
+### Gas Snapshots
+
+```shell
+$ forge snapshot
+```
+
+### Anvil
+
+```shell
+$ anvil
+```
+
+### Deploy
+
+```shell
+$ forge script script/Counter.s.sol:CounterScript --rpc-url <your_rpc_url> --private-key <your_private_key>
+```
+
+### Cast
+
+```shell
+$ cast <subcommand>
+```
+
+### Help
+
+```shell
+$ forge --help
+$ anvil --help
+$ cast --help
+```

README.md

@@ -1,66 +1,101 @@
-## Foundry
+# BatchCallAndSponsor
 
-**Foundry is a blazing fast, portable and modular toolkit for Ethereum application development written in Rust.**
+An educational project demonstrating account abstraction and sponsored transaction execution using EIP-7702. This project uses Foundry for deployment, scripting, and testing.
 
-Foundry consists of:
+## Overview
 
--   **Forge**: Ethereum testing framework (like Truffle, Hardhat and DappTools).
--   **Cast**: Swiss army knife for interacting with EVM smart contracts, sending transactions and getting chain data.
--   **Anvil**: Local Ethereum node, akin to Ganache, Hardhat Network.
--   **Chisel**: Fast, utilitarian, and verbose solidity REPL.
+The `BatchCallAndSponsor` contract enables batch execution of calls by verifying signatures over a nonce and batched call data. It supports:
+- **Direct execution**: by the smart account itself.
+- **Sponsored execution**: via an off-chain signature (by a sponsor).
 
-## Documentation
+Replay protection is provided by an internal nonce that increments after each batch execution.
 
-https://book.getfoundry.sh/
+## Features
 
-## Usage
+- Batch transaction execution
+- Off-chain signature verification using ECDSA
+- Replay protection through nonce incrementation
+- Support for both ETH and ERC-20 token transfers
 
-### Build
+## Prerequisites
 
-```shell
-$ forge build
-```
+- [Foundry](https://github.com/foundry-rs/foundry)
+- Solidity ^0.8.20
+
+## Running the Project
 
-### Test
+### Step 1: Install Foundry
 
-```shell
-$ forge test
+```sh
+curl -L https://foundry.paradigm.xyz | bash
+git clone https://github.com/quiknode-labs/qn-guide-examples.git
+cd qn-guide-examples/ethereum/eip-7702
 ```
 
-### Format
+### Step 2: Install Packages and Create the Remappings File
 
-```shell
-$ forge fmt
+```sh
+forge install OpenZeppelin/openzeppelin-contracts
+forge install foundry-rs/forge-std
+forge remappings > remappings.txt
 ```
 
-### Gas Snapshots
+### Step 3: Run a Local Network
+
+Run the following command on your terminal to start a local network with the Prague hardfork. 
 
-```shell
-$ forge snapshot
+```bash
+anvil --hardfork prague
 ```
 
-### Anvil
+### Step 4: Build the Contract
 
-```shell
-$ anvil
+On another terminal, run the following command to build the contract.
+
+```bash
+forge build
 ```
 
-### Deploy
+### Step 5: Run the Test Cases
+
+After building the contract, run the following command to run the test cases. If you want to display stack traces for all tests, use `-vvvv` flag instead of `-vvv`.
 
-```shell
-$ forge script script/Counter.s.sol:CounterScript --rpc-url <your_rpc_url> --private-key <your_private_key>
+```bash
+forge test -vvv
 ```
 
-### Cast
+The output should look like this:
+
+```bash
+Ran 4 tests for test/BatchCallAndSponsor.t.sol:BatchCallAndSponsorTest
+[PASS] testDirectExecution() (gas: 128386)
+Logs:
+  Sending 1 ETH from Alice to Bob and transferring 100 tokens to Bob in a single transaction
 
-```shell
-$ cast <subcommand>
+[PASS] testReplayAttack() (gas: 114337)
+Logs:
+  Test replay attack: Reusing the same signature should revert.
+
+[PASS] testSponsoredExecution() (gas: 110461)
+Logs:
+  Sending 1 ETH from Alice to a random address while the transaction is sponsored by Bob
+
+[PASS] testWrongSignature() (gas: 37077)
+Logs:
+  Test wrong signature: Execution should revert with 'Invalid signature'.
+
+Suite result: ok. 4 passed; 0 failed; 0 skipped;
 ```
 
-### Help
+#### Step 6: Run the Script
+
+Now that you’ve set up the project, it’s time to run the deployment script. This script deploys the contract, mints tokens, and tests both batch execution and sponsored execution features.
+
+We use the following command:
+- **`--broadcast`**: Broadcasts the transactions to your local network.
+- **`--rpc-url 127.0.0.1:8545`**: Connects to your local network.
+- **`--tc BatchCallAndSponsorScript`**: Specifies the target contract for the script.
 
-```shell
-$ forge --help
-$ anvil --help
-$ cast --help
+```bash
+forge script ./script/BatchCallAndSponsor.s.sol --tc BatchCallAndSponsorScript --broadcast --rpc-url 127.0.0.1:8545
 ```

remappings.txt

@@ -0,0 +1,5 @@
+@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/
+erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/
+forge-std/=lib/forge-std/src/
+halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/
+openzeppelin-contracts/=lib/openzeppelin-contracts/

script/BatchCallAndSponsor.s.sol

@@ -0,0 +1,111 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import "forge-std/Script.sol";
+import {Vm} from "forge-std/Vm.sol";
+import {BatchCallAndSponsor} from "../src/BatchCallAndSponsor.sol";
+import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+import {MessageHashUtils} from "@openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol";
+
+contract MockERC20 is ERC20 {
+    constructor() ERC20("Mock Token", "MOCK") {}
+
+    function mint(address to, uint256 amount) external {
+        _mint(to, amount);
+    }
+}
+
+contract BatchCallAndSponsorScript is Script {
+    // Alice's address and private key (EOA with no initial contract code).
+    address payable ALICE_ADDRESS = payable(0x70997970C51812dc3A010C7d01b50e0d17dc79C8);
+    uint256 constant ALICE_PK = 0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d;
+
+    // Bob's address and private key (Bob will execute transactions on Alice's behalf).
+    address constant BOB_ADDRESS = 0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC;
+    uint256 constant BOB_PK = 0x5de4111afa1a4b94908f83103eb1f1706367c2e68ca870fc3fb9a804cdab365a;
+
+    // The contract that Alice will delegate execution to.
+    BatchCallAndSponsor public implementation;
+
+    // ERC-20 token contract for minting test tokens.
+    MockERC20 public token;
+
+    function run() external {
+        // Start broadcasting transactions with Alice's private key.
+        vm.startBroadcast(ALICE_PK);
+
+        // Deploy the delegation contract (Alice will delegate calls to this contract).
+        implementation = new BatchCallAndSponsor();
+
+        // Deploy an ERC-20 token contract where Alice is the minter.
+        token = new MockERC20();
+
+        // // Fund accounts
+        token.mint(ALICE_ADDRESS, 1000e18);
+
+        vm.stopBroadcast();
+
+        // Perform direct execution
+        performDirectExecution();
+
+        // Perform sponsored execution
+        performSponsoredExecution();
+    }
+
+    function performDirectExecution() internal {
+        BatchCallAndSponsor.Call[] memory calls = new BatchCallAndSponsor.Call[](2);
+
+        // ETH transfer
+        calls[0] = BatchCallAndSponsor.Call({to: BOB_ADDRESS, value: 1 ether, data: ""});
+
+        // Token transfer
+        calls[1] = 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();
+
+        console.log("Bob's balance after direct execution:", BOB_ADDRESS.balance);
+        console.log("Bob's token balance after direct execution:", token.balanceOf(BOB_ADDRESS));
+    }
+
+    function performSponsoredExecution() internal {
+        console.log("Sending 1 ETH from Alice to a random address, the transaction is sponsored by Bob");
+
+        BatchCallAndSponsor.Call[] memory calls = new BatchCallAndSponsor.Call[](1);
+        address recipient = makeAddr("recipient");
+        calls[0] = BatchCallAndSponsor.Call({to: recipient, value: 1 ether, data: ""});
+
+        // Alice signs a delegation allowing `implementation` to execute transactions on her behalf.
+        Vm.SignedDelegation memory signedDelegation = vm.signDelegation(address(implementation), ALICE_PK);
+
+        // Bob attaches the signed delegation from Alice and broadcasts it.
+        vm.startBroadcast(BOB_PK);
+        vm.attachDelegation(signedDelegation);
+
+        // Verify that Alice's account now temporarily behaves as a smart contract.
+        bytes memory code = address(ALICE_ADDRESS).code;
+        require(code.length > 0, "no code written to Alice");
+        // console.log("Code on Alice's account:", vm.toString(code));
+
+        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(BatchCallAndSponsor(ALICE_ADDRESS).nonce(), encodedCalls));
+        (uint8 v, bytes32 r, bytes32 s) = vm.sign(ALICE_PK, MessageHashUtils.toEthSignedMessageHash(digest));
+        bytes memory signature = abi.encodePacked(r, s, v);
+
+        // As Bob, execute the transaction via Alice's temporarily assigned contract.
+        BatchCallAndSponsor(ALICE_ADDRESS).execute(calls, signature);
+
+        vm.stopBroadcast();
+
+        console.log("Recipient balance after sponsored execution:", recipient.balance);
+    }
+}