Complete Attester Guide

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.

​

Overview

​

What are Attesters?

​

Types of Attesters

• Identity Verifiers: KYC providers, government agencies
• Skill Assessors: Educational institutions, certification bodies
• Protocol Operators: DeFi protocols, NFT marketplaces
• Community Moderators: DAO administrators, social platform moderators
• Automated Systems: Smart contracts, oracles

​

The Attester Whitelisting Process

​

Why Whitelisting?

• Quality Control: Ensures only reputable organizations become attesters
• Spam Prevention: Prevents low-quality or fraudulent attestations
• Trust Building: Users can trust that attestations come from verified sources
• Ecosystem Health: Maintains the integrity of the trust layer
• Regulatory Compliance: Helps meet compliance requirements

​

Attester Tiers

​

Application Requirements

​

1. Organization Identity

• Legal Entity: Must be a registered legal entity
• Business License: Valid business license or registration
• Website: Professional website with clear information
• Contact Information: Verifiable contact details

​

2. Technical Capability

• API Integration: Ability to integrate with ZKScore APIs
• Technical Team: Dedicated technical team or expertise
• Infrastructure: Reliable infrastructure for attestation services
• Security: Basic security practices and procedures

​

3. Trustworthiness

• Reputation: Established reputation in relevant field
• References: Professional references from industry peers
• Track Record: History of reliable service delivery
• Compliance: Adherence to relevant regulations

​

4. Use Case

• Clear Purpose: Well-defined use case for issuing attestations
• Business Model: Sustainable business model
• Target Users: Clear understanding of target user base
• Value Proposition: Clear value proposition for users

​

5. Staking Requirements

• SCORE Tokens: Required amount of SCORE tokens for staking
• Lock Period: Minimum staking period (varies by tier)
• Slashing Risk: Understanding of slashing conditions
• Financial Capacity: Ability to maintain stake

​

Step-by-Step Application Process

​

Step 1: Initial Application

// Submit initial application
const application = await client.submitAttesterApplication({
  // Organization details
  organization: {
    name: 'Blockchain Academy',
    legal_name: 'Blockchain Academy LLC',
    registration_number: 'LLC-2024-001',
    jurisdiction: 'Delaware, USA',
    website: 'https://blockchain-academy.com',
    founded_date: '2020-01-15',
    employees: 25
  },
  
  // Contact information
  contact: {
    email: 'contact@blockchain-academy.com',
    phone: '+1-555-0123',
    address: '123 Blockchain St, San Francisco, CA 94105',
    primary_contact: 'John Smith',
    technical_contact: 'Jane Doe'
  },
  
  // Business information
  business: {
    type: 'skill_assessor',
    description: 'Certified blockchain education and certification provider',
    target_market: 'blockchain_developers',
    estimated_monthly_attestations: 1000,
    business_model: 'subscription_certification'
  },
  
  // Technical information
  technical: {
    team_size: 5,
    api_integration_experience: true,
    security_practices: ['encryption', 'audit_logging', 'access_controls'],
    infrastructure: 'aws_cloud',
    backup_procedures: true
  },
  
  // Compliance information
  compliance: {
    data_protection_compliant: true,
    privacy_policy_url: 'https://blockchain-academy.com/privacy',
    terms_of_service_url: 'https://blockchain-academy.com/terms',
    regulatory_compliance: ['GDPR', 'CCPA'],
    audit_reports: ['audit_2024.pdf']
  }
});

console.log('Application submitted:', application.application_id);

​

Step 2: Technical Review

• API integration capability demonstrated
• Security practices documented
• Infrastructure reliability verified
• Data handling procedures reviewed
• Backup and recovery procedures in place

• Architecture discussion
• Security practices review
• Integration timeline assessment
• Performance requirements discussion
• Support and maintenance plans

​

Step 3: Business Review

• Sustainable business model
• Clear value proposition
• Target market analysis
• Competitive positioning
• Revenue projections

• Attestation schemas defined
• Verification processes documented
• Quality assurance procedures
• User experience design
• Dispute resolution procedures

​

Step 4: Compliance Review

• Legal entity verification
• Business license validation
• Regulatory compliance review
• Data protection compliance
• Liability and insurance coverage

​

Step 5: Staking and Approval

// Stake SCORE tokens for attester status
const stakingResult = await client.stakeForAttester({
  amount: ethers.utils.parseEther('1000'), // 1000 SCORE tokens
  lockPeriod: 365 * 24 * 60 * 60, // 1 year lock
  tier: 'verified'
});

console.log('Staking transaction:', stakingResult.transactionHash);

// Wait for confirmation and get attester credentials
const credentials = await client.getAttesterCredentials();
console.log('Attester API Key:', credentials.apiKey);
console.log('Organization ID:', credentials.organizationId);

​

Application Timeline

​

Application Tips

​

1. Prepare Thoroughly

• Documentation: Prepare all required documents in advance
• References: Line up professional references
• Demo: Prepare a demonstration of your technical capabilities
• Business Plan: Have a clear business plan and use case

​

2. Technical Readiness

• API Knowledge: Familiarize yourself with ZKScore APIs
• Security: Implement basic security practices
• Infrastructure: Ensure reliable infrastructure
• Testing: Test your integration thoroughly

​

3. Business Clarity

• Value Proposition: Clearly articulate your value proposition
• Target Market: Define your target market clearly
• Attestation Types: Specify what types of attestations you’ll issue
• Quality Standards: Define your quality standards

​

4. Compliance Preparation

• Legal Structure: Ensure proper legal structure
• Regulatory Compliance: Understand relevant regulations
• Data Protection: Implement data protection measures
• Insurance: Consider appropriate insurance coverage

​

Common Rejection Reasons

​

Technical Issues

• Insufficient Technical Capability: Unable to integrate with APIs
• Poor Security Practices: Inadequate security measures
• Unreliable Infrastructure: Infrastructure not suitable for production
• Lack of Technical Team: No dedicated technical resources

​

Business Issues

• Unclear Use Case: Vague or poorly defined use case
• Unsustainable Model: Business model not viable
• No Target Market: Unclear target market
• Poor Value Proposition: No clear value for users

​

Compliance Issues

• Legal Issues: Problems with legal entity or registration
• Regulatory Non-compliance: Failure to meet regulatory requirements
• Data Protection Issues: Inadequate data protection measures
• Insurance Coverage: Insufficient insurance coverage

​

Post-Approval Onboarding

​

1. Credential Setup

// Initialize your attester client
const attesterClient = new ZKScoreAttester({
  apiKey: 'att_...',
  organizationId: 'org_123',
  environment: 'mainnet'
});

// Verify your credentials
const verification = await attesterClient.verifyCredentials();
console.log('Credentials verified:', verification.valid);

​

2. Schema Creation

// Create your attestation schemas
const schemas = await Promise.all([
  attesterClient.createSchema({
    name: 'blockchain_certification_v1',
    description: 'Blockchain development certification',
    fields: [
      { name: 'certificate_id', type: 'string', required: true },
      { name: 'skill_level', type: 'number', required: true },
      { name: 'exam_score', type: 'number', required: true },
      { name: 'valid_until', type: 'timestamp', required: true }
    ]
  }),
  
  attesterClient.createSchema({
    name: 'project_completion_v1',
    description: 'Blockchain project completion verification',
    fields: [
      { name: 'project_name', type: 'string', required: true },
      { name: 'completion_date', type: 'timestamp', required: true },
      { name: 'github_url', type: 'string', required: false },
      { name: 'assessment_score', type: 'number', required: true }
    ]
  })
]);

console.log('Schemas created:', schemas.map(s => s.id));

​

3. Testing Phase

// Test your integration
const testAttestation = await attesterClient.createAttestation({
  schemaId: 'blockchain_certification_v1',
  recipient: 'test_user_address',
  data: {
    certificate_id: 'TEST-001',
    skill_level: 8,
    exam_score: 95,
    valid_until: new Date('2025-12-31')
  },
  testMode: true
});

console.log('Test attestation created:', testAttestation.id);

​

4. Production Launch

// Launch in production
await attesterClient.enableProductionMode();

// Create your first production attestation
const productionAttestation = await attesterClient.createAttestation({
  schemaId: 'blockchain_certification_v1',
  recipient: 'alice.zks',
  data: {
    certificate_id: 'BCA-2024-001',
    skill_level: 8,
    exam_score: 95,
    valid_until: new Date('2025-12-31')
  }
});

console.log('First production attestation:', productionAttestation.id);

​

Creating Attestations

​

Basic Attestation Creation

// Create skill verification attestation
const attestation = await client.createAttestation({
  recipient: 'alice.zks',
  schema: 'skill_verification',
  data: {
    skill: 'Solidity Development',
    level: 8,
    verifiedBy: 'Blockchain Academy',
    certificateId: 'BCA-2024-001',
    expirationDate: '2025-12-31'
  },
  expiration: Math.floor(Date.now() / 1000) + (365 * 24 * 60 * 60), // 1 year
  revocable: true
});

console.log('Attestation created:', attestation.transactionHash);

​

Batch Attestation Creation

// Create multiple attestations
const attestations = [
  {
    recipient: 'alice.zks',
    schema: 'skill_verification',
    data: { skill: 'Solidity', level: 8 }
  },
  {
    recipient: 'bob.zks',
    schema: 'skill_verification',
    data: { skill: 'React', level: 6 }
  }
];

const results = await client.createBatchAttestations(attestations);
console.log('Batch attestations created:', results);

​

Attestation Schemas

​

Skill Verification Schema

{
  "name": "Skill Verification",
  "description": "Verifies a user has specific skills",
  "fields": [
    { "name": "skill", "type": "string", "required": true },
    { "name": "level", "type": "uint256", "required": true },
    { "name": "verifiedBy", "type": "string", "required": true },
    { "name": "certificateId", "type": "string", "required": false },
    { "name": "expirationDate", "type": "string", "required": false }
  ]
}

​

Education Certificate Schema

{
  "name": "Education Certificate",
  "description": "Verifies educational achievements",
  "fields": [
    { "name": "institution", "type": "string", "required": true },
    { "name": "degree", "type": "string", "required": true },
    { "name": "field", "type": "string", "required": true },
    { "name": "graduationDate", "type": "string", "required": true },
    { "name": "gpa", "type": "uint256", "required": false }
  ]
}

​

Work Experience Schema

{
  "name": "Work Experience",
  "description": "Verifies professional work experience",
  "fields": [
    { "name": "company", "type": "string", "required": true },
    { "name": "position", "type": "string", "required": true },
    { "name": "startDate", "type": "string", "required": true },
    { "name": "endDate", "type": "string", "required": false },
    { "name": "description", "type": "string", "required": false }
  ]
}

​

Attester Dashboard

​

Managing Attestations

class AttesterDashboard {
  constructor(client) {
    this.client = client;
  }
  
  async getAttesterStats() {
    const stats = await this.client.getAttesterStats();
    return {
      totalAttestations: stats.totalAttestations,
      activeAttestations: stats.activeAttestations,
      revokedAttestations: stats.revokedAttestations,
      reputation: stats.reputation
    };
  }
  
  async getAttestationHistory(limit = 50) {
    const history = await this.client.getAttestationHistory({ limit });
    return history.map(attestation => ({
      id: attestation.id,
      recipient: attestation.recipient,
      schema: attestation.schema,
      createdAt: new Date(attestation.createdAt),
      status: attestation.revoked ? 'revoked' : 'active'
    }));
  }
  
  async revokeAttestation(attestationId, reason) {
    const result = await this.client.revokeAttestation(attestationId, reason);
    return result;
  }
}

​

Trust Modules

​

Custom Trust Logic

// Create custom trust module
const trustModule = {
  name: 'Skill Trust Module',
  description: 'Evaluates trust based on skill attestations',
  logic: `
    function evaluateTrust(address user) public view returns (uint256) {
      uint256 skillScore = getSkillScore(user);
      uint256 experienceScore = getExperienceScore(user);
      uint256 certificationScore = getCertificationScore(user);
      
      return (skillScore + experienceScore + certificationScore) / 3;
    }
  `
};

// Register trust module
const result = await client.registerTrustModule(trustModule);
console.log('Trust module registered:', result.transactionHash);

​

Best Practices

​

Attestation Quality

1. Accurate Data: Only attest to verified information
2. Clear Schemas: Use well-defined, consistent schemas
3. Appropriate Expiration: Set reasonable expiration times
4. Regular Review: Periodically review and update attestations
5. Revocation Process: Have clear revocation procedures

​

Attester Reputation

1. High Standards: Maintain high verification standards
2. Transparent Process: Be transparent about verification process
3. Responsive: Respond to disputes and inquiries
4. Consistent: Apply standards consistently across all attestations
5. Continuous Improvement: Regularly improve verification processes

​

Compliance and Legal

​

Data Privacy

• GDPR Compliance: Ensure compliance with data protection regulations
• Data Minimization: Only collect necessary data
• User Consent: Obtain proper consent for data processing
• Data Retention: Implement appropriate data retention policies

​

Legal Considerations

• Jurisdiction: Understand applicable laws and regulations
• Liability: Consider liability for false attestations
• Dispute Resolution: Have clear dispute resolution procedures
• Terms of Service: Maintain clear terms of service

​

Related Documentation

• Trust Registry
• Create Attestation API
• Attestations Guide