Network SDK

Browser-first blockchain SDK for building decentralized applications where every user is a real node. Full cryptographic primitives, identity management, and P2P networking.

Installation

npm install @tenzro/network
# or
pnpm add @tenzro/network

Overview

The Network SDK provides everything needed to build decentralized applications that run in the browser:

Crypto: ed25519, secp256k1, BLS12-381, Blake3, encryption
Identity: 4-level identity system with passkey support
Chain: Light client for syncing and verifying chain data
P2P: WebTransport and WebRTC networking
Transaction: Transaction builder and signing
Storage: SQLite-WASM based local storage

Quick Start

import {
  IdentityManager,
  ChainClient,
  P2PNode,
  TransactionBuilder,
} from '@tenzro/network';

// Create identity
const identity = new IdentityManager();
const session = await identity.createPersistent({ password: 'secure123' });

// Connect to network via bootstrap nodes
const p2p = new P2PNode({
  networkId: 'devnet',  // Current network: devnet -> testnet -> mainnet
  privateKey: session.privateKey!,
  publicKey: session.identity.publicKey,
  bootstrapPeers: [
    'wss://bootstrap.tenzro.network',
    'wss://bootstrap2.tenzro.network',
  ],
});
await p2p.start();

// Sync chain
const chain = new ChainClient({
  chainId: 'devnet',
  p2pNode: p2p,
});
await chain.sync();

// Build and sign transaction
const builder = new TransactionBuilder({ chainId: 'devnet' });
builder.setFrom(session.identity.address, 0);

const tx = await builder.transfer({
  to: 'user:abc123...',
  amount: BigInt(1000000),
});

const signed = builder.sign(tx, {
  publicKey: session.identity.publicKey,
  privateKey: session.privateKey!,
  algorithm: 'ed25519',
});

// Broadcast to connected peers
p2p.broadcast('transaction', signed);

Cryptography

Key Generation

import {
  generateKeyPair,
  generateKeyPairFromSeed,
  sign,
  verify,
  generateRandomBytes,
} from '@tenzro/network';

// Generate random keypair
const keyPair = await generateKeyPair('ed25519');
console.log(keyPair.publicKey);  // Uint8Array
console.log(keyPair.privateKey); // Uint8Array

// From seed (deterministic)
const seed = generateRandomBytes(32);
const keyPair2 = await generateKeyPairFromSeed(seed, 'ed25519');

// Supported algorithms: 'ed25519', 'secp256k1'

Signing and Verification

import { sign, verify } from '@tenzro/network';

// Sign message
const message = new TextEncoder().encode('Hello, World!');
const signature = await sign(message, privateKey, 'ed25519');

// Verify signature
const isValid = await verify(message, signature, publicKey, 'ed25519');
console.log(isValid);  // true

Hashing

import {
  blake3Hash,
  blake3HashString,
  sha256Hash,
  keccak256Hash,
  doubleBlake3,
} from '@tenzro/network';

// Hash bytes
const hash = blake3Hash(data);

// Hash string (returns hex)
const hashHex = blake3HashString('Hello');

// SHA-256
const sha = sha256Hash(data);

// Keccak-256 (Ethereum compatible)
const keccak = keccak256Hash(data);

// Double hash (for addresses)
const doubleHash = doubleBlake3(data);

BLS Signatures

import {
  generateBLSKeyPair,
  signBLS,
  verifyBLS,
  aggregateSignatures,
  verifyAggregate,
} from '@tenzro/network';

// Generate BLS keypair
const blsKey = await generateBLSKeyPair();

// Sign
const sig1 = await signBLS(message, blsKey.privateKey);
const sig2 = await signBLS(message, otherKey.privateKey);

// Aggregate signatures (for consensus)
const aggregated = aggregateSignatures([sig1, sig2]);

// Verify aggregate
const valid = await verifyAggregate(
  message,
  aggregated,
  [blsKey.publicKey, otherKey.publicKey]
);

Encryption

import {
  deriveKey,
  encrypt,
  decrypt,
  encryptPrivateKey,
  decryptPrivateKey,
} from '@tenzro/network';

// Derive key from password
const key = await deriveKey('password', salt, {
  iterations: 100000,
  keyLength: 32,
});

// Encrypt data
const encrypted = await encrypt(data, key);

// Decrypt data
const decrypted = await decrypt(encrypted, key);

// Encrypt private key for storage
const encryptedKey = await encryptPrivateKey(privateKey, 'password');

// Decrypt private key
const recoveredKey = await decryptPrivateKey(encryptedKey, 'password');

Mnemonic Phrases

import {
  generateMnemonic,
  validateMnemonic,
  mnemonicToSeed,
  generateMnemonicKeyPair,
  recoverFromMnemonic,
  deriveMultipleKeys,
} from '@tenzro/network';

// Generate mnemonic (12 or 24 words)
const mnemonic = generateMnemonic(24);
console.log(mnemonic);
// "abandon abandon ... zoo"

// Validate
const isValid = validateMnemonic(mnemonic);

// Generate keypair from mnemonic
const keyPair = await generateMnemonicKeyPair(mnemonic, 'ed25519');

// Recover with password
const recovered = await recoverFromMnemonic(mnemonic, 'password');

// Derive multiple keys (HD wallet)
const keys = await deriveMultipleKeys(mnemonic, 5, 'ed25519');

Identity Management

Four levels of identity with increasing security:

Identity Levels

Level	Storage	Recovery	Use Case
`ephemeral`	Memory only	None	Temporary sessions
`persistent`	Encrypted IndexedDB	Password	Regular users
`exportable`	Encrypted + mnemonic	Mnemonic phrase	Power users
`passkey`	Hardware authenticator	Passkey	Maximum security

Creating Identities

import { IdentityManager } from '@tenzro/network';

const manager = new IdentityManager();

// Ephemeral (session-only)
const ephemeral = await manager.createEphemeral();

// Persistent (password protected)
const persistent = await manager.createPersistent({
  password: 'secure-password',
  label: 'Main Account',
});

// Exportable (with mnemonic)
const exportable = await manager.createExportable({
  password: 'secure-password',
  strength: 24,  // 24-word mnemonic
});
console.log(exportable.mnemonic);  // Save this!

// Passkey (hardware security)
const passkey = await manager.createPasskey({
  username: 'user@example.com',
  displayName: 'John Doe',
});

Unlocking and Managing

// List stored identities
const identities = await manager.list();

// Unlock with password
const session = await manager.unlock(identityId, {
  password: 'secure-password',
});

// Unlock with passkey
const passkeySession = await manager.unlockWithPasskey(identityId);

// Export identity
const exported = await manager.export(identityId, {
  password: 'export-password',
  format: 'json',
});

// Import identity
await manager.import(exported, {
  password: 'export-password',
});

// Delete identity
await manager.delete(identityId);

Chain Client

import { ChainClient, getChainClient } from '@tenzro/network';

const chain = new ChainClient({
  chainId: 'devnet',  // Current: devnet -> testnet -> mainnet
  p2pNode: p2p,
  syncMode: 'light',   // or 'full'
});

// Sync blockchain headers
await chain.sync();

// Get sync status
const status = chain.getSyncStatus();
console.log(status.currentBlock, status.highestBlock);

// Get account state
const account = await chain.getAccountState('user:abc123...');
console.log(account.balance, account.nonce);

// Get transaction receipt
const receipt = await chain.getTransactionReceipt(txHash);

// Subscribe to events
chain.on('newBlock', (block) => {
  console.log('New block:', block.number);
});

chain.on('transaction', (tx) => {
  console.log('New transaction:', tx.hash);
});

Cloud Telemetry

Browser nodes can report telemetry and transaction data to Tenzro Cloud for monitoring and analytics in the dashboard.

// P2P node with telemetry enabled
const p2p = new P2PNode({
  networkId: 'devnet',  // Current network
  projectId: 'your-project-id',
  apiKey: 'your-api-key',
  cloudApiUrl: 'https://api.cloud.tenzro.com',
  enableTelemetry: true,
  telemetryInterval: 30000,  // Report every 30 seconds
});

// Telemetry automatically reports:
// - Peer count and connection events
// - Messages sent/received
// - Transactions broadcast/received
// - Sync height and progress
// - Memory usage and uptime

// View telemetry in dashboard or via API:
// GET /cloud/network/nodes?projectId=xxx
// GET /cloud/network/stats?projectId=xxx
// GET /cloud/network/events?projectId=xxx

P2P Networking

import {
  P2PNode,
  createP2PNode,
  isWebTransportAvailable,
  isWebRTCAvailable,
} from '@tenzro/network';

// Check transport availability
console.log('WebTransport:', isWebTransportAvailable());
console.log('WebRTC:', isWebRTCAvailable());

// Create P2P node with bootstrap peers
const p2p = createP2PNode({
  networkId: 'devnet',  // Current network
  privateKey: myPrivateKey,
  publicKey: myPublicKey,
  bootstrapPeers: [
    'wss://bootstrap.tenzro.network',
    'wss://bootstrap2.tenzro.network',
  ],
  maxPeers: 50,
  enableWebTransport: true,
  enableWebRTC: true,
});

// Start the node (auto-connects to bootstrap peers)
await p2p.start();

// Get connected peers
const peers = p2p.getConnectedPeers();
console.log(`Connected to ${peers.length} peers`);

// Subscribe to events
p2p.on((event) => {
  if (event.type === 'peer_connected') {
    console.log('Peer connected:', event.peer?.id);
  }
  if (event.type === 'message_received') {
    console.log('Message:', event.message?.type);
  }
});

// Handle specific message types
p2p.onMessage('transaction', (msg, peer) => {
  console.log('Transaction from', peer.id);
});

// Broadcast message to all peers
p2p.broadcast('transaction', signedTx);

// Send to specific peer
await p2p.send(peerId, 'headers_request', { startHeight: 1000, maxHeaders: 100 });

// Gossip (propagates through network)
p2p.gossip('new_block', blockData);

Transactions

import {
  TransactionBuilder,
  createTransactionBuilder,
  calculateTxHash,
  verifyTransaction,
} from '@tenzro/network';

const builder = createTransactionBuilder({ chainId: 'devnet' });

// Set sender
builder.setFrom(address, nonce);

// Transfer tokens
const transferTx = await builder.transfer({
  to: recipientAddress,
  amount: BigInt(1000000),
  memo: 'Payment for services',
});

// Deploy contract
const deployTx = await builder.deploy({
  code: contractBytecode,
  args: [arg1, arg2],
  gasLimit: 1000000,
});

// Call contract
const callTx = await builder.call({
  contract: contractAddress,
  method: 'transfer',
  args: [to, amount],
  value: BigInt(0),
});

// Stake tokens
const stakeTx = await builder.stake({
  validator: validatorAddress,
  amount: BigInt(10000000000),
});

// Sign transaction
const signed = builder.sign(transferTx, {
  publicKey: session.identity.publicKey,
  privateKey: session.privateKey!,
  algorithm: 'ed25519',
});

// Calculate hash
const hash = calculateTxHash(signed);

// Verify signature
const isValid = verifyTransaction(signed);

Local Storage

import { createSQLiteStorage } from '@tenzro/network';

// Create storage (uses SQLite-WASM)
const storage = await createSQLiteStorage({
  name: 'tenzro-chain',
  path: '/data/chain.db',
});

// Store header
await storage.storeHeader(header);

// Get header by hash
const header = await storage.getHeader(blockHash);

// Get headers by height range
const headers = await storage.getHeadersByHeight(1000, 1100);

// Store transaction
await storage.storeTransaction(tx);

// Query transactions
const txs = await storage.getTransactionsByAddress(address, {
  limit: 50,
  offset: 0,
});

// Get storage stats
const stats = await storage.getStats();
console.log(stats);
// { headers: 10000, transactions: 50000, proofs: 1000, size: 1234567 }

Constants

import {
  TENZRO_NETWORK,
  IDENTITY_LEVELS,
  TRANSACTION_TYPES,
} from '@tenzro/network';

// Networks (current progression: devnet -> testnet -> mainnet)
TENZRO_NETWORK.DEVNET   // 'devnet' (current)
TENZRO_NETWORK.TESTNET  // 'testnet' (upcoming)
TENZRO_NETWORK.MAINNET  // 'mainnet' (future)

// Identity levels
IDENTITY_LEVELS.EPHEMERAL   // 'ephemeral'
IDENTITY_LEVELS.PERSISTENT  // 'persistent'
IDENTITY_LEVELS.EXPORTABLE  // 'exportable'
IDENTITY_LEVELS.PASSKEY     // 'passkey'

// Transaction types
TRANSACTION_TYPES.TRANSFER       // 'transfer'
TRANSACTION_TYPES.CONTRACT_CALL  // 'contract_call'
TRANSACTION_TYPES.STAKE          // 'stake'
TRANSACTION_TYPES.VOTE           // 'vote'

Worker Pools

Use Web Workers for CPU-intensive crypto operations:

import {
  createCryptoWorkerPool,
  getCryptoWorkerPool,
  terminateCryptoWorkerPool,
} from '@tenzro/network';

// Create worker pool
const pool = await createCryptoWorkerPool({
  workers: 4,
  warmup: true,
});

// Get shared pool
const sharedPool = getCryptoWorkerPool();

// Run operations in parallel
const results = await Promise.all([
  sharedPool.hash(data1),
  sharedPool.hash(data2),
  sharedPool.sign(message, key),
]);

// Cleanup
terminateCryptoWorkerPool();