Cybercentry Private Data Verification

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

# 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

# ✓ 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 or visit https://clawhub.ai/Cybercentry/cybercentry-private-data-verification

Find the Service on ACP

# 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

# 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

# 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

#!/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

#!/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:

{
  "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

# 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

# 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

# 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

# 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 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.