> ## Documentation Index
> Fetch the complete documentation index at: https://core.anylayer.org/llms.txt
> Use this file to discover all available pages before exploring further.

# Welcome to ZKScore

> Build trust-enabled applications with privacy-preserving reputation scores

<img className="block dark:hidden" src="https://mintlify.s3.us-west-1.amazonaws.com/zkscore/images/hero-light.png" alt="ZKScore Hero Light" />

<img className="hidden dark:block" src="https://mintlify.s3.us-west-1.amazonaws.com/zkscore/images/hero-dark.png" alt="ZKScore Hero Dark" />

## What is ZKScore?

ZKScore is a comprehensive reputation and identity protocol that enables developers to build trust-enabled applications with privacy-preserving scores. Our platform combines on-chain identity, verifiable reputation scoring, and zero-knowledge proofs to create a new paradigm for trust in Web3.

<CardGroup cols={2}>
  <Card title="Privacy-First Architecture" icon="shield-halved" href="/concepts/privacy">
    Zero-knowledge proofs ensure users maintain control over their data while proving reputation
  </Card>

  <Card title="Soulbound Identity" icon="fingerprint" href="/concepts/identity">
    Non-transferable NFT identities that represent unique individuals across chains
  </Card>

  <Card title="Dynamic Scoring" icon="chart-line" href="/concepts/scoring">
    Real-time reputation scores based on on-chain activity, achievements, and attestations
  </Card>

  <Card title="Trust Layer" icon="check-double" href="/concepts/trust-layer">
    Flexible attestation system for building custom trust frameworks
  </Card>
</CardGroup>

## Key Features

### 🔐 Soulbound Identities

Create unique, non-transferable identities represented as NFTs. Each identity is bound to an individual and serves as the foundation for building reputation.

```typescript theme={null}
import { ZKScoreSDK } from '@zkscore/sdk';

const sdk = new ZKScoreSDK({ apiKey: 'your-api-key' });

// Mint a new identity
const identity = await sdk.identity.mint({
  address: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb1',
  username: 'alice',
});
```

### 📊 Reputation Scoring

Dynamic scoring system that evaluates on-chain behavior across multiple dimensions:

* **Wallet Age**: Time since wallet creation
* **Transaction Volume**: Total transaction count and value
* **DeFi Activity**: Interactions with DeFi protocols
* **NFT Holdings**: Quality and diversity of NFT collection
* **Social Reputation**: Community engagement and attestations
* **Achievement Progress**: Milestone completions

```typescript theme={null}
// Get comprehensive score
const score = await sdk.scores.getScore('0x742d35...');

console.log(score);
// {
//   overall: 850,
//   breakdown: {
//     walletAge: 95,
//     transactions: 78,
//     defi: 88,
//     nfts: 72,
//     social: 85
//   }
// }
```

### 🏆 Achievement System

Gamified achievement system that rewards users for completing milestones and demonstrating expertise.

* Pre-built achievement templates
* Custom achievement creation
* On-chain verification
* NFT badges and rewards

```typescript theme={null}
// Get user achievements
const achievements = await sdk.achievements.getUserAchievements(
  '0x742d35...'
);

// Claim an achievement
await sdk.achievements.claim({
  achievementId: 'defi-expert',
  proof: zkProof,
});
```

### 🔒 Zero-Knowledge Proofs

Prove reputation without revealing sensitive data. Users can generate ZK proofs to verify:

* Score thresholds (e.g., "score > 700")
* Specific achievements
* Attestations
* Historical activity

```typescript theme={null}
// Generate a ZK proof
const proof = await sdk.zkProofs.generate({
  type: 'score-threshold',
  threshold: 700,
  hideExactScore: true,
});

// Verify proof
const isValid = await sdk.zkProofs.verify(proof);
```

### ✅ Trust Layer & Attestations

Flexible attestation framework for building custom trust systems:

* Protocol-specific attestations
* Multi-signature attestations
* Time-bound attestations
* Revocable attestations

```typescript theme={null}
// Create an attestation
const attestation = await sdk.trustLayer.createAttestation({
  subject: '0x742d35...',
  schema: 'kyc-verification',
  data: {
    verified: true,
    level: 'tier-2',
    expiresAt: '2025-12-31',
  },
});
```

## Use Cases

<CardGroup cols={2}>
  <Card title="DeFi Lending" icon="hand-holding-dollar" href="/use-cases/lending">
    Undercollateralized lending based on reputation scores
  </Card>

  <Card title="NFT Gating" icon="image" href="/use-cases/nft-gating">
    Gate access to exclusive NFT mints and communities
  </Card>

  <Card title="DAO Governance" icon="users" href="/use-cases/dao-governance">
    Weighted voting based on expertise and contribution
  </Card>

  <Card title="Social Platforms" icon="comments" href="/use-cases/social">
    Verify user identity and build trust in social apps
  </Card>

  <Card title="Gaming" icon="gamepad" href="/use-cases/gaming">
    Create player rankings and anti-sybil systems
  </Card>

  <Card title="Marketplaces" icon="store" href="/use-cases/marketplace">
    Build seller reputation and buyer protection
  </Card>
</CardGroup>

## Architecture Overview

ZKScore is built on a modular architecture that separates concerns and enables flexibility:

```mermaid theme={null}
graph TB
    A[User Application] --> B[ZKScore SDK]
    B --> C[REST API]
    B --> D[Smart Contracts]
    C --> E[Indexer]
    D --> F[IdentitySBT]
    D --> G[ScoreCalculator]
    D --> H[AchievementRegistry]
    D --> I[TrustRegistry]
    E --> J[Database]
    E --> K[Event Processor]
    K --> L[Score Engine]
```

### Components

* **Smart Contracts**: On-chain identity, scoring, and attestation logic
* **REST API**: High-level API for querying data and generating proofs
* **Indexer**: Real-time event processing and score calculation
* **SDK**: Client libraries for JavaScript, TypeScript, and React
* **Score Engine**: Advanced scoring algorithms and analytics

## Getting Started

<CardGroup cols={2}>
  <Card title="Quickstart" icon="rocket" href="/quickstart">
    Get up and running in 5 minutes
  </Card>

  <Card title="API Reference" icon="code" href="/api-reference/introduction">
    Explore the complete API documentation
  </Card>

  <Card title="SDK Documentation" icon="book" href="/sdk/introduction">
    Learn how to use our SDKs
  </Card>

  <Card title="Smart Contracts" icon="file-contract" href="/contracts/introduction">
    Direct contract integration guide
  </Card>
</CardGroup>

## Supported Networks

ZKScore is deployed on multiple EVM-compatible networks:

<CardGroup cols={3}>
  <Card title="Ethereum Mainnet" icon="ethereum">
    Full production deployment
  </Card>

  <Card title="Base" icon="circle">
    Low-cost L2 deployment
  </Card>

  <Card title="Polygon" icon="triangle">
    High-throughput sidechain
  </Card>

  <Card title="Arbitrum" icon="layer-group">
    Optimistic rollup deployment
  </Card>

  <Card title="Optimism" icon="layer-group">
    Optimistic rollup deployment
  </Card>

  <Card title="BSC" icon="link">
    Binance Smart Chain
  </Card>
</CardGroup>

## Why ZKScore?

### For Developers

* **Easy Integration**: Simple SDK with TypeScript support
* **Flexible**: Build custom scoring models and attestation schemas
* **Privacy-Preserving**: ZK proofs protect user data
* **Multi-chain**: Deploy on any EVM-compatible network
* **Well-Documented**: Comprehensive guides and examples

### For Users

* **Own Your Reputation**: Portable identity across applications
* **Privacy First**: Control what you share with ZK proofs
* **Earn Rewards**: Achievements and badges for on-chain activity
* **Build Trust**: Verifiable reputation without centralized platforms
* **No Vendor Lock-in**: Export your data anytime

### For Protocols

* **Reduce Risk**: Better assess user trustworthiness
* **Prevent Sybils**: One identity per person
* **Increase Engagement**: Gamification and achievements
* **Custom Trust Models**: Define your own attestation schemas
* **Interoperable**: Leverage reputation across the ecosystem

## Community & Support

<CardGroup cols={2}>
  <Card title="Discord Community" icon="discord" href="https://discord.gg/zkscore">
    Join our developer community
  </Card>

  <Card title="GitHub" icon="github" href="https://github.com/metalanddev/ZKScoreEVM">
    Contribute to the codebase
  </Card>

  <Card title="Twitter" icon="twitter" href="https://twitter.com/onzks">
    Follow for updates
  </Card>

  <Card title="Blog" icon="newspaper" href="https://blog.onzks.com">
    Read our latest articles
  </Card>
</CardGroup>

## What's Next?

<Steps>
  <Step title="Read the Quickstart">
    Get your first identity and score in 5 minutes
    [Start here →](/quickstart)
  </Step>

  <Step title="Understand Core Concepts">
    Learn about identities, scoring, and attestations
    [Core Concepts →](/concepts/identity)
  </Step>

  <Step title="Integrate the SDK">
    Add ZKScore to your application
    [SDK Docs →](/sdk/introduction)
  </Step>

  <Step title="Deploy to Production">
    Launch your trust-enabled application
    [Deployment Guide →](/contracts/deployment)
  </Step>
</Steps>

***

<Note>
  **Need help?** Join our [Discord](https://discord.gg/zkscore) or reach out on [Twitter](https://twitter.com/onzks)
</Note>