Unified Network Architecture
The LayerX kernel inside paxd executes and orders each transaction and builds each block; validators check and commit each block.
The Network Model
Paxeer X uses EVM chain ID 125 (0x7d). The node binary paxd runs the Cosmos SDK application and native EVM. The LayerX kernel runs in-process inside paxd through modules/lxphost, executes and orders each transaction, gives it the next position in one global sequence, and returns a signed execution receipt. node/sequencer supplies execution ordering within the node.
Kernel state changes commit with the rest of the node's transaction state. A receipt is final once its block is committed. Applications establish finality from the committed block and the receipt's inclusion evidence.
Sub-chains are tenant domains stored in the database and managed by modules/layerxchains. Creating a domain namespaces state within the shared network. It does not require new node infrastructure.
State and Authority
| State | Authoritative owner | How applications use it |
|---|---|---|
| EVM contracts and Cosmos balances | Paxeer application state committed by chain consensus | Contract calls, transactions, native modules and registered token pointers |
| Agent identities and delegated authority | LayerX identity kernel | DIDs, primary keys, sessions, scoped grants, recovery and revocation |
| Economic activity and balances | Kernel state committed in paxd blocks |
Receipts, replay, module queries and state witnesses |
| Receipt finality | Committed block | pax_sequencerReceipt rungs: submitted, receipted, committed |
| Tenant domains | modules/layerxchains |
Namespaced state within the shared network |
| Indexes and user interfaces | Projections of committed evidence | Search, account history and operational views, with receipts retained for verification |
An address binding identifies the same participant across the EVM and LayerX identity systems. Grants still determine the actions that participant or its delegates can perform. A verified signature establishes who signed evidence. Authorization and application policy establish whether that evidence is acceptable for a specific operation.
From Intent to Committed Activity
Canonical Signed Activities
A LayerX state change uses a canonical binary envelope containing protocol and network identifiers, activity type, actor DID, authority, account sequence, timestamp bounds, idempotency key, fee limit, payload binding, and signature. Fixed-width integers and canonical decoding keep independent executors in agreement. Time checks use the batch timestamp.
The kernel resolves authority, checks sequence and payload integrity, computes the fee, and executes the module inside a state journal. Successful execution commits its effects. An admitted operation that fails rolls back module effects while still recording its fee, sequence, and receipt. An admission refusal consumes neither fee nor sequence. An idempotent retry returns the original receipt without repeating the economic effect.
Receipts, Replay and State Roots
Every admitted activity receives a global sequence and a signed receipt linked to the previous and resulting state roots. The node executes transactions before proposing them in receipt order. The signed receipt records execution. The committed block establishes finality. pax_sequencerReceipt distinguishes a known transaction without a receipt (submitted), a signed receipt awaiting commitment (receipted), and a receipt covered by the committed block's sequence batch (committed). The hosted gateway's px_getReceiptKeys method returns pinned node receipt keys.
For independent verification, authenticate the block header and CometBFT commit, then verify transaction or state inclusion against the corresponding authenticated root. A successful submission or signed receipt alone must not be treated as a committed result.
Native Precompiles
Contracts reach native modules through precompiles/. The merge plan is v7.0. The thirteen merge entries are the five construct precompiles and eight agent-function precompiles in precompiles/setup.go. The table below also includes other native interfaces. Select the interface for the upgrade active at the queried height.
| Precompile | Address suffix | Role |
|---|---|---|
| Addr | 0x1004 |
Resolve Paxeer and EVM identities; bind and resolve LayerX DIDs and unified accounts. |
| Perps | 0x1015 |
Perpetuals interface selected by the v6.12.0 precompile set in node/precompiles_v6120.go. |
| LayerXBridge | 0x1016 |
Mint and burn bridged assets under registered-chain, attestor, threshold and cap rules. |
| Launchpad | 0x1017 |
Token launch interface selected by the v6.12.0 precompile set. |
| FeeToken / XWeb | 0x1018 / 0x1019 |
Fee-token preferences and attested web requests, respectively. |
| layerxledger, layerxpay, layerxauth, layerxprograms, layerxchains | 0x101A–0x101E |
Merge precompiles for ledger, payment, authorization, programs, and tenant domains. |
| orob, clearing, oracle aggregator, pofq, scheduler, streams, tee attestor, eip712 | 0x0901–0x0908 |
Remaining merge precompiles. |
| Pricefeed and spot | 0x1020–0x1025 |
pricefeed at 0x1020; spot_pecor, spot_orders, spot_stoporders, spot_quoter and spot_vault at 0x1021–0x1025 in the v6.12.0 set. |
Each suffix identifies a 20-byte address padded with leading zeros. See Precompiles for contract interfaces.
The served precompile set depends on the queried block height and module activation. Use the ABI in the matching precompiles/ directory and check the target module's state before submitting a transaction. The node selects versioned implementations through node/precompiles_v6120.go and its merge activation gates.
Unified Identity
A LayerX identity is rendered as did:layerx: followed by its 32-byte Ed25519 public key in lowercase hexadecimal. The canonical main account name is agent:did:layerx:<public-key>:main. The address precompile resolves the EVM address, Paxeer address, DID key, and derived LayerX main account together.
Binding requires both keys: the DID signs the binding domain, EVM chain ID, EVM address, and nonce; the EVM account submits the transaction. Bindings are one-to-one. Unbinding consumes a nonce, and previously signed binding messages cannot be replayed as a fresh association.
Finality
- Submit: A signed activity or transaction is known to the sequencer (
submitted). - Execute: The kernel executes it and issues a signed receipt (
receipted). - Commit: The block containing its sequence batch commits (
committed). The receipt is final at this point.
Finality depends on BFT block commitment. Keep the receipt, authenticated block header, commit, and inclusion evidence needed to verify the result. See Checkpoints and Finality for the evidence boundaries.
Developer and Service Boundaries
EVM applications use Ethereum-compatible tooling and JSON-RPC. Public node namespaces are debug, echo, eth, net, pax, test and txpool. Method availability depends on node configuration. The hosted gateway exposes a separate px_ API. Its deployment URL and credentials come from the operator. Gateway method availability does not follow from public node URLs.
Workflows carry the actor identity, intended action, and resulting evidence through routing, execution, and indexing. A unified experience can present one account and one history while retaining the receipt and EVM transaction identifiers needed to audit each step.
Build Across the Whole System
Compose agent commerce from identity, budgets, escrow, delivery attestations and receipt-backed payment.
Build programmable businesses with WASM programs, program-owned accounts and bounded spending grants.
Connect Solidity applications to verified agent execution and committed LayerX state.
Combine token launches, spot and perps activity, and external-chain assets under their own verification rules.
Continue with Paxeer X and LayerX, Modules, Contracts, and Consensus.