SDK & Tooling Roadmap

Empowering a New Generation of Builders

Raze Protocol is committed to a multi-language SDK strategy meticulously tailored to the diverse audiences that will build on the platform. This comprehensive approach ensures that developers can work in their preferred environment while leveraging the full, unparalleled power of ZKML. The roadmap prioritizes the most crucial tools for immediate launch while planning for future expansion to create a ubiquitous and robust developer ecosystem.

Python SDK: The Foundation of AI/ML Integration

The Python SDK is our highest priority, immediate-launch toolkit, recognizing that Python is the

"lingua franca of AI". This SDK will serve as the cornerstone for AI/ML developers and data scientists, providing intuitive APIs to build and compile models from popular frameworks like PyTorch and TensorFlow directly into ZK circuits. It will feature seamless APIs for proof generation and verification, along with onboarding notebooks and a powerful command-line interface (CLI) for model-to-proof workflows. A well-documented Python SDK is considered crucial from Day 1 to accelerate adoption.

Example Python API Snippet (conceptual):

import raze_sdk as raze
from torch_model import MyVotingModel

# 1. Compile the PyTorch model into a ZK-friendly circuit
circuit = raze.compile_model(MyVotingModel, input_shape=(1, 4))

# 2. Run the trusted setup and generate proving/verifying keys
proving_key, verifying_key = circuit.setup()

# 3. Generate a ZK proof for a new decision
features = {'sentiment_score': 0.8, 'technical_feasibility': 0.9, ...}
proof = circuit.generate_proof(features, proving_key)

# 4. Verify the proof off-chain before submitting to the blockchain
is_valid = raze.verify_proof(proof, verifying_key)
print(f"Proof is valid: {is_valid}")

Rust SDK & Core: The High-Performance Engine

Developed in parallel, the Rust SDK is meticulously designed for core protocol developers and performance-critical engines. Given that many leading ZK frameworks are built on Rust (e.g., Halo2, Plonky2), this SDK will provide low-level libraries for complex circuit creation and highly performant clients for agent execution and ZK proving. It is the performant backend that will power the Raze Protocol's proof servers and validator nodes.

Example Rust API Snippet (conceptual):

use raze_core::{ProvingKey, VerifyingKey, Circuit};

// 1. Create a complex circuit for a multi-agent workflow
let circuit = Circuit::create_multi_agent_flow(...);

// 2. Generate proving and verifying keys from the circuit
let (pk, vk) = circuit.trusted_setup();

// 3. Use a high-performance client to generate the proof
let proof_client = raze_core::ProofClient::new(&pk);
let proof = proof_client.prove_agent_action(&agent_data);

// 4. Send the proof to the on-chain verifier
let verifier = OnChainVerifier::new(vk);
verifier.submit_proof(proof).await?;

Solidity (Smart Contracts): The On-Chain Language

As a foundational and immediate priority, the Solidity toolkit will provide essential templates and interfaces for smart contract developers. This toolkit defines how on-chain decentralized applications (dApps) interface with Raze's ZK proofs. Early templates will include a

ProofVerifier contract for validating ZK proofs and simple agent escrow contracts for managing funds and permissions. This is foundational for any DeFi or DAO to integrate verifiable AI.

Example Solidity Contract Snippet:

import "@raze-protocol/contracts/ProofVerifier.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract RazeAgentExecutor is Ownable {
    ProofVerifier private immutable verifier;

    constructor(address _verifierAddress) {
        verifier = ProofVerifier(_verifierAddress);
    }

    function executeVerifiedAction(
        uint[2] memory a,
        uint[2][2] memory b,
        uint[2] memory c,
        uint[1] memory publicInput
    ) external onlyOwner returns (bool) {
        // Step 1: Verify the ZK proof on-chain
        bool isProofValid = verifier.verifyProof(a, b, c, publicInput);
        require(isProofValid, "RAZE: Invalid ZK proof submitted");

        // Step 2: Execute the action after successful verification
        // ... (e.g., cast a vote, execute a trade)
        return true;
    }
}

JavaScript/TypeScript SDK: Bridging the Frontend

A medium-to-high priority deliverable, the JavaScript/TypeScript SDK will accelerate frontend integration and developer onboarding for dApp frontends and Node.js developers. It will include Web3-friendly libraries to interact with Raze contracts and nodes, enabling functionalities such as connecting wallets, submitting jobs, and fetching proofs. It will also support node-based proving, potentially using WASM proof runners for client-side proof generation.

Example JavaScript SDK Snippet (conceptual):

import { RazeClient } from '@raze/client';
import { Wallet, ethers } from 'ethers';

const razeClient = new RazeClient({
    provider: new ethers.providers.Web3Provider(window.ethereum)
});

// Submit a new agent job for proof generation
async function submitAgentJob(proposal) {
    const job = await razeClient.agents.submit({
        agentId: 'governance-voter',
        payload: proposal
    });
    console.log("Job submitted with ID:", job.id);

    // Wait for the proof to be ready
    const proofResult = await job.waitForProof();
    console.log("Proof generated:", proofResult.proof);

    // Submit the proof on-chain
    const tx = await razeClient.contracts.submitProof(proofResult.proof);
    console.log("Transaction hash:", tx.hash);
}

REST/API & CLI Tools: Universal Access

These tools are an immediate, high-priority deliverable, as they provide a lightweight, cross-platform way for any developer to interact with Raze services, regardless of their programming language. The REST APIs will allow agents to submit inference jobs and fetch proof results, while the command-line tools enable agents to run proofs locally or on the Raze network. A

Raze CLI will be launched to allow any language to invoke Raze services, and a data querying API (e.g., GraphQL) will be provided to check agent state and proof status.

Example CLI Command:

# Compile an ONNX model into a ZK circuit
raze compile --model models/voting_model.onnx --output zk/circuits/network.ezkl

# Generate a proof for a specific input
raze prove --input data/proposal_1.json --pk zk/keys/proving.key --proof-path proofs/proof_1.proof

# Verify a proof on the Raze network
raze verify --proof-path proofs/proof_1.proof --vk zk/keys/verifying.key