Supported Networks & Protocols

Acceso supports networks and protocols through domain services. Each domain owns parsing, normalization, caching, and upstream failover.

“Supported” means you get stable schemas and consistent behavior. Upstreams can change without breaking your client contract.

What “support” means (practically)

You should expect these guarantees when a network or protocol is supported:

• Normalized schemas (same field names and types across venues).

• App-ready primitives (transfers, balances, market data, derived views).

• Consistent delivery (REST + SDKs, plus WebSockets/webhooks where relevant).

• Operational safety (timeouts, retries, caching, and consistent errors).

Related design docs

• High-Level System Overview

• Request Flow & Data Lifecycle

• Service Architecture

Supported today

Solana (network layer)

Acceso provides native Solana primitives and decoded, app-friendly views.

Coverage you can rely on

• Accounts and account state reads.

• Token standards and balances (SPL-focused normalization).

• Transactions parsed into higher-level events (transfers, fees, instructions).

• Program-level interactions surfaced as structured data (where applicable).

Why this matters

• You write fewer “if provider A vs provider B” branches.

• You can swap RPC vendors without rewriting client logic.

DeFi analytics (protocol layer)

Prediction markets (market layer)

How you consume coverage

Pick the delivery surface based on update frequency and latency needs.

• REST + SDKs for snapshots, historical queries, and analytics reads.

• WebSockets for low-latency streaming.

• Webhooks for event-driven workflows and async processing.

Avoid high-frequency polling for real-time needs. Use streams or webhooks. This reduces cost and rate-limit pressure.

How we add a new network, protocol, or venue (without breaking clients)

Acceso expands coverage behind stable contracts. This is the usual rollout shape:

1

1) Define the contract

We define the resource schema and semantics first. This is what stays stable for clients.

2

2) Build adapters and parsers

We add upstream adapters, decoders, and mapping logic. Vendor quirks stay internal.

3

3) Normalize and validate

We enforce consistent typing and naming. We add strict input validation at the gateway.

4

4) Add caching + derived views

We cache normalized payloads where safe. We compute aggregates (like OHLCV) as derived datasets.

5

5) Roll out safely

We ship behind version-aware routing. We add telemetry and degraded-mode behavior before widening traffic.

For how we evolve the platform over time: Platform Evolution Strategy

Want something added?

Share the network/protocol, required resources (e.g. trades, pools, balances), and freshness needs (snapshot vs real-time). That’s enough to scope an adapter + contract quickly.