> SDK_REFERENCE

SDK Reference

Complete API documentation for ZKPrime TypeScript and Rust SDKs

TypeScript SDK

ZKPrimeClient

Main client for interacting with ZKPrime privacy layer

class ZKPrimeClient {
  constructor(config: ClientConfig)
  
  // Transaction methods
  createPrivateTransfer(params: TransferParams): Promise<Transaction>
  submitTransaction(tx: Transaction): Promise<string>
  
  // Proof generation
  generateProof(params: ProofParams): Promise<Proof>
  verifyProof(proof: Proof): Promise<boolean>
  
  // State management
  getEncryptedBalance(address: string): Promise<EncryptedBalance>
  decryptBalance(encrypted: EncryptedBalance): Promise<number>
}

createPrivateTransfer()

Creates a confidential transfer transaction

const tx = await client.createPrivateTransfer({
  from: wallet,           // Sender wallet
  to: 'recipient_address', // Recipient public key
  amount: 1000,           // Amount in lamports
  memo?: 'Optional memo', // Optional transaction memo
  privacyLevel?: 'high'   // 'low' | 'medium' | 'high'
});

generateProof()

Generates a zero-knowledge proof for a statement

const proof = await client.generateProof({
  statement: 'balance >= 1000', // Statement to prove
  witness: { balance: 5000 },   // Private witness data
  circuit?: 'custom_circuit',   // Optional custom circuit
  hideWitness: true            // Hide witness in proof
});

getEncryptedBalance()

Retrieves encrypted balance for an address

const encrypted = await client.getEncryptedBalance(
  'address_public_key'
);

// Decrypt with private key
const balance = await client.decryptBalance(encrypted);
console.log('Balance:', balance);

Rust SDK

Native Rust SDK for high-performance integration with Solana programs

use zkprime_sdk::{ZKPrimeClient, PrivateTransfer};

// Initialize client
let client = ZKPrimeClient::new(Config {
    rpc_url: "https://api.mainnet-beta.solana.com",
    network: Network::MainnetBeta,
})?;

// Create private transfer
let transfer = PrivateTransfer {
    from: sender_keypair,
    to: recipient_pubkey,
    amount: 1000,
    privacy_level: PrivacyLevel::High,
};

// Submit transaction
let signature = client.submit_private_transfer(transfer).await?;
println!("Transaction: {}", signature);

Key Types

pub struct ZKPrimeClient { ... }
pub struct PrivateTransfer { ... }
pub struct Proof { ... }
pub struct EncryptedBalance { ... }

pub enum PrivacyLevel {
    Low,
    Medium,
    High,
}

pub enum Network {
    Devnet,
    Testnet,
    MainnetBeta,
}

API Reference

Common types and interfaces used across both SDKs

ClientConfig

interface ClientConfig {
  rpcUrl: string;
  network: 'devnet' | 'testnet' | 'mainnet-beta';
  defaultPrivacyLevel?: PrivacyLevel;
  proofCaching?: boolean;
  batchTransactions?: boolean;
  debug?: boolean;
}

TransferParams

interface TransferParams {
  from: Wallet | Keypair;
  to: string;
  amount: number;
  memo?: string;
  privacyLevel?: PrivacyLevel;
}

Proof

interface Proof {
  isValid: boolean;
  statement: string;
  publicInputs: any[];
  proofData: Uint8Array;
  privacyScore: number;
}

Code Examples

Private Token Transfer

import { ZKPrimeClient } from '@zkprime/sdk';
import { Wallet } from '@solana/web3.js';

const client = new ZKPrimeClient({
  rpcUrl: process.env.SOLANA_RPC_URL,
  network: 'mainnet-beta'
});

const wallet = new Wallet(secretKey);

async function sendPrivateTokens() {
  const tx = await client.createPrivateTransfer({
    from: wallet,
    to: 'recipient_address',
    amount: 1000000, // 1 token (6 decimals)
    privacyLevel: 'high'
  });
  
  const signature = await client.submitTransaction(tx);
  console.log('Sent private tokens:', signature);
}

sendPrivateTokens();

Verify Private Balance

async function checkPrivateBalance() {
  // Get encrypted balance
  const encrypted = await client.getEncryptedBalance(
    wallet.publicKey.toString()
  );
  
  // Decrypt with private key
  const balance = await client.decryptBalance(encrypted);
  
  // Generate proof of sufficient balance
  const proof = await client.generateProof({
    statement: 'balance >= 1000',
    witness: { balance },
    hideWitness: true
  });
  
  console.log('Has sufficient balance:', proof.isValid);
}

Next Steps

→ SECURITY

Security Best Practices

Learn how to build secure applications

→ ADVANCED

Advanced Topics

Custom circuits and optimization