EIP-7702 Delegation

EIP-7702 delegation allows you to temporarily upgrade an Externally Owned Account (EOA) with smart contract capabilities. This enables existing EOA accounts to use features like user operations, batch transactions, and spend permissions without deploying a new smart contract account.

What is EIP-7702?

EIP-7702 is an Ethereum improvement proposal that enables EOAs to delegate their execution to a smart contract implementation. This provides:

Smart account features for EOAs: Use account abstraction without migration
Temporary delegation: The EOA can revoke delegation at any time
Backward compatibility: Works with existing wallets and tools
User operations: Send transactions via ERC-4337 bundlers
Spend permissions: Enable gasless allowance-based spending

Creating an EIP-7702 Delegation

Get or create an EOA account

Start with an existing EOA account:

TypeScript
Python

import { CdpClient } from "@coinbase/cdp-sdk";

const cdp = new CdpClient();
const account = await cdp.evm.getOrCreateAccount({ 
  name: "EIP7702-Demo" 
});

console.log(`Account address: ${account.address}`);

from cdp import CdpClient

async with CdpClient() as cdp:
    account = await cdp.evm.get_or_create_account(
        name="EIP7702-Demo"
    )
    
    print(f"Account address: {account.address}")

Ensure the account has ETH for gas

The delegation transaction requires ETH:

TypeScript
Python

// Request testnet ETH
const faucetResult = await cdp.evm.requestFaucet({
  address: account.address,
  network: "base-sepolia",
  token: "eth"
});

// Wait for faucet transaction
await publicClient.waitForTransactionReceipt({
  hash: faucetResult.transactionHash
});

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("https://sepolia.base.org"))

# Request testnet ETH
faucet_result = await cdp.evm.request_faucet(
    address=account.address,
    network="base-sepolia",
    token="eth"
)

# Wait for faucet transaction
w3.eth.wait_for_transaction_receipt(faucet_result.transaction_hash)

Create the delegation

Create the EIP-7702 delegation:

TypeScript
Python

const txHash = await cdp.evm.createEvmEip7702Delegation({
  address: account.address,
  network: "base-sepolia",
  enableSpendPermissions: true // Optional
});

console.log(`Delegation transaction: ${txHash}`);

tx_hash = await cdp.evm.create_evm_eip7702_delegation(
    address=account.address,
    network="base-sepolia",
    enable_spend_permissions=True  # Optional
)

print(f"Delegation transaction: {tx_hash}")

Wait for delegation to be active

Wait for the delegation status to be CURRENT:

TypeScript
Python

const status = await cdp.evm.waitForEvmEip7702DelegationStatus({
  address: account.address,
  network: "base-sepolia"
});

console.log(`Delegation status: ${status.status}`);
console.log(`Smart contract: ${status.smartContractAddress}`);

status = await cdp.evm.wait_for_evm_eip7702_delegation_status(
    address=account.address,
    network="base-sepolia"
)

print(f"Delegation status: {status.status}")
print(f"Smart contract: {status.smart_contract_address}")

Using the Delegated Account

Once delegation is active, convert the EOA to a delegated account:

TypeScript
Python

import { toEvmDelegatedAccount } from "@coinbase/cdp-sdk";

// Convert EOA to delegated account
const delegatedAccount = toEvmDelegatedAccount(account);

// Now use smart account features
const userOp = await delegatedAccount.sendUserOperation({
  calls: [
    {
      to: "0x0000000000000000000000000000000000000000",
      value: 0n,
      data: "0x"
    }
  ],
  network: "base-sepolia"
});

console.log(`User operation: ${userOp.userOpHash}`);

from cdp import to_evm_delegated_account
from cdp.evm_call_types import EncodedCall

# Convert EOA to delegated account
delegated_account = to_evm_delegated_account(account)

# Now use smart account features
user_op = await delegated_account.send_user_operation(
    calls=[
        EncodedCall(
            to="0x0000000000000000000000000000000000000000",
            value=0,
            data="0x"
        )
    ],
    network="base-sepolia"
)

print(f"User operation: {user_op.user_op_hash}")

Sending User Operations

Delegated accounts can send user operations like smart accounts:

TypeScript
Python

import { encodeFunctionData, erc20Abi } from "viem";

const delegatedAccount = toEvmDelegatedAccount(account);

// Send a token transfer via user operation
const userOp = await delegatedAccount.sendUserOperation({
  calls: [
    {
      to: "0xUSDCAddress...",
      value: 0n,
      data: encodeFunctionData({
        abi: erc20Abi,
        functionName: "transfer",
        args: ["0xRecipient...", 1000000n]
      })
    }
  ],
  network: "base-sepolia",
  paymasterUrl: "https://paymaster.example.com" // Optional
});

// Wait for confirmation
const confirmed = await delegatedAccount.waitForUserOperation(
  userOp.userOpHash
);
console.log(`Transaction hash: ${confirmed.transactionHash}`);

from cdp.evm_call_types import EncodedCall

delegated_account = to_evm_delegated_account(account)

# Send a token transfer via user operation
user_op = await delegated_account.send_user_operation(
    calls=[
        EncodedCall(
            to="0xUSDCAddress...",
            value=0,
            data="0x...",  # Encoded transfer call
        )
    ],
    network="base-sepolia",
    paymaster_url="https://paymaster.example.com"  # Optional
)

# Wait for confirmation
confirmed = await delegated_account.wait_for_user_operation(
    user_op_hash=user_op.user_op_hash
)
print(f"Transaction hash: {confirmed.transaction_hash}")

Batch Operations

Execute multiple operations atomically:

TypeScript
Python

const userOp = await delegatedAccount.sendUserOperation({
  calls: [
    {
      to: "0xContract1...",
      value: 0n,
      data: "0x..."
    },
    {
      to: "0xContract2...",
      value: 0n,
      data: "0x..."
    },
    {
      to: "0xContract3...",
      value: 0n,
      data: "0x..."
    }
  ],
  network: "base-sepolia"
});

user_op = await delegated_account.send_user_operation(
    calls=[
        EncodedCall(to="0xContract1...", value=0, data="0x..."),
        EncodedCall(to="0xContract2...", value=0, data="0x..."),
        EncodedCall(to="0xContract3...", value=0, data="0x..."),
    ],
    network="base-sepolia"
)

Spend Permissions

With enableSpendPermissions: true, delegated accounts support spend permissions:

TypeScript
Python

// Create delegation with spend permissions
await cdp.evm.createEvmEip7702Delegation({
  address: account.address,
  network: "base-sepolia",
  enableSpendPermissions: true
});

// Wait for delegation
await cdp.evm.waitForEvmEip7702DelegationStatus({
  address: account.address,
  network: "base-sepolia"
});

// Now the account can create and use spend permissions
const delegatedAccount = toEvmDelegatedAccount(account);

// Create a spend permission
const permission = await cdp.evm.createSpendPermission({
  account: delegatedAccount.address,
  spender: "0xSpenderAddress...",
  token: "usdc",
  allowance: 1000000n, // 1 USDC
  period: 86400, // 1 day
  start: 0,
  end: 281474976710655,
  network: "base-sepolia"
});

# Create delegation with spend permissions
await cdp.evm.create_evm_eip7702_delegation(
    address=account.address,
    network="base-sepolia",
    enable_spend_permissions=True
)

# Wait for delegation
await cdp.evm.wait_for_evm_eip7702_delegation_status(
    address=account.address,
    network="base-sepolia"
)

# Now the account can create and use spend permissions
delegated_account = to_evm_delegated_account(account)

# Create spend permissions as needed

Checking Delegation Status

Check the current delegation status:

TypeScript
Python

const status = await cdp.evm.getEvmEip7702DelegationStatus({
  address: account.address,
  network: "base-sepolia"
});

console.log(`Status: ${status.status}`);
// Possible values: "NOT_STARTED", "PENDING", "CURRENT", "REVOKED"

if (status.status === "CURRENT") {
  console.log(`Delegated to: ${status.smartContractAddress}`);
}

status = await cdp.evm.get_evm_eip7702_delegation_status(
    address=account.address,
    network="base-sepolia"
)

print(f"Status: {status.status}")
# Possible values: "NOT_STARTED", "PENDING", "CURRENT", "REVOKED"

if status.status == "CURRENT":
    print(f"Delegated to: {status.smart_contract_address}")

Delegation Lifecycle

NOT_STARTED: No delegation has been created
PENDING: Delegation transaction is submitted but not confirmed
CURRENT: Delegation is active and the account has smart account features
REVOKED: Delegation has been revoked (future feature)

Complete Example

TypeScript
Python

import { CdpClient, toEvmDelegatedAccount } from "@coinbase/cdp-sdk";
import { createPublicClient, http } from "viem";
import { baseSepolia } from "viem/chains";

const cdp = new CdpClient();
const publicClient = createPublicClient({
  chain: baseSepolia,
  transport: http()
});

// Step 1: Get or create account
const account = await cdp.evm.getOrCreateAccount({ 
  name: "EIP7702-Example" 
});
console.log(`Account: ${account.address}`);

// Step 2: Ensure account has ETH
const balance = await publicClient.getBalance({ 
  address: account.address 
});
if (balance === 0n) {
  console.log("Requesting ETH from faucet...");
  const faucetTx = await cdp.evm.requestFaucet({
    address: account.address,
    network: "base-sepolia",
    token: "eth"
  });
  await publicClient.waitForTransactionReceipt({ 
    hash: faucetTx.transactionHash 
  });
  console.log("Faucet confirmed!");
}

// Step 3: Create delegation
console.log("Creating EIP-7702 delegation...");
const txHash = await cdp.evm.createEvmEip7702Delegation({
  address: account.address,
  network: "base-sepolia",
  enableSpendPermissions: false
});
console.log(`Delegation transaction: ${txHash}`);

// Step 4: Wait for delegation to be active
console.log("Waiting for delegation to be active...");
const status = await cdp.evm.waitForEvmEip7702DelegationStatus({
  address: account.address,
  network: "base-sepolia"
});
console.log(`Delegation active! (${status.status})`);
console.log(
  `Explorer: https://sepolia.basescan.org/tx/${txHash}`
);

// Step 5: Use the delegated account
console.log("Sending user operation...");
const delegatedAccount = toEvmDelegatedAccount(account);
const userOp = await delegatedAccount.sendUserOperation({
  calls: [
    {
      to: "0x0000000000000000000000000000000000000000",
      value: 0n,
      data: "0x"
    }
  ],
  network: "base-sepolia"
});

console.log(`User operation: ${userOp.userOpHash}`);
console.log(
  `Check status: https://base-sepolia.blockscout.com/op/${userOp.userOpHash}`
);

See the example file at: /home/daytona/workspace/source/examples/python/evm/eip7702/create_eip7702_delegation.py

Supported Networks

EIP-7702 delegation is currently supported on:

Base Sepolia: base-sepolia (testnet)

Check the Networks documentation for the latest list of supported networks.

Troubleshooting

Delegation Transaction Failed

Ensure the account has sufficient ETH for gas:

await cdp.evm.requestFaucet({
  address: account.address,
  network: "base-sepolia",
  token: "eth"
});

Delegation Status Stuck at PENDING

Wait for the transaction to be mined. You can check the transaction on a block explorer using the returned txHash.

User Operation Rejected

Ensure delegation is active before sending user operations:

const status = await cdp.evm.getEvmEip7702DelegationStatus({
  address: account.address,
  network: "base-sepolia"
});

if (status.status !== "CURRENT") {
  throw new Error("Delegation not active");
}

Cannot Convert to Delegated Account

Only accounts with active delegations can be converted:

// This will throw if delegation is not active
const delegatedAccount = toEvmDelegatedAccount(account);

Get Started

Core Concepts

Guides

Examples

EIP-7702 Delegation

What is EIP-7702?

Creating an EIP-7702 Delegation

Using the Delegated Account

Sending User Operations

Batch Operations

Spend Permissions

Checking Delegation Status

Delegation Lifecycle

Complete Example

Supported Networks

Troubleshooting

Delegation Transaction Failed

Delegation Status Stuck at PENDING

User Operation Rejected

Cannot Convert to Delegated Account

Next Steps

Build docs developers (and LLMs) love

Get Started

Core Concepts

Guides

Examples

​What is EIP-7702?

​Creating an EIP-7702 Delegation

​Using the Delegated Account

​Sending User Operations

​Batch Operations

​Spend Permissions

​Checking Delegation Status

​Delegation Lifecycle

​Complete Example

​Supported Networks

​Troubleshooting

​Delegation Transaction Failed

​Delegation Status Stuck at PENDING

​User Operation Rejected

​Cannot Convert to Delegated Account

​Next Steps

Build docs developers (and LLMs) love

What is EIP-7702?

Creating an EIP-7702 Delegation

Using the Delegated Account

Sending User Operations

Batch Operations

Spend Permissions

Checking Delegation Status

Delegation Lifecycle

Complete Example

Supported Networks

Troubleshooting

Delegation Transaction Failed

Delegation Status Stuck at PENDING

User Operation Rejected

Cannot Convert to Delegated Account

Next Steps