SDK Reference

Complete reference for the Tenzro Rust SDK and TypeScript SDK. Both SDKs provide full access to Tenzro Network functionality including blockchain queries, identity management, AI inference, agent operations, payments, and provider management.

# Rust — add to Cargo.toml
tenzro-sdk = "0.2"

# TypeScript — npm or yarn
npm install @tenzro/sdk

Quick Start

Rust

use tenzro_sdk::{TenzroClient, config::SdkConfig};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = SdkConfig::testnet();
    let client = TenzroClient::connect(config).await?;

    let block = client.block_number().await?;
    println!("Current block: {}", block);

    Ok(())
}

TypeScript

import { TenzroClient } from "@tenzro/sdk";

const client = TenzroClient.testnet();

const block = await client.getBlockNumber();
console.log("Current block:", block);

TenzroClient (Main)

The primary entry point for interacting with Tenzro Network. Provides blockchain queries, transaction submission, and access to all sub-clients.

Core Examples

// Rust
let balance = client.get_balance(address).await?;
let block = client.get_block(1000).await?;
let info = client.node_info().await?;
println!("Block: {}, Peers: {}", info.block_height, info.peer_count);

// TypeScript
const balance = await client.getBalance("0xabc...");
const block = await client.getBlock(1000);
const info = await client.nodeInfo();
console.log("Block:", info.block_height, "Peers:", info.peer_count);

New in v0.2: Transaction Queries and Node Status

// Rust
let tx = client.get_transaction("0xabc123...").await?;
println!("Transaction: {:?}", tx);

let is_syncing = client.syncing().await?;
let finalized = client.get_finalized_block().await?;
println!("Syncing: {}, Finalized block: {}", is_syncing, finalized);

let config = client.export_config().await?;
let history = client.get_transaction_history("0xabc...", Some(50)).await?;
let accounts = client.list_accounts().await?;

// TypeScript
const tx = await client.getTransaction("0xabc123...");
console.log("Transaction:", tx);

const syncing = await client.isSyncing();
const finalized = await client.getFinalizedBlock();
console.log("Syncing:", syncing, "Finalized block:", finalized);

const config = await client.exportConfig();
const history = await client.getTransactionHistory("0xabc...", 50);
const accounts = await client.listAccounts();

IdentityClient

Manages TDIP (Tenzro Decentralized Identity Protocol) identities for both humans and machines. Accessed via client.identity() (Rust) or client.identity (TypeScript).

Identity Examples

// Rust
let identity = client.identity();
let result = identity.register_human("Alice").await?;
println!("DID: {}", result.did);

let info = identity.resolve("did:tenzro:human:abc123").await?;
println!("Status: {}, Keys: {}", info.status, info.key_count);

// TypeScript
const identity = client.identity;
const result = await identity.registerHuman("Alice");
console.log("DID:", result.did);

const info = await identity.resolve("did:tenzro:human:abc123");
console.log("Status:", info.status, "Keys:", info.key_count);

New in v0.2: Credentials and Services

// Rust
let identity = client.identity();

// List all identities
let all = identity.list_identities().await?;
println!("Found {} identities", all);

// Add a verifiable credential
identity.add_credential(
    "did:tenzro:human:abc123",
    "KycAttestation",
    Some("did:tenzro:human:issuer456"),
    Some(serde_json::json!({"tier": 2})),
).await?;

// Add a service endpoint
identity.add_service(
    "did:tenzro:human:abc123",
    "MessagingService",
    "https://msg.example.com/agent",
).await?;

// TypeScript
const identity = client.identity;

// List all identities (optionally filter by type)
const all = await identity.listIdentities("Human");
console.log("Found", all.length, "human identities");

// Add a verifiable credential
await identity.addCredential(
  "did:tenzro:human:abc123",
  "KycAttestation",
  "did:tenzro:human:issuer456"
);

// Add a service endpoint
await identity.addService(
  "did:tenzro:human:abc123",
  "MessagingService",
  "https://msg.example.com/agent"
);

AgentClient

AI agent lifecycle management, messaging, swarms, and template-based agents. Accessed via client.agent() (Rust) or client.agent (TypeScript).

Agent Examples

// Rust
let agent = client.agent();
let resp = agent.register("bot-1", "TradingBot", &["inference", "trading"]).await?;
println!("Agent: {}", resp.agent_id);

let msg = agent.send_message("bot-1", "Analyze market conditions").await?;
println!("Response: {}", msg.payload);

// TypeScript
const agent = client.agent;
const resp = await agent.register("bot-1", "TradingBot", ["inference", "trading"]);
console.log("Agent:", resp.agent_id);

const msg = await agent.sendMessage("bot-1", "Analyze market conditions");
console.log("Response:", msg.payload);

New in v0.2: Discovery, Skills, and Autonomous Payments

// Rust
let agent = client.agent();

// Discover models by modality
let models = agent.discover_models(Some("text"), Some(true), None).await?;

// Discover agents with a specific capability
let agents = agent.discover_agents(Some("inference")).await?;

// Spawn an agent with a skill from the skills registry
let skilled = agent.spawn_agent_with_skill(
    "parent-agent-id",
    "SolanaTrader",
    "solana-defi",
    Some(vec!["swap".to_string(), "stake".to_string()]),
).await?;

// Fund an agent's wallet
agent.fund_agent("bot-1", "0xmywallet...", 10.0).await?;

// Token swap via agent
agent.swap_token("bot-1", "TNZO", "USDC", "100", Some("ethereum")).await?;

// End-to-end: agent pays for inference automatically
let result = agent.agent_pay_for_inference(
    "bot-1",
    "gemma4-9b",
    "Summarize today's market trends",
    Some(500),
).await?;

// TypeScript
const agent = client.agent;

// Discover models (filter by modality, serving status, or search query)
const models = await agent.discoverModels({
  modality: "text",
  servingOnly: true,
});

// Discover agents with a specific capability
const agents = await agent.discoverAgents("inference");

// Spawn an agent with a skill attached
const skilled = await agent.spawnAgentWithSkill(
  "parent-agent-id",
  "SolanaTrader",
  "solana-defi",
  ["swap", "stake"]
);

// Fund an agent's wallet
await agent.fundAgent("bot-1", "0xmywallet...", 10.0);

// Token swap via agent
await agent.swapToken("bot-1", "TNZO", "USDC", "100", "ethereum");

// End-to-end: agent pays for inference automatically
const result = await agent.agentPayForInference(
  "bot-1",
  "gemma4-9b",
  "Summarize today's market trends",
  500
);

SettlementClient

Payment settlement, escrow, and micropayment channels. Accessed via client.settlement() (Rust) or client.settlement (TypeScript).

New in v0.2: Close Payment Channel

// Rust
let settlement = client.settlement();
let channel_id = settlement.open_payment_channel("0xpayee...", 10000000).await?;

// ... after streaming payments ...

let result = settlement.close_payment_channel(&channel_id).await?;
println!("Channel closed: {:?}", result);

// TypeScript
const settlement = client.settlement;
const channelId = await settlement.openPaymentChannel("0xpayee...", 10000000n);

// ... after streaming payments ...

const result = await settlement.closePaymentChannel(channelId);
console.log("Channel closed:", result);

PaymentClient

HTTP 402-based payment protocols (MPP and x402), card payments, and session management. Accessed via client.payment() (Rust) or client.payment (TypeScript).

New in v0.2: Card Payment Protocols

// Rust
let payment = client.payment();

// Visa TAP payment
let visa_result = payment.pay_visa_tap(serde_json::json!({
    "tap_token": "vtap_abc123...",
    "amount": 1000,
    "currency": "USD",
})).await?;

// Mastercard Agent Pay
let mc_result = payment.pay_mastercard(serde_json::json!({
    "agent_token": "mc_agent_xyz...",
    "amount": 500,
    "currency": "USD",
})).await?;

// TypeScript
const payment = client.payment;

// Visa TAP payment
const visaResult = await payment.payVisaTap({
  tap_token: "vtap_abc123...",
  amount: 1000,
  currency: "USD",
});

// Mastercard Agent Pay
const mcResult = await payment.payMastercard({
  agent_token: "mc_agent_xyz...",
  amount: 500,
  currency: "USD",
});

ProviderClient

Network participation, model serving, hardware management, and endpoint registration. Accessed via client.provider() (Rust) or client.provider (TypeScript).

New in v0.2: Micro Nodes, Scheduling, and Endpoint Management

// Rust
let provider = client.provider();

// Join as a lightweight micro node (no full P2P binary required)
let result = provider.join_as_micro_node(
    Some("MyMicroNode"),
    Some("inference"),
).await?;

// Set availability schedule
provider.set_provider_schedule(serde_json::json!({
    "timezone": "UTC",
    "windows": [
        {"day": "weekday", "start": "09:00", "end": "17:00"},
    ],
})).await?;

// Set pricing
provider.set_provider_pricing(serde_json::json!({
    "input_per_token": 0.00001,
    "output_per_token": 0.00003,
    "currency": "TNZO",
})).await?;

// Register a remote model endpoint
provider.register_model_endpoint(
    "gemma4-9b",
    "https://my-gpu.example.com/v1",
    Some("https://my-gpu.example.com/mcp"),
    Some("Gemma 4 9B"),
    Some("MyProvider"),
).await?;

// Get a specific endpoint
let ep = provider.get_model_endpoint("instance-123").await?;

// Unregister an endpoint
provider.unregister_model_endpoint("instance-123").await?;

// Send a signed transaction
let tx = provider.send_signed_transaction(
    "0xsender...", "0xrecipient...", "1000000000", Some("TNZO"),
).await?;

// TypeScript
const provider = client.provider;

// Join as a lightweight micro node
const result = await provider.joinAsMicroNode("MyMicroNode", "inference");

// Set availability schedule
await provider.setProviderSchedule({
  timezone: "UTC",
  windows: [
    { day: "weekday", start: "09:00", end: "17:00" },
  ],
});

// Set pricing
await provider.setProviderPricing({
  input_per_token: 0.00001,
  output_per_token: 0.00003,
  currency: "TNZO",
});

// Register a remote model endpoint
await provider.registerModelEndpoint(
  "gemma4-9b",
  "https://my-gpu.example.com/v1",
  "https://my-gpu.example.com/mcp",
  "Gemma 4 9B",
  "MyProvider"
);

// Get a specific endpoint
const ep = await provider.getModelEndpoint("instance-123");

// Unregister an endpoint
await provider.unregisterModelEndpoint("instance-123");

// Send a signed transaction
const tx = await provider.sendTransaction(
  "0xsender...", "0xrecipient...", "1000000000", "TNZO"
);

TaskClient

Task marketplace operations including posting, listing, quoting, assigning, and completing tasks. Accessed via client.task() (both Rust and TypeScript).

New in v0.2: Update Task

// Rust
let task = client.task();

// Update task title and status
let updated = task.update_task(
    "task-123",
    Some("Updated Title"),
    None,
    Some("in_progress"),
    None,
).await?;

// Update task output
let updated = task.update_task(
    "task-123",
    None,
    None,
    None,
    Some("Partial result: analysis complete"),
).await?;

// TypeScript
const task = client.task();

// Update task title and status
const updated = await task.updateTask("task-123", {
  title: "Updated Title",
  status: "in_progress",
});

// Update task output
const updated2 = await task.updateTask("task-123", {
  output: "Partial result: analysis complete",
});

TokenClient

Token creation, querying, cross-VM transfers, and balance lookups across all VMs. Accessed via client.token() (Rust) or client.token (TypeScript).

Token Examples

// Rust
let token = client.token();

// Create a new ERC-20 token
let result = token.create_token(
    "My Token", "MTK", 18,
    "1000000000000000000000000",
    "0xcreator...",
).await?;
println!("Token created: {} at {}", result.symbol, result.evm_address);

// Get token info by symbol
let info = token.get_token_info("MTK").await?;
println!("Token: {} decimals={}", info.name, info.decimals);

// List all EVM tokens
let tokens = token.list_tokens(Some("EVM")).await?;
println!("Found {} EVM tokens", tokens.len());

// Get TNZO balance across all VMs
let balance = token.get_token_balance("0xaddress...").await?;
println!("EVM: {}, SVM: {}, DAML: {}", balance.evm, balance.svm, balance.daml);

// Cross-VM transfer: move TNZO from EVM to SVM
let transfer = token.cross_vm_transfer(
    "EVM", "SVM", "TNZO",
    "5000000000000000000",
    "0xevm-sender...",
    "solana-recipient-pubkey...",
).await?;
println!("Transfer {}: {}", transfer.transfer_id, transfer.status);

// TypeScript
const token = client.token;

// Create a new ERC-20 token
const result = await token.createToken({
  name: "My Token",
  symbol: "MTK",
  decimals: 18,
  initial_supply: "1000000000000000000000000",
  creator: "0xcreator...",
});
console.log("Token created:", result.symbol, "at", result.evm_address);

// Get token info by symbol
const info = await token.getTokenInfo("MTK");
console.log("Token:", info.name, "decimals:", info.decimals);

// List all EVM tokens
const tokens = await token.listTokens("EVM");
console.log("Found", tokens.length, "EVM tokens");

// Get TNZO balance across all VMs
const balance = await token.getTokenBalance("0xaddress...");
console.log("EVM:", balance.evm, "SVM:", balance.svm, "DAML:", balance.daml);

// Cross-VM transfer: move TNZO from EVM to SVM
const transfer = await token.crossVmTransfer({
  from_vm: "EVM",
  to_vm: "SVM",
  token: "TNZO",
  amount: "5000000000000000000",
  sender: "0xevm-sender...",
  recipient: "solana-recipient-pubkey...",
});
console.log("Transfer:", transfer.transfer_id, transfer.status);

ContractClient

Smart contract deployment across EVM, SVM, and DAML runtimes via the MultiVmRuntime. Accessed via client.contract() (Rust) or client.contract (TypeScript).

Contract Examples

// Rust
let contract = client.contract();

// Deploy EVM bytecode
let result = contract.deploy(
    "0x608060405234801561001057600080fd5b50...",
    "EVM",
    "0xdeployer...",
    None,
).await?;
println!("Contract deployed at: {}", result.contract_address);

// Deploy SVM program
let svm_result = contract.deploy(
    "0x7f454c46...",
    "SVM",
    "deployer-pubkey...",
    None,
).await?;
println!("Program deployed: {}", svm_result.contract_address);

// TypeScript
const contract = client.contract;

// Deploy EVM bytecode
const result = await contract.deploy({
  bytecode: "0x608060405234801561001057600080fd5b50...",
  vm_type: "EVM",
  sender: "0xdeployer...",
});
console.log("Contract deployed at:", result.contract_address);

// Deploy SVM program
const svmResult = await contract.deploy({
  bytecode: "0x7f454c46...",
  vm_type: "SVM",
  sender: "deployer-pubkey...",
});
console.log("Program deployed:", svmResult.contract_address);

AP2Client

Agent Payment Protocol v2 (AP2) session management for autonomous agent payments. Accessed via client.ap2() (Rust) or client.ap2 (TypeScript).

AgentPaymentsClient

Agent spending policies and autonomous payment execution within configurable bounds. Accessed via client.agent_payments() (Rust) or client.agentPayments (TypeScript).

NanopaymentClient

Off-chain nanopayment channels for per-token billing with batched on-chain settlement. Accessed via client.nanopayment() (Rust) or client.nanopayment (TypeScript).

BridgeClient

Cross-chain token bridging via LayerZero, Chainlink CCIP, deBridge, and Canton adapters. Accessed via client.bridge() (Rust) or client.bridge (TypeScript).

ERC7802Client

ERC-7802 crosschain mint/burn interface for native cross-chain token transfers. Accessed via client.erc7802() (Rust) or client.erc7802 (TypeScript).

CircuitBreakerClient

Provider health monitoring and circuit breaker management for inference routing. Accessed via client.circuit_breaker() (Rust) or client.circuitBreaker (TypeScript).

JSON-RPC Direct Access

You can also interact with Tenzro Network directly via JSON-RPC without the SDK. This is useful for languages without a dedicated SDK.

Endpoint URL

Testnet RPC: https://rpc.tenzro.network
Testnet API: https://api.tenzro.network

Basic Request (curl)

curl -X POST https://rpc.tenzro.network \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_blockNumber",
    "params": [],
    "id": 1
  }'

Basic Request (JavaScript/fetch)

async function callRpc(method, params = []) {
  const response = await fetch('https://rpc.tenzro.network', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      jsonrpc: '2.0',
      method,
      params,
      id: 1,
    }),
  });

  const data = await response.json();
  return data.result;
}

// Get block number
const blockNumber = await callRpc('eth_blockNumber');
console.log('Block number:', blockNumber);

// Get balance
const balance = await callRpc('eth_getBalance', [
  '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb5',
  'latest'
]);
console.log('Balance:', balance);

Available RPC Methods

Complete Workflow Example

End-to-End: Register, Discover, Infer, and Settle (TypeScript)

import { TenzroClient } from "@tenzro/sdk";

async function workflow() {
  const client = TenzroClient.testnet();

  // 1. Register identity
  const identity = await client.identity.registerHuman("Alice");
  console.log("Registered DID:", identity.did);

  // 2. Discover models
  const models = await client.agent.discoverModels({ modality: "text", servingOnly: true });
  console.log("Available models:", models);

  // 3. Request inference via agent
  const agent = await client.agent.register("alice-bot", "AliceBot", ["inference"]);
  const result = await client.agent.agentPayForInference(
    agent.agent_id,
    "gemma4-9b",
    "Explain quantum computing",
    200
  );
  console.log("Inference result:", result);

  // 4. Check transaction history
  const history = await client.getTransactionHistory(identity.did, 10);
  console.log("Recent transactions:", history);
}

workflow().catch(console.error);

Error Handling

// Rust — errors are typed via SdkError enum
use tenzro_sdk::error::SdkError;

match client.get_balance(address).await {
    Ok(balance) => println!("Balance: {} wei", balance),
    Err(SdkError::RpcError(msg)) => eprintln!("RPC error: {}", msg),
    Err(SdkError::ConnectionError(msg)) => eprintln!("Connection failed: {}", msg),
    Err(e) => eprintln!("Unexpected error: {}", e),
}

// TypeScript — standard try/catch
try {
  const balance = await client.getBalance("0xabc...");
  console.log("Balance:", balance);
} catch (error) {
  console.error("Failed:", error.message);
}