Rust SDK

[dependencies]
# All 8 service features are enabled by default
tenzro-platform-rust-sdk = "1.0"

# Opt into the explicit full feature alias
tenzro-platform-rust-sdk = { version = "1.0", features = ["full"] }

# Select only the features you need (disables the rest)
tenzro-platform-rust-sdk = { version = "1.0", default-features = false, features = ["ai", "ledger"] }

use tenzro_platform::{TenzroPlatform, TenzroConfig, Network, TenzroError, Result};

use tenzro_platform::TenzroPlatform;

// 1. Direct construction — supply an API key and tenant ID
let platform = TenzroPlatform::new("tnz_mytenant_secret", "my-tenant-id")?;

// 2. From environment variables
//    TENZRO_API_KEY       — required
//    TENZRO_TENANT_ID     — optional; extracted from the key if absent
//    TENZRO_NETWORK       — optional; default "devnet"
//    TENZRO_BASE_URL      — optional; default "https://api.platform.tenzro.com"
//    TENZRO_TIMEOUT_MS    — optional; default 30000
let platform = TenzroPlatform::from_env()?;

// 3. From a TenzroConfig struct for full control
use tenzro_platform::{TenzroConfig, Network};

let config = TenzroConfig::new("tnz_mytenant_secret", "my-tenant-id")
    .with_network(Network::Mainnet)
    .with_base_url("https://api.platform.tenzro.com")
    .with_timeout(60_000);   // milliseconds

let platform = TenzroPlatform::from_config(config)?;

pub struct TenzroConfig {
    pub api_key:    String,   // format: tnz_{tenant}_{secret}
    pub tenant_id:  String,
    pub network:    Network,  // default: Network::Devnet
    pub base_url:   String,   // default: "https://api.platform.tenzro.com"
    pub timeout_ms: u64,      // default: 30_000 ms
}

// Builder-style setters (consume and return Self)
impl TenzroConfig {
    pub fn with_network(self, network: Network)   -> Self { ... }
    pub fn with_base_url(self, base_url: &str)    -> Self { ... }
    pub fn with_timeout(self, timeout_ms: u64)    -> Self { ... }
}

use tenzro_platform::Network;

// Three variants; Devnet is the default
Network::Devnet   // "devnet"  — GSF DevNet (default)
Network::Testnet  // "testnet" — GSF TestNet
Network::Mainnet  // "mainnet" — GSF MainNet

// Network::Devnet is the Default implementation
let config = TenzroConfig::new("tnz_mytenant_secret", "my-tenant-id");
assert_eq!(config.network, Network::Devnet);

use tenzro_platform::TenzroPlatform;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let platform = TenzroPlatform::new(
        "tnz_mytenant_secret",
        "my-tenant-id",
    )?;

    // AI time-series forecasting with TEE attestation
    let models = platform.ai().list_forecast_models().await?;
    println!("Available models: {:?}", models.len());

    // Canton Ledger operations
    let parties = platform.ledger().list_parties().await?;
    println!("Parties: {}", parties.len());

    // Cross-chain bridge routes
    let routes = platform.bridge().get_routes().await?;
    println!("Bridge routes: {}", routes.len());

    Ok(())
}

use tenzro_platform::TenzroPlatform;
use tenzro_platform::ai::{ForecastRequest, CreateSessionRequest, ContributeRequest};

let platform = TenzroPlatform::new("tnz_mytenant_secret", "my-tenant-id")?;

// List available forecast models
let models = platform.ai().list_forecast_models().await?;
for m in &models {
    println!("Model: {} (backend: {})", m.id, m.backend);
}

// Run a time-series forecast
let result = platform.ai().forecast(&ForecastRequest {
    context: vec![100.0, 112.0, 108.0, 125.0, 118.0, 130.0, 127.0],
    prediction_length: 5,
    model: "amazon/chronos-bolt-small".to_string(),
}).await?;

println!("Median forecast:  {:?}", result.predictions);
println!("10th percentile:  {:?}", result.low);
println!("90th percentile:  {:?}", result.high);

// Inspect TEE attestation on the result
if let Some(att) = &result.attestation {
    println!("TEE platform: {}", att.platform);
    println!("Attested:     {}", att.attested);
}

// Verify a TEE attestation quote independently
use tenzro_platform::ai::VerifyAttestationRequest;

let verification = platform.ai().verify_attestation(&VerifyAttestationRequest {
    quote: "0xdeadbeef...".to_string(),
    platform: Some("intel-tdx".to_string()),
}).await?;
println!("Attestation valid: {}", verification.valid);

// Multi-party confidential inference
let session = platform.ai().create_multiparty_session(&CreateSessionRequest {
    model_id: "amazon/chronos-bolt-small".to_string(),
    initiator: "party-A".to_string(),
    participants: vec!["party-A".to_string(), "party-B".to_string()],
}).await?;

// Each party contributes their private time-series data
platform.ai().contribute_data(&session.session_id, &ContributeRequest {
    party_id: "party-A".to_string(),
    data: vec![90.0, 95.0, 102.0, 98.0],
}).await?;

// Execute inference once all parties have contributed
use tenzro_platform::ai::ExecuteSessionRequest;

let output = platform.ai().execute_session(
    &session.session_id,
    &ExecuteSessionRequest { party_id: "party-A".to_string() },
).await?;
println!("Inference result: {:?}", output.result);

use tenzro_platform::TenzroPlatform;
use tenzro_platform::ledger::{
    AllocatePartyRequest, CreateContractRequest, ExerciseChoiceRequest,
    TransferRequest, UploadPackageRequest, CreateAllocationRequest,
};

let platform = TenzroPlatform::new("tnz_mytenant_secret", "my-tenant-id")?;

// Participant identity and network status
let identity = platform.ledger().get_identity().await?;
println!("Participant: {:?}", identity.participant_id);

let status = platform.ledger().get_status().await?;
println!("Connected: {:?}", status.connected);

// List all parties
let parties = platform.ledger().list_parties().await?;
for p in &parties {
    println!("Party: {} ({})", p.party_id, p.display_name);
}

// Allocate a new party
let new_party = platform.ledger().allocate_party(&AllocatePartyRequest {
    party_id_hint: "treasury".to_string(),
    display_name:  "Treasury Party".to_string(),
    annotations:   None,
    organization_id: None,
}).await?;
println!("Allocated: {}", new_party.party_id);

// Canton Coin balance
let balance = platform.ledger().get_balance(&new_party.party_id).await?;
println!("Unlocked CC: {:?}", balance.unlocked_cc);
println!("Total CC:    {:?}", balance.total_cc);

// Canton Coin transfer
let tx = platform.ledger().transfer(&TransferRequest {
    from_party_id: "party-1::abc123".to_string(),
    to_party_id:   "party-2::def456".to_string(),
    amount: "100.0".to_string(),
    asset:  "CC".to_string(),
}).await?;
println!("Transfer tx: {:?}", tx.transaction_id);

// Create a DAML contract
let contract = platform.ledger().create_contract(&CreateContractRequest {
    template_id: "MyModule:MyTemplate".to_string(),
    payload: serde_json::json!({ "owner": "party-1::abc123", "amount": 1000 }),
    party_id: "party-1::abc123".to_string(),
}).await?;
println!("Contract ID: {}", contract.contract_id);

// Exercise a choice on a contract
let result = platform.ledger().exercise_choice(
    &contract.contract_id,
    &ExerciseChoiceRequest {
        choice:   "Transfer".to_string(),
        argument: serde_json::json!({ "newOwner": "party-2::def456" }),
        party_id: "party-1::abc123".to_string(),
    },
).await?;
println!("Exercise success: {}", result.success);

// Query active contracts for a party
let contracts = platform.ledger()
    .query_contracts("party-1::abc123", Some("MyModule:MyTemplate"))
    .await?;
println!("Active contracts: {}", contracts.len());

// Upload a DAR package (base64-encoded .dar bytes)
let pkg = platform.ledger().upload_package(&UploadPackageRequest {
    name:    "my-app".to_string(),
    version: "1.0.0".to_string(),
    content: base64_dar_bytes.to_string(),
}).await?;
println!("Package ID: {:?}", pkg.package_id);

// List synchronization domains
let domains = platform.ledger().list_domains().await?;
for d in &domains {
    println!("Domain: {} — status: {}", d.domain_id, d.status);
}

// Resource allocation
let alloc = platform.ledger().create_allocation(&CreateAllocationRequest {
    app_id:        "app-123".to_string(),
    app_name:      "My Daml App".to_string(),
    network:       "devnet".to_string(),
    max_contracts: Some(10_000),
    ..Default::default()
}).await?;
println!("Allocation: {:?}", alloc.id);

// Transaction history
let txs = platform.ledger().get_transactions("party-1::abc123", Some(50)).await?;
for tx in &txs {
    println!("Tx: {} at {:?}", tx.transaction_id, tx.effective_at);
}

// Ledger statistics
let stats = platform.ledger().get_stats().await?;
println!("Active contracts: {:?}", stats.active_contracts);
println!("Total parties:   {:?}", stats.total_parties);

use tenzro_platform::TenzroPlatform;
use tenzro_platform::bridge::CreateOperationRequest;

let platform = TenzroPlatform::new("tnz_mytenant_secret", "my-tenant-id")?;

// Available cross-chain routes
let routes = platform.bridge().get_routes().await?;
for r in &routes {
    println!("Route: {:?}", r);
}

// Supported chains
let chains = platform.bridge().get_chains().await?;

// Transfer limits per route
let limits = platform.bridge().get_limits().await?;

// List bridge operations
let ops = platform.bridge().list_operations().await?;

// Bridge statistics
let stats = platform.bridge().get_stats().await?;

use tenzro_platform::TenzroPlatform;
use tenzro_platform::anchor::AnchorContractRequest;

let platform = TenzroPlatform::new("tnz_mytenant_secret", "my-tenant-id")?;

// Anchor a Canton contract state root to an EVM chain
let anchored = platform.anchor().anchor_contract(&AnchorContractRequest {
    contract_id: "00abc123...#1".to_string(),
    template_id: "MyModule:MyTemplate".to_string(),
    hash:        "sha256:0xdeadbeef...".to_string(),
    chain:       "ethereum".to_string(),
    party_id:    "party-1::abc123".to_string(),
}).await?;

println!("Anchor status: {:?}", anchored.status);
println!("On-chain tx:   {:?}", anchored.tx_hash);

// Retrieve the Merkle proof for independent verification
let proof = platform.anchor().get_proof(&anchored.contract_id).await?;
println!("Root hash:  {}", proof.root_hash);
println!("Proof path: {:?}", proof.proof);

// Verify the proof server-side
let verification = platform.anchor().verify_proof(&anchored.contract_id).await?;
assert!(verification.valid);

// List anchor batches
let batches = platform.anchor().list_batches().await?;
for b in &batches {
    println!("Batch: {:?} — contracts: {:?}", b.batch_id, b.contract_count);
}

// Anchor service statistics
let stats = platform.anchor().get_stats().await?;
println!("Total anchored:   {:?}", stats.total_contracts);
println!("Pending:          {:?}", stats.pending_anchors);
println!("Supported chains: {:?}", stats.supported_chains);

use tenzro_platform::TenzroPlatform;
use tenzro_platform::token::{CreateCollectionRequest, MintRequest};

let platform = TenzroPlatform::new("tnz_mytenant_secret", "my-tenant-id")?;

// Supported token standards (ERC-20, ERC-721, etc.)
let standards = platform.token().get_supported().await?;

// List token collections
let collections = platform.token().list_collections().await?;
for c in &collections {
    println!("Collection: {:?}", c);
}

// Token holdings for the current tenant
let holdings = platform.token().list_holdings().await?;

// Service statistics
let stats = platform.token().get_stats().await?;

use tenzro_platform::TenzroPlatform;
use tenzro_platform::wallet::{
    CreateWalletRequest, CreatePolicyRequest, WhitelistRequest,
    WalletSignRequest, ApproveRequest,
};

let platform = TenzroPlatform::new("tnz_mytenant_secret", "my-tenant-id")?;

// Governance configuration
let settings = platform.wallet().get_settings().await?;
println!("Governance enabled:  {:?}", settings.governance_enabled);
println!("Approval threshold:  {:?}", settings.default_approval_threshold);

// Create an MPC wallet
let wallet = platform.wallet().create_wallet(&CreateWalletRequest {
    name:        "Treasury MPC Wallet".to_string(),
    wallet_type: Some("mpc".to_string()),
    chain:       Some("ethereum".to_string()),
}).await?;

// Create a spending policy
let _policy = platform.wallet().create_policy(&CreatePolicyRequest {
    name:               "High-value transfers".to_string(),
    max_amount:         Some("10000.00".to_string()),
    daily_limit:        Some("50000.00".to_string()),
    required_approvals: Some(2),
}).await?;

// Whitelist a destination address
platform.wallet().add_to_whitelist(&WhitelistRequest {
    address: "0xabc123...".to_string(),
    label:   "Partner settlement account".to_string(),
}).await?;

// List pending approval requests
let approvals = platform.wallet().list_approvals().await?;
for approval in &approvals {
    println!("Pending: {:?} — amount: {:?}", approval.request_id, approval.amount);
}

// Approve a pending transaction
if let Some(req_id) = approvals.first().and_then(|a| a.request_id.as_deref()) {
    platform.wallet().approve(req_id, &ApproveRequest {
        comment: Some("Approved by treasury officer".to_string()),
    }).await?;
}

// MPC signing
let sig = platform.wallet().sign(&WalletSignRequest {
    wallet_id:    wallet.wallet_id.unwrap_or_default(),
    data:         "0xdeadbeef".to_string(),
    message_type: Some("transaction".to_string()),
}).await?;
println!("Signature: {}", sig.signature);

use tenzro_platform::TenzroPlatform;
use tenzro_platform::provision::{
    AllocatePartyRequest, CreateAppRequest, DeployAppRequest,
    UpdateAccessRequest, ListPartiesFilter,
};

let platform = TenzroPlatform::new("tnz_mytenant_secret", "my-tenant-id")?;

// List parties (paginated)
let response = platform.provision().list_parties(None).await?;
println!("Total parties: {:?}", response.total_count);
for p in &response.parties {
    println!("  {} — {:?}", p.party_id, p.network);
}

// Paginated request with filter
let filter = ListPartiesFilter {
    network:    Some("devnet".to_string()),
    page_size:  Some(20),
    page_token: None,
};
let page = platform.provision().list_parties(Some(&filter)).await?;
println!("Next page token: {:?}", page.next_page_token);

// Allocate a new party
// party_type values: 6 = Application
// network values:    1 = Devnet, 2 = Testnet, 3 = Mainnet
let allocation = platform.provision().allocate_party(&AllocatePartyRequest {
    tenant_id:         "my-tenant-id".to_string(),
    display_name:      "My App Party".to_string(),
    party_type:        Some(6),
    network:           Some(1),
    party_id_hint:     Some("myapp".to_string()),
    use_external_keys: None,
}).await?;

if allocation.success {
    println!("Allocated party: {:?}", allocation.party_id);
    println!("Participant:     {:?}", allocation.participant_id);
}

// Register a Daml application
let app = platform.provision().create_app(&CreateAppRequest {
    name:            "my-daml-app".to_string(),
    tenant_id:       "my-tenant-id".to_string(),
    description:     Some("My tokenization application".to_string()),
    deployment_type: Some("custom".to_string()),
    repository:      Some("https://github.com/my-org/my-daml-app".to_string()),
    endpoint:        None,
}).await?;
println!("App ID: {}", app.id);

// Request devnet access for the app
platform.provision().update_app_access(&app.id, &UpdateAccessRequest {
    network: "devnet".to_string(),
    status:  "requested".to_string(),
}).await?;

// Deploy to devnet once access is approved
let deploy = platform.provision().deploy_app(&app.id, &DeployAppRequest {
    network: "devnet".to_string(),
}).await?;

if deploy.success {
    if let Some(info) = &deploy.deployment {
        println!("Party ID:   {:?}", info.party_id);
        println!("Ledger API: {:?}", info.ledger_api_url);
        println!("JSON API:   {:?}", info.json_api_url);
    }
}

// Undeploy when done
use tenzro_platform::provision::UndeployAppRequest;

platform.provision().undeploy_app(&app.id, &UndeployAppRequest {
    network: "devnet".to_string(),
}).await?;

use tenzro_platform::{TenzroPlatform, TenzroError, Result};

let platform = TenzroPlatform::new("tnz_mytenant_secret", "my-tenant-id")?;

match platform.ledger().list_parties().await {
    Ok(parties) => {
        println!("Got {} parties", parties.len());
    }

    // Structured API error — includes HTTP status, machine-readable code, and message
    Err(TenzroError::Api { status, code, message }) => {
        eprintln!("API error {}: [{}] {}", status, code, message);
    }

    // HTTP 401 — invalid or expired API key
    Err(TenzroError::Unauthorized(msg)) => {
        eprintln!("Authentication failed: {}", msg);
    }

    // HTTP 404 — resource does not exist
    Err(TenzroError::NotFound(msg)) => {
        eprintln!("Not found: {}", msg);
    }

    // HTTP 429 — too many requests
    Err(TenzroError::RateLimited(msg)) => {
        eprintln!("Rate limited: {}", msg);
    }

    // Network/TLS/DNS failure from reqwest
    Err(TenzroError::Http(e)) => {
        eprintln!("HTTP transport error: {}", e);
    }

    // Invalid SDK configuration (e.g. bad header value)
    Err(TenzroError::Config(msg)) => {
        eprintln!("Configuration error: {}", msg);
    }

    // serde_json parse failure
    Err(TenzroError::Serialization(e)) => {
        eprintln!("Deserialisation error: {}", e);
    }

    // Request exceeded the configured timeout_ms
    Err(TenzroError::Timeout(msg)) => {
        eprintln!("Timeout: {}", msg);
    }

    // Caller-supplied argument rejected before any network call
    Err(TenzroError::InvalidArgument(msg)) => {
        eprintln!("Invalid argument: {}", msg);
    }
}

use tenzro_platform::{TenzroPlatform, PageRequest};
use tenzro_platform::pagination::{ContractFilter, ContractStatus, SortOrder};

let platform = TenzroPlatform::new("tnz_mytenant_secret", "my-tenant-id")?;

// Paginated party listing
let page = platform.ledger().list_parties_paged(PageRequest {
    page_size: Some(20),
    page_token: None,
    offset: None,
    sort_by: None,
    sort_order: Some(SortOrder::Desc),
}).await?;

println!("Got {} parties, has_more: {}", page.items.len(), page.has_more());

// Iterate through all pages
if let Some(next_token) = page.next_page_token {
    let next_page = platform.ledger().list_parties_paged(PageRequest {
        page_token: Some(next_token),
        ..Default::default()
    }).await?;
}

// Advanced contract filtering
let filter = ContractFilter {
    party_id: Some("party-1::abc123".to_string()),
    template_ids: Some(vec!["MyModule:MyTemplate".to_string()]),
    status: Some(ContractStatus::Active),
    domain_id: None,
    created_after: None,
    created_before: None,
    payload_search: Some("treasury".to_string()),
    payload_filter: None,
    include_archived: Some(false),
};
let contracts = platform.ledger().query_contracts_filtered(&filter).await?;

use tenzro_platform::TenzroPlatform;
use tenzro_platform::streaming::StreamConfig;

let platform = TenzroPlatform::new("tnz_mytenant_secret", "my-tenant-id")?;

// Polling-based transaction stream
let config = StreamConfig {
    party_id: "party-1::abc123".to_string(),
    poll_interval_ms: Some(2000),
    begin_offset: None,
    template_filter: Some(vec!["MyModule:MyTemplate".to_string()]),
};
let mut stream = platform.ledger().stream_transactions(config).await?;

// Poll for new transactions
while let Some(event) = stream.next().await? {
    println!("Tx: {} at offset {}", event.transaction.transaction_id, event.offset);
}

// Watch a specific contract for changes
let watcher = platform.ledger().watch_contract("contract-id-123", "party-1::abc123").await?;

use tenzro_platform::TenzroError;

// Retryable errors (automatically retried by the SDK):
// - TenzroError::Http(_)         — transport failures
// - TenzroError::Timeout(_)      — request timeouts
// - TenzroError::RateLimited(_)  — HTTP 429
// - TenzroError::Api { status: 502|503|504, .. } — gateway errors

// Default retry configuration:
// - max_retries: 3
// - initial_backoff: 500ms
// - backoff_multiplier: 2.0x (exponential)
// - max_backoff: 10,000ms

// Check if an error is retryable:
match platform.ledger().list_parties().await {
    Err(e) if e.is_retryable() => {
        println!("Transient error, SDK will have already retried: {}", e);
    }
    Err(e) => {
        println!("Non-retryable error: {}", e);
    }
    Ok(parties) => {
        println!("Got {} parties", parties.len());
    }
}

use std::path::Path;

// Upload a DAR file from disk
let pkg = platform.ledger().upload_dar_file(
    Path::new("/path/to/my-app.dar"),
    Some("my-app"),      // optional name
    Some("1.0.0"),       // optional version
).await?;
println!("Uploaded package: {:?}", pkg.package_id);

// Or upload raw base64 bytes manually
use tenzro_platform::ledger::UploadPackageRequest;

let pkg = platform.ledger().upload_package(&UploadPackageRequest {
    name:    "my-app".to_string(),
    version: "1.0.0".to_string(),
    content: base64_dar_string,
}).await?;

use tenzro_platform::ledger::UpdatePartyRequest;

// Update party display name and annotations
platform.ledger().update_party("party-1::abc123", &UpdatePartyRequest {
    display_name: Some("Updated Name".to_string()),
    annotations: Some(serde_json::json!({ "role": "treasury", "tier": "premium" })),
}).await?;

// Inspect templates in an uploaded package
let templates = platform.ledger().get_package_templates("package-id-123").await?;
for t in &templates {
    println!("Template: {}:{} — choices: {:?}", t.module_name, t.template_name, t.choices);
}

use tenzro_platform::TenzroPlatform;
use tenzro_platform::ai::ForecastRequest;
use tenzro_platform::anchor::AnchorContractRequest;
use tenzro_platform::ledger::{AllocatePartyRequest, CreateContractRequest};
use tenzro_platform::provision::{CreateAppRequest, DeployAppRequest};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialise from environment variables
    let platform = TenzroPlatform::from_env()?;

    // Allocate a Canton party
    let party = platform.ledger().allocate_party(&AllocatePartyRequest {
        party_id_hint:   "operator".to_string(),
        display_name:    "My App Operator".to_string(),
        annotations:     None,
        organization_id: None,
    }).await?;
    println!("Party: {}", party.party_id);

    // Check Canton Coin balance
    let balance = platform.ledger().get_balance(&party.party_id).await?;
    println!("CC balance: {:?}", balance.total_cc);

    // Create a DAML contract on the ledger
    let contract = platform.ledger().create_contract(&CreateContractRequest {
        template_id: "Finance:Invoice".to_string(),
        payload: serde_json::json!({
            "issuer":   party.party_id,
            "amount":   5000,
            "currency": "USD"
        }),
        party_id: party.party_id.clone(),
    }).await?;
    println!("Contract: {}", contract.contract_id);

    // Anchor the contract state root to Ethereum
    let anchored = platform.anchor().anchor_contract(&AnchorContractRequest {
        contract_id: contract.contract_id.clone(),
        template_id: "Finance:Invoice".to_string(),
        hash:        format!("sha256:{}", contract.contract_id),
        chain:       "ethereum".to_string(),
        party_id:    party.party_id.clone(),
    }).await?;
    println!("Anchored tx: {:?}", anchored.tx_hash);

    // Run a TEE-secured time-series forecast
    let forecast = platform.ai().forecast(&ForecastRequest {
        context:           vec![5000.0, 5200.0, 4900.0, 5300.0, 5100.0],
        prediction_length: 3,
        model:             "amazon/chronos-bolt-small".to_string(),
    }).await?;
    println!("Next 3 periods (median): {:?}", forecast.predictions);

    // Register and deploy a Daml application
    let app = platform.provision().create_app(&CreateAppRequest {
        name:        "finance-app".to_string(),
        tenant_id:   std::env::var("TENZRO_TENANT_ID").unwrap_or_default(),
        description: Some("Finance module".to_string()),
        ..Default::default()
    }).await?;

    let deploy = platform.provision().deploy_app(&app.id, &DeployAppRequest {
        network: "devnet".to_string(),
    }).await?;

    if deploy.success {
        if let Some(info) = deploy.deployment {
            println!("Ledger API: {:?}", info.ledger_api_url);
            println!("JSON API:   {:?}", info.json_api_url);
        }
    }

    Ok(())
}