Private Transactions
Reimagined

Introduction

Blaze Protocol is a privacy-preserving transaction layer built on Solana. It enables users to transact without revealing sensitive information like sender identity, receiver identity, or transaction amounts.

Built with zk-SNARKs and deployed on Solana's high-performance blockchain, Blaze offers institutional-grade privacy with consumer-grade usability.

Key Features

• Complete transaction privacy using zk-SNARKs
• Sub-second confirmation times
• Non-custodial architecture
• Cross-chain private bridges
• MEV protection built-in
• Optional compliance tools

Use Cases

• Private payroll and vendor payments
• Confidential trading strategies
• Personal financial privacy
• Institutional treasury management
• Cross-border remittances

Quick Start

Get up and running with Blaze in under 5 minutes. This guide covers the basics of creating a wallet, funding it, and making your first private transaction.

1. Install Blaze CLI

npm install -g @blazeprotocol/cli

2. Create a Wallet

blaze wallet create --name my-wallet
# Save your seed phrase securely!

3. Fund Your Wallet

blaze wallet fund --amount 10 SOL
# Or transfer from an existing wallet

4. Send a Private Transaction

blaze send --private \
  --amount 100 USDC \
  --to 7xK9...mP2Q \
  --from my-wallet

That's it! Your transaction is now private and untraceable on the blockchain.

Installation

Blaze can be installed as a CLI tool, JavaScript SDK, or used directly via REST API. Choose the option that best fits your workflow.

CLI Installation

# Using npm
npm install -g @blazeprotocol/cli

# Using yarn
yarn global add @blazeprotocol/cli

# Using pnpm
pnpm add -g @blazeprotocol/cli

SDK Installation

# Using npm
npm install @blazeprotocol/sdk

# Using yarn
yarn add @blazeprotocol/sdk

# Using pnpm
pnpm add @blazeprotocol/sdk

Verify Installation

blaze --version
# Should output: blaze-cli v1.0.0

Privacy Model

Blaze uses a combination of zero-knowledge proofs, shielded pools, and stealth addresses to provide comprehensive transaction privacy.

Privacy Layers

Layer 1 — zk-SNARKs: Mathematical proofs that verify transaction validity without revealing transaction details. This is the core privacy primitive.

Layer 2 — Shielded Pools: Shared liquidity pools where funds are mixed with other users' deposits. Withdrawals use new addresses, breaking the transaction chain.

Layer 3 — Stealth Addresses: One-time addresses generated for each incoming payment. Even if someone knows your public key, they can't link payments to you.

What Gets Hidden

• Sender address
• Receiver address
• Transaction amount
• Token type
• Transaction timestamp (approximate)

Zero-Knowledge Proofs

Blaze uses Groth16 zk-SNARKs for efficient proof generation and verification. This allows transactions to be verified in milliseconds while maintaining complete privacy.

Proof Generation

import { BlazeSDK } from '@blazeprotocol/sdk';

const sdk = new BlazeSDK();

// Generate proof locally
const proof = await sdk.generateProof({
  input: {
    privateKey: userPrivateKey,
    amount: 1000,
    recipient: recipientAddress
  },
  public: {
    merkleRoot: poolMerkleRoot,
    nullifierHash: computeNullifier()
  }
});

Proof Verification

// Verify on-chain
const isValid = await sdk.verifyProof(proof, publicInputs);
console.log(isValid); // true

Shielded Pools

Shielded pools are shared liquidity pools where users deposit funds to gain privacy. When you withdraw, you receive funds from the pool with no link to your deposit.

How It Works

// Deposit into pool
const deposit = await sdk.pool.deposit({
  amount: 1000,
  token: 'USDC',
  denomination: 100 // Use 100 USDC notes
});

// Wait for mixing...

// Withdraw to new address
const withdraw = await sdk.pool.withdraw({
  proof: deposit.proof,
  recipient: newStealthAddress
});

Pool Denominations

To maximize privacy, deposits and withdrawals use fixed denominations. Currently supported: 1, 10, 100, 1000, 10000 USDC.

JavaScript SDK

The Blaze JavaScript SDK provides a simple interface for integrating privacy features into your applications.

Initialize SDK

import { BlazeSDK } from '@blazeprotocol/sdk';

const blaze = new BlazeSDK({
  network: 'mainnet', // or 'devnet'
  rpcUrl: 'https://api.mainnet-beta.solana.com'
});

Send Private Transaction

const tx = await blaze.send({
  private: true,
  amount: 100,
  token: 'USDC',
  recipient: '7xK9...mP2Q',
  wallet: myWallet
});

console.log(tx.signature); // Private signature

CLI Reference

The Blaze CLI provides command-line access to all protocol features.

Commands

# Wallet management
blaze wallet create --name <name>
blaze wallet list
blaze wallet balance

# Private transactions
blaze send --private --amount <n> --to <address>
blaze receive --stealth

# Pool operations
blaze pool deposit --amount <n> --denomination <n>
blaze pool withdraw --proof <proof>

# Stealth addresses
blaze stealth generate
blaze stealth list

REST API

Blaze provides a REST API for server-side integrations and third-party applications.

Base URL

https://api.blazeprotocol.io/v1

Endpoints

GET /health - Check API status
POST /tx/send - Submit private transaction
GET /tx/status/:id - Get transaction status
POST /pool/deposit - Deposit to shielded pool
POST /pool/withdraw - Withdraw from pool
GET /pool/stats - Get pool statistics

Authentication

curl -H "Authorization: Bearer YOUR_API_KEY" \
  https://api.blazeprotocol.io/v1/pool/stats