Transaction Execution
Namera defines a lane-based execution model for smart accounts that enables:
- Single transactions
- Atomic batching
- Parallel execution (via nonce lanes)
- Multi-chain execution
- Cross-chain parallelism
This model is designed for agents, automation, and programmable session keys.
Core Concepts
1. Call
A Call is the smallest unit of execution.
export type Call = {
target: Address; // contract or EOA
data: Hex; // encoded calldata
value?: bigint; // optional ETH/native value
}2. Batch
A Batch is a group of calls executed sequentially on a single chain.
export type Batch = {
chainId: number; // target chain
calls: Call[];
// execution lane (2D Nonce)
nonceKey?: string;
// execution semantics
atomic?: boolean; // default: true
}3. Execute Transaction Params
Top-level execution container.
export type ExecuteTransactionParams = {
batches: Batch[];
}Execution Model
Sequential Execution (within a batch)
- Calls inside a batch are executed in order
- If atomic = true:
- Any failure → entire batch reverts
- If atomic = false:
- Partial execution may be allowed (implementation-specific)
Parallel Execution (across batches)
Parallelism is controlled via nonceKey (execution lanes):
- Same nonceKey → executed sequentially
- Different nonceKey → can execute in parallel
Multi-chain Execution
- Each batch specifies its own chainId
- Batches are routed and executed per chain
- A single logical request can span multiple chains
Execution Scenarios
Single Transaction
Example: Transfer USDC on Ethereum
A user wants to send 100 USDC to a friend.
Flow:
- Token: USDC
- Chain: Ethereum
- Action:
transfer(address _to, uint256 _value)
{
batches: [
{
calls: [
{
data: "transfer(0xALICE, 100e6)",
target: "0xUSDC",
},
],
chainId: 1,
},
],
}Smart Account executes a single call, no batching, no parallelism.
Sequential Batch (Atomic)
Example: Swap USDC → ETH on Uniswap
User wants to swap USDC to ETH using Uniswap.
Required steps:
- Approve USDC to router
- Execute swap
{
batches: [
{
chainId: 1,
nonceKey: "swap",
calls: [
{
target: "0xUSDC",
data: "approve(0xUniswapRouter, 100e6)"
},
{
target: "0xUniswapRouter",
data: "swapExactTokensForETH(...)"
}
]
}
]
}Smart Accounts executes a batch of calls in order, fully atomic, no parallelism.
Parallel Batches (Same Chain)
Example: Swap on Uniswap + Deposit into Aave (Ethereum)
User wants to:
- Swap USDC → ETH on Uniswap
- Deposit DAI into Aave
These actions are independent → can run in parallel.
{
batches: [
{
chainId: 1,
nonceKey: "swap",
calls: [
{
target: "0xUniswapRouter",
data: "swapExactTokensForETH(...)"
}
]
},
{
chainId: 1,
nonceKey: "lend",
calls: [
{
target: "0xDAI",
data: "approve(AavePool, 1000e18)"
},
{
target: "0xAavePool",
data: "supply(DAI, 1000e18, ...)"
}
]
}
]
}Smart Account executes two independent nonce lanes:
swapandlend, both in parallel. Two transaction hashes are generated. each batch is atomic.
Multi-Chain Batches
Example: Trade on Ethereum + Lend on Polygon*
User strategy:
- Swap ETH → USDC on Uniswap (Ethereum)
- Deposit USDC into Aave (Polygon)
{
batches: [
{
chainId: 1, // Ethereum
calls: [
{
target: "0xUniswapRouter",
data: "swapExactETHForTokens(...)"
}
]
},
{
chainId: 137, // Polygon
calls: [
{
target: "0xUSDC",
data: "approve(AavePool, 1000e6)"
},
{
target: "0xAavePool",
data: "supply(USDC, 1000e6, ...)"
}
]
}
]
}Smart Account executes two different chains, via separate bundlers. Same user intent, split execution. Not atomic across chains.
Multi-Chain + Parallel Execution
Example: Full Portfolio Strategy (Ethereum + Base)
User wants to:
On Ethereum:
- Swap on Uniswap
- Add liquidity on Curve
On Base:
- Deposit into Aave
- Stake in a vault
{
batches: [
// Ethereum - lane A
{
chainId: 1,
nonceKey: "eth-swap",
calls: [
{
target: "0xUniswapRouter",
data: "swapExactTokensForETH(...)"
}
]
},
// Ethereum - lane B
{
chainId: 1,
nonceKey: "eth-liquidity",
calls: [
{
target: "0xCurve",
data: "add_liquidity(...)"
}
]
},
// Base - lane C
{
chainId: 8453,
nonceKey: "base-lend",
calls: [
{
target: "0xAavePool",
data: "supply(...)"
}
]
},
// Base - lane D
{
chainId: 8453,
nonceKey: "base-stake",
calls: [
{
target: "0xVault",
data: "deposit(...)"
}
]
}
]
}Smart Account executes four independent execution lanes:
eth-swap,eth-liquidity,base-lend, andbase-stake, all in parallel. Parallel execution within Ethereum and Base.