Rust SDK

tapehouse-sdk gives you alloy contract instances for Tapehouse's contracts at the addresses of a chain's registry, plus typed helpers for the reads and quotes that need more than one call. A method on an instance builds a typed call or transaction, which you .call() or .send() through your own alloy provider and signer.

Read and send#

use alloy::providers::ProviderBuilder;
use tapehouse_sdk::{Deployments, Tapehouse, to_bytes32};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let deployments = Deployments::load("deployments/46630.json")?;
    let provider = ProviderBuilder::new()
        .connect_http("https://rpc.testnet.chain.robinhood.com".parse()?);
    let tapehouse = Tapehouse::new(provider, deployments);

    let quote = tapehouse.band()?.quote(to_bytes32("TSLA")?).call().await?;
    println!("{} {} {}", quote.state, quote.low, quote.high);
    Ok(())
}

To send, give the provider a wallet (ProviderBuilder::new().wallet(signer)) and send the call the instance builds:

use alloy::primitives::U256;
use tapehouse_sdk::CROSS;

let receipt = tapehouse
    .accounts()?
    .borrow(CROSS, U256::from(50_000_000u64), account, account)
    .send()
    .await?
    .get_receipt()
    .await?;

An asset is its symbol as &str, turned into a B256 with to_bytes32. A position is CROSS or an asset's B256. Amounts are U256 in raw units. A fallible method returns tapehouse_sdk::Result.

Registry#

Tapehouse#

Tapehouse::new(provider, deployments) takes an alloy Provider + Clone. Its accessors return alloy instances generated with sol! from the contracts' ABIs, so every function of the contract is a method on them.

The bindings in tapehouse_sdk::bindings also cover the margin engine, the liquidator, the gap backstop, the reopening auction, the stock lending vault, the supply vault, Morpho Blue, Uniswap's QuoterV2, the sponsor paymaster, WETH and the Stock Token registry.

Helpers#

These are on Tapehouse and do what an instance cannot do in one call.

Layer is { notional, deductible_bps, limit_bps }. PackageSource is a trait with one method, payload(&self, feed_ids: &[&str]), that returns the signed RedStone payload as Bytes.

Errors#

tapehouse_sdk::Error is Registry, Argument, Revert, Unexpected, Contract and Source. A call that fails inside alloy converts to Error::Revert when its revert data matches an error of the contracts. decode_revert(&alloy::contract::Error) and decode_revert_data(&[u8]) return the Revert { name, args, data }. See errors.

use tapehouse_sdk::decode_revert;

if let Some(revert) = decode_revert(&error) {
    println!("{revert}");
}

Example#

crates/sdk/examples/devnode.rs runs the crate against a local Nitro dev node: PRIVATE_KEY=0x… cargo run --example devnode -- RPC_URL DEPLOYMENTS_JSON PAYLOAD_FILE. It reads the key from the environment, never from an argument.

Next#

• SDKs overview: the three SDKs side by side.
• Errors: decode a revert and fix it.
• Quickstart: the first read in each language.