TypeScript SDK

The official TypeScript SDK for Tenzro Platform provides type-safe access to all services with built-in authentication, error handling, and automatic retries.

Installation

npm install @tenzro/platform
# or
yarn add @tenzro/platform
# or
pnpm add @tenzro/platform

Requirements

Node.js 18 or later
TypeScript 5.0 or later (recommended)

Basic Usage

Getting Started

Initialize the client and access services

import { TenzroPlatform } from '@tenzro/platform';

const platform = new TenzroPlatform({
  apiKey: process.env.TENZRO_API_KEY!, // tnz_{tenantId}_{key}
  network: 'devnet', // or 'mainnet'
});

// Access services
const wallets = await platform.wallet.list();
const balance = await platform.wallet.getBalance(wallets.data[0].id);

Configuration Options

interface TenzroClientConfig {
  // Required
  apiKey: string;         // API key (starts with tnz_)

  // Optional
  tenantId?: string;      // Tenant UUID (extracted from apiKey if omitted)
  network?: Network;      // 'devnet' | 'mainnet' (default: 'devnet')
  timeout?: number;       // Request timeout in ms (default: 30000)
  baseUrl?: string;       // Custom API base URL (overrides network)
}

Available Services

The SDK provides typed clients for all Tenzro Platform services:

Service	Property	Description
AI	`platform.ai`	TEE-secured inference, multi-party sessions, RAG, forecasting
Ledger	`platform.ledger`	Canton Network Ledger API (parties, contracts, domains)
Bridge	`platform.bridge`	Cross-chain transfers via Chainlink CCIP
Token	`platform.token`	Tokenization, collections, holdings, DvP
Wallet	`platform.wallet`	Create and manage wallets, policies, approvals
Custody	`platform.custody`	MPC key management, signing, TEE attestation
Anchor	`platform.anchor`	State root anchoring, Merkle proofs, batches
API Keys	`platform.apiKeys`	API key management and rotation
Events	`platform.events`	Real-time WebSocket event streaming
Provision	`platform.provision`	Canton Network party allocation and app deployment

Service Methods

AI Service

TEE-secured inference, embeddings, forecasting, and chat

// List available models
const models = await platform.ai.listModels();

// Run inference with TEE attestation
const result = await platform.ai.infer({
  modelId: 'llama-3.1-70b',
  prompt: 'Analyze this transaction for risk.',
  maxTokens: 1024,
  temperature: 0.7,
  attestation: true,
});
console.log(result.content);

// Streaming inference with retry
for await (const chunk of platform.ai.inferStream(
  { modelId: 'llama-3.1-70b', prompt: 'Write a detailed analysis...' },
  { maxRetries: 3, baseDelay: 1000 }
)) {
  process.stdout.write(chunk);
}

// Generate embeddings
const embeddings = await platform.ai.embed({
  modelId: 'text-embedding-3-small',
  input: ['Transaction 1 data', 'Transaction 2 data'],
});

// Time series forecasting (Chronos-Bolt)
const forecast = await platform.ai.forecast({
  context: [100.0, 120.0, 115.0, 130.0],
  prediction_length: 5,
  model: 'amazon/chronos-bolt-small',
});

// Chat
const chat = await platform.ai.chat([
  { role: 'user', content: 'What are common DeFi risks?' },
]);

// AI stats
const stats = await platform.ai.getStats();

Multi-Party Inference

v1.1

Run secure inference across multiple parties without exposing individual data.

// Create a multi-party session
const session = await platform.ai.createMultiPartySession({
  name: 'Cross-Bank Analysis',
  modelId: 'risk-analyzer-v2',
  inferenceType: 'completion',
  requiredApprovals: 2,
  initiator: {
    partyId: 'party-1',
    name: 'Bank A Treasury',
    organizationId: 'bank-a',
  },
  dataPolicy: {
    shareInputs: false,
    shareOutputs: true,
    recordToLedger: true,
    requireEncryption: true,
  },
});

// Join a session
await platform.ai.joinMultiPartySession(session.id, {
  partyId: 'party-2',
  name: 'Bank B Analytics',
  organizationId: 'bank-b',
  role: 'data_provider',
});

// Provide consent
await platform.ai.provideMultiPartyConsent(session.id, 'party-2');

// Submit data contribution
await platform.ai.submitMultiPartyContribution(session.id, {
  partyId: 'party-2',
  contributionType: 'context',
  data: { transactions: [...] },
  encrypt: true,
});

// Execute inference
const result = await platform.ai.executeMultiPartyInference(session.id, {
  partyId: 'party-1',
});

// List and manage sessions
const sessions = await platform.ai.listMultiPartySessions({ status: 'active' });
await platform.ai.cancelMultiPartySession(session.id);

Verifiable AI

v1.1

Record AI inference to Canton Network for immutable audit trails.

// Record inference on the ledger
const proof = await platform.ai.recordInferenceOnLedger({
  modelId: 'llama-3.1-70b',
  inputHash: inference.inputHash,
  outputHash: inference.outputHash,
  attestation: inference.teeAttestation,
  metadata: { purpose: 'compliance' },
});

// Verify a recorded inference
const verification = await platform.ai.verifyInferenceOnLedger({
  proofId: proof.proofId,
});
console.log('Valid:', verification.valid);

// Query inference history
const history = await platform.ai.getInferenceHistory({
  modelId: 'llama-3.1-70b',
  limit: 100,
});

RAG (Retrieval-Augmented Generation)

// Query with RAG
const result = await platform.ai.queryRAG({
  query: 'What are the compliance requirements?',
  dataSourceIds: ['ds-legal', 'ds-regulations'],
  maxResults: 5,
});

// Index documents
await platform.ai.indexRAGDocuments({
  documents: [...],
  dataSourceId: 'ds-legal',
});

// List data sources
const sources = await platform.ai.listRAGDataSources();

// Delete a data source
await platform.ai.deleteRAGDataSource('ds-old');

Error Handling

import { TenzroApiError } from '@tenzro/platform';

try {
  await platform.ledger.allocateParty({ displayName: 'Alice' });
} catch (error) {
  if (error instanceof TenzroApiError) {
    console.log('Code:', error.code);       // e.g., 'RATE_LIMIT_EXCEEDED'
    console.log('Message:', error.message);  // Human-readable message
    console.log('Status:', error.status);    // HTTP status code
    console.log('Details:', error.details);  // Additional context
  }
}

TypeScript Types

The SDK exports all types for strong typing:

import type {
  // Wallet
  Wallet, WalletBalance, WalletTransaction, CreateWalletRequest,
  SpendingPolicy, ApprovalRequest, WhitelistAddress,
  // Token
  TokenCollection, Token, MintRequest, TransferRequest,
  TokenAgreement, Holding, DvPOperation,
  // Ledger
  PartyInfo, AllocatePartyRequest, BalanceResponse,
  CreateContractRequest, ExerciseChoiceRequest, DomainInfo,
  // Bridge
  BridgeRoute, QuoteRequest, BridgeOperation, BridgeLimits,
  // AI
  AIModel, InferRequest, InferResponse, EmbedRequest,
  MultiPartySession, ForecastRequest, RAGQueryRequest,
  // Anchor
  AnchorRecord, AnchorBatch, VerifyProofResponse,
  // Custody
  CustodyKey, SignRequest, SignResponse, VerifyResponse,
  // Provision
  CantonAllocation, NetworkAccess, App, QuotaUsage,
} from '@tenzro/platform';