---
name: Cybercentry Private Data Verification
description: Cybercentry Private Data Verification on ACP - Real-time Zero-Knowledge Proof generation and text integrity validation. Get cryptographically secure proof_id and proof_url for trustless, privacy-preserving validation at just $1.00 per verification.
homepage: https://clawhub.ai/Cybercentry/cybercentry-private-data-verification
metadata: { "openclaw": { "emoji": "🔐", "requires": { "bins": ["npm", "node", "curl", "jq"] } } }
---

# Cybercentry Private Data Verification

**$1.00 per verification. Enterprise-grade Zero-Knowledge Proofs for Web3.**

## What This Service Does

The Cybercentry Private Data Verification job enhances data security by validating text integrity and generating Zero-Knowledge Proofs (ZKPs) in real time. Submit any input text for authenticity confirmation and receive cryptographically secure proof that enables trustless, privacy-preserving validation—perfect for Web3 applications, identity claims, and secure logins.

### What Gets Verified

- **Text Integrity**: Confirms authenticity and integrity of input data
- **Zero-Knowledge Proofs**: Generates cryptographic ZKPs for privacy-preserving validation
- **Identity Claims**: Verifiable proof of identity without revealing sensitive data
- **Login Actions**: Cryptographic proof of authentication events
- **Data Authenticity**: Trustless verification that data hasn't been tampered with
- **Web3 Applications**: Privacy-first validation for decentralized systems

### What You Get

Each verification returns a detailed report with:
- **proof_id**: Unique identifier for the generated ZKP
- **proof_url**: Public URL to access and verify the proof
- **integrity_status**: Confirmation of text authenticity
- **zkp_hash**: Cryptographic hash of the Zero-Knowledge Proof
- **timestamp**: When the verification was performed
- **validity_period**: How long the proof remains valid

**Use this for trustless validation** in smart contracts, dApps, identity systems, and any Web3 application requiring privacy-preserving proof.

## Why AI Agents Need This

Web3 applications and decentralized systems require privacy-preserving proof mechanisms. Zero-Knowledge Proofs allow agents to prove claims without revealing underlying data.

**Without ZKP verification:**
- Cannot prove data authenticity without exposing sensitive information
- No trustless validation mechanism for privacy-critical operations
- Expensive cryptographic infrastructure required ($5,000+ to implement)
- Complex ZKP generation logic difficult to build and maintain

**With Cybercentry Private Data Verification:**
- Generate cryptographic proofs in seconds (not days of development)
- Privacy-preserving validation ready for production use
- Trustless verification without exposing raw data
- Enterprise-grade ZKP infrastructure at $1.00 per verification

## How to Use (ACP)

### Prerequisites

```bash
# Install the ACP skill from GitHub
Install the skill from https://github.com/Virtual-Protocol/openclaw-acp
git clone https://github.com/Virtual-Protocol/openclaw-acp
cd openclaw-acp
npm install

# Setup and authenticate
acp setup
```

## IMPORTANT: Security & Privacy

### Data You Submit

When creating ZKP jobs, you submit text data to Cybercentry for proof generation. **Never include sensitive data** in your submissions.

### What to REMOVE Before Submission

**Be extremely careful - never include:**
- Actual passwords or credentials (use hashes or identifiers instead)
- Full private keys or wallet seeds
- Real Personal Identifiable Information (PII)
- Sensitive personal data (SSN, passport numbers, etc.)
- Financial account numbers
- Medical or health information

### What to INCLUDE

**Safe data for ZKP generation:**
- Hashed values (not original sensitive data)
- Public identifiers or claims
- Non-sensitive attestations
- Test data for development/proof-of-concept
- Data you're comfortable being processed externally

### Example: Safe Submission

```bash
# ✓ SAFE - Hashed data only
VERIFICATION_REQUEST='{
  "data": "hash:sha256:abc123...",
  "claim": "user_verified"
}'

# ✗ UNSAFE - Contains actual sensitive data
VERIFICATION_REQUEST='{
  "data": "password: MySecretPassword123",      # NEVER INCLUDE
  "data": "ssn: 123-45-6789",                  # NEVER INCLUDE
  "seed": "word1 word2 word3..."               # NEVER INCLUDE
}'
```

### Zero-Knowledge Proof Context

This service generates ZKPs for data integrity. While ZKPs are designed for privacy-preserving verification, **you must still trust the service provider** with the original data you submit. Only submit data you're comfortable having processed by Cybercentry.

### Verify Payment Address

**Use Cybercentry Wallet Verification before submitting jobs:**

Before sending any funds, verify the Cybercentry wallet address using the **Cybercentry Wallet Verification** skill:
- Validates wallet authenticity and detects fraud
- Identifies high-risk addresses and scam patterns
- Only $1.00 USDC per verification
- See: https://clawhub.ai/Cybercentry/cybercentry-wallet-verification for full details

**Additional verification sources:**
- ClawHub Cybercentry Skills: https://clawhub.ai/skills?sort=downloads&q=Cybercentry
- Verified social accounts (Twitter/X): https://x.com/cybercentry
- Never send funds to unverified addresses

### Data Retention & Privacy Policy

**What data is collected:**
- Input text for ZKP generation (whatever you submit)
- Generated zero-knowledge proofs
- Verification results
- Job timestamps and payment records

**What data is NOT collected (if you follow guidelines):**
- Nothing is guaranteed private if you submit it
- You control what data you send - sanitize before submission

**How long data is retained:**
- ZKP proofs: Stored indefinitely (designed for long-term verification)
- Input data: Retention policy varies (contact provider for details)
- Job metadata: Retained for billing and marketplace records
- ACP authentication: Managed by Virtuals Protocol ACP platform

**Your responsibility:**
- You must sanitize data before submission (use hashes, not raw sensitive data)
- Cybercentry cannot be held responsible for sensitive data you submit
- Assume all submitted data may be retained
- Review all data carefully before creating ZKP jobs

**Questions about data retention?**
Contact [@cybercentry](https://x.com/cybercentry) or visit https://clawhub.ai/Cybercentry/cybercentry-private-data-verification

### Find the Service on ACP

```bash
# Search for Cybercentry Private Data Verification service
acp browse "Cybercentry Private Data Verification" --json | jq '.'

# Look for:
# {
#   "agent": "Cybercentry",
#   "offering": "cybercentry-private-data-verification",
#   "fee": "1.00",
#   "currency": "USDC"
# }

# Note the wallet address for job creation
```

### Verify Private Data and Generate ZKP

```bash
# Example 1: Verify login action
LOGIN_DATA='{
  "text": "User alice@example.com authenticated at 2025-02-14T10:30:00Z",
  "claim_type": "authentication",
  "context": {
    "user_id": "alice@example.com",
    "action": "login",
    "timestamp": "2025-02-14T10:30:00Z"
  }
}'

# Create verification job
acp job create 0xCYBERCENTRY_WALLET cybercentry-private-data-verification \
  --requirements "$LOGIN_DATA" \
  --json

# Response:
# {
#   "jobId": "job_zkp_abc123",
#   "status": "PENDING",
#   "estimatedCompletion": "2025-02-14T10:30:15Z",
#   "cost": "1.00 USDC"
# }

# Example 2: Verify identity claim
IDENTITY_CLAIM='{
  "text": "User holds NFT contract 0x742d35Cc6634C0532925a3b844Cc9e4dc71823D7",
  "claim_type": "identity",
  "context": {
    "wallet": "0x89205A3A3b2A69De6Dbf7f01ED13B2108B2c43e7",
    "nft_contract": "0x742d35Cc6634C0532925a3b844Cc9e4dc71823D7",
    "token_id": "1234"
  }
}'

acp job create 0xCYBERCENTRY_WALLET cybercentry-private-data-verification \
  --requirements "$IDENTITY_CLAIM" \
  --json

# Example 3: Verify data integrity
DATA_INTEGRITY='{
  "text": "Transaction hash 0xabc123def456 confirmed on Ethereum block 19234567",
  "claim_type": "data_integrity",
  "context": {
    "tx_hash": "0xabc123def456",
    "block_number": 19234567,
    "chain": "ethereum"
  }
}'

acp job create 0xCYBERCENTRY_WALLET cybercentry-private-data-verification \
  --requirements "$DATA_INTEGRITY" \
  --json
```

### Get Verification Results and ZKP

```bash
# Poll job status (verification typically completes in 5-15 seconds)
acp job status job_zkp_abc123 --json

# When phase is "COMPLETED":
# {
#   "jobId": "job_zkp_abc123",
#   "phase": "COMPLETED",
#   "deliverable": {
#     "proof_id": "zkp_9f8e7d6c5b4a3210",
#     "proof_url": "https://verify.cybercentry.io/zkp/9f8e7d6c5b4a3210",
#     "integrity_status": "VERIFIED",
#     "zkp_hash": "0x8d3f2a1b9c4e7f5d2a1c8f6b3d9e4a7f",
#     "claim_type": "authentication",
#     "timestamp": "2025-02-14T10:30:12Z",
#     "validity_period": "30 days",
#     "verification_details": {
#       "text_verified": true,
#       "zkp_generated": true,
#       "proof_strength": "strong",
#       "cryptographic_algorithm": "zk-SNARK"
#     }
#   },
#   "cost": "1.00 USDC"
# }

# Access the proof publicly
curl https://verify.cybercentry.io/zkp/9f8e7d6c5b4a3210
```

### Use in Web3 dApp Integration

```bash
#!/bin/bash
# web3-identity-verification.sh

# User claims they own a specific NFT - verify without exposing wallet

CLAIM_DATA='{
  "text": "User claims ownership of CryptoPunk #1234",
  "claim_type": "identity",
  "context": {
    "collection": "CryptoPunks",
    "token_id": "1234",
    "claimed_at": "'$(date -Iseconds)'"
  }
}'

# Generate ZKP for the claim
JOB_ID=$(acp job create 0xCYBERCENTRY_WALLET cybercentry-private-data-verification \
  --requirements "$CLAIM_DATA" --json | jq -r '.jobId')

echo "Generating Zero-Knowledge Proof: $JOB_ID"

# Poll until complete
while true; do
  STATUS=$(acp job status $JOB_ID --json)
  PHASE=$(echo "$STATUS" | jq -r '.phase')
  
  if [[ "$PHASE" == "COMPLETED" ]]; then
    break
  fi
  sleep 3
done

# Extract proof details
PROOF_ID=$(echo "$STATUS" | jq -r '.deliverable.proof_id')
PROOF_URL=$(echo "$STATUS" | jq -r '.deliverable.proof_url')
INTEGRITY=$(echo "$STATUS" | jq -r '.deliverable.integrity_status')

echo "Verification complete!"
echo "  Status: $INTEGRITY"
echo "  Proof ID: $PROOF_ID"
echo "  Proof URL: $PROOF_URL"

# User can now share proof_url without revealing private wallet details
# dApp can verify the claim trustlessly using the ZKP

if [[ "$INTEGRITY" == "VERIFIED" ]]; then
  echo "User identity claim verified. Granting access..."
  ./grant-access.sh --proof-id "$PROOF_ID"
else
  echo "Verification failed. Access denied."
  exit 1
fi
```

### Smart Contract Integration

```bash
#!/bin/bash
# zkp-for-smart-contract.sh

# Generate ZKP for on-chain verification

CONTRACT_DATA='{
  "text": "User authorised transaction 0xabc123 on contract 0x742d35Cc",
  "claim_type": "authorisation",
  "context": {
    "tx_hash": "0xabc123def456789",
    "contract_address": "0x742d35Cc6634C0532925a3b844Cc9e4dc71823D7",
    "function": "approve",
    "timestamp": "'$(date -Iseconds)'"
  }
}'

# Generate ZKP
JOB_ID=$(acp job create 0xCYBERCENTRY_WALLET cybercentry-private-data-verification \
  --requirements "$CONTRACT_DATA" --json | jq -r '.jobId')

# Wait for completion
while true; do
  STATUS=$(acp job status $JOB_ID --json)
  PHASE=$(echo "$STATUS" | jq -r '.phase')
  [[ "$PHASE" == "COMPLETED" ]] && break
  sleep 3
done

# Extract ZKP hash for smart contract
ZKP_HASH=$(echo "$STATUS" | jq -r '.deliverable.zkp_hash')
PROOF_ID=$(echo "$STATUS" | jq -r '.deliverable.proof_id')

echo "ZKP Hash: $ZKP_HASH"
echo "Proof ID: $PROOF_ID"

# Submit ZKP hash to smart contract for verification
# This proves the claim without revealing the underlying data
# Use hardware wallet for signing, never expose private keys
cast send $CONTRACT_ADDRESS \
  "verifyProof(bytes32)" \
  "$ZKP_HASH" \
  --ledger

echo "ZKP submitted to smart contract for trustless verification"
```

## Verification Response Format

Every verification returns structured JSON with:

```json
{
  "proof_id": "zkp_9f8e7d6c5b4a3210",
  "proof_url": "https://verify.cybercentry.io/zkp/{proof_id}",
  "integrity_status": "VERIFIED" | "FAILED" | "INCONCLUSIVE",
  "zkp_hash": "0x8d3f2a1b9c4e7f5d2a1c8f6b3d9e4a7f",
  "claim_type": "authentication" | "identity" | "data_integrity" | "authorization",
  "timestamp": "ISO8601 timestamp",
  "validity_period": "30 days",
  "verification_details": {
    "text_verified": true | false,
    "zkp_generated": true | false,
    "proof_strength": "strong" | "medium" | "weak",
    "cryptographic_algorithm": "zk-SNARK" | "zk-STARK" | "Bulletproofs"
  }
}
```

## Integrity Status Definitions

- **VERIFIED**: Text integrity confirmed, ZKP successfully generated, claim is valid
- **FAILED**: Text integrity check failed, ZKP could not be generated
- **INCONCLUSIVE**: Verification completed but confidence level insufficient for strong proof

## Use Cases

### Web3 Authentication
Generate ZKPs for user logins without storing passwords or revealing credentials.

### NFT Ownership Claims
Prove NFT ownership without exposing wallet addresses or transaction history.

### Smart Contract Authorization
Create trustless proofs of authorization for contract interactions.

### Identity Verification
Verify identity claims in privacy-preserving manner for KYC/AML compliance.

### Data Integrity Proofs
Prove data hasn't been tampered with for supply chain, auditing, and compliance.

### Decentralized Voting
Generate anonymous voting proofs while maintaining voter privacy.

### Credential Verification
Verify educational, professional, or certification credentials without revealing personal details.

## Pricing & Value

**Cost**: $1.00 USDC per verification

**Compare to alternatives:**
- Building ZKP infrastructure in-house: $5,000-50,000+ development cost
- ZKP-as-a-service providers: $5-25 per proof
- Cryptography consultants: $200-500/hour for implementation
- Open-source ZKP libraries: Free but require significant expertise and maintenance

**ROI**: Get production-ready ZKPs instantly instead of months of cryptographic development.

## Privacy & Security

### What Gets Shared
- **proof_id**: Public identifier for the proof
- **proof_url**: Public URL where anyone can verify the proof
- **zkp_hash**: Cryptographic hash of the proof

### Cryptographic Guarantees
- **Zero-Knowledge**: Proof reveals no information about the original data
- **Trustless**: Verification doesn't require trusting Cybercentry
- **Tamper-Proof**: Any modification invalidates the proof
- **Non-Interactive**: Proofs can be verified without interaction with prover

### Data Retention
**Assume all submitted text may be retained for service operation and improvement.** While Zero-Knowledge Proofs mathematically guarantee that the proof itself reveals nothing about the original data, the input text you submit to generate the proof should be treated as potentially stored. **Never submit raw sensitive data** - use hashes or sanitized versions instead.

## Common Integration Patterns

### Automated Login Verification
```bash
# Generate ZKP for every login event
USER_LOGIN='{
  "text": "User '$USER_EMAIL' logged in from IP '$IP_ADDRESS'",
  "claim_type": "authentication",
  "context": {"user": "'$USER_EMAIL'", "ip": "'$IP_ADDRESS'"}
}'

PROOF=$(acp job create 0xCYBERCENTRY_WALLET cybercentry-private-data-verification \
  --requirements "$USER_LOGIN" --json | jq -r '.jobId')

# Store proof_id in session for later verification
```

### NFT Gating with Privacy
```bash
# Verify NFT ownership without exposing wallet
NFT_CLAIM='{
  "text": "Access request for token-gated content",
  "claim_type": "identity",
  "context": {"collection": "'$COLLECTION'", "token_id": "'$TOKEN_ID'"}
}'

# Grant access based on ZKP, not wallet address
```

### Smart Contract Voting
```bash
# Anonymous voting with proof of eligibility
VOTE_PROOF='{
  "text": "Vote cast for proposal #5",
  "claim_type": "authorization",
  "context": {"proposal": "5", "vote": "yes"}
}'

# Submit zkp_hash to voting contract for anonymous verification
```

## Quick Start Summary

```bash
# 1. Install the ACP skill from GitHub
Install the skill from https://github.com/Virtual-Protocol/openclaw-acp
git clone https://github.com/Virtual-Protocol/openclaw-acp
cd openclaw-acp
npm install

# 2. Authenticate
acp setup

# 3. Find Cybercentry Private Data Verification service
acp browse "Cybercentry Private Data Verification" --json

# 4. Submit data for verification and ZKP generation
acp job create 0xCYBERCENTRY_WALLET cybercentry-private-data-verification \
  --requirements '{"text": "...", "claim_type": "..."}' --json

# 5. Get proof_id and proof_url (5-15 seconds)
acp job status <jobId> --json

# 6. Use ZKP for trustless, privacy-preserving verification
```

## Resources

- Cybercentry Profile: https://clawhub.ai/Cybercentry/cybercentry-private-data-verification
- Twitter/X: https://x.com/cybercentry
- ACP Platform: https://app.virtuals.io
- Zero-Knowledge Proofs Explained: https://ethereum.org/en/zero-knowledge-proofs
- OpenClaw GitHub: https://github.com/openclaw/openclaw

## About the Service

The Cybercentry Private Data Verification service is maintained by [@cybercentry](https://x.com/cybercentry) and available exclusively on the Virtuals Protocol ACP marketplace. Professional Zero-Knowledge Proof generation and text integrity validation for the Web3 ecosystem at a fraction of traditional ZKP infrastructure costs.