Three tools.One realm.Identity-aware by default.
Three surfaces for three modes of participation: code the realm with the SDK, live in it through the Wallet, read it through Scan. Each one designed to the same standard as the components they serve.
Inside the realm, not next to it.
The integration argument applies to your developer experience too. When components are designed alongside each other, the SDK that addresses them doesn’t have to bridge them. You compose, and the platform enforces the contract.
Xyress gives you a working environment.
The SDK is identity-aware before you write your first line. Calls are Sigil-bound by default. Transactions are Witness-attested without ceremony. Component composition is declarative, not procedural — describe what you want, and the realm wires it.
The wallet isn’t a separate product to integrate; it’s the standard envelope every resident already holds. Scan isn’t a third-party explorer; it’s Xyress’s own observability surface, identity-aware in what it shows whom.
Compose components. Skip the glue.
A typed, identity-aware client for Xyress. Three lines of code to issue a credential, three lines to verify — sensible defaults handling cryptographic complexity invisibly. TypeScript first; additional language bindings follow.
What the SDK does
A small client surface, designed around the things a real builder actually needs to do. Identity is implicit, not boilerplate. Composition is declarative.
Every client instance is bound to a Sigil. Calls inherit the caller's identity without you wiring it through every function.
Compose Witness, Synod, Charter, Commons in one expression. The SDK enforces the contract; you describe the intent.
Type definitions match the on-chain schema. State, transactions, and proofs are typed end-to-end — no hand-rolled interfaces.
TypeScript ships first. Rust, Go, and Python bindings follow before Phase 1 mainnet. Same surface across all of them.
// Compose identity, proof, and tokenization // in a single declarative call. import { createClient } from "@xyress/sdk"; const client = createClient({ sigil: process.env.SIGIL_KEY, network: "mainnet" }); const result = await client.compose({ charter: { mint: { supply: 1000n } }, commons: { grant: { to: recipient } }, witness: { attest: true } }); // One transaction. Three components. // Identity, proof, attribution all enforced.
Not a key store. An envelope around your Sigil.
The wallet is the resident’s working interface to Xyress. It holds your Sigil, your assets, your access grants, and your hired agents — all under one identity-bound surface, with consumer-grade usability.
What the wallet holds
The standard envelope every resident holds. A regulated bank, a developer, and a casual user are looking at the same primitive surfaces — different in tier, identical in architecture.
The cryptographic identity itself. Tier-aware: pseudonymous, verified, or proof-of-personhood (PoP)-bound. The wallet is where it lives, not where it begins.
Native Xyress tokens, Charter-minted assets, off-chain attestations. Native and bridged assets in one view.
What you've granted others, what's been granted to you. Commons-bound permissions visible and revocable from one place.
Your Retinue — the platform-tuned agents you've hired to act under your authority. Bounded scope, attributable behavior, all visible.
Make the realm legible.
Xyress Scan is the block explorer and trust-discovery surface. Identity-aware from the start: who can see what depends on who is asking. Auditors get audit views, residents get their own activity, regulators get the surfaces they’re entitled to.
What you can see, by who you are
Most explorers show everything to everyone. Scan is identity-aware: visibility follows the same access model the rest of the platform enforces.
Public realm state. Block headers, public component activity, aggregate analytics. Rate-limited; no Sigil required.
Your activity, plus public. Your transactions, your holdings, your access grants, your agents — alongside everything the Guest level sees.
An Auditor is a Resident holding an explicit audit grant — a scoped grant, not a tier. Specific systems or actors are made visible under that grant, and the scope is itself on-chain: you see only what you’ve been authorized to see.
Read the docs before they exist.
Comprehensive documentation arrives with the public testnet. The four entry points below establish the structure — each will be a full sub-tree of guides and reference material by Phase 1 mainnet.
Getting started
Install the SDK, generate a developer Sigil, send your first transaction. The shortest path from zero to a working build environment.
Identity model
How Sigils work. The tier system. How to bind a service identity, an agent identity, or a device identity. Reference for the foundation primitive.
Component composition
How to combine Witness, Synod, Charter, Commons, and the rest in a single declarative call. Patterns, examples, anti-patterns.
Deployment
From local dev to public testnet to mainnet. Deployment modes, environment configuration, and the boundaries between them.
Compose, ground, or get in touch.
Three tools. Designed alongside the realm.
Build something the substrate was waiting for.
SDK in active build. Wallet and Scan in active build. Public testnet on the horizon. The first builders are arriving early, and we’d like to know what you’re working on.