strata-sdk

The official async Rust client for live Strata markets and Sonar quotes.

Install

[dependencies]
strata-public-contract = "0.2"
strata-sdk = "0.2"

Request a Sonar quote

use strata_public_contract::{QuoteRequest, QuoteSide, DEFAULT_MAXIMUM_TOLERANCE_BPS};
use strata_sdk::StrataClient;

# async fn run() -> Result<(), Box<dyn std::error::Error>> {
let strata = StrataClient::production()?;

// Exact input: sell 0.01 SOL, receive at least `minimum_output_atoms` USDC.
let quote = strata
    .quote(QuoteRequest {
        market_id: "SOL/USDC".into(),
        side: QuoteSide::Sell,
        amount_in_atoms: Some("10000000".into()),
        amount_out_atoms: None,
        maximum_tolerance_bps: DEFAULT_MAXIMUM_TOLERANCE_BPS,
    })
    .await?;

println!("Sonar output: {}", quote.amount_out_atoms);
println!("Minimum:      {}", quote.minimum_output_atoms);
println!("Price impact: {}%", quote.price_impact_pct);

// Exact output: buy 1 SOL. Strata inverts its best route and returns the USDC
// that delivers it as `amount_in_atoms`; `maximum_tolerance_bps` is the usual
// optional lower floor (zero → exactly 1 SOL or the execution fails closed).
let buy_one_sol = strata
    .quote(QuoteRequest {
        market_id: "SOL/USDC".into(),
        side: QuoteSide::Buy,
        amount_in_atoms: None,
        amount_out_atoms: Some("1000000000".into()),
        maximum_tolerance_bps: DEFAULT_MAXIMUM_TOLERANCE_BPS,
    })
    .await?;
println!("Spend USDC atoms: {}", buy_one_sol.amount_in_atoms);
# Ok(())
# }

Sonar returns one Strata quote with expected user-net output, consumed input, fees, user-net minimum output, price impact, and expiry in one typed result. Gross route output for an external route-quality comparison is exactly amount_out_atoms + output_fee_atoms; all-in user comparisons use amount_out_atoms.

Client operations

Manage Strands and Currents

Both maker products use the same custody-safe flow: request exact transaction bytes, verify and sign those bytes outside Strata, then submit the signed transaction with an idempotency key. The Rust SDK exposes every live control:

use strata_public_contract::{
    PlatformMakerControlSubmitRequest, PlatformMakerCurrentPrepareRequest,
    PlatformMakerStrandPrepareRequest,
};

# async fn run() -> Result<(), Box<dyn std::error::Error>> {
# let strata = strata_sdk::StrataClient::production()?;
# let market_id = "market_33333333333333333333333333333333";
# let maker_wallet = "5Ji61Fbeb22Yntgv1hhHeSSLgdEdZchHeM1Tv1MjGhSL";
let prepared = strata
    .platform_maker_strand_prepare(
        market_id,
        PlatformMakerStrandPrepareRequest::Cancel {
            maker_wallet: maker_wallet.into(),
        },
    )
    .await?;

// Verify `prepared.transaction_base64`, sign it in your wallet or signer, then:
# let signed_transaction_base64 = "AQ==";
let submitted = strata
    .platform_maker_strand_submit(
        market_id,
        PlatformMakerControlSubmitRequest {
            maker_control_id: prepared.maker_control_id,
            signed_transaction_base64: signed_transaction_base64.into(),
            idempotency_key: "strand-cancel-1".into(),
        },
    )
    .await?;

// Current uses the identical prepare/sign/submit boundary.
let _current = strata
    .platform_maker_current_prepare(
        market_id,
        PlatformMakerCurrentPrepareRequest::Cancel {
            maker_wallet: maker_wallet.into(),
        },
    )
    .await?;
# let _ = submitted;
# Ok(())
# }

Upserts use PlatformMakerStrandPrepareRequest::Upsert or PlatformMakerCurrentPrepareRequest::Upsert. Amounts are base-asset atoms, encoded as unsigned decimal strings. platform_maker_status_for_wallet(...) reports the resulting live controls, remaining exposure, expiry, and health.

Token amounts use unsigned decimal strings in atomic units. The client validates contract compatibility, quote binding, lifetime, and economic fields before returning data to the caller.

The 2.0 methods use stable product identities and the Strata book. They expose no private implementation details. Signed account reads use Strata's server time and exact SDK-generated authorization bytes; wallet keys remain in the agent owner's AccountSigner implementation.

maximum_tolerance_bps is yours: the most you accept below the quoted output, 0 by default (DEFAULT_MAXIMUM_TOLERANCE_BPS), applied in minimum_output_atoms and echoed back on the quote. price_impact_pct is measured: how far the quoted fills' average price sits from the best price before your order. They are unrelated — a quote can show 0 impact with a 25 bps tolerance, or 40 bps of impact with 0 tolerance.

Terminal companion

cargo install strata-agent-cli

strata-agent markets
strata-agent quote --market SOL/USDC --side sell --amount-atoms 10000000

Add --json for scripts, pipes, and agents.

Execution uses external-owner implementations of SessionSigner and ExecutionVerifier. execute_quote(...) is one signature per action: it prepares directly from the quote binding (no challenge, no message signature), validates the quote, minimum output, expiry, prepared response, and receipt, and calls the verifier before the session adapter can sign the transaction. It never accepts private key bytes. The agent owner controls permission and signer policy; MCP exposes the same prepare and submit operations when live capabilities allow them. The two-step challenge path (execution_challenge + ExecutionPrepareRequest::Authorized) remains available, with validate_execution_authorization to check the payload before signing it.

Resting-order actions use the same external-owner boundary. The high-level execute_order(...) helper sends the operation itself to orders/prepare (PlatformOrderPrepareRequest::Direct), checks the prepared market, action, and order IDs against the request, then requires an OrderVerifier before requesting the one transaction signature. DefaultTransactionVerifier is the built-in verifier: it decodes the base64 v0/legacy transaction without any RPC and refuses to sign unless the session key co-signs without paying fees, the owner wallet is not asked to sign, the session signs only Vault-delegated instructions of one program (never a system, token, or other well-known program), and every delegated place/cancel matches the requested sides, prices, sizes, order types, order IDs, and market exactly. Supply your own verifier for stricter policies; the context carries the bound operation, market_id, the prepared response, and (two-step path only) the challenge.

TWAP actions follow the same pattern. execute_twap(...) prepares directly from the action, checks the prepared bindings, then requires a TwapVerifier (DefaultTransactionVerifier applies the structural checks) before the session adapter signs the one transaction.

See the workspace README for the complete guide.