Quickstart

# Cargo.toml
[package]
name = "cloak-quickstart"
version = "0.1.0"
edition = "2024"

[dependencies]
cloak-sdk = { git = "https://github.com/cloak-ag/rustsdk" }
tokio = { version = "1", features = ["rt-multi-thread", "macros"] }
anyhow = "1"
solana-keypair = "3.1"

use std::sync::Arc;

use cloak_sdk::{
    constants::{MIN_DEPOSIT_LAMPORTS, NATIVE_SOL_MINT},
    core::{
        transact::{transact, TransactOptions},
        utxo::{Utxo, UtxoKeypair},
    },
    rpc::SolanaRpc,
};
use solana_keypair::Keypair;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // ---- 1. Wire up RPC + payer -----------------------------------------
    let rpc = Arc::new(SolanaRpc::new("https://api.mainnet-beta.solana.com"));
    let payer = Arc::new(Keypair::new()); // replace with a funded keypair

    // ---- 2. Create the output UTXO --------------------------------------
    // A UTXO is a (keypair, amount, mint) triple. The keypair is local-only
    // — save it somewhere durable, it's how you'll spend this note later.
    let utxo_kp = UtxoKeypair::generate()?;
    let output = Utxo::new(MIN_DEPOSIT_LAMPORTS, utxo_kp, NATIVE_SOL_MINT)?;

    // ---- 3. Describe the transaction ------------------------------------
    let opts = TransactOptions {
        // Flow shape: no inputs, one output, external_amount > 0 = deposit.
        inputs: vec![],
        outputs: vec![output],
        external_amount: MIN_DEPOSIT_LAMPORTS as i64,

        // Handles
        rpc: Some(rpc),
        payer: Some(payer),
        relay_url: Some("https://api.cloak.ag".into()),

        ..Default::default()
    };

    // ---- 4. Run the engine ----------------------------------------------
    let result = transact(opts).await?;

    println!("signature: {}", result.signature);
    println!("output commitments: {:?}", result.output_commitments);
    println!("assigned leaf indices: {:?}", result.output_indices);

    // Cache the post-tx Merkle tree for the next transact to skip
    // `/commitments` on the next call:
    if let Some(tree) = &result.cached_merkle_tree {
        println!("cached tree has {} leaves", tree.len());
    }

    Ok(())
}

let first = transact(deposit_opts).await?;

let transfer_opts = TransactOptions {
    // Spend the output we just created
    inputs: vec![/* the Utxo with its keypair, index set to first.output_indices[0] */],
    outputs: vec![/* one new output for the recipient, one zero-UTXO change */],
    external_amount: 0, // shield-to-shield transfer
    cached_merkle_tree: first.cached_merkle_tree,
    address_lookup_table_accounts: first.address_lookup_table_accounts,
    ..base_opts
};

let second = transact(transfer_opts).await?;