Thesettlementlayerforthemachineeconomy.

Interface

Register a signer, claim one grant

Onboarding and team-allocated funding

Two gateway methods register your LayerX identity and claim one bounded beta grant allocated by the team.

Call lx_register with a 32-byte Ed25519 public key and its signature, and the gateway derives your principal from the key itself, so a repeated call returns the same principal. Call lx_requestFunds to claim one bounded grant, reported only after the faucet confirms it funded, with the same grant reachable from the layerx CLI and the faucet.request MCP tool. The beta has not opened, so the gateway and faucet are not reachable yet.

What it does

The Paxeer X gateway publishes lx_register and lx_requestFunds as the onboarding pair for the LayerX agent domain. lx_register creates one self-service identity principal from a 32-byte Ed25519 signer public key and its 64-byte signature over the registration binding; the subject is derived from the key, so registration is idempotent and cannot name another key holder's principal. lx_requestFunds claims one bounded beta grant for the authenticated principal and reports it only after the faucet confirms it as funded. Distribution is team-gated: this is a mainnet beta on real value, so the team does not run the faucet for general use and approved developers receive allocations directly from the team.

Key capabilities

  • lx_register derives the principal subject from the signer key, so a repeated call returns the same principal.
  • lx_requestFunds derives its idempotency key from principal, DID and signer key, so a repeat returns the same grant.
  • A claim result carries funded, funding_id, transaction_id, a decimal-string amount and network.
  • The faucet caps claims per identity, per address and per network across a configured window.
  • The same grant is reachable through the layerx faucet command and the faucet.request served MCP tool.
  • Both methods answer with typed JSON-RPC errors rather than a partial success.

Who it's for

Developers and agent operators approved for the Paxeer X beta who need a LayerX identity and starting funds.

Why it matters

A developer goes from a local key pair to a funded LayerX account in two calls, with no account provisioning by hand. Because both calls are idempotent, a retried request cannot create a second principal or a second grant.

Differentiators

Idempotency comes from derivation rather than a client-supplied request id: the register subject is derived from the signer key and the faucet idempotency key from principal, DID and signer key. A claim whose funded evidence is incomplete returns -32603 and is never reported as funded (platform/hosted/gateway/openrpc.json).

Outcomes

  • Go from a local key pair to a funded account.
  • Retry either call without creating a second principal or grant.
  • Read typed JSON-RPC errors instead of a partial success.

Technical notes

  • Faucet claims run on a hosted identity session (Authorization: Bearer <session-token>), and lx_requestFunds requires that the named signer key be one the session authorises.
  • The faucet service route requires an Idempotency-Key header and refuses any request carrying a forwarded-client-IP or client-supplied principal header.
  • Bounds are configured: LAYERX_FAUCET_CLAIM_AMOUNT, LAYERX_FAUCET_IDENTITY_LIMIT, LAYERX_FAUCET_ADDRESS_LIMIT and LAYERX_FAUCET_NETWORK_LIMIT over LAYERX_FAUCET_WINDOW_SECONDS (default 86400), with idempotency retention LAYERX_FAUCET_IDEMPOTENCY_SECONDS (default 604800) and a default per-network budget of 60 requests per 60 seconds.
  • When the identity or faucet upstream is not configured the method answers -32001 with data.code registration_not_configured or faucet_not_configured.
  • The limited beta has not opened, so the gateway API and the faucet are not yet reachable; https://faucet.paxeer.network and https://beta.paxeer.network are declared in the deployment manifests, not shown live in the tree.
  • The Python SDK reaches both methods through the public PaymentRpc.call; the TypeScript SDK's JsonRpcClient.call is private and exposes no register or funding method. The credential-free local path is the emulator at http://127.0.0.1:9402, and no sample under platform/docs/samples runs without LAYERX_API_TOKEN and its companion variables.
# pip install layerx-sdk   (Python 3.11 or newer)
from layerx_sdk import PaymentRpc

rpc = PaymentRpc(
    "https://api.paxeer.network/rpc",
    {"Authorization": "Bearer " + session_token},
)
principal = rpc.call("lx_register", [signer_public_key, registration_signature])
grant = rpc.call("lx_requestFunds", [did, signer_public_key])
print(principal["sub"], grant["funded"], grant["amount"])

More in Interface

Build on Paxeer.

Give your agent a wallet, set its policy, and settle your first call on LayerX.