PONS - Proof of Non-Spam for Bitcoin Demo

[AbdelStark]

PONS E2E Test Demo - Technical Breakdown

PONS (Proof Of Non-Spam) demonstrates a complete Bitcoin signature verification system using STARK proofs. This documentation breaks down the end-to-end test flow showing how Bitcoin BIP-340 signatures are verified through zero-knowledge cryptographic proofs.

pons-demo.mov

System Architecture

PONS consists of two main components:

• pons_cli (Rust): Bitcoin operations (keygen, signing, verification)
• pons_stark (Cairo): STARK proof generation and verification

Test Flow Breakdown

Step 1: Build Cairo Components

Component: pons_stark/ directory
Operation: Compile Cairo program using Scarb build system
Purpose: Prepares the STARK proof generator that will create zero-knowledge proofs

cd pons_stark && scarb build

Step 2: Build Rust CLI

Component: pons_cli/ directory
Operation: Compile Rust binary using Cargo
Purpose: Creates command-line tools for Bitcoin cryptographic operations

cd pons_cli && cargo build --release

Step 3: Generate Bitcoin keypair

Component: pons-cli keygen
Operation: Generate BIP-340 Taproot keypair
Artifact: keypair.json (contains public/private key pair)
Output: 64-character hex public key

The keypair follows Bitcoin's BIP-340 specification for Schnorr signatures over secp256k1.

Step 4: Create Digital Signature

Component: pons-cli sign
Input: Keypair + message ("Hello PONS E2E Test!")
Operation: BIP-340 Schnorr signature generation
Artifact: signature.json (contains signature + metadata)
Output: 128-character hex signature

Step 5: Prepare STARK Arguments

Component: gen_args_bitcoin.py
Input: Public key + signature + message
Operation: Convert cryptographic data to Cairo-compatible format
Artifact: args.json (44 mathematical field elements)
Purpose: Transform Bitcoin signature data into Cairo program inputs

This step converts the signature verification inputs into finite field elements that the Cairo program can process.

Step 6: Generate STARK Proof

Component: cairo-prove
Input: Cairo executable + arguments
Operation: Generate zero-knowledge proof of signature validity
Artifact: proof.json (~21MB STARK proof)
Time: ~12 seconds
Purpose: Create cryptographic proof that signature is valid.

The STARK proof demonstrates knowledge of a valid signature.

Step 7: Verify STARK Proof

Component: cairo-prove verify
Input: Generated proof
Operation: Verify proof validity
Purpose: Demonstrate that anyone can verify the proof's correctness

This verification step proves the signature was valid without requiring access to the original signature or private key.

Generated Artifacts

File	Size	Purpose
keypair.json	171B	BIP-340 public/private keypair
signature.json	422B	Schnorr signature + metadata
args.json	1.1KB	Cairo circuit inputs (44 field elements)
proof.json	21MB	STARK zero-knowledge proof

Flow Diagram

graph TD
    A[Generate BIP-340 Keypair] --> B[Sign Message with Private Key]
    B --> C[Convert to Cairo Arguments]
    C --> D[Generate STARK Proof]
    D --> E[Verify STARK Proof]
    
    subgraph "Artifacts Generated"
        F[keypair.json<br/>171B]
        G[signature.json<br/>422B] 
        H[args.json<br/>1.1KB]
        I[proof.json<br/>21MB]
    end
    
    A --> F
    B --> G
    C --> H
    D --> I
    
    subgraph "Components"
        J[Rust CLI<br/>Bitcoin Operations]
        K[Cairo Program<br/>STARK Generation]
        L[Python Script<br/>Argument Conversion]
    end
    
    A -.-> J
    B -.-> J
    C -.-> L
    D -.-> K
    E -.-> K
    
    style A fill:#e1f5fe
    style B fill:#e8f5e8
    style C fill:#fff3e0
    style D fill:#fce4ec
    style E fill:#f3e5f5

Loading