Open a market for any tokenized asset and buyers reach it from every chain at once. Funds never bridge; trades settle natively on both ledgers the moment they match, and every fill leaves a receipt anyone can verify end to end.
The whole stack runs on your hardware, your cloud, or a secure enclave. Builds are reproducible, so what you ship is provably what you audited.
$ just deploy --stack core
Point the settlement contracts at whichever chains your traders use. Audited templates, deployed by you, owned by you.
forge script Deploy.s.sol
The pieces connect over encrypted, mutually-authenticated channels out of the box. Nothing to hand-roll, nothing left open.
arborter.toml, signer.toml
Add any tokenized asset and set the rules for each pair yourself: pricing, fees, and how liquidity is kept in balance.
aspens-cli token add
Launch the order book and your asset is instantly purchasable from every connected chain. Live in minutes.
POST /v1/markets
Run the entire Aspens stack on your own infrastructure. Reproducible builds, signed releases, and remote attestation — so what you deploy is exactly what you audited.
Components: arborter, signer (TEE), rebalancer, aspens-sdk.
If it's tokenized, it trades. Pair any asset against any other across any supported ledger, and every buyer on those ledgers can reach it. No liquidity middlemen, no custodial bridges, no rehypothecated wrappers.
Native assets, stablecoins, RWAs, memecoins, LSTs, yield tokens. Any pairs, any ledgers.
Drop the SDK into your terminal, bot, or treasury workflow in under 50 lines. REST, gRPC, and TypeScript first — compose with whatever already runs your trading.
SDKs: TypeScript, Rust, Python. Transports: gRPC, REST, WebSocket.
// connect to your operator instance import { AspensClient } from "@aspens/sdk" const client = new AspensClient({ endpoint: "https://your-operator.aspens.xyz", market: "ETH-SOL", signer: teeSigner, }) await client.submitIntent({ side: "buy", size: 1.25, price: 0.0489, }) // matched, attested, settled
Scope a pilot with the engineers who built the stack: market design for your asset, onboarding from spec through your first live market, and a direct line whenever something needs an answer.
We onboard credible projects only.
Orders are matched across ledgers in microseconds, at the best available price, and nobody ever takes custody of your assets to do it. Price discovery happens at engine speed, not block time.
The moment a trade matches, it settles. No bridge to wait on, no overnight batch, no capital sitting locked in transit. Value moves the instant the match is signed, across chains as readily as within one: both legs execute against their own ledger's settlement contract at the same time, under a single signed intent.
Every fill produces a signed journal entry — engine version, signer attestation, route, latencies. Pull a report for any window and selectively disclose it to whoever needs to see it.
$ curl -X POST https://operator.aspens.xyz/v1/markets \ -H "Authorization: Bearer $OPERATOR_KEY" \ -H "Content-Type: application/json" \ -d '{ "pair": "ETH-SOL", "origin": { "chain": "ethereum", "token": "<WETH address>" }, "dest": { "chain": "solana", "token": "<wSOL mint>" }, "lot": "0.001", "tick": "0.00001", "fee_bps": 6 }' # 201 Created — market live $ aspens-cli market watch <market-id> # streams matched intents as they settle
{ "trade_id": "<id>", "market": "ETH-SOL", "timestamp": "<unix-ts>", "side": "buy", "size": "<size>", "price": "<price>", "execution": { "engine": "arborter", "latency": "<ms>", "hops": ["eth-mainnet", "solana-mb"] }, "proof": { "tee": "intel-sgx", "attestation": "<quote>", "signer_pk": "<pubkey>", "verified": true } }
Each trade emits a signed journal entry — engine version, signer attestation, route, latencies. Selectively disclose the trade journal: replay it locally or hand over a complete window on demand.
Fills settle the moment they're signed. No waiting on a bridge, no overnight batches — value moves between counterparties at the speed of the match itself.
A real central limit order book under the hood, resolving pairs across ledgers in microseconds. Price discovery happens at engine speed, not block time.
Every intent, every match, every settlement leaves a signed receipt — one canonical history, replayable bit for bit. Pull a complete report for any window and use selective disclosure to share exactly what's needed, with exactly who needs it.
Your hardware, your keys, your policy. We ship the stack. You run it under whatever jurisdiction, uptime regime, and customer agreement makes sense for you.
You never have to trust our word for what ran. Signing keys stay inside hardware-attested enclaves, and the system can prove its code, its inputs, and the exact trade it produced to anyone, on demand.
If you have an asset that needs buyers on every chain, a short call will tell you what a pilot market looks like for it. Every note gets a reply.