For Developers
Build on Tenzro
Access comprehensive SDKs, CLI tools, JSON-RPC APIs, and extensive documentation. Deploy smart contracts across EVM, SVM, and DAML. Integrate identity and payment protocols.
SDKs & Tools
Rust SDK
Native Rust library with full type safety, async/await support, and integration with the full Tenzro platform. Production-ready for node operators and backend services.
TypeScript SDK
Browser and Node.js compatible SDK with JSON-RPC client, type definitions, and promise-based API. Perfect for web applications and frontend integrations.
CLI
Command-line tool for node operation, wallet management, governance participation, and provider configuration. Essential for operators and power users.
Integration Options
JSON-RPC
Ethereum-compatible JSON-RPC 2.0 interface for querying blockchain state and submitting transactions. Default endpoint: http://127.0.0.1:8545
curl -X POST http://localhost:8545 \
-H "Content-Type: application/json" \
-d '{
"jsonrpc": "2.0",
"method": "eth_getBalance",
"params": [
"0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
"latest"
],
"id": 1
}'Web Verification API
REST API for verifying ZK proofs, TEE attestations, transaction signatures, and inference results. Default endpoint: http://0.0.0.0:8080/api
curl -X POST \
http://localhost:8080/verify/zk-proof \
-H "Content-Type: application/json" \
-d '{
"proof": "0x...",
"public_inputs": ["0x..."],
"circuit_type": "InferenceVerification"
}'MCP (Model Context Protocol)
Bridge integration for AI agents to communicate using Anthropic's Model Context Protocol standard. A2A messages automatically convert to/from MCP format for interoperability.
A2A (Agent-to-Agent)
Peer-to-peer protocol for direct inter-agent communication. Capability negotiation and task delegation with cryptographic signatures.
Smart Contracts
Deploy smart contracts across EVM, SVM, and DAML runtimes with unified gas metering and parallel execution via Block-STM.
EVM Contracts
Deploy existing Solidity contracts without modification. Full EVM opcode support, Keccak-256 hashing, and deterministic CREATE2 addresses.
// Deploy contract
const factory = new ContractFactory(
abi,
bytecode,
signer
);
const contract = await factory.deploy(
...constructorArgs
);
await contract.deployed();SVM Programs
Deploy BPF programs with PDA derivation and compute units metering. Parallel execution via Block-STM MVCC for high throughput.
// Deploy program
let program = await Program.deploy(
provider,
programBinary,
programId
);
// Invoke instruction
await program.methods
.initialize()
.accounts({ ... })
.rpc();DAML Contracts
Deploy Canton/DAML contracts for enterprise use cases with privacy-preserving execution and multi-party workflows.
// Create contract
let create_cmd = DamlCommand::Create {
template_id: "MyContract",
arguments: vec![...],
};
let tx = client
.submit_command(create_cmd)
.await?;Code Examples
Rust SDK
use tenzro_sdk::{TenzroClient, InferenceRequest};
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
// Connect to node
let client = TenzroClient::connect(
"http://localhost:8545"
).await?;
// Get block number
let block = client.get_block_number().await?;
println!("Block: {}", block);
// Query balance
let balance = client.get_balance(
"0x742d35Cc6634C0532925a3b844Bc454e4438f44e"
).await?;
println!("Balance: {} TNZO", balance);
// Request inference
let models = client.list_models()
.category("text")
.send()
.await?;
let response = client.inference()
.model_id(&models[0].id)
.prompt("Explain consensus")
.max_tokens(100)
.send()
.await?;
println!("Response: {}", response.text);
Ok(())
}TypeScript SDK
import { TenzroClient, Amount } from "@tenzro/sdk";
async function main() {
// Connect to node
const client = new TenzroClient({
endpoint: "http://localhost:8545",
});
// Get block number
const block = await client.getBlockNumber();
console.log("Block:", block);
// Query balance
const balance = await client.getBalance(
"0x742d35Cc6634C0532925a3b844Bc454e4438f44e"
);
console.log("Balance:", balance, "TNZO");
// Request inference
const models = await client.listModels({
category: "text",
});
const response = await client.requestInference({
modelId: models[0].id,
prompt: "Explain consensus",
maxTokens: 100,
});
console.log("Response:", response.output);
}
main().catch(console.error);Identity Integration
Register Identities
Use TDIP (Tenzro Decentralized Identity Protocol) to register human and machine identities with W3C DID format, verifiable credentials, and delegation scopes.
// Register human identity
let identity = client.identity()
.register_human(
"Alice",
KycTier::Enhanced
)
.await?;
println!("DID: {}", identity.did);
// Register machine identity
let agent = client.identity()
.register_machine(
controller_did,
vec![
Capability::InferenceRequest,
Capability::PaymentAuthorization,
],
delegation_scope
)
.await?;
// Auto-provisioned MPC wallet
let wallet = agent.wallet();Payment Integration
Implement MPP or x402 payment flows with automatic credential verification and settlement.
MPP Server Example
use tenzro_payments::{MppServer, MppConfig};
// Create MPP server
let mpp = MppServer::new(MppConfig {
min_payment: Amount::tnzo(0.01),
session_timeout: Duration::from_secs(3600),
..Default::default()
});
// Add payment middleware to API
app.use(mpp.middleware());
// Protected endpoint
app.get("/api/premium", require_payment, |req| {
// Payment verified automatically
Ok(json!({ "data": premium_content() }))
});
// Start server
app.listen(8080).await?;Ready to Build?
Start integrating Tenzro Network into your application with comprehensive SDKs and documentation.