Quick Start - Tapedrive

This guide connects the Rust SDK to Tapenet, reserves a tape, writes a file, and reads it back. You’ll need the crate installed and a connection to Tapenet. Current network details are on the networks page.

Fund a wallet

Complete the wallet and funding setup and use that wallet as the payer in your SDK client. Local Tapedrive isn’t released yet, so this guide runs against Tapenet. Check the wallet’s SOL and TAPE balances before writing:

let client = Tapedrive::new(rpc, payer);
let sol = client.sol_balance().await?;   // in lamports
let tape = client.tape_balance().await?; // missing accounts read as zero

Set up a wallet and client

Create or load the Solana keypair that signs everything and owns the tape, then build the client. The full client takes an RPC connection and your keypair as payer. If you only read, a gateway endpoint is enough. No keypair needed.

use tape_sdk::Tapedrive;

let payer = read_keypair_file("~/.config/solana/id.json")?;
let client = Tapedrive::new(rpc, payer);                          // full client
let reader = Tapedrive::new_gateway_read_only(rpc, GATEWAY_URL)?; // gateway reads, no keypair

Reserve a tape

The one payment step. Create the tape’s key (or derive its address from your wallet), price the reservation, then reserve capacity for a duration. What you get back is a tape controlled by that key, with room for the uploads that follow.The tape key is the tape: store it like you store the data (why).

let tape = TapeKey::generate();
let cost = client.estimate_cost(capacity, epochs).await?;
client.reserve(&tape, capacity, epochs).await?;
println!("tape: {}", tape.address());

Write

One call writes a file. The SDK picks the path by size: small data rides inside the transaction, larger data is erasure-coded, and very large data streams in segments (how the paths work). This example uses a file big enough to take the erasure-coded path.The write certifies the track before it returns. Certification is the network’s proof that your data is held: a quorum of the storage nodes that received your slices signs, and that aggregate signature lands on-chain (what certification promises).The receipt carries the manifest address, which the last step reads back.

let data = std::fs::read("photo.jpg")?;
let receipt = client.write_bytes(&tape, &data).await?;
println!("manifest track: {}", receipt.manifest);

Read it back

Two ways to get your bytes: through the SDK by track address, or from any gateway over plain HTTP. The address is the same in both.

let bytes = client.read_bytes(&receipt.manifest).await?;
assert_eq!(bytes.len(), data.len());

curl "$TAPE_GATEWAY/object/<track-address>" -o photo.jpg

Where to go next

You’ve connected, reserved, written, and read back. From here: reading and writing for everything those flows can do, objects for the S3-style layer, and docs.rs for every method.

​Where to go next

Where to go next