How to use the infrastructure.
Practical reference for delegators, integration partners, and institutional teams. For what we offer as services, see /services. This page is the operational manual.
Stake directly to 01node.
We validate 23+ PoS networks. Every listing below has an on-chain validator address, a current commission rate, and a wallet deep-link. No intermediaries, no custody hand-off — your delegation stays in your wallet, we sign blocks.
Standalone networks
Native wallets · per-chain portals| Network | Token | Ecosystem | Comm. | APR | Validator | Stake |
|---|---|---|---|---|---|---|
| SKALE | SKL | Ethereum | 10% | 8-10% | Valida…0,43→ | Stake |
| Monad | MON | Monad | 15% | ~37% | 0x8F5e…3Ccb→ | Stake |
| NEAR Protocol | NEAR | NEAR | 3% | 8-10% | 01node…near→ | Stake |
| Solana | SOL | Solana | 5% | 6-7% | BH7asD…wDhg→ | Stake |
| Sui | SUI | Sui | 5% | ~2% | 0x876e…cfbc→ | Stake |
Monad
15%NEAR Protocol
3%Solana
5%Sui
5%Per-ecosystem delegation.
Cosmos ecosystem
Keplr, Leap, Cosmostation
Click the Stake button on any Cosmos chain in the table above — it deep-links into Keplr with our validator pre-selected. Same pattern works with Leap and Cosmostation via their respective modals.
Ethereum-family (SKALE)
MetaMask, Ledger, Trezor
SKALE delegation runs through portal.skale.space. Connect your hardware or software wallet, search for validator #10,43, and delegate.
Solana
Phantom, Solflare, Ledger
Open your wallet's staking panel, search validator address BH7asDZb…wDhg, and create a stake account.
Sui
Sui Wallet, Suiet, Ethos
Use the Stake button in the table — it opens explorer.sui.io with our validator pre-selected.
NEAR
NEAR Wallet, MyNearWallet, Ledger
Stake to 01node.poolv1.near via your wallet's staking UI.
Monad
Rabby, MetaMask, Ledger
Direct stake on monadvision.com to validator 0x8F5eFD…3Ccb.
Things to check.
- Unbonding periods vary per chain (typically 14–28 days). Your tokens are locked and earn no rewards during unbonding.
- APR figures above are reward-only estimates at current inflation and stake distribution; they change daily.
- Commission rates change through governance or validator-initiated moves; always verify the current value in your wallet before signing.
- Slashing events across 40+ mainnets since 2019: 0. Read how we do key management at /security.
- Chain not listed? Email [email protected].
Free read-only RPC for builders.
Public endpoints we run on our own validator-grade hardware. Same nodes that back our staking ops — bare metal, sub-second monitoring, multi-region. No signup, no API key, fair-use rate limits. Use them for prototyping, indexers, light wallets, or anything that fits within shared throughput. For dedicated capacity see Premium.
Sui Mainnet endpoints.
We run a full Sui Mainnet RPC stack with both the new GraphQL service and the protobuf-based gRPC API. Both are read-only and intended for queries against current chain state, transactions, objects, checkpoints, and events.
| Protocol | Network | Endpoint | Transport | Status |
|---|---|---|---|---|
| GraphQL | Mainnet | https://sui.01.ro/graphql | HTTPS · POST | Live |
| gRPC | Mainnet | sui.01.ro:443 | HTTP/2 · TLS | Live |
GraphQL
Mainnet · HTTPS · POSThttps://sui.01.ro/graphql
Mysten GraphQL RPC. Chain ID verified: 4btiuiMP…SZ7DR6S.
gRPC
Mainnet · HTTP/2 · TLSsui.01.ro:443
Reflection enabled. Services exposed at host root, not under /grpc.
Why gRPC?
Wire size
Protobuf is binary and schema-aware — payloads are typically 3–5× smaller than equivalent JSON. Matters for bulk reads (object batches, checkpoint history, indexer backfills).
Streaming
Server-streaming RPCs push new checkpoints, transactions, and events over one HTTP/2 connection. No polling loop, no WebSocket layer to maintain.
Strong typing
Generated client stubs in Go, Rust, TypeScript, Python, Java give compile-time guarantees against the schema. No hand-rolled DTOs, no JSON parsing edge cases.
When to pick what
- GraphQL — ad-hoc queries, frontends, exploration. Pick this if you don't want to compile .proto files.
- gRPC — indexers, backends under load, streaming consumers, latency-sensitive services.
- JSON-RPC — legacy SDK compatibility, transaction submission (Premium only).
Quickstart
GraphQL · curl
200 OK · <50mscurl -sS https://sui.01.ro/graphql \
-H "content-type: application/json" \
-d '{"query":"{ chainIdentifier }"}'
# → {"data":{"chainIdentifier":"4btiuiMPv…"}}gRPC · grpcurl
Reflection enabled# List services via reflection grpcurl sui.01.ro:443 list # Health probe grpcurl sui.01.ro:443 \ grpc.health.v1.Health/Check
gRPC services
Service names follow the upstream Sui spec (currently the sui.rpc.v2beta2.* namespace; reflection is enabled, so always run grpcurl sui.01.ro:443 list for the canonical, version-current list).
| Service | Purpose | Public tier |
|---|---|---|
| LedgerService | Read objects, transactions, checkpoints, epochs, balances, dynamic fields, owned objects, coin info, events. | Live |
| SubscriptionService | Server-streaming new checkpoints with the transactions and effects they contain. | Live |
| MovePackageService | Move package metadata — module bytecode, datatype layouts, function signatures, package version history. | Live |
| SignatureVerificationService | Verify personal-message and transaction signatures off-chain against on-chain state. | Live |
| TransactionExecutionService | Submit and simulate transactions. Write paths — not exposed on the public tier. | Premium |
| grpc.health.v1.Health | Standard gRPC health probe (Check, Watch). | Live |
| grpc.reflection.v1.ServerReflection | Service discovery — list services, describe methods and message types at runtime. | Live |
LedgerService
LiveRead objects, transactions, checkpoints, epochs, balances, dynamic fields, owned objects, coin info, events.
SubscriptionService
LiveServer-streaming new checkpoints with the transactions and effects they contain.
MovePackageService
LiveMove package metadata — module bytecode, datatype layouts, function signatures.
SignatureVerificationService
LiveVerify personal-message and transaction signatures off-chain.
TransactionExecutionService
PremiumSubmit and simulate transactions. Write paths — not on the public tier.
grpc.health.v1.Health
LiveStandard gRPC health probe (Check, Watch).
grpc.reflection.v1.ServerReflection
LiveService discovery at runtime.
Client examples
Same call (LedgerService.GetCheckpoint, latest) in three languages. Generated stubs assume you've compiled the upstream .proto files (see Proto files & codegen below).
Node.js · @grpc/grpc-js
import { credentials } from "@grpc/grpc-js";
import { LedgerServiceClient }
from "./gen/sui/rpc/v2beta2/ledger_service.js";
const client = new LedgerServiceClient(
"sui.01.ro:443",
credentials.createSsl(),
);
client.getCheckpoint({}, (err, res) => {
if (err) throw err;
console.log("seq:", res.checkpoint?.sequenceNumber);
});Python · grpcio
import grpc
from sui.rpc.v2beta2 import (
ledger_service_pb2_grpc as svc,
ledger_service_pb2 as msg,
)
chan = grpc.secure_channel(
"sui.01.ro:443",
grpc.ssl_channel_credentials(),
)
stub = svc.LedgerServiceStub(chan)
resp = stub.GetCheckpoint(msg.GetCheckpointRequest())
print("seq:", resp.checkpoint.sequence_number)Go · google.golang.org/grpc
conn, _ := grpc.NewClient(
"sui.01.ro:443",
grpc.WithTransportCredentials(
credentials.NewTLS(&tls.Config{}),
),
)
defer conn.Close()
c := ledgerv2.NewLedgerServiceClient(conn)
res, _ := c.GetCheckpoint(ctx,
&ledgerv2.GetCheckpointRequest{})
fmt.Println("seq:", res.Checkpoint.SequenceNumber)Streaming subscriptions
SubscriptionService.SubscribeCheckpointsis server-streaming — open it once and consume new checkpoints (and the transactions inside) as they finalize. The connection is held over HTTP/2; the server pushes, you don't poll.
Go · streaming consumer
sub := subv2.NewSubscriptionServiceClient(conn)
stream, err := sub.SubscribeCheckpoints(ctx,
&subv2.SubscribeCheckpointsRequest{})
if err != nil { log.Fatal(err) }
for {
msg, err := stream.Recv()
if err == io.EOF { break }
if err != nil { log.Fatal(err) }
cp := msg.Checkpoint
fmt.Printf("checkpoint %d · %d txs\n",
cp.SequenceNumber, len(cp.Transactions))
}Common queries
Copy-paste recipes using grpcurl. Same request shapes work from any generated client — the JSON in -d maps 1:1 to the protobuf message.
Get object by ID
grpcurl \
-d '{"object_id":"0x6"}' \
sui.01.ro:443 \
sui.rpc.v2beta2.LedgerService/GetObjectGet latest checkpoint
grpcurl \
-d '{}' \
sui.01.ro:443 \
sui.rpc.v2beta2.LedgerService/GetCheckpointGet transaction by digest
grpcurl \
-d '{"digest":"<base58_digest>"}' \
sui.01.ro:443 \
sui.rpc.v2beta2.LedgerService/GetTransactionGet balance for an address
grpcurl \
-d '{"owner":"0x...","coin_type":"0x2::sui::SUI"}' \
sui.01.ro:443 \
sui.rpc.v2beta2.LedgerService/GetBalanceProto files & codegen
We do not host or modify .proto files — clients should consume the canonical schemas from MystenLabs. They live under crates/sui-rpc-api/proto in the upstream repo.
Fetch + generate (Go example)
# 1. Fetch upstream protos (sparse checkout or submodule) git clone --depth=1 --filter=blob:none --sparse \ https://github.com/MystenLabs/sui.git cd sui && git sparse-checkout set crates/sui-rpc-api/proto # 2. Generate Go stubs protoc \ -I crates/sui-rpc-api/proto \ --go_out=./gen --go_opt=paths=source_relative \ --go-grpc_out=./gen --go-grpc_opt=paths=source_relative \ $(find crates/sui-rpc-api/proto -name '*.proto')
For Python use grpcio-tools (python -m grpc_tools.protoc); for TypeScript, @bufbuild/protoc-gen-es or ts-proto; for Rust, tonic-build. Buf users can point buf.gen.yaml directly at the upstream proto path.
- gRPC clients connect to sui.01.ro:443 over HTTP/2 + TLS — services live at the host root, the literal path /grpc is informational only.
- Mainnet chain identifier returned by our node: 4btiuiMPvEENsttpZC7CZ53DruC3MAgfznDbASZ7DR6S.
- Methods, schema, and types follow the upstream Sui spec — we do not modify or proxy. If a query works against the Mysten endpoint, it works here.
- No write paths exposed publicly. ExecuteTransaction and similar are off on the public tier — request Premium for write-capable dedicated endpoints.
- Set sensible deadlines on every call (e.g. 5–10s) — public-tier capacity is shared, and a missing deadline can starve your own retries.
JSON-RPC, gRPC, EVM RPC.
We operate RPC nodes for every chain we validate. Cosmos-ecosystem chains expose both JSON-RPC and gRPC; Ethereum-family chains expose standard EVM JSON-RPC with additional namespace support on request. Public read access is live for Sui (see Public RPC / Sui); the broader public tier ships Q3 2026. Enterprise endpoints — per-key, dedicated, IP-allowlisted — are available now under SLA.
Fast-sync snapshots per chain.
Compressed chain-data snapshots generated on our hot-standby nodes. Used internally for sub-SLA failover; available to enterprise partners for integration bring-up and disaster recovery.
Access tiers for RPC & Snapshots.
Public (roadmap)
Q3 2026Rate-limited JSON-RPC and gRPC for light integrations. IP-based throttling, no auth.
API-keyed
AvailablePer-key rate limits, header auth, usage metering, documented per-method quotas.
Dedicated
AvailableIsolated endpoints per client, IP allowlist, private peering available, contracted under SLA.
Five steps from first call to live.
Every enterprise engagement follows the same sequence. Typical first-call-to-live is 4–8 weeks depending on compliance reviews on your side. We do not process live stake until contracts are counter-signed.
Intro call
30 minutes with our head of institutional. We cover the chains you need, your custody stack, compliance posture on both sides, and a realistic timeline. No technical deep-dive yet — just scope.
Technical review
Your integration lead meets our technical owner. We review RPC requirements, snapshot needs, reporting format, monitoring integration, and the slashing-insurance approach if applicable.
Contract
DPA, MSA, and SLA. SLA covers uptime, latency, incident response time, and service credits. MSA is multi-year by default; shorter terms available on request.
Provisioning
Credentials delivered via encrypted channel (PGP or GPG/Keybase). API keys, RPC endpoint URLs, snapshot access, a named technical contact, and an escalation path.
Go-live & review
Soft-launch window with both teams on-call. After 30 days, a written review on performance vs. SLA. Quarterly executive review from there.
What gets delivered.
- →Credentials package — API keys, RPC URLs, snapshot locations, delivered via PGP-encrypted email or a shared Keybase channel. Never by plaintext Slack / Telegram.
- →Named contacts — technical lead and commercial owner on our side, with phone and encrypted messenger. Expected to acknowledge incidents within the SLA window.
- →Reporting access — read-only dashboard for rewards, uptime, attestations, incidents. Monthly CSV + PDF exports.
- →Compliance pack — ISO 27001 certificate, penetration test summary (when applicable), SOC 2 readiness letter, DPA, architectural diagrams. Delivered under NDA.
- →Escalation path — written P1/P2/P3 definitions, response SLAs per tier, and names/contacts at each escalation level up to founder.
How support works after go-live.
Named owners, not queues
Your technical lead has context on your integration. No re-explaining architecture every incident. Commercial owner handles contract, invoicing, roadmap alignment.
Quarterly review
90-minute executive review every quarter: performance vs. SLA, incidents and root cause, roadmap alignment, upcoming chain upgrades that affect your stack.
Incident response
P1 = <15 min ack. P2 = <1h ack. P3 = <4h ack. Every incident followed by a written post-mortem within 5 business days for P1/P2.
Chain upgrade coordination
Protocol upgrades tested on our internal testnet before production. Clients get upgrade notifications 72h ahead with impact analysis.
The part your auditor will ask about.
Full control map, current status, and disclosure policy live on the /security page. Every claim is tagged active / in-progress / planned so your third-party-risk team gets the true state, not a marketing page.
$ 01.ro --docs --summary
DELEGATION_CHAINS: 23
RPC_PUBLIC_LIVE: SUI_MAINNET (GRAPHQL + GRPC)
RPC_PUBLIC_TIER: Q3 2026 ROADMAP (MULTI-CHAIN)
RPC_ENTERPRISE: API_KEY + IP_ALLOWLIST
SNAPSHOTS: ENTERPRISE · tar.lz4 / tar.zst · daily refresh
ONBOARDING: 5 STEPS · 4-8 WEEKS TYPICAL
SUPPORT: NAMED_OWNER · QUARTERLY_REVIEW · P1 <15M
SLASHING_EVENTS_LIFETIME: 0