Version 1.0
October 2025
Solstice Protocol introduces a privacy-preserving identity verification system built on Solana blockchain, leveraging India's Aadhaar infrastructure and zero-knowledge cryptography. By combining Groth16 SNARKs, Light Protocol's ZK compression, and government-issued digital identities, Solstice enables users to prove identity attributes (age, nationality, uniqueness) without revealing personal information. This creates a self-sovereign identity layer that is privacy-first, cost-efficient, and regulatory compliant, serving as critical infrastructure for Web3 applications requiring KYC/AML compliance, Sybil resistance, and human verification.
Key Innovation: Solstice transforms government-issued identity credentials into portable, privacy-preserving ZK proofs that can be verified across any Web3 application, achieving a 5000x cost reduction compared to traditional on-chain storage while maintaining cryptographic security and regulatory compliance.
- Introduction
- Problem Statement
- Technical Architecture
- Zero-Knowledge Proof System
- Light Protocol Integration
- Smart Contract Design
- Security Model
- Use Cases
- Economic Model
- Roadmap
- Conclusion
Web3 promises decentralization and user sovereignty, yet most applications still struggle with basic identity verification challenges:
- DeFi protocols need KYC/AML compliance but compromise user privacy
- Gaming platforms face Sybil attacks from bot accounts
- DAOs require one-person-one-vote without centralized identity providers
- Social platforms struggle to distinguish humans from AI agents
Solstice Protocol solves these challenges by creating a self-sovereign identity layer where users control their identity data, generate proofs locally, and verify attributes cryptographically across any application—without centralized intermediaries or data exposure.
- Privacy by Design: Zero-knowledge proofs ensure no personal data ever leaves user control
- Self-Sovereignty: Users own their identity commitments and generate proofs independently
- Interoperability: Single identity verification works across all Solana dApps
- Regulatory Compliance: Built-in support for KYC/AML requirements without privacy trade-offs
- Cost Efficiency: Light Protocol compression reduces storage costs by 5000x
- Government-Grade Security: Leverages UIDAI's cryptographic infrastructure
- 1.4 billion Aadhaar holders (potential users)
- $24.5 billion blockchain identity market by 2028 (CAGR 71.5%)
- 100+ DeFi protocols requiring KYC compliance
- Gaming & social platforms needing Sybil resistance
- DAOs seeking democratic governance mechanisms
- Privacy Violations: Centralized databases leak sensitive data (Equifax: 147M records, Aadhaar: multiple breaches)
- Vendor Lock-in: Users must create new accounts for each service
- Data Monetization: User data sold without consent
- Single Point of Failure: Database breaches expose millions
- Wallet ≠ Identity: Public addresses reveal transaction history but prove nothing about the human
- KYC Paradox: Regulatory compliance requires centralized KYC, defeating Web3's purpose
- Sybil Vulnerability: No cost-effective way to prove uniqueness
- High Storage Costs: Full identity data on-chain costs $100-1000 per user on Solana
- Worldcoin: Requires physical orb scanning (privacy concerns, limited access)
- Civic: Centralized verification, not zero-knowledge
- BrightID: Social graph-based (gameable, not regulatory compliant)
- Polygon ID: Not Solana-native, complex implementation
Solstice combines three breakthrough technologies:
- Aadhaar Infrastructure: 1.4B government-verified identities with 2048-bit RSA signatures
- Groth16 SNARKs: Sub-second proof generation, constant-size proofs (256 bytes)
- Light Protocol: 5000x compression, $0.00001 per identity vs $0.05 traditional
Result: Privacy-preserving, cost-efficient, government-backed identity verification at Web3 scale.
┌─────────────────────────────────────────────────────────────┐
│ User Device │
│ ┌────────────────┐ ┌──────────────┐ ┌────────────────┐ │
│ │ mAadhaar App │→ │ QR Scanner │→ │ ZK Prover │ │
│ │ (UIDAI) │ │ (Frontend) │ │ (Browser) │ │
│ └────────────────┘ └──────────────┘ └────────────────┘ │
└─────────────────────────────────────────────────────────────┘
↓
┌───────────────────────┐
│ Identity Commitment │
│ (32-byte hash) │
└───────────────────────┘
↓
┌─────────────────────────────────────────────────────────────┐
│ Solana Blockchain │
│ ┌────────────────────────────────────────────────────────┐ │
│ │ Solstice Smart Contracts (Rust/Anchor) │ │
│ │ ┌──────────────┐ ┌──────────────┐ ┌─────────────┐ │ │
│ │ │ Registry │ │ Identity │ │ Session │ │ │
│ │ │ Program │ │ Accounts │ │ Manager │ │ │
│ │ └──────────────┘ └──────────────┘ └─────────────┘ │ │
│ │ │ │
│ │ ┌──────────────────────────────────────────────────┐ │ │
│ │ │ Groth16 Verifier (BN254 Pairing) │ │ │
│ │ │ • Age Proof Verification │ │ │
│ │ │ • Nationality Proof Verification │ │ │
│ │ │ • Uniqueness Proof Verification │ │ │
│ │ └──────────────────────────────────────────────────┘ │ │
│ └────────────────────────────────────────────────────────┘ │
│ ↕ │
│ ┌────────────────────────────────────────────────────────┐ │
│ │ Light Protocol ZK Compression Layer │ │
│ │ • Compressed Merkle Trees │ │
│ │ • Poseidon Hash Function │ │
│ │ • Nullifier Management │ │
│ │ • State Diff Compression │ │
│ └────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘
↓
┌───────────────────────┐
│ dApp Integration │
│ (Any Solana App) │
└───────────────────────┘
- QR Scanner: Captures and decodes Aadhaar Secure QR codes
- Data Parser: Extracts demographic data from XML structure
- Commitment Generator: Creates Pedersen commitment from identity data
- Proof Generator: Runs snarkjs in browser to generate Groth16 proofs
- Wallet Integration: Connects via Solana Wallet Adapter
// Program ID
declare_id!("ELqNcvWpY4L5qAe7P4PuEKMo86zrouKctZF3KuSysuYY");
// Core Instructions
pub fn initialize() // Initialize global registry
pub fn register_identity() // Store identity commitment
pub fn verify_identity() // Verify ZK proof
pub fn update_identity() // Update commitment
pub fn revoke_identity() // Revoke verification
pub fn create_session() // Create dApp session
pub fn close_session() // End sessionAccount Structures:
pub struct Identity {
pub owner: Pubkey, // User's wallet
pub identity_commitment: [u8; 32], // Pedersen commitment
pub merkle_root: [u8; 32], // Merkle tree root
pub is_verified: bool, // Verification status
pub verification_timestamp: i64, // Last verification
pub attributes_verified: u32, // Bitmap: 1=age, 2=nationality, 4=uniqueness
pub bump: u8, // PDA bump seed
}
pub struct IdentityRegistry {
pub authority: Pubkey, // Registry admin
pub total_identities: u64, // Total registered
pub bump: u8, // PDA bump
}
pub struct Session {
pub user: Pubkey, // Session owner
pub identity: Pubkey, // Associated identity
pub dapp: Pubkey, // Requesting dApp
pub expires_at: i64, // Expiration timestamp
pub attributes_shared: u32, // Shared attribute bitmap
pub bump: u8, // PDA bump
}- QR Parser: Validates UIDAI signature, extracts data
- Proof Service: Coordinates proof generation workflow
- Database: PostgreSQL for audit trail, session management
- API Gateway: RESTful endpoints for frontend integration
circuits/
├── age_proof.circom // Proves age > threshold
├── nationality_proof.circom // Proves nationality
├── uniqueness_proof.circom // Proves one-person-one-account
└── build/
├── age_proof.r1cs // Compiled circuit
├── age_proof.wasm // WebAssembly prover
└── verification_key.json // On-chain verifier key
1. User opens mAadhaar app → Displays QR code
2. User scans QR in Solstice dApp
3. Frontend extracts: name, DOB, gender, address, photo, signature
4. Validate UIDAI RSA signature (2048-bit)
5. Generate identity commitment: H(data || nonce)
6. Create Merkle tree of attributes
7. Send to Solana: register_identity(commitment, merkle_root)
8. Light Protocol compresses state (5000x reduction)
9. Store compressed commitment on-chain
10. Backend logs transaction in audit database
1. dApp requests: "Prove you're 18+ and in India"
2. User generates ZK proof locally:
- Private inputs: DOB, nationality, nonce
- Public inputs: commitment, attribute claims
- Circuit: age_proof.circom
3. Browser generates Groth16 proof (2-5 seconds)
4. User signs and submits proof to Solana
5. Smart contract verifies proof:
- Check proof validity (BN254 pairing)
- Verify public inputs match commitment
- Check attribute claims
6. Update identity.attributes_verified bitmap
7. dApp receives verification confirmation
8. User can reuse proof across any dApp
Why Groth16?
- Constant Proof Size: 256 bytes regardless of circuit complexity
- Fast Verification: Sub-millisecond on-chain verification
- Small Public Inputs: Only commitment + attribute claims
- Battle-Tested: Used in Zcash, Filecoin, Loopring
Proof Structure:
Proof = (A, B, C) // 256 bytes total
- A: 32 bytes (G1 point)
- B: 64 bytes (G2 point)
- C: 32 bytes (G1 point)
- Public inputs: 32-64 bytes
template AgeProof() {
// Private inputs
signal input dateOfBirth; // DOB as YYYYMMDD
signal input nonce; // Random nonce
// Public inputs
signal input commitment; // Identity commitment
signal input ageThreshold; // Minimum age (e.g., 18)
signal input currentDate; // Current date YYYYMMDD
// Constraint 1: Commitment validation
signal computedCommitment;
component hasher = Poseidon(2);
hasher.inputs[0] <== dateOfBirth;
hasher.inputs[1] <== nonce;
computedCommitment <== hasher.out;
commitment === computedCommitment;
// Constraint 2: Age calculation
signal age;
age <== (currentDate - dateOfBirth) / 10000;
// Constraint 3: Age threshold check
component greaterThan = GreaterThan(8);
greaterThan.in[0] <== age;
greaterThan.in[1] <== ageThreshold;
greaterThan.out === 1;
}Constraints: ~50,000
Proving Time: 2-3 seconds (browser)
Verification Time: <1ms (on-chain)
template NationalityProof() {
signal input nationality; // Country code (e.g., "IN")
signal input nonce;
signal input commitment;
signal input allowedNationality; // Expected country
// Validate commitment
component hasher = Poseidon(2);
hasher.inputs[0] <== nationality;
hasher.inputs[1] <== nonce;
commitment === hasher.out;
// Check nationality match
nationality === allowedNationality;
}Constraints: ~30,000
Proving Time: 1-2 seconds
template UniquenessProof() {
signal input aadhaarNumber; // 12-digit Aadhaar
signal input nonce;
signal input commitment;
signal input nullifierHash; // Prevents double-registration
// Validate commitment
component hasher = Poseidon(2);
hasher.inputs[0] <== aadhaarNumber;
hasher.inputs[1] <== nonce;
commitment === hasher.out;
// Generate nullifier (prevents reuse)
component nullifier = Poseidon(1);
nullifier.inputs[0] <== aadhaarNumber;
nullifierHash === nullifier.out;
}Constraints: ~10,000
Proving Time: <1 second
Powers of Tau Ceremony:
- Phase 1: Universal setup (BN254 curve, 2^15 constraints)
- Phase 2: Circuit-specific setup (age, nationality, uniqueness)
- Participants: 10+ independent contributors
- Security: Safe if ≥1 participant honest
Verification Keys:
// Exported to Rust for on-chain verification
pub struct VerificationKey {
pub alpha: G1Affine,
pub beta: G2Affine,
pub gamma: G2Affine,
pub delta: G2Affine,
pub ic: Vec<G1Affine>,
}Zero-Knowledge: Verifier learns nothing beyond claim validity
Soundness: Impossible to forge valid proof without knowing witness
Completeness: Valid witness always produces accepted proof
Non-Malleability: Proof cannot be modified or reused
Problem: Traditional Solana accounts cost ~0.002 SOL (≈$0.05) per identity
Solution: Light Protocol stores only state roots, data in ledger history
Compression Ratio:
Traditional Account:
- Identity data: 115 bytes
- Rent: 0.00169 SOL
- Cost per 1M users: 1,690 SOL ($42,250)
Compressed Account:
- State root: 32 bytes
- Rent: 0.00000034 SOL
- Cost per 1M users: 0.34 SOL ($8.50)
Savings: 5000x cost reduction
Root (32 bytes)
/ \
Branch Branch
/ \ / \
Leaf1 Leaf2 Leaf3 Leaf4
(User1) (User2) (User3) (User4)
Leaf = H(identity_commitment || merkle_root || owner)
On-Chain Storage: Only root hash
Off-Chain Storage: Full tree in Solana ledger history
Proof Size: log₂(n) * 32 bytes (e.g., 20 hashes for 1M users = 640 bytes)
Why Poseidon?
- ZK-friendly: Efficient in arithmetic circuits
- Low constraints: ~150 constraints per hash vs 20,000 for SHA-256
- Collision-resistant: 128-bit security
Implementation:
pub fn compress_identity_data(
owner: &Pubkey,
commitment: &[u8; 32],
merkle_root: &[u8; 32],
) -> Result<[u8; 32]> {
let mut hasher = Poseidon::new();
hasher.update(owner.to_bytes());
hasher.update(commitment);
hasher.update(merkle_root);
Ok(hasher.finalize())
}Sybil Prevention:
// Nullifier = H(aadhaar_number || app_id)
pub fn generate_nullifier(aadhaar: &str, app_id: &Pubkey) -> [u8; 32] {
let mut hasher = Poseidon::new();
hasher.update(aadhaar.as_bytes());
hasher.update(app_id.to_bytes());
hasher.finalize()
}Properties:
- Unique per user per app
- Cannot link across apps
- Prevents double-registration
- Preserves privacy
#[program]
pub mod solstice_protocol {
// Registry management
pub fn initialize(ctx: Context<Initialize>) -> Result<()>
// Identity lifecycle
pub fn register_identity(
ctx: Context<RegisterIdentity>,
identity_commitment: [u8; 32],
merkle_root: [u8; 32],
) -> Result<()>
pub fn update_identity(
ctx: Context<UpdateIdentity>,
new_commitment: [u8; 32],
new_merkle_root: [u8; 32],
) -> Result<()>
// Verification
pub fn verify_identity(
ctx: Context<VerifyIdentity>,
proof: Vec<u8>, // 256-byte Groth16 proof
public_inputs: Vec<u8>, // Public signals
attribute_type: u8, // 1=age, 2=nationality, 4=uniqueness
) -> Result<()>
// Session management
pub fn create_session(
ctx: Context<CreateSession>,
dapp: Pubkey,
duration: i64,
attributes: u32,
) -> Result<()>
pub fn close_session(ctx: Context<CloseSession>) -> Result<()>
}PDA (Program Derived Addresses):
// Identity PDA: ["identity", user_pubkey]
let (identity_pda, bump) = Pubkey::find_program_address(
&[b"identity", user.key().as_ref()],
program_id,
);
// Session PDA: ["session", user_pubkey, dapp_pubkey]
let (session_pda, bump) = Pubkey::find_program_address(
&[b"session", user.key().as_ref(), dapp.key().as_ref()],
program_id,
);Benefits:
- Deterministic address generation
- No private key required
- Cannot be front-run
- Program controls via seeds
pub fn verify_identity(
ctx: Context<VerifyIdentity>,
proof: Vec<u8>,
public_inputs: Vec<u8>,
attribute_type: u8,
) -> Result<()> {
let identity = &mut ctx.accounts.identity;
// 1. Validate proof format
require!(proof.len() == 256, ErrorCode::InvalidProof);
require!(public_inputs.len() > 0, ErrorCode::InvalidPublicInputs);
// 2. Select verification key based on attribute
let vkey = match attribute_type {
1 => &AGE_VERIFICATION_KEY,
2 => &NATIONALITY_VERIFICATION_KEY,
4 => &UNIQUENESS_VERIFICATION_KEY,
_ => return Err(ErrorCode::InvalidAttributeType.into()),
};
// 3. Verify Groth16 proof
let is_valid = verify_groth16_proof(&proof, &public_inputs, vkey)?;
require!(is_valid, ErrorCode::InvalidProof);
// 4. Update verification status
identity.attributes_verified |= attribute_type; // Set bit
identity.is_verified = true;
identity.verification_timestamp = Clock::get()?.unix_timestamp;
// 5. Emit event
msg!("Attribute {} verified for {}", attribute_type, identity.owner);
Ok(())
}use light_compressed_account::CompressedAccount;
pub fn register_identity(
ctx: Context<RegisterIdentity>,
identity_commitment: [u8; 32],
merkle_root: [u8; 32],
) -> Result<()> {
// Create compressed account
let compressed_data = compress_identity_data(
ctx.accounts.user.key(),
&identity_commitment,
&merkle_root,
)?;
// Store only the hash on-chain
let identity = &mut ctx.accounts.identity;
identity.owner = ctx.accounts.user.key();
identity.identity_commitment = identity_commitment;
identity.merkle_root = merkle_root;
// Log compression savings
let (bytes_saved, percentage) = calculate_compression_savings();
msg!("Compressed: {} bytes saved ({}%)", bytes_saved, percentage);
Ok(())
}#[error_code]
pub enum ErrorCode {
#[msg("Invalid proof provided")]
InvalidProof,
#[msg("Public inputs do not match commitment")]
InvalidPublicInputs,
#[msg("Unauthorized access to identity")]
UnauthorizedAccess,
#[msg("Identity already verified")]
AlreadyVerified,
#[msg("Session expired")]
SessionExpired,
#[msg("Invalid attribute type")]
InvalidAttributeType,
#[msg("Nullifier already used (double registration)")]
NullifierAlreadyUsed,
}Adversary Capabilities:
- Can observe all on-chain data
- Can attempt to forge proofs
- Can try to link identities across apps
- Cannot break cryptographic primitives
Security Guarantees:
- Privacy: Zero-knowledge proofs reveal no personal data
- Integrity: UIDAI signatures prevent forgery
- Sybil Resistance: Nullifiers prevent double-registration
- Unlinkability: Different nullifiers per app
- Availability: Decentralized Solana blockchain
Attack: Attacker generates proof without valid witness
Mitigation: Groth16 soundness (computationally infeasible)
Security Level: 128-bit (BN254 curve)
Attack: Two users generate same commitment
Mitigation: Poseidon hash with random nonce
Security Level: 256-bit collision resistance
Attack: One person creates multiple identities
Mitigation: Nullifier system based on Aadhaar number
Detection: On-chain nullifier registry checks duplicates
Attack: Reuse proof across different apps
Mitigation: App-specific nullifiers, timestamp validation
Prevention: Each proof bound to (user, app, timestamp)
Attack: MEV bot front-runs identity registration
Mitigation: PDAs (no signature required), Jito MEV protection
Security: Deterministic addresses, no extractable value
Attack: Link identity across apps via on-chain patterns
Mitigation: Different PDAs per app, nullifiers unlink
Privacy Level: k-anonymity set of all Aadhaar holders
- Aadhaar Signature Security: RSA-2048 unbreakable (NIST recommended until 2030)
- Groth16 Security: Relies on q-PKE and q-PDH assumptions on BN254
- Poseidon Security: Collision resistance with 128-bit security
- Trusted Setup: Secure if ≥1 of n participants honest (n=10+)
Planned Audits:
- Smart contract audit (Trail of Bits, Q1 2026)
- ZK circuit audit (Least Authority, Q2 2026)
- Economic audit (Gauntlet, Q3 2026)
Formal Verification:
- Rust contract verification with Prusti
- Circom circuit equivalence checking
- PDA generation correctness proofs
Problem: Regulated protocols need user verification without centralized KYC
Solution: Users prove nationality ≠ sanctioned country + age ≥ 18
Benefit: Regulatory compliance with privacy preservation
Example: Decentralized exchange
// Check user eligibility
const session = await program.methods
.createSession(dappPubkey, 3600, 0b011) // age + nationality
.accounts({ user, identity })
.rpc();
// Verify attributes
if (identity.attributes_verified & 0b011 === 0b011) {
// User verified: 18+ and non-sanctioned
enableTrading(user);
}Problem: Security token offerings require investor accreditation
Solution: Extend circuit to prove income/net worth thresholds
Benefit: Compliant STOs without revealing financial data
Problem: Bots farm airdrops with fake accounts
Solution: Require uniqueness proof (one Aadhaar = one account)
Benefit: Fair token distribution to real users
Example: Game item airdrop
// Require human verification
const uniquenessProof = await generateUniquenessProof();
await claimAirdrop(uniquenessProof);
// Smart contract checks nullifier
if (!isNullifierUsed(uniquenessProof.nullifier)) {
grantReward(user);
markNullifierUsed(uniquenessProof.nullifier);
}Problem: Platforms face liability for underage users
Solution: Age proof requirement (≥13, ≥18, ≥21)
Benefit: Compliance without identity collection
Problem: Plutocratic voting (1 token = 1 vote)
Solution: Quadratic voting with uniqueness proofs
Benefit: True democratic governance
Example: DAO proposal
pub fn vote(
ctx: Context<Vote>,
proposal_id: u64,
uniqueness_proof: Vec<u8>,
) -> Result<()> {
// Verify uniqueness (one person one vote)
verify_uniqueness_proof(&uniqueness_proof)?;
// Cast vote
let vote_weight = (tokens_held as f64).sqrt() as u64;
record_vote(proposal_id, vote_weight);
Ok(())
}Problem: Nation-state DAOs need citizenship proof
Solution: Nationality proof circuit
Benefit: Governance rights tied to citizenship
Problem: Undercollateralized lending needs identity/credit history
Solution: Prove age, income range, employment status
Benefit: Credit without data exposure
Problem: DeFi insurance requires policyholder verification
Solution: Prove identity attributes required by policy
Benefit: Compliant insurance without centralization
Identity Registration:
- On-chain transaction: 0.000005 SOL ($0.0001)
- Compressed storage rent: 0.00000034 SOL ($0.000008)
- Total: ~$0.0001 (vs $0.05 traditional)
Proof Generation:
- Age proof: Free (browser-based)
- Nationality proof: Free
- Uniqueness proof: Free
Verification:
- Submit proof: 0.000005 SOL ($0.0001)
- Total per verification: $0.0001
SDK Integration: Free (open-source)
Smart contract calls: 0.000005 SOL per verification
Session creation: 0.000005 SOL per session
Monthly costs (10K active users):
- 10,000 verifications × $0.0001 = $1
- vs centralized KYC: 10,000 × $2 = $20,000
Savings: 99.995%
- 0.1% fee on commercial verifications
- Free for public goods / open-source projects
- Revenue splits:
- 50% → Treasury for development
- 30% → Stakers / validators
- 20% → User privacy grants
- Advanced circuits (income proofs, credit scores)
- Enterprise SLA support
- White-label solutions
- Analytics dashboards
SOLSTICE Token (TBD):
- Governance: Vote on protocol upgrades
- Staking: Earn verification fees
- Privacy Mining: Rewards for ZK proof generation
- Treasury: Fund public goods
Distribution:
- 40% Community (airdrops, incentives)
- 25% Team & Advisors (4-year vest)
- 20% Ecosystem Fund
- 10% Early Supporters
- 5% Liquidity Provision
- Core smart contracts (Rust/Anchor)
- Age, nationality, uniqueness circuits
- Frontend QR scanner + prover
- Light Protocol compression
- Backend API & database
- Testnet deployment
- Developer documentation
- Professional smart contract audit
- ZK circuit security review
- Penetration testing
- Bug bounty program ($100K pool)
- Mainnet beta launch
- SDK releases (JavaScript, Rust, Python)
- 10+ dApp integrations (DeFi, gaming, social)
- Developer grants program ($1M)
- Hackathon sponsorships
- Marketing campaigns (target 100K users)
- Token launch (governance + utility)
- DAO formation (protocol governance)
- Decentralized sequencer network
- Cross-chain bridges (Ethereum, Polygon)
- Mobile app (iOS + Android)
- Additional ID systems (PassportNFT, eID)
- Biometric proofs (FaceID, fingerprint)
- AI agent verification
- Compliance framework (GDPR, CCPA)
- Enterprise partnerships
Solstice Protocol represents a paradigm shift in digital identity: from centralized data collection to self-sovereign, privacy-preserving verification. By combining India's robust Aadhaar infrastructure with cutting-edge zero-knowledge cryptography and Solana's high-performance blockchain, we enable 1.4 billion users to prove their identity without exposing personal information.
- Privacy at Scale: ZK proofs protect 1.4B potential users' data
- Cost Efficiency: 5000x reduction vs traditional on-chain storage
- Regulatory Compliance: Government-backed verification meets KYC/AML requirements
- Developer-Friendly: Simple SDK, 10-minute integration
- Interoperability: Single identity works across entire Solana ecosystem
- First-Mover: First Aadhaar-based ZK identity on Solana
- Network Effects: Each new user/dApp increases value
- Technical Moat: Deep integration of Groth16 + Light + Solana
- Regulatory Moat: Compliance-first design attracts institutions
- Cost Moat: 99.995% cheaper than alternatives
Web3's promise of decentralization cannot be fulfilled without self-sovereign identity. Solstice Protocol provides the missing infrastructure layer, enabling a future where:
- Users control their data and privacy
- Developers build without centralized dependencies
- Regulators can enforce compliance without surveillance
- Billions can participate in the global digital economy
The future of identity is private, portable, and self-sovereign. The future is Solstice.
Solana Program:
- Program ID:
ELqNcvWpY4L5qAe7P4PuEKMo86zrouKctZF3KuSysuYY - Network: Solana Mainnet Beta
- Framework: Anchor 0.30.1
- Language: Rust 1.75+
ZK Circuits:
- Proving System: Groth16 (snarkjs)
- Curve: BN254 (alt_bn128)
- Hash: Poseidon
- Constraints: 10K-2M depending on circuit
Compression:
- Protocol: Light Protocol v0.3+
- Tree Depth: 26 (67M capacity)
- Compression Ratio: 5000x
- Groth, Jens. "On the Size of Pairing-Based Non-interactive Arguments." Eurocrypt 2016.
- Light Protocol Documentation: https://docs.lightprotocol.com
- Aadhaar Authentication API: https://uidai.gov.in/ecosystem/authentication
- Solana Documentation: https://docs.solana.com
- Circom Documentation: https://docs.circom.io
Disclaimer: This whitepaper is for informational purposes only and does not constitute financial advice, investment advice, trading advice, or any other type of advice. Cryptocurrencies and blockchain technologies involve risk. Please do your own research before participating.
© 2025 Solstice Protocol. All rights reserved.