Skip to main content

Documentation Index

Fetch the complete documentation index at: https://docs.startale.com/llms.txt

Use this file to discover all available pages before exploring further.

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 caseWhy 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 accountEach worker owns a distinct lane, so they can submit concurrently without nonce collisions.
High-throughput dapps batching on behalf of many usersOne 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 })
SymbolSourceRole
account.getNonce({ key })@startale-scs/aa-sdkReads 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:
StrategyExample
Stable lane per workerkey = workerId
Stable lane per user inside a service accountkey = hash(userId) >> 64
One lane per business flowkey = 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.

Sponsored paymaster

Sponsor every UserOperation across all lanes.

EIP-7702

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