SDK

Turn strategy into execution.

Build agents that trade, quote, settle, and react to orderbook events without wiring Canton infrastructure from scratch.

Start buildingRead the SDK docs

Start with CLI, configure in agent.toml, and move from local testing to live execution.

Agent-ready CLI

Onboard, configure, and run agents through a developer-first command line flow.

Reusable crates

Build custom agents, tools, and integrations from core SDK components.

Trading modes included

Start with RFQ, grid market making, taker loops, and DvP-native settlement flows.

Keys stay local

Prepared transactions are verified before signing, keeping execution controlled.

Why the SDK exists

Stop rebuilding the agent stack

Building agents on Canton requires orderbook access, signing, settlement tracking, gRPC communication, state persistence, and failure handling. Silvana SDK packages those primitives into a developer stack focused on strategy logic.

Without the SDK

Orderbook wiring

Agents need to submit orders, read market data, track fills, and subscribe to order and settlement updates.

Settlement complexity

DvP settlement requires coordinated steps, allocation handling, lifecycle tracking, and safe completion.

Signing boundaries

Automation requires local signing and transaction verification rather than blind execution authority.

Agent state

Production agents need persistence, balance providers, order tracking, queues, caches, and recovery logic.

With Silvana SDK

One agent runtime

Orderbook access, settlement, signing, gRPC, state, and recovery — packaged behind a developer stack, so you focus on strategy logic.

From config to running agent

Configure once. Run continuously.

The SDK flow starts with setup, moves through agent configuration, and ends with a long-running agent that can quote, trade, and settle.

  1. 1

    Install or build

    Download the cloud-agent binary for your platform or build the CLI from source.

  2. 2

    Onboard

    Register the agent, connect it to the Silvana environment, and generate the local configuration required to run.

  3. 3

    Configure

    Edit agent.toml with market, spread, size, levels, limits, and strategy behavior.

  4. 4

    Run

    Start the agent and let it submit orders, respond to RFQs, stream settlement events, and execute DvP workflows.

  5. 5

    Extend

    Use reusable crates and gRPC clients to build custom logic beyond the default agent modes.

# agent.toml — your strategy, in one file
[market]
pair     = "CC/USDC"
mid      = "orderbook"

[grid]
spread   = 0.0008
levels   = 6
size     = 2_500
rebalance = "on_move"

[signing]
mode     = "local"  # key never leaves the agent
Agent capabilities

Build agents that actually trade

Silvana SDK is built around real orderbook and settlement workflows, not demo-only automation.

Trading logic

Trader-facing
Orderbook access

Submit orders, read market data, and subscribe to orderbook, order, and settlement updates.

RFQ trading

Compute quotes, validate balances, accept quote flows, and respond to private requests in real time.

Grid market making

Place limit orders across configured price levels around the mid price and adjust as conditions change.

Taker execution

Run buy and sell flows that request quotes, accept the best offer, and settle through the same atomic flow.

Settlement logic

Trader-facing
DvP settlement

Coordinate Delivery-versus-Payment so both sides complete together or the flow rolls back.

Settlement streams

Track RFQs, preconfirmations, settlement proposals, lifecycle events, and outcomes through continuous updates.

Signing and safety

Developer-facing
Local signing

Sign prepared transactions inside the agent environment upon verification.

Extension layer

Developer-facing
Extensible libraries

Reuse core crates to build custom agents, trading tools, settlement handlers, and integrations.

Trading modes

Start with proven modes

Use ready-made flows first, then customize the strategy logic as your agent becomes more specialized.

RFQ buy · 25,000 CCexpires 0:24
Quoted price0.0808
Best offer acceptedmulticall
Settled atomically · DvP

RFQ buy and sell

Request quotes on supported pairs, accept the best offer, and settle atomically through a multicall.

SDK architecture

Built from reusable parts

Silvana SDK exposes the building blocks needed to run agents, verify transactions, sign messages, talk to the orderbook, and coordinate settlement.

Your agent logic
agent-logic

Base config, settlement backend traits, balance provider traits, liquidity manager, orderbook clients, order tracking, settlement execution, and state persistence.

ConfigSettlementBackendBalanceProviderLiquidityManager
cloud-agent

A ready agent backend with cloud settlement support, DAppProviderClient, multicall settlement, RFQ handling, payment queues, amulet cache, fill loops, and onboarding helpers.

DAppProviderClientMulticallRfqHandlerFillLoop
orderbook-proto

Generated gRPC clients, protobuf types, market data, orders, settlement proposals, token balances, and reflection descriptors.

MarketDataOrdersSettlementProposalReflection
message-signing

Canonical Ed25519 signing helpers, verification utilities, and payload builders for DAppProviderService RPCs.

Ed25519verifyPayloadBuilder
tx-verifier

Verify and hash Canton transactions before signing through independent transaction verification and layered SHA-256 hashing.

verify_txsha256_layered
Silvana gRPC service · Canton DvP settlement
Developer workflow

From idea to live agent

The SDK supports the full loop from local setup to production-ready execution — agent development is iterative.

01

Prototype

Start with an example agent, default configuration, and quickstart commands.

02

Simulate

Use Playground or mock feeds to test strategy behavior before real execution.

03

Configure

Tune agent.toml with markets, spreads, levels, size, strategy rules, and limits.

04

Run

Launch the agent locally or in a controlled runtime and stream orderbook and settlement events.

05

Verify

Use transaction verification, local signing, and status outputs before execution.

06

Scale

Move from a single strategy to custom agents, integrations, or TEE-backed deployments.

Safety and signing

Automate without blind signing

The SDK is designed for agents that can act continuously while keeping execution bounded by verification, local signing, and settlement rules.

  1. Step 1

    Prepared first

    Transactions are prepared before signing, so agents can inspect what will be executed.

  2. Step 2

    Verified before signing

    The agent can verify prepared transactions and hashes before approving execution.

  3. Step 3

    Signed locally

    Private keys stay inside the agent environment instead of being passed to Silvana.

    Your key never leaves the agent
  4. Step 4

    Executed through Silvana gRPC

    Ledger operations are proxied through Silvana gRPC, so agents do not need direct ledger access.

  5. Step 5

    Settled through DvP

    Settlement completes atomically through Canton-native DvP when all conditions are met.

  6. Step 6

    Tracked through streams

    Agents follow lifecycle events, settlement status, and outcomes without polling.

No-code to custom agents

Choose your build depth

Start with the ready cloud-agent, configure strategy behavior, or compose your own agent from SDK crates.

01

Run the cloud-agent

Use the ready binary to onboard, request faucet funds, buy or sell through RFQ, and start LP mode.

Open quickstart
02

Configure a strategy

Edit agent.toml to set markets, spreads, grid levels, size, and risk parameters.

View configuration
03

Build with crates

Use agent-logic, cloud-agent, orderbook-proto, message-signing, and tx-verifier to compose custom tools and agents.

Explore SDK crates
04

Connect to gRPC APIs

Use the Silvana gRPC surface for execution, pricing, settlement, ledger gateway, and supporting API flows.

View gRPC API
gRPC API area

Connect deeper when needed

The SDK works with Silvana's gRPC layer, giving developers access to the lower-level surfaces required for custom agent and application logic.

01

gRPC API types

Shared types, enums, messages, and data structures used across Silvana services.

02

Execution API

Operations for transaction preparation, execution, orderbook interaction, and agent-driven workflows.

03

Pricing API

Price and quote-related data for strategies, RFQ flows, and execution decisions.

04

Settlement API

Settlement proposals, DvP lifecycle events, allocation logic, and finalization status.

05

Ledger Gateway API

Canton-facing ledger access through Silvana's controlled service layer.

06

News API

External signal and market context data for agents that rely on informational triggers.

Who the SDK is for

Built for agent builders

Silvana SDK is designed for developers who want to build real agents, not just connect to an interface.

Strategy developers

Turn trading logic into agents that place orders, respond to RFQs, and react to fills.

agent.tomlRFQGrid

Liquidity teams

Run grid and RFQ agents while keeping strategy parameters controlled and configurable.

GridRFQDvP

Product engineers

Add agent execution, settlement tracking, and orderbook automation into Canton applications.

gRPCCLIDvP

Infrastructure teams

Build custom runtimes, signing flows, monitoring tools, and settlement-aware integrations.

Local signingTEEgRPC
Connected products

Connect the rest of the stack

SDK is the build layer for agents that interact with Silvana Book, Agentic API, and EarnHub.

Silvana Book

Use the SDK to build agents that submit orders, manage RFQs, run grid strategies, and track settlement events.

Explore Silvana Book

Agentic API

Use the API layer for payments, DvP, transfers, multicall workflows, user services, and backend execution.

Explore Agentic API

EarnHub

Connect settled trading activity to seasonal progress, leaderboard movement, and reward opportunities.

Open EarnHub
Docs strip

Go deeper into the SDK

Read the technical guides for setup, configuration, agent flow, signing, and custom development.

SDK introUnderstand the SDK entry point and how it abstracts orderbook and settlement communication.Silvana Book AgentLearn how automated orderbook workflows manage orders, execution, and settlement end-to-end.QuickstartInstall the cloud-agent, onboard, request faucet funds, run RFQ buy and sell flows, and start LP mode.Agent sampleUse an example agent as a base for your own deployment.ConfigurationTune agent.toml for market, spread, size, levels, and strategy behavior.CLI referenceReview commands for onboarding, balances, RFQ buy and sell, faucet, and agent mode.Trading modesUnderstand RFQ, grid, taker loops, and long-running market-maker operation.Authentication and signingReview local signing, message authentication, and transaction verification.Security modelUnderstand how the SDK limits execution risk and protects signing boundaries.gRPC APIExplore lower-level endpoints for Silvana Book and execution workflows.

Not sure where to start?

Tell us whether you want to run a ready agent, configure a strategy, build custom crates, or integrate through gRPC, and we'll point you to the right SDK path.

Find your path
Get started

Build your first agent

Start with the SDK guide, run the cloud-agent, or open the docs to build a custom trading and settlement workflow.

Start buildingRead the SDK docs

Run the quickstart

Install the cloud-agent, onboard, request test funds, and run your first RFQ flow.

Open quickstart

Build custom logic

Use SDK crates, gRPC clients, local signing, and transaction verification to compose your own agent.

Explore crates