The Verity Client SDK is a Rust-based client library that enables interaction with the Verity Prover service. It’s built on top of the reqwest HTTP client and provides a convenient interface for making verifiable HTTP requests. To read the docs.rs documentation on the verity-client crate, please visit: https://usherlabs.github.io/verity-dp/packages/verity-client/doc/verity_client/index.html

​
Installation

Add the following to your Cargo.toml: 
[dependencies]
verity-client = "0.1.0"

​
VerityClient

The main client struct that handles all interactions with the Verity Prover service. It’s built upon reqwest and provides methods for making HTTP requests with built-in verification. 
let config = VerityClientConfig {
    prover_url: String::from("http://127.0.0.1:8080"),
};

let client = VerityClient::new(config);

​
Request Building

The SDK provides a builder pattern for constructing requests. You can:
  • Make GET and POST requests
  • Add headers
  • Set request bodies
  • Configure redaction rules

​
Making Requests

​
GET Request Example

Here’s how to make a simple GET request: 
let response = VerityClient::new(config)
    .get("https://api.example.com/data")
    .send()
    .await?;

​
POST Request with JSON

For POST requests with JSON payload: 
let response = VerityClient::new(config)
    .post("https://api.example.com/data")
    .json(&serde_json::json!({
        "userId": 1000,
        "firstName": "John"
    }))
    .send()
    .await?;

​
Data Redaction

The SDK supports redacting sensitive information from both requests and responses in the generated TLS proofs using the redact() method: 
let client = VerityClient::new(config);
let response = client
    .post("https://api.example.com/users")
    .redact(String::from("req:body:firstName, res:body:firstName"))
    .json(&user_data)
    .send()
    .await?;

​
Response Handling

The SDK returns a VerityResponse struct containing:
  • The original response (subject)
  • A proof of the request/response interaction (proof)
  • The notary’s public key (notary_pub_key)

​
Advanced Features

​
Notary Information

You can retrieve information about the connected notary: 
let notary_info = client.get_notary_info().await?;
println!("Notary Version: {}", notary_info.version);
println!("Public Key: {}", notary_info.public_key);

​
Response to Proof Timeout

The SDK implements a default proof timeout of 1000ms, after which it will cancel the proof awaiting process if no proof is received. This is the time to wait for a proof received over SSE connection since receiving HTTP response.

​
Error Handling

The SDK uses anyhow for error handling, providing detailed error information when requests fail. All async operations return Result types that should be properly handled: 
match client.get("https://api.example.com/data").send().await {
    Ok(response) => {
        println!("Response received with proof");
    },
    Err(e) => {
        eprintln!("Request failed: {}", e);
    }
}

​
Examples

​
Basic GET Request

#[tokio::main()]
async fn main() -> anyhow::Result<()> {
    let config = VerityClientConfig {
        prover_url: String::from("http://127.0.0.1:8080"),
    };

    let response = VerityClient::new(config)
        .get("https://jsonplaceholder.typicode.com/posts/98")
        .redact(String::from("res:body:dolor"))
        .send()
        .await?;

    println!("{:#?}", response);
    Ok(())
}

​
POST Request with Redaction

#[tokio::main()]
async fn main() -> anyhow::Result<()> {
    let config = VerityClientConfig {
        prover_url: String::from("http://127.0.0.1:8080"),
    };

    let response = VerityClient::new(config)
        .post("https://jsonplaceholder.typicode.com/posts")
        .redact(String::from("req:body:firstName, res:body:firstName"))
        .json(&serde_json::json!({
            "userId": 1000,
            "firstName": "John",
            "lastName": "Smith",
            "fullName": "John Smith"
        }))
        .send()
        .await?;

    println!("{:#?}", response);
    Ok(())
}

​
Technical Details

The SDK is built on several key components:
  • reqwest for HTTP client functionality
  • tokio for async runtime
  • serde for JSON serialization/deserialization
  • Event Source implementation for proof streaming
  • UUID v4 for request identification
For more detailed information about the implementation, refer to the source code, review the docs.rs, or contact the Usher Labs team.