Rust

​

Who this is for

• Rust services and backends.
• Authors of tooling around the node or the programs.
• Anyone who wants the reference implementation: everything documented anywhere in this section exists here first.

​

Installation

[dependencies]
tape-sdk = "0.4"

​

The client

use tape_sdk::Tapedrive;

let payer = read_keypair_file("~/.config/solana/id.json")?;
let client = Tapedrive::new(rpc, payer);
let reader = Tapedrive::new_read_only(rpc);
let gw = Tapedrive::new_gateway_read_only(rpc, GATEWAY_URL)?;
let instrumented = Tapedrive::new(rpc, payer).with_metrics(my_metrics);

​

The modules

• Writes: write / write_bytes / write_stream and their write_named counterparts, size-dispatched, with AsyncRead sources for streams (writing). Track-level control: write_track / write_named_track / write_raw for callers choosing the path explicitly.
• Reads: read_bytes / read_into for whole content into a buffer or an AsyncWrite sink; track-level read and verify for commitment checks (reading).
• Tape lifecycle: reserve with the estimate_cost / reservation_cost / remaining_epochs pricing helpers; get_tape; extend_expiry / extend_capacity (permissionless); set_tape_delegate / revoke_tape_delegate (tapes).
• Tracks: get_track, get_track_by_number, find_track, list_tracks_by_tape, get_track_proof, delete (tracks).
• Objects: put_object, get_object / get_object_into, head_object, list_objects with the query builder (prefix, delimiter, cursor, limit), delete_object (objects).
• Gateway: the gateway-backed client for read-side consumers, constructed read-only against a gateway endpoint and exposing the same read methods (gateway API).
• Stream: the segment and manifest machinery under stream writes: manifest types, receipts, stream readers (streams).
• Staking: node and delegation staking operations (token economics).
• Keys: TapeKey and stake-key types with generation, persistence, and address derivation.
• Codec, transfer, error, metrics: on-chain state codecs, the slice upload/download and certify machinery behind writes, the TapedriveError type every method returns, and the metrics trait for instrumentation.

// end to end, natively; every write path certifies before returning
let tape = TapeKey::generate();
let cost = client.estimate_cost(capacity, epochs).await?;
client.reserve(&tape, capacity, epochs).await?;

let track = client.put_object(&tape, "hello.txt", b"hello", Some("text/plain")).await?;

let listing = client.list_objects(&tape.address(), ListObjectsQuery::new("")).await?;
let bytes = client.get_object(&tape.address(), "hello.txt").await?;

​

Certified writes