EIP-7702: delegate an EOA and batch transactions

import { createWalletClient, createPublicClient, http } from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { sepolia } from "viem/chains";

const account = privateKeyToAccount("0xYOUR_PRIVATE_KEY");
const NODE_URL = "YOUR_CHAINSTACK_ENDPOINT";

const walletClient = createWalletClient({ account, chain: sepolia, transport: http(NODE_URL) });
const publicClient = createPublicClient({ chain: sepolia, transport: http(NODE_URL) });

// The contract whose code the EOA will run (deploy your own; see "Batch transactions" below)
const DELEGATE = "0xYOUR_DELEGATE_CONTRACT";

// 1. Sign the authorization. executor: 'self' sets authorization.nonce = tx.nonce + 1
const authorization = await walletClient.signAuthorization({
  account,
  contractAddress: DELEGATE,
  executor: "self",
});

// 2. Send the type-0x04 set-code transaction
const hash = await walletClient.sendTransaction({
  authorizationList: [authorization],
  to: account.address,
});
console.log("set-code tx:", hash);

const code = await publicClient.getCode({ address: account.address });
console.log(code);
// 0xef0100ca11bde05977b3631167028862be2a173976ca11
//  ^^^^^^ prefix      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ delegate address

const revoke = await walletClient.signAuthorization({
  account,
  contractAddress: "0x0000000000000000000000000000000000000000",
  executor: "self",
});

await walletClient.sendTransaction({ authorizationList: [revoke], to: account.address });

const after = await publicClient.getCode({ address: account.address });
console.log(after); // 0x  (delegation removed)

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

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

    function execute(Call[] calldata calls) external payable {
        // Runs in the EOA's storage context: add require(msg.sender == address(this))
        // in production to prevent arbitrary callers from spending the EOA's balance.
        for (uint256 i = 0; i < calls.length; i++) {
            Call memory call = calls[i];
            (bool success, bytes memory result) = call.to.call{value: call.value}(call.data);
            if (!success) {
                assembly { revert(add(result, 32), mload(result)) }
            }
        }
    }
}

import { createWalletClient, http, encodeFunctionData } from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { sepolia } from "viem/chains";

const account = privateKeyToAccount("0xYOUR_PRIVATE_KEY");
const walletClient = createWalletClient({ account, chain: sepolia, transport: http("YOUR_CHAINSTACK_ENDPOINT") });

const erc20Abi = [
  { name: "approve", type: "function", inputs: [{ name: "spender", type: "address" }, { name: "amount", type: "uint256" }], outputs: [{ type: "bool" }] },
  { name: "transfer", type: "function", inputs: [{ name: "to", type: "address" }, { name: "amount", type: "uint256" }], outputs: [{ type: "bool" }] },
];
const batchAbi = [
  { name: "execute", type: "function", inputs: [{ name: "calls", type: "tuple[]", components: [{ name: "data", type: "bytes" }, { name: "to", type: "address" }, { name: "value", type: "uint256" }] }], outputs: [] },
];

// 1. Authorize the deployed BatchCallDelegation contract
const authorization = await walletClient.signAuthorization({
  account,
  contractAddress: "0xYOUR_BATCH_EXECUTOR",
  executor: "self",
});

// 2. Build the calls: approve, then transfer
const calls = [
  { to: "0xTOKEN", value: 0n, data: encodeFunctionData({ abi: erc20Abi, functionName: "approve", args: ["0xSPENDER", 1000000n] }) },
  { to: "0xTOKEN", value: 0n, data: encodeFunctionData({ abi: erc20Abi, functionName: "transfer", args: ["0xRECIPIENT", 1000000n] }) },
];

// 3. One atomic transaction: delegate + run the batch on the EOA's own address
const hash = await walletClient.writeContract({
  abi: batchAbi,
  address: account.address,
  authorizationList: [authorization],
  functionName: "execute",
  args: [calls],
});
console.log("batch tx:", hash);

import { createWalletClient, http } from "viem";
import { privateKeyToAccount } from "viem/accounts";
import { sepolia } from "viem/chains";

const relay = privateKeyToAccount("0xRELAY_PRIVATE_KEY"); // pays gas
const eoa = privateKeyToAccount("0xEOA_PRIVATE_KEY");     // delegates, pays nothing

const walletClient = createWalletClient({ account: relay, chain: sepolia, transport: http("YOUR_CHAINSTACK_ENDPOINT") });

// EOA signs the authorization (no executor: 'self')
const authorization = await walletClient.signAuthorization({ account: eoa, contractAddress: "0xYOUR_DELEGATE_CONTRACT" });

// Relay submits the set-code transaction and pays the gas
const hash = await walletClient.sendTransaction({ authorizationList: [authorization], to: eoa.address });