SDK Usage Examples

[dependencies]
zeris-sdk = "1.0.0"
solana-sdk = "1.18"
tokio = { version = "1.35", features = ["full"] }

npm install @zeris/sdk @solana/web3.js
# or
yarn add @zeris/sdk @solana/web3.js

use zeris_sdk::{ZerisClient, PoWConfig};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize Zeris client
    let client = ZerisClient::new()?;
    
    // Configure PoW parameters
    let pow_config = PoWConfig {
        difficulty: 20,
        worker_threads: 4,
        timeout_secs: 30,
    };
    
    // Transaction data to prove
    let tx_data = b"my transaction payload";
    
    // Generate proof
    let pow_proof = client
        .generate_pow_proof(tx_data, pow_config)
        .await?;
    
    println!("PoW Proof generated!");
    println!("  Nonce: {}", pow_proof.nonce);
    println!("  Hash: {:?}", pow_proof.hash);
    println!("  Time: {}ms", pow_proof.generation_time_ms);
    
    Ok(())
}

use zeris_sdk::{ZerisClient, ProofBundle};
use solana_sdk::{
    signature::{Keypair, Signer},
    transaction::Transaction,
};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize clients
    let zeris = ZerisClient::new()?;
    let solana = solana_client::rpc_client::RpcClient::new(
        "https://api.devnet.solana.com".to_string()
    );
    
    // Your transaction data
    let tx_data = b"transfer 100 tokens to alice";
    let payer = Keypair::new();
    
    // Step 1: Generate PoW proof
    println!("Generating PoW proof...");
    let pow_proof = zeris.generate_pow_proof(tx_data, Default::default()).await?;
    
    // Step 2: Create PoH anchor
    println!("Creating PoH anchor...");
    let poh_anchor = zeris.anchor_to_poh(tx_data, &pow_proof).await?;
    
    // Step 3: Get PoS signatures
    println!("Waiting for validator signatures...");
    let pos_signatures = zeris
        .collect_validator_signatures(tx_data, 10)
        .await?;
    
    // Step 4: Create proof bundle
    let proof_bundle = ProofBundle {
        pow_proof,
        poh_anchor,
        pos_signatures,
    };
    
    // Step 5: Submit to Solana
    println!("Submitting to Solana...");
    let ix = zeris.create_verify_instruction(
        &payer.pubkey(),
        tx_data,
        &proof_bundle,
    )?;
    
    let recent_blockhash = solana.get_latest_blockhash()?;
    let transaction = Transaction::new_signed_with_payer(
        &[ix],
        Some(&payer.pubkey()),
        &[&payer],
        recent_blockhash,
    );
    
    let signature = solana.send_and_confirm_transaction(&transaction)?;
    println!("Verification successful! Signature: {}", signature);
    
    Ok(())
}

import { ZerisClient, PoWConfig } from '@zeris/sdk';

async function generateProof() {
  // Initialize client
  const client = new ZerisClient();
  
  // Configure PoW
  const config: PoWConfig = {
    difficulty: 20,
    workerThreads: 4,
    timeoutMs: 30000,
  };
  
  // Transaction data
  const txData = Buffer.from('my transaction payload');
  
  // Generate proof
  const powProof = await client.generatePoWProof(txData, config);
  
  console.log('PoW Proof generated!');
  console.log('  Nonce:', powProof.nonce);
  console.log('  Hash:', powProof.hash.toString('hex'));
  console.log('  Time:', powProof.generationTimeMs, 'ms');
  
  return powProof;
}

import { ZerisClient } from '@zeris/sdk';
import { Connection, Keypair, Transaction } from '@solana/web3.js';

async function verifyTransaction() {
  // Initialize clients
  const zeris = new ZerisClient();
  const connection = new Connection(
    'https://api.devnet.solana.com',
    'confirmed'
  );
  
  // Your transaction data
  const txData = Buffer.from('transfer 100 tokens to alice');
  const payer = Keypair.generate();
  
  // Step 1: Generate PoW proof
  console.log('Generating PoW proof...');
  const powProof = await zeris.generatePoWProof(txData);
  
  // Step 2: Create PoH anchor
  console.log('Creating PoH anchor...');
  const pohAnchor = await zeris.anchorToPoH(txData, powProof);
  
  // Step 3: Collect PoS signatures
  console.log('Waiting for validator signatures...');
  const posSignatures = await zeris.collectValidatorSignatures(
    txData,
    10 // number of validators
  );
  
  // Step 4: Create proof bundle
  const proofBundle = {
    powProof,
    pohAnchor,
    posSignatures,
  };
  
  // Step 5: Build Solana transaction
  console.log('Submitting to Solana...');
  const verifyIx = zeris.createVerifyInstruction(
    payer.publicKey,
    txData,
    proofBundle
  );
  
  const transaction = new Transaction().add(verifyIx);
  transaction.recentBlockhash = (
    await connection.getLatestBlockhash()
  ).blockhash;
  transaction.feePayer = payer.publicKey;
  
  // Sign and send
  transaction.sign(payer);
  const signature = await connection.sendRawTransaction(
    transaction.serialize()
  );
  
  await connection.confirmTransaction(signature);
  console.log('Verification successful! Signature:', signature);
  
  return signature;
}

import { ZerisClient, AdaptiveDifficulty } from '@zeris/sdk';

const client = new ZerisClient();

// Enable adaptive difficulty based on network conditions
const adaptiveConfig = new AdaptiveDifficulty({
  baseDifficulty: 18,
  minDifficulty: 16,
  maxDifficulty: 24,
  adjustmentWindow: 100, // Adjust every 100 transactions
});

// Generate proof with adaptive difficulty
const proof = await client.generatePoWProof(txData, {
  difficulty: adaptiveConfig.getCurrentDifficulty(),
  onProgress: (progress) => {
    console.log(`PoW Progress: ${progress}%`);
  },
});

use zeris_sdk::{ZerisClient, BatchProofGenerator};

async fn batch_verify_transactions(
    transactions: Vec<&[u8]>
) -> Result<Vec<ProofBundle>, ZerisError> {
    let client = ZerisClient::new()?;
    let batch_generator = BatchProofGenerator::new(client);
    
    // Generate proofs in parallel
    let proofs = batch_generator
        .generate_batch_proofs(transactions)
        .await?;
    
    println!("Generated {} proofs", proofs.len());
    
    Ok(proofs)
}

import { ZerisClient, ProofCache } from '@zeris/sdk';

const client = new ZerisClient();

// Enable proof caching to avoid regenerating for identical data
const cache = new ProofCache({
  maxSize: 1000,
  ttlMs: 300000, // 5 minutes
});

client.setProofCache(cache);

// First call: generates proof
const proof1 = await client.generatePoWProof(txData);

// Second call with same data: returns cached proof
const proof2 = await client.generatePoWProof(txData);

console.log('Cache hit:', cache.stats.hits);
console.log('Cache miss:', cache.stats.misses);

import { 
  ZerisClient, 
  PoWError, 
  PoHError, 
  PoSError 
} from '@zeris/sdk';

async function verifyWithErrorHandling(txData: Buffer) {
  const client = new ZerisClient();
  
  try {
    const proof = await client.generateTripleProof(txData);
    return proof;
  } catch (error) {
    if (error instanceof PoWError) {
      console.error('PoW generation failed:', error.message);
      // Retry with lower difficulty
      return client.generateTripleProof(txData, {
        powConfig: { difficulty: 16 }
      });
    } else if (error instanceof PoHError) {
      console.error('PoH anchoring failed:', error.message);
      // Wait and retry
      await new Promise(resolve => setTimeout(resolve, 1000));
      return client.generateTripleProof(txData);
    } else if (error instanceof PoSError) {
      console.error('Insufficient validator signatures:', error.message);
      // Wait longer for validators
      return client.generateTripleProof(txData, {
        posConfig: { timeoutMs: 60000 }
      });
    }
    throw error;
  }
}

import { ZerisClient, MockProofGenerator } from '@zeris/sdk';

describe('Zeris Integration', () => {
  let client: ZerisClient;
  
  beforeEach(() => {
    // Use mock proof generator for fast tests
    client = new ZerisClient({
      proofGenerator: new MockProofGenerator({
        instantProofs: true,
        mockDifficulty: 1,
      }),
    });
  });
  
  it('should generate proof quickly', async () => {
    const txData = Buffer.from('test transaction');
    
    const start = Date.now();
    const proof = await client.generatePoWProof(txData);
    const duration = Date.now() - start;
    
    expect(duration).toBeLessThan(10); // Mock proof is instant
    expect(proof.nonce).toBeDefined();
  });
});

# Generate a PoW proof
zeris pow generate --data "my transaction" --difficulty 20

# Verify a proof
zeris pow verify --proof proof.json --data "my transaction"

# Benchmark performance
zeris benchmark --difficulty 20 --iterations 100

# Check validator set
zeris validators list --network devnet