Struct LiteClient 

pub struct LiteClient { /* private fields */ }

A light Swarm client: a read endpoint, plus an optional stamped node for uploads.

Implementations

impl LiteClient

pub fn read(endpoint: &str) -> Result<Self>

Build a read client pointed at endpoint (a public gateway or any Bee HTTP base URL).

Examples found in repository

examples/read.rs (line 17)

async fn main() -> anyhow::Result<()> {
    let reference = std::env::args()
        .nth(1)
        .expect("usage: read <reference> [path]");
    let path = std::env::args().nth(2);
    let gateway = std::env::var("BEE_GATEWAY")
        .unwrap_or_else(|_| "https://download.gateway.ethswarm.org".into());

    let scout = LiteClient::read(&gateway)?;
    let data = match &path {
        Some(p) => scout.cat_path(&reference, p).await?,
        None => scout.cat(&reference).await?,
    };
    print!("{}", String::from_utf8_lossy(&data));
    Ok(())
}

examples/upload_and_feed.rs (line 16)

async fn main() -> anyhow::Result<()> {
    let file = std::env::args().nth(1).expect("usage: upload_and_feed <file>");
    let node = std::env::var("BEE_NODE").unwrap_or_else(|_| "http://localhost:1633".into());
    let stamp = std::env::var("BEE_STAMP").expect("set BEE_STAMP to a usable postage batch id");

    // Reads use the node here too; in practice the read endpoint can be a gateway.
    let scout = LiteClient::read(&node)?.with_write(&node, &stamp)?;

    let data = std::fs::read(&file)?;
    let file_ref = scout.up_bytes(data).await?;
    println!("uploaded:      {file_ref}");

    // A throwaway feed identity for the demo; persist this key to keep the handle.
    let (key, _owner, _pubkey) = scout::generate_key()?;
    let handle = scout.publish(&key, "example-feed", &file_ref).await?;
    println!("feed handle:   {handle}");
    println!("read latest:   scout cat {handle} --gateway {node}");
    Ok(())
}

pub fn with_write(self, node_endpoint: &str, stamp: &str) -> Result<Self>

Attach a write endpoint: a Bee node holding a usable postage batch (stamp, hex). Uploads go here; reads keep using the read endpoint.

Examples found in repository

examples/upload_and_feed.rs (line 16)

async fn main() -> anyhow::Result<()> {
    let file = std::env::args().nth(1).expect("usage: upload_and_feed <file>");
    let node = std::env::var("BEE_NODE").unwrap_or_else(|_| "http://localhost:1633".into());
    let stamp = std::env::var("BEE_STAMP").expect("set BEE_STAMP to a usable postage batch id");

    // Reads use the node here too; in practice the read endpoint can be a gateway.
    let scout = LiteClient::read(&node)?.with_write(&node, &stamp)?;

    let data = std::fs::read(&file)?;
    let file_ref = scout.up_bytes(data).await?;
    println!("uploaded:      {file_ref}");

    // A throwaway feed identity for the demo; persist this key to keep the handle.
    let (key, _owner, _pubkey) = scout::generate_key()?;
    let handle = scout.publish(&key, "example-feed", &file_ref).await?;
    println!("feed handle:   {handle}");
    println!("read latest:   scout cat {handle} --gateway {node}");
    Ok(())
}

pub async fn cat(&self, reference: &str) -> Result<Vec<u8>>

Download manifest-aware content at reference (GET /bzz/{ref}).

Examples found in repository

examples/read.rs (line 20)

async fn main() -> anyhow::Result<()> {
    let reference = std::env::args()
        .nth(1)
        .expect("usage: read <reference> [path]");
    let path = std::env::args().nth(2);
    let gateway = std::env::var("BEE_GATEWAY")
        .unwrap_or_else(|_| "https://download.gateway.ethswarm.org".into());

    let scout = LiteClient::read(&gateway)?;
    let data = match &path {
        Some(p) => scout.cat_path(&reference, p).await?,
        None => scout.cat(&reference).await?,
    };
    print!("{}", String::from_utf8_lossy(&data));
    Ok(())
}

pub async fn cat_path(&self, reference: &str, path: &str) -> Result<Vec<u8>>

Download one path inside a collection (GET /bzz/{ref}/{path}).

Examples found in repository

examples/read.rs (line 19)

async fn main() -> anyhow::Result<()> {
    let reference = std::env::args()
        .nth(1)
        .expect("usage: read <reference> [path]");
    let path = std::env::args().nth(2);
    let gateway = std::env::var("BEE_GATEWAY")
        .unwrap_or_else(|_| "https://download.gateway.ethswarm.org".into());

    let scout = LiteClient::read(&gateway)?;
    let data = match &path {
        Some(p) => scout.cat_path(&reference, p).await?,
        None => scout.cat(&reference).await?,
    };
    print!("{}", String::from_utf8_lossy(&data));
    Ok(())
}

pub async fn bytes(&self, reference: &str) -> Result<Vec<u8>>

Download raw bytes (GET /bytes/{ref}).

pub async fn up_file( &self, name: &str, content_type: &str, data: Vec<u8>, ) -> Result<String>

Upload a file (manifest-wrapped, POST /bzz). Returns the bzz reference as hex.

pub async fn up_bytes(&self, data: Vec<u8>) -> Result<String>

Upload raw bytes (POST /bytes). Returns the bytes reference as hex.

Examples found in repository

examples/upload_and_feed.rs (line 19)

async fn main() -> anyhow::Result<()> {
    let file = std::env::args().nth(1).expect("usage: upload_and_feed <file>");
    let node = std::env::var("BEE_NODE").unwrap_or_else(|_| "http://localhost:1633".into());
    let stamp = std::env::var("BEE_STAMP").expect("set BEE_STAMP to a usable postage batch id");

    // Reads use the node here too; in practice the read endpoint can be a gateway.
    let scout = LiteClient::read(&node)?.with_write(&node, &stamp)?;

    let data = std::fs::read(&file)?;
    let file_ref = scout.up_bytes(data).await?;
    println!("uploaded:      {file_ref}");

    // A throwaway feed identity for the demo; persist this key to keep the handle.
    let (key, _owner, _pubkey) = scout::generate_key()?;
    let handle = scout.publish(&key, "example-feed", &file_ref).await?;
    println!("feed handle:   {handle}");
    println!("read latest:   scout cat {handle} --gateway {node}");
    Ok(())
}

pub async fn up_dir( &self, folder: &str, index_document: Option<&str>, ) -> Result<String>

Upload a whole directory as a browsable Swarm collection (a mantaray manifest). index_document (e.g. index.html) is served as the default document at bzz/<ref>/. Returns the manifest reference. Needs a write endpoint (--stamp).

pub async fn publish( &self, key_hex: &str, topic: &str, reference: &str, ) -> Result<String>

Point a feed (key owner + topic) at reference and ensure a feed manifest exists. Returns the manifest reference — a stable handle that always resolves to the feed’s latest content. Read it later with LiteClient::cat; re-publishing updates what that same handle serves. Needs a write endpoint (--stamp).

Examples found in repository

examples/upload_and_feed.rs (line 24)

async fn main() -> anyhow::Result<()> {
    let file = std::env::args().nth(1).expect("usage: upload_and_feed <file>");
    let node = std::env::var("BEE_NODE").unwrap_or_else(|_| "http://localhost:1633".into());
    let stamp = std::env::var("BEE_STAMP").expect("set BEE_STAMP to a usable postage batch id");

    // Reads use the node here too; in practice the read endpoint can be a gateway.
    let scout = LiteClient::read(&node)?.with_write(&node, &stamp)?;

    let data = std::fs::read(&file)?;
    let file_ref = scout.up_bytes(data).await?;
    println!("uploaded:      {file_ref}");

    // A throwaway feed identity for the demo; persist this key to keep the handle.
    let (key, _owner, _pubkey) = scout::generate_key()?;
    let handle = scout.publish(&key, "example-feed", &file_ref).await?;
    println!("feed handle:   {handle}");
    println!("read latest:   scout cat {handle} --gateway {node}");
    Ok(())
}

pub async fn share( &self, name: &str, content_type: &str, data: Vec<u8>, grantees: &[String], ) -> Result<ShareInfo>

Upload data under an ACT and grant the given compressed-pubkey grantees. Returns the refs to download it (file_ref + history + publisher) and to manage access (grantee_ref). Needs --stamp.

pub async fn revoke( &self, grantee_ref: &str, history: &str, remove: &[String], ) -> Result<(String, String)>

Revoke remove grantees from a grantee list anchored at the upload’s history. Returns the new (grantee_ref, grantee_history). Needs --stamp.

pub async fn grantees(&self, grantee_ref: &str) -> Result<Vec<String>>

List the grantees of a grantee-list reference. Read-only.

pub async fn fetch_act( &self, file_ref: &str, publisher: &str, history: &str, ) -> Result<Vec<u8>>

Download ACT-protected content as publisher (their compressed pubkey) using the upload’s history. The Bee node decrypts — it must be the publisher or an authorised grantee. Read-only.