Parallel transactions

A regular EOA has a single nonce, so transactions strictly serialize. ERC-7579 smart accounts have a two-dimensional nonce: a nonceKey (the lane) and a nonce (the position inside that lane). Different lanes are independent, so you can send UserOperations on different lanes in parallel.

Source: StartaleGroup/scs-aa-sdk.

When to use parallel lanes

Use case	Why a lane helps
Independent flows that should not block each other (e.g. claim + swap)	A revert or delay on lane A does not block lane B.
Multiple worker processes signing for the same account	Each worker owns a distinct lane, so they can submit concurrently without nonce collisions.
High-throughput dapps batching on behalf of many users	One lane per user keeps their UserOperations independent.

Mental model

Within a lane, UserOperations are still ordered. Across lanes, they are independent.

Read a lane nonce

const nonceLane1 = await smartAccountClient.account.getNonce({ key: 1n })
const nonceLane2 = await smartAccountClient.account.getNonce({ key: 2n })

Symbol	Source	Role
`account.getNonce({ key })`	`@startale-scs/aa-sdk`	Reads the next available nonce for the given lane. `key` is a `bigint`; `0n` is the default lane.

Send two UserOperations in parallel

Pass each lane’s nonce when calling sendUserOperation. Do not await the calls back to back; fire them together so the bundler sees both at once.

const [hash1, hash2] = await Promise.all([
  smartAccountClient.sendUserOperation({
    calls: [{ to: target, data: callA, value: 0n }],
    nonce: nonceLane1,
  }),
  smartAccountClient.sendUserOperation({
    calls: [{ to: target, data: callB, value: 0n }],
    nonce: nonceLane2,
  }),
])

const [receipt1, receipt2] = await Promise.all([
  smartAccountClient.waitForUserOperationReceipt({ hash: hash1 }),
  smartAccountClient.waitForUserOperationReceipt({ hash: hash2 }),
])

If you fire many UserOperations on a single lane, the bundler will queue them strictly in order; one stuck UserOp blocks the rest of the lane. Use lanes whenever ordering between two flows does not matter.

Pick lane keys deliberately

The key is a uint192 packed into the nonce, which leaves plenty of room for application-defined schemes:

Strategy	Example
Stable lane per worker	`key = workerId`
Stable lane per user inside a service account	`key = hash(userId) >> 64`
One lane per business flow	`key = 1n` for swaps, `key = 2n` for claims, etc.

The lane key is opaque to the EntryPoint; pick whatever scheme keeps your flows from colliding.

Caveats

Lanes are per smart account. Two different smart accounts already have independent nonces; you only need lanes within a single account.
Lane state lives onchain. Bumping key does not cost gas, but the first UserOp on a brand-new lane still pays whatever gas the EntryPoint charges for storage initialisation.
The paymaster does not care about lanes; sponsored and ERC-20 paymaster flows work the same way on any lane.

Next steps

Contract interactions

Combine batched calls inside a single UserOperation with parallel UserOperations across lanes.

Smart sessions

Run scoped session UserOperations on dedicated lanes.

EIP-7702

Use lane nonces on a delegated EOA-as-smart-account.

Overview

Getting started

Tutorials

Auth providers

Advanced

EIP-7702

Resources

FAQ

When to use parallel lanes

Mental model

Read a lane nonce

Send two UserOperations in parallel

Pick lane keys deliberately

Caveats

Next steps

Contract interactions

Smart sessions

Sponsored paymaster

EIP-7702

​When to use parallel lanes

​Mental model

​Read a lane nonce

​Send two UserOperations in parallel

​Pick lane keys deliberately

​Caveats

​Next steps

Contract interactions

Smart sessions

Sponsored paymaster

EIP-7702

When to use parallel lanes

Mental model

Read a lane nonce

Send two UserOperations in parallel

Pick lane keys deliberately

Caveats

Next steps