Get Attestations

{
  "success": true,
  "address": "0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb",
  "zksId": "alice.zks",
  "attestations": [
    {
      "id": "att_1234567890abcdef",
      "subject": "alice.zks",
      "issuer": "0x9876543210fedcba...",
      "schema": "skill",
      "data": {
        "title": "Solidity Developer",
        "description": "Expert in smart contract development",
        "category": "programming",
        "value": "expert",
        "metadata": {
          "yearsExperience": 5,
          "projects": ["DeFi Protocol", "NFT Marketplace"],
          "certifications": ["Certified Solidity Developer"]
        },
        "evidence": [
          {
            "type": "url",
            "value": "https://github.com/alice/solidity-projects",
            "description": "GitHub repository with Solidity projects"
          }
        ]
      },
      "signature": "0xabcdef1234567890...",
      "createdAt": "2024-01-15T10:30:00Z",
      "expiry": "2025-01-15T10:30:00Z",
      "revocable": true,
      "public": true,
      "status": "active",
      "tags": ["solidity", "blockchain", "developer"],
      "verification": {
        "verified": true,
        "verificationMethod": "signature_verification",
        "verificationTimestamp": "2024-01-15T10:30:00Z",
        "trustScore": 85.5
      }
    },
    {
      "id": "att_abcdef1234567890",
      "subject": "alice.zks",
      "issuer": "0x1234567890abcdef...",
      "schema": "relationship",
      "data": {
        "title": "Business Partner",
        "description": "Long-term business partnership",
        "category": "business",
        "value": "trusted",
        "metadata": {
          "relationshipType": "business_partner",
          "duration": "3 years",
          "projects": ["Joint Venture", "Consulting"]
        },
        "evidence": [
          {
            "type": "transaction",
            "value": "0x1234567890abcdef...",
            "description": "Business transaction history"
          }
        ]
      },
      "signature": "0x1234567890abcdef...",
      "createdAt": "2024-01-10T14:20:00Z",
      "expiry": null,
      "revocable": true,
      "public": true,
      "status": "active",
      "tags": ["business", "partnership", "trusted"],
      "verification": {
        "verified": true,
        "verificationMethod": "signature_verification",
        "verificationTimestamp": "2024-01-10T14:20:00Z",
        "trustScore": 92.3
      }
    }
  ],
  "pagination": {
    "total": 15,
    "limit": 50,
    "offset": 0,
    "hasMore": false
  },
  "summary": {
    "totalAttestations": 15,
    "activeAttestations": 12,
    "expiredAttestations": 2,
    "revokedAttestations": 1,
    "schemaBreakdown": {
      "skill": 8,
      "relationship": 4,
      "achievement": 2,
      "reputation": 1
    },
    "categoryBreakdown": {
      "programming": 5,
      "business": 4,
      "blockchain": 3,
      "leadership": 2,
      "education": 1
    },
    "averageTrustScore": 78.5,
    "verifiedCount": 14
  },
  "timestamp": "2024-01-20T15:45:00Z"
}

function createReputationProfile(attestations) {
  const profile = {
    skills: attestations.filter(a => a.schema === 'skill'),
    relationships: attestations.filter(a => a.schema === 'relationship'),
    achievements: attestations.filter(a => a.schema === 'achievement'),
    reputation: attestations.filter(a => a.schema === 'reputation'),
    identity: attestations.filter(a => a.schema === 'identity')
  };

  return {
    ...profile,
    summary: {
      totalSkills: profile.skills.length,
      totalRelationships: profile.relationships.length,
      totalAchievements: profile.achievements.length,
      averageTrustScore: calculateAverageTrustScore(attestations),
      verifiedCount: attestations.filter(a => a.verification.verified).length
    }
  };
}

function verifySkills(attestations, requiredSkills) {
  const skillAttestations = attestations.filter(a => a.schema === 'skill');
  
  const verifiedSkills = requiredSkills.map(skill => {
    const attestation = skillAttestations.find(a => 
      a.data.title.toLowerCase().includes(skill.toLowerCase()) ||
      a.data.category === skill
    );
    
    return {
      skill,
      verified: !!attestation,
      attestation: attestation || null,
      trustScore: attestation?.verification.trustScore || 0
    };
  });
  
  return verifiedSkills;
}

// Usage
const requiredSkills = ['Solidity', 'React', 'Node.js'];
const skills = verifySkills(attestations, requiredSkills);

function calculateTrustScore(attestations) {
  const activeAttestations = attestations.filter(a => a.status === 'active');
  
  if (activeAttestations.length === 0) {
    return 0;
  }
  
  const totalScore = activeAttestations.reduce((sum, attestation) => {
    return sum + attestation.verification.trustScore;
  }, 0);
  
  const averageScore = totalScore / activeAttestations.length;
  
  // Weight by schema type
  const weights = {
    skill: 1.0,
    relationship: 1.2,
    achievement: 1.1,
    reputation: 1.3,
    identity: 1.5
  };
  
  const weightedScore = activeAttestations.reduce((sum, attestation) => {
    const weight = weights[attestation.schema] || 1.0;
    return sum + (attestation.verification.trustScore * weight);
  }, 0);
  
  const totalWeight = activeAttestations.reduce((sum, attestation) => {
    return sum + (weights[attestation.schema] || 1.0);
  }, 0);
  
  return {
    averageScore,
    weightedScore: weightedScore / totalWeight,
    totalAttestations: activeAttestations.length,
    breakdown: groupBySchema(activeAttestations)
  };
}

function filterAttestations(attestations, filters) {
  return attestations.filter(attestation => {
    if (filters.schema && attestation.schema !== filters.schema) return false;
    if (filters.status && attestation.status !== filters.status) return false;
    if (filters.category && attestation.data.category !== filters.category) return false;
    if (filters.public !== null && attestation.public !== filters.public) return false;
    if (filters.verified && !attestation.verification.verified) return false;
    if (filters.minTrustScore && attestation.verification.trustScore < filters.minTrustScore) return false;
    if (filters.tags && !filters.tags.some(tag => attestation.tags.includes(tag))) return false;
    
    return true;
  });
}

// Usage
const filteredAttestations = filterAttestations(attestations, {
  schema: 'skill',
  status: 'active',
  verified: true,
  minTrustScore: 80,
  tags: ['blockchain', 'programming']
});

function analyzeAttestations(attestations) {
  const analysis = {
    bySchema: groupBy(attestations, 'schema'),
    byCategory: groupBy(attestations, 'data.category'),
    byStatus: groupBy(attestations, 'status'),
    byIssuer: groupBy(attestations, 'issuer'),
    trustScoreDistribution: calculateTrustScoreDistribution(attestations),
    timeDistribution: calculateTimeDistribution(attestations),
    evidenceTypes: analyzeEvidenceTypes(attestations)
  };
  
  return analysis;
}

function groupBy(array, key) {
  return array.reduce((groups, item) => {
    const value = item[key];
    if (!groups[value]) {
      groups[value] = [];
    }
    groups[value].push(item);
    return groups;
  }, {});
}

let attestationCache = new Map();
const CACHE_TTL = 5 * 60 * 1000; // 5 minutes

async function getCachedAttestations(identity, options = {}) {
  const cacheKey = `${identity}-${JSON.stringify(options)}`;
  const cached = attestationCache.get(cacheKey);
  
  if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
    return cached.data;
  }
  
  const data = await getAttestations(identity, options);
  attestationCache.set(cacheKey, {
    data,
    timestamp: Date.now()
  });
  
  return data;
}

async function getAllAttestations(identity, options = {}) {
  const allAttestations = [];
  let offset = 0;
  const limit = 100;
  
  while (true) {
    const data = await getAttestations(identity, {
      ...options,
      limit,
      offset
    });
    
    allAttestations.push(...data.attestations);
    
    if (!data.pagination.hasMore) {
      break;
    }
    
    offset += limit;
  }
  
  return allAttestations;
}

function subscribeToAttestationUpdates(identity, callback) {
  const ws = new WebSocket(`wss://api.onzks.com/v1/trust/attestations/${identity}/subscribe`);
  
  ws.onmessage = (event) => {
    const update = JSON.parse(event.data);
    callback(update);
  };
  
  return () => ws.close();
}

async function verifyAttestation(attestation) {
  const message = JSON.stringify({
    subject: attestation.subject,
    schema: attestation.schema,
    data: attestation.data,
    createdAt: attestation.createdAt
  });
  
  const recoveredAddress = await recoverAddress(message, attestation.signature);
  const isValid = recoveredAddress === attestation.issuer;
  
  return {
    valid: isValid,
    issuer: attestation.issuer,
    recoveredAddress,
    message
  };
}