Shroud SDK Documentation

npm install @shroud/sdk

yarn add @shroud/sdk

/shroud-sdk
  /src
    /core
      ShroudClient.ts      # Main SDK client
      ProofEngine.ts       # Proof generation engine
      BackendManager.ts    # Backend abstraction layer
      types.ts             # TypeScript definitions
    /backends
      /halo2
        halo2.prover.ts
        halo2.verifier.ts
      /risc0
        risc0.prover.ts
        risc0.verifier.ts
      /nova
        nova.prover.ts
        nova.verifier.ts
      /fflonk
        fflonk.prover.ts
        fflonk.verifier.ts
    /solana
      SolanaClient.ts      # Solana integration
      SolanaVerifier.ts    # On-chain verifier
    index.ts

import { Shroud } from "@shroud/sdk";
import { Keypair } from "@solana/web3.js";

const shroud = new Shroud({
  network: "devnet", // or "mainnet-beta"
  rpcUrl: "https://api.devnet.solana.com",
  programId: "xxxxxxxxxxxxxxxxxxxxxxxx", // Shroud verifier program
  signer: Keypair.fromSecretKey(secretKey) // Your wallet
});

// Generate proof
const proof = await shroud.prover.generate({
  backend: "halo2",
  inputs: {
    secret: secretValue,
    public: { amount: 1000 }
  }
});

// Submit to Solana
const txSignature = await shroud.solana.verifyProof(proof, {
  computeUnits: 400_000, // Optional: adjust compute budget
  priorityFee: 1000       // Optional: priority fee in micro-lamports
});

console.log("Transaction:", txSignature);

// Check if proof was verified
const status = await shroud.solana.getProofStatus(txSignature);

if (status.verified) {
  console.log("Proof verified successfully!");
  console.log("Public outputs:", status.publicOutputs);
} else {
  console.log("Verification failed:", status.error);
}

import { PublicKey, Transaction } from "@solana/web3.js";

// Build custom transaction
const ix = await shroud.solana.createVerifyInstruction({
  proof: serializedProof,
  publicInputs: publicData,
  backend: "risc0"
});

const tx = new Transaction().add(ix);
const signature = await shroud.solana.sendTransaction(tx);

interface ShroudConfig {
  network: "devnet" | "mainnet-beta";
  rpcUrl?: string;
  programId?: string;
  signer?: Keypair | Wallet;
  logLevel?: "debug" | "info" | "warn" | "error";
}

interface ProofGenerationOptions {
  backend: "halo2" | "risc0" | "nova" | "fflonk";
  inputs: {
    secret?: any;        // Private inputs
    public?: any;        // Public inputs
    witness?: any;       // Circuit witness
    program?: string;    // For Risc0: program name
    steps?: any[];       // For Nova: computation steps
    circuit?: any;       // For Fflonk: circuit definition
  };
  options?: {
    optimize?: boolean;  // Enable proof optimization
    compression?: boolean; // Enable proof compression
  };
}

class ProofEngine {
  // Generate a proof
  async generate(options: ProofGenerationOptions): Promise<Proof>
  
  // Verify a proof locally
  async verify(proof: Proof): Promise<boolean>
  
  // Get supported backends
  getSupportedBackends(): string[]
  
  // Switch backend
  setBackend(backend: BackendType): void
}

class SolanaClient {
  // Submit proof for on-chain verification
  async verifyProof(
    proof: Proof, 
    options?: TransactionOptions
  ): Promise<string>
  
  // Get proof verification status
  async getProofStatus(signature: string): Promise<ProofStatus>
  
  // Create verify instruction (advanced)
  async createVerifyInstruction(
    params: VerifyInstructionParams
  ): Promise<TransactionInstruction>
  
  // Send custom transaction
  async sendTransaction(tx: Transaction): Promise<string>
}

// lib/shroud.ts
import { Shroud } from "@shroud/sdk";

let shroudInstance: Shroud | null = null;

export function getShroudClient(): Shroud {
  if (!shroudInstance) {
    shroudInstance = new Shroud({
      network: process.env.SOLANA_NETWORK as "devnet" | "mainnet-beta",
      rpcUrl: process.env.SOLANA_RPC_URL,
      programId: process.env.SHROUD_PROGRAM_ID,
      logLevel: process.env.NODE_ENV === "production" ? "warn" : "debug"
    });
  }
  return shroudInstance;
}

// Usage in API routes
import { getShroudClient } from "@/lib/shroud";

export async function POST(request: Request) {
  const shroud = getShroudClient();
  const proof = await shroud.prover.generate({ ... });
  return Response.json({ proof });
}

// High-volume production workloads
import { Queue } from "bullmq";
import { getShroudClient } from "@/lib/shroud";

const proofQueue = new Queue("proofs", {
  connection: { host: "localhost", port: 6379 }
});

// Add proof generation job
async function requestProof(inputs: any) {
  const job = await proofQueue.add("generate", {
    backend: "halo2",
    inputs
  });
  return job.id;
}

// Worker process
proofQueue.process(async (job) => {
  const shroud = getShroudClient();
  const proof = await shroud.prover.generate(job.data);
  await shroud.solana.verifyProof(proof);
  return { proofId: proof.id };
});

import { getShroudClient } from "@/lib/shroud";
import { logger } from "@/lib/logger";

const shroud = getShroudClient();

// Listen to proof generation events
shroud.on("proof:generated", (proof) => {
  logger.info("Proof generated", {
    proofId: proof.id,
    backend: proof.backend,
    duration: proof.generationTime
  });
});

shroud.on("proof:verified", (result) => {
  logger.info("Proof verified on-chain", {
    signature: result.signature,
    slot: result.slot
  });
});

shroud.on("error", (error) => {
  logger.error("Shroud error", { error });
});