Ship software thatpays its own way.
A standard EVM chain on chain ID 125, plus LayerX for wallets, limits and signed receipts. Start on your laptop with the layerx CLI, then reach the network from the language you already write.

import { createPublicClient, defineChain, http } from 'viem'
export const paxeer = defineChain({
id: 125,
name: 'Paxeer X Network',
nativeCurrency: { name: 'Paxeer', symbol: 'PAX', decimals: 18 },
rpcUrls: { default: { http: ['https://api-mainnet-beta.paxeer.network/rpc'] } },
blockExplorers: { default: { name: 'Paxscan', url: 'https://paxscan.io' } },
})
const client = createPublicClient({ chain: paxeer, transport: http() })
await client.getChainId() // 125
await client.getBlockNumber()import type { HardhatUserConfig } from 'hardhat/config'
const config: HardhatUserConfig = {
solidity: '0.8.28',
networks: {
paxeer: {
url: 'https://api-mainnet-beta.paxeer.network/rpc',
chainId: 125,
accounts: [process.env.DEPLOYER_KEY!],
},
},
}
export default configexport PAXEER_RPC=https://api-mainnet-beta.paxeer.network/rpc
cast chain-id --rpc-url $PAXEER_RPC # 125
cast block-number --rpc-url $PAXEER_RPC
forge create src/Counter.sol:Counter \
--rpc-url $PAXEER_RPC --private-key $DEPLOYER_KEYPoint your tools at chain 125.
The Paxeer X chain serves the standard Ethereum JSON-RPC. Add it to viem, Hardhat or Foundry and keep the code you have.
npm install @sidiora/layerx-sdk viemA short, documented list of JSON-RPC methods refuses on purpose, and blob transactions are not supported.
Everything in one repository.
Open source in one public monorepo. The examples in the docs are compiled and checked in CI, so they do not drift from what runs.
- CLIlayerxOne Rust binary with 17 command groups: wallets, payments, receipts, programs, the emulator, MCP and A2A. Every write is signed locally.
- Node.js 22+, Python 3.11+@sidiora/layerx-sdkThe LayerX SDK for TypeScript, with Python, Rust, Go, JVM, .NET and Swift alongside. Every client verifies receipts locally.
- TypeScript, Pythonpaxeer-xdkOne client for the whole network: resolve an account across both domains and read its unified history.
- x402 version 2layerx-expressx402 payment middleware that mounts on Express and Next.js in one call. FastAPI and Spring Boot have their own mounts.
- MCP, A2Alayerx-mcp21 scoped tools for model agents. A tool the session has no scope for never appears in the list.
- Offlinelayerx-verifyChecks a trust root, a receipt or an inclusion bundle against the signed genesis manifest, and names the stage that failed.
Run the network on your laptop.
No shared endpoint, funded account or beta access needed. The emulator returns real signed receipts, so local runs fail or succeed for the same reasons deployed ones do.
- 01
Provision
Write a sequencer seed and its trust anchor under your profile.
- 02
Run
Serve the LayerX gateway on 127.0.0.1:9402. Any other address is refused.
- 03
Build
Create a wallet, charge for a route and verify the receipt it returns.
layerx emulator provision
layerx emulator up --sequencer-seed-file "$HOME/.config/layerx/emulator/sequencer.seed"
# second terminal, same LAYERX_CONFIG
layerx environment use emulator --endpoint http://127.0.0.1:9402 \
--network-id 402 \
--sequencer-trust-anchor-file "$HOME/.config/layerx/emulator/sequencer.anchor"
layerx wallet create alice
layerx --json wallet balanceimport express from 'express'
import { mountLayerX, SingleProcessWebhookDeliveryStore } from 'layerx-express'
const app = express()
// Answers 402 with an offer, and releases the resource only
// after a sequencer-signed receipt verifies against it.
mountLayerX(app, {
environment: process.env,
resources: { async release() { return { contentType: 'application/json', body } } },
fulfillments: repository,
deliveries: new SingleProcessWebhookDeliveryStore(),
events: { async handle(event, deliveryId) { await record(deliveryId, event) } },
})
app.listen(8080)from layerx_sdk.x402_http import BuyerMiddleware
buyer = BuyerMiddleware(rpc, signatures, resolve_receipt, {("exact", "layerx:1")})
challenge = response.headers["PAYMENT-REQUIRED"]
required, offer = buyer.parse_offer(challenge)
header = buyer.prepare(challenge, canonical_hex, activity_id, payer)
if header is None:
raise RuntimeError("payment pending; recover the receipt for this activity")
paid = session.get(required["resource"]["url"], headers={"PAYMENT-SIGNATURE": header})What developers ask first.
Start locally without beta access. Apply when you are ready for chain ID 125.

Do I need beta access to start?
No. The emulator and the local four-node chain run without a shared endpoint, a funded account or beta access. When you are ready for chain ID 125, apply for the limited beta. Approved developers receive allocations from the team.
Which SDK should I use?
The one your team already writes. Rust, TypeScript and Python are the most complete, with Go, JVM, .NET and Swift alongside. All share one wire format and verify receipts locally, and each quickstart names exactly which calls its package carries.
What versions do the SDKs need?
Every SDK is at version 0.1.0. The TypeScript SDK is ESM-only and needs Node.js 22 or newer. The Python SDK needs Python 3.11 or newer. The CLI builds with Rust 1.91.1.
Do Foundry and Hardhat work?
Yes. Both are used to build and test the network’s own contracts. Any library that speaks standard Ethereum JSON-RPC works against chain ID 125.
Can I write programs for LayerX itself?
Yes, as deterministic WebAssembly. Program SDKs cover Rust, AssemblyScript and C, and layerx program build refuses non-deterministic code on your machine before the network would. Porting kits cover EVM, Solana and CosmWasm.
Where is the documentation?
At docs.paxeer.app, built from the project wiki. The source is on GitHub under Sidiora-Labs/Paxeer-X-Network, and the whitepaper sets out the full design.
Start with nothing at stake.
Run the emulator, settle a paid request locally, then point the same code at chain ID 125.
