Documentation // v1

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.

// Delegate / Overview

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.

// Delegate / Networks

Standalone networks

Native wallets · per-chain portals
5 chains
// Delegate / Wallet guides

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.

// Delegate / Before you stake

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].
// Public RPC / Overview

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.

Currently liveSui Mainnet · GraphQL + gRPC
Coming nextSui JSON-RPC · Solana · Cosmos chains
Fair-useRate-limited per IP · No SLA · Best effort
// Public RPC / Sui

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.

GraphQL

Mainnet · HTTPS · POST
Live

https://sui.01.ro/graphql

Mysten GraphQL RPC. Chain ID verified: 4btiuiMP…SZ7DR6S.

gRPC

Mainnet · HTTP/2 · TLS
Live

sui.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 · <50ms
curl -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).

LedgerService

Live

Read objects, transactions, checkpoints, epochs, balances, dynamic fields, owned objects, coin info, events.

SubscriptionService

Live

Server-streaming new checkpoints with the transactions and effects they contain.

MovePackageService

Live

Move package metadata — module bytecode, datatype layouts, function signatures.

SignatureVerificationService

Live

Verify personal-message and transaction signatures off-chain.

TransactionExecutionService

Premium

Submit and simulate transactions. Write paths — not on the public tier.

grpc.health.v1.Health

Live

Standard gRPC health probe (Check, Watch).

grpc.reflection.v1.ServerReflection

Live

Service 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/GetObject

Get latest checkpoint

grpcurl \
  -d '{}' \
  sui.01.ro:443 \
  sui.rpc.v2beta2.LedgerService/GetCheckpoint

Get transaction by digest

grpcurl \
  -d '{"digest":"<base58_digest>"}' \
  sui.01.ro:443 \
  sui.rpc.v2beta2.LedgerService/GetTransaction

Get balance for an address

grpcurl \
  -d '{"owner":"0x...","coin_type":"0x2::sui::SUI"}' \
  sui.01.ro:443 \
  sui.rpc.v2beta2.LedgerService/GetBalance

Proto 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.
// Public RPC / Premium

When fair-use isn't enough.

If you're building something serious on top of these endpoints — an indexer, a wallet, a trading bot, an analytics product — talk to us. We provision per-tenant capacity on the same nodes, with a contracted SLA and a named technical owner.

bolt

Dedicated throughput

Per-key rate limits sized to your workload, IP allowlist, header auth, usage metering with monthly reports. No noisy-neighbor effects.

storage

Archive + custom indexers

Full archive nodes, historical state queries, custom indexer schemas, snapshot delivery (tar.lz4 / tar.zst). We can run bespoke read paths on request.

verified_user

Write-capable endpoints

Transaction submission, sponsored-transaction support, gas station integration. Hardened for production wallets and exchanges.

support_agent

SLA + named owner

Contracted uptime, P1 <15min ack, monthly performance review. Same model as our enterprise validator clients — see Integration / Onboarding.

// Infrastructure / RPC endpoints

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.

ProtocolsJSON-RPC · gRPC · EVM JSON-RPC · WebSocket
AuthAPI key header · IP allowlist
MonitoringSub-second eBPF probes
// Infrastructure / Chain snapshots

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.

Formattar.lz4 / tar.zst
RefreshDaily per chain
PruningPruned · Archive on request
// Infrastructure / Access tiers

Access tiers for RPC & Snapshots.

Public (roadmap)

Q3 2026

Rate-limited JSON-RPC and gRPC for light integrations. IP-based throttling, no auth.

API-keyed

Available

Per-key rate limits, header auth, usage metering, documented per-method quotas.

Dedicated

Available

Isolated endpoints per client, IP allowlist, private peering available, contracted under SLA.

// Integration / Onboarding flow

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.

01

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.

02

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.

03

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.

04

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.

05

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.

// Integration / Provisioning

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.
// Integration / Support model

How support works after go-live.

support_agent

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.

monitoring

Quarterly review

90-minute executive review every quarter: performance vs. SLA, incidents and root cause, roadmap alignment, upcoming chain upgrades that affect your stack.

priority_high

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.

update

Chain upgrade coordination

Protocol upgrades tested on our internal testnet before production. Clients get upgrade notifications 72h ahead with impact analysis.

// Integration / Security & compliance

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