EOA Code Delegation

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

const eoa       = privateKeyToAccount(process.env.EOA_PRIVATE_KEY);
const eoaClient = createWalletClient({ chain: hederaTestnet, transport: http(), account: eoa });

// `executor: 'self'` tells viem the EOA will also submit the transaction,
// so the authorization must be signed with the next nonce (current + 1).
const authorization = await eoaClient.signAuthorization({
  contractAddress: "0x<smart-account-implementation>",
  executor: "self",
});

const hash = await eoaClient.sendTransaction({
  authorizationList: [authorization],
  to: eoa.address,    // can be the EOA itself, the zero address, or any target
  data: "0x",         // optional follow-up call data (executed after the auth is processed)
});

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

const eoa     = privateKeyToAccount(process.env.EOA_PRIVATE_KEY);
const sponsor = privateKeyToAccount(process.env.SPONSOR_PRIVATE_KEY);

const eoaClient     = createWalletClient({ chain: hederaTestnet, transport: http(), account: eoa });
const sponsorClient = createWalletClient({ chain: hederaTestnet, transport: http(), account: sponsor });

// Omit `executor`; the sponsor submits the transaction, so the EOA's nonce
// is only consumed once (by the authorization itself).
const authorization = await eoaClient.signAuthorization({
  contractAddress: "0x<smart-account-implementation>",
});

const hash = await sponsorClient.sendTransaction({
  authorizationList: [authorization],
  to: eoa.address,
  data: "0x",
});

import { EthereumTransaction, Hbar } from "@hashgraph/sdk";

const tx = await new EthereumTransaction()
  .setEthereumData(rawType4RlpBytes)          // raw 0x04 || rlp(...)
  .setMaxGasAllowanceHbar(new Hbar(2))
  .execute(client);

const receipt = await tx.getReceipt(client);
console.log(receipt.status.toString());

import { AccountUpdateTransaction, AccountId } from "@hashgraph/sdk";

// Point an existing EOA at a smart-account implementation
const tx = await new AccountUpdateTransaction()
  .setAccountId(AccountId.fromString("0.0.4567"))
  .setDelegationAddress("0x019b8ee526333d9cbbbc35fff0309794dfa73451")
  .freezeWith(client)
  .sign(eoaKey);                              // EOA must sign

await (await tx.execute(client)).getReceipt(client);

// Read it back via property access
console.log(`Delegation address: ${tx.delegationAddress?.toString()}`);

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

/// @title MinimalSmartAccount
/// @notice Intended to be installed as an EOA delegation target via EIP-7702.
///         All state read/written here lives in the *EOA's* storage frame.
contract MinimalSmartAccount {
    // EIP-7201 namespaced storage slot for "hedera.smart-account.v1".
    // Derivation: keccak256(abi.encode(uint256(keccak256("hedera.smart-account.v1")) - 1)) & ~bytes32(uint256(0xff))
    // Reproduce with Foundry: `cast index-erc7201 "hedera.smart-account.v1"`
    // If you change the namespace string, recompute this constant.
    bytes32 private constant SLOT =
        0xf7bd8ee8b6b02e586c7a21c9ecc95fa2e26786f8e462f9f9103d541de5d4bf00;

    struct Layout {
        uint256 nonce;
    }

    function _s() private pure returns (Layout storage $) {
        assembly { $.slot := SLOT }
    }

    /// Only the EOA itself (i.e. address(this) == msg.sender after delegation) may call.
    modifier onlyOwner() {
        require(msg.sender == address(this), "not owner");
        _;
    }

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

    /// Execute a batch of calls atomically from the EOA's address.
    function executeBatch(Call[] calldata calls) external onlyOwner {
        _s().nonce++;
        for (uint256 i = 0; i < calls.length; i++) {
            (bool ok, bytes memory ret) = calls[i].to.call{value: calls[i].value}(calls[i].data);
            require(ok, _revertReason(ret));
        }
    }

    function nonce() external view returns (uint256) { return _s().nonce; }

    receive() external payable {}

    function _revertReason(bytes memory ret) private pure returns (string memory) {
        if (ret.length < 68) return "call reverted";
        assembly { ret := add(ret, 0x04) }
        return abi.decode(ret, (string));
    }
}

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

const eoa     = privateKeyToAccount(process.env.EOA_PRIVATE_KEY);       // new user, no HBAR
const sponsor = privateKeyToAccount(process.env.SPONSOR_PRIVATE_KEY);   // pays the gas

const eoaClient     = createWalletClient({ chain: hederaTestnet, transport: http(), account: eoa });
const sponsorClient = createWalletClient({ chain: hederaTestnet, transport: http(), account: sponsor });

// 1. The EOA signs an authorization delegating to the deployed MinimalSmartAccount.
//    No `executor` field, because the sponsor (not the EOA) submits the transaction.
const authorization = await eoaClient.signAuthorization({
  contractAddress: "0x<deployed-MinimalSmartAccount>",
});

// 2. Build the batched call: approve a router, then swap (both run in the EOA's context).
const smartAccountAbi = parseAbi([
  "struct Call { address to; uint256 value; bytes data; }",
  "function executeBatch(Call[] calls)",
]);
const erc20Abi  = parseAbi(["function approve(address spender, uint256 amount)"]);
const routerAbi = parseAbi(["function swapExactTokensForHBAR(uint256 amountIn, address token)"]);

const batch = encodeFunctionData({
  abi: smartAccountAbi,
  functionName: "executeBatch",
  args: [[
    { to: "0x<token>",  value: 0n, data: encodeFunctionData({ abi: erc20Abi,  functionName: "approve", args: ["0x<router>", 1_000_000n] }) },
    { to: "0x<router>", value: 0n, data: encodeFunctionData({ abi: routerAbi, functionName: "swapExactTokensForHBAR", args: [1_000_000n, "0x<token>"] }) },
  ]],
});

// 3. Sponsor submits one Type 4 transaction: it sets the delegation AND invokes the batch.
const hash = await sponsorClient.sendTransaction({
  authorizationList: [authorization],   // sets eoa.delegation_address
  to: eoa.address,                      // call resolves to the delegate code, in the EOA's context
  data: batch,                          // executeBatch([approve, swap])
});