Paxeer X and LayerX
One network combines EVM smart contracts, autonomous agent execution, programmable finance, and proof-backed settlement.
One Network, Two Execution Domains
Paxeer X brings Paxeer and LayerX together into a unified network. Paxeer supplies the Cosmos SDK chain, native EVM, asset custody, and settlement authority. LayerX supplies deterministic activity execution, agent identity, economic modules, and programmable WASM execution. Applications compose both domains through cryptographic evidence and native EVM precompiles.
The distinction describes where an operation executes and which state authorizes it. A normal agent payment executes as a signed LayerX activity without requiring a separate EVM transaction. Depositing an asset, finalizing a checkpoint, or releasing custody executes on Paxeer. Solidity applications can verify LayerX receipts and state directly inside the EVM.
| Capability | Paxeer domain | LayerX domain |
|---|---|---|
| Application execution | Solidity contracts, native precompiles, Cosmos modules | Signed activities, economic modules, deterministic WASM programs |
| Identity | EVM and Paxeer addresses | Agent DIDs, sessions, scoped grants, recovery and revocation |
| Money | Native assets, token custody, deposits and payouts | Payments, holds, escrow, budgets, streams and protocol balances |
| Markets | Exchange intents, external-chain bridge and token launch AMM | Trading, positions, funding, liquidation and settlement requests |
| Evidence | On-chain verification, checkpoint roots and finalized custody claims | Signed receipts, ordered batches, state witnesses and replay |
| Security authority | Validators, governance, bonded guarantors and challenge resolution | Actor authority, deterministic execution and independently replayed activity |
What the Merger Enables
Agent Businesses with Real Financial Controls
An agent operates through its own identity and bounded authority. It pays for services, commits funds to escrow, spends against a budget, and receives delivery evidence. Businesses issue assets and agents trade the resulting instruments. Programs coordinate these operations while the protocol controls every balance change.
Solidity Applications That Understand Agent Activity
A contract consumes a verified service receipt, proves a LayerX account balance, or checks a program result before applying its own rules. Native verification supplies receipt and batch facts; the application chooses the trusted sequencer authorization and required settlement state.
Connected Markets and Assets
Applications route exchange instructions from the EVM into LayerX, move margin through custody, launch tokens on the native constant-product curve, and connect registered external chains through attested bridge transfers. Each path retains its own economic and verification rules.
A Shared Account, Explicit Authority
The address precompile binds an EVM address to a did:layerx identity with consent from both keys. The DID signs a chain-bound, address-bound message with a nonce; the EVM owner submits it. Unified account resolution connects the EVM address, Paxeer address, DID public key, and LayerX main account.
Binding makes identity discoverable across domains. Spending remains subject to the authority of the operation: an EVM transaction, a LayerX session or scoped grant, or a program spending grant. Revocation and expiry constrain delegated actions.
Settlement Follows Evidence
- Deposit an asset into Paxeer custody for the intended LayerX beneficiary.
- Execute payments, trades, deliveries, or program calls as signed activities.
- Receive signed receipts and inclusion evidence for ordered batches.
- Anchor checkpoints with guarantor attestations and complete the challenge window.
- Withdraw against finalized receipt evidence, or use a state-proof exit according to custody rules.
PAX pays EVM transaction gas. LayerX activities use their committed fee schedule and declared fee limits. Applications show the activity fee, EVM gas, and any custody delay at the corresponding step.
Choose Your Starting Point
- Read Unified Network Architecture for state, proof and authority boundaries.
- Build contracts with Foundry or Hardhat, then explore native precompiles.
- Explore protocol modules and the WASM runtime for programmable execution.
- Use Network Parameters for chain identity and Building a Frontend for wallet integration.