Astree Documentation

npm install -g @astree/cli

astree init my-dappcd my-dapp

npm run dev

What are Zero-Knowledge Proofs?

Zero-knowledge proofs (ZKPs) allow one party to prove to another that a statement is true without revealing any information beyond the validity of the statement itself. In Astree, this enables private computation and verification on-chain.

• Completeness: If the statement is true, an honest prover can convince an honest verifier
• Soundness: If the statement is false, no cheating prover can convince the verifier
• Zero-Knowledge: The proof reveals nothing except the truth of the statement

Astree's ZK Implementation

Astree uses state-of-the-art PLONK-based proving systems optimized for Solana's architecture:

• Optimized for low verification costs on Solana
• Fast proof generation using GPU acceleration
• Recursive proofs for scalability
• Batched verification for efficiency

On-Chain Verification

Astree provides optimized Solana programs for verifying ZK proofs on-chain with minimal compute units.

import { AstreeClient } from '@astree/sdk';
import { Connection, PublicKey } from '@solana/web3.js';

const connection = new Connection('https://api.mainnet-beta.solana.com');
const astreeClient = new AstreeClient(connection);

// Submit proof for verification
const tx = await astreeClient.verifyProof({
  circuit: ageVerificationCircuit,
  proof: proof,
  programId: new PublicKey('Astree1111...'),
});

console.log('Proof verified on-chain:', tx);

Account Structure

Astree uses dedicated Solana accounts to store circuit definitions and verification keys:

• Circuit Account: Stores circuit definition and metadata
• Verification Key Account: Contains cryptographic keys for proof verification
• Proof Account: Temporary storage for proof data during verification

Privacy Guarantees

• Input Privacy:

  Private inputs are never revealed on-chain or to any party

• Computation Privacy:

  Intermediate computation steps remain confidential

• State Privacy:

  Application state can be kept private using commitments

Use Cases

Circuit Class

class Circuit {
  constructor(config: CircuitConfig)
  prove(inputs: CircuitInputs): Promise<Proof>
  verify(proof: Proof): Promise<boolean>
  compile(): Promise<CompiledCircuit>
  deploy(connection: Connection): Promise<PublicKey>
}

The main class for defining and working with ZK circuits in Astree.

Field Types

import { Field, Bool, UInt64, Struct } from '@astree/circuits';

// Basic field element
const age = Field(25);

// Boolean
const isAdult = Bool(true);

// Unsigned 64-bit integer
const amount = UInt64(1000);

// Custom struct
class User extends Struct({
  id: Field,
  balance: UInt64,
  isActive: Bool,
}) {}

Basic Proof Generation

// Generate a proof
const proof = await circuit.prove({
  privateInputs: {
    age: 25,
    secret: "my-secret-key"
  },
  publicInputs: {
    minimumAge: 18
  }
});

// Proof contains:
// - Proof data (serialized for on-chain verification)
// - Public outputs
// - Metadata
console.log(proof.data); // Uint8Array
console.log(proof.publicOutputs); // { isOldEnough: true }

Performance Optimization

• Use GPU acceleration for faster proof generation
• Cache compiled circuits to avoid recompilation
• Use web workers for non-blocking proof generation in browsers

Circuit Design

• Keep circuits small and focused on specific functionality
• Minimize the number of constraints for faster proving
• Use built-in optimized operations when possible

Security

• Never expose private inputs in logs or error messages
• Validate all public inputs before proof generation
• Use secure random number generation for nonces and salts