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

# Complete Attester Guide

> Comprehensive guide to becoming an attester, whitelisting process, and building reputation in ZKScore

## Overview

Attesters are trusted entities that can create and verify attestations in the ZKScore Trust Layer V1. This comprehensive guide covers the complete journey from application to becoming a successful attester, including the whitelisting process, technical integration, and best practices.

<Info>
  Attesters are the backbone of the ZKScore ecosystem. They verify and certify information about users, creating the foundation for trust-based decisions across Web3 applications.
</Info>

## What are Attesters?

Attesters are organizations, individuals, or automated systems that can create cryptographically signed attestations about users' identities, skills, behaviors, or achievements.

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

ZKScore Trust Layer V1 uses a whitelist model to ensure quality and prevent spam. All attesters must go through a comprehensive approval process.

### Why Whitelisting?

The whitelist model provides several benefits:

* **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

ZKScore offers different attester tiers with varying requirements and capabilities:

| Tier          | Requirements              | Staking      | Capabilities                  | Approval Time |
| ------------- | ------------------------- | ------------ | ----------------------------- | ------------- |
| **Team**      | ZKScore internal team     | None         | Full access, all features     | Immediate     |
| **Partner**   | Strategic partners        | 10,000 SCORE | High limits, priority support | 1-2 weeks     |
| **Verified**  | Established organizations | 1,000 SCORE  | Standard limits               | 2-4 weeks     |
| **Community** | Community attesters       | 100 SCORE    | Basic limits                  | 4-6 weeks     |

### 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 your initial application through the ZKScore attester portal:

```javascript theme={null}
// 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

The ZKScore team will conduct a technical review:

**Technical Requirements Checklist:**

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

**Technical Interview:**

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

#### Step 3: Business Review

**Business Model Assessment:**

* [ ] Sustainable business model
* [ ] Clear value proposition
* [ ] Target market analysis
* [ ] Competitive positioning
* [ ] Revenue projections

**Use Case Validation:**

* [ ] Attestation schemas defined
* [ ] Verification processes documented
* [ ] Quality assurance procedures
* [ ] User experience design
* [ ] Dispute resolution procedures

#### Step 4: Compliance Review

**Legal and Compliance Assessment:**

* [ ] Legal entity verification
* [ ] Business license validation
* [ ] Regulatory compliance review
* [ ] Data protection compliance
* [ ] Liability and insurance coverage

#### Step 5: Staking and Approval

Once approved, you'll need to stake the required SCORE tokens:

```javascript theme={null}
// 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

| Phase                   | Duration  | Activities                           |
| ----------------------- | --------- | ------------------------------------ |
| **Initial Application** | 1-2 days  | Submit application, upload documents |
| **Technical Review**    | 1-2 weeks | Technical assessment, interviews     |
| **Business Review**     | 1-2 weeks | Business model validation            |
| **Compliance Review**   | 1 week    | Legal and compliance verification    |
| **Staking & Approval**  | 2-3 days  | Token staking, credential generation |
| **Total**               | 4-6 weeks | Complete approval process            |

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

Understanding common rejection reasons can help you prepare a stronger application:

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

Once approved, you'll go through an onboarding process:

#### 1. Credential Setup

```javascript theme={null}
// 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

```javascript theme={null}
// 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

```javascript theme={null}
// 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

```javascript theme={null}
// 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

<CodeGroup>
  ```javascript JavaScript theme={null}
  // 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);
  ```
</CodeGroup>

### Batch Attestation Creation

<CodeGroup>
  ```javascript JavaScript theme={null}
  // 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);
  ```
</CodeGroup>

## Attestation Schemas

### Skill Verification Schema

```json theme={null}
{
  "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

```json theme={null}
{
  "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

```json theme={null}
{
  "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

<CodeGroup>
  ```javascript JavaScript theme={null}
  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;
    }
  }
  ```
</CodeGroup>

## Trust Modules

### Custom Trust Logic

<CodeGroup>
  ```javascript JavaScript theme={null}
  // 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);
  ```
</CodeGroup>

## 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](/contracts/trust-registry/overview)
* [Create Attestation API](/api-reference/trust-layer/create-attestation)
* [Attestations Guide](/contracts/trust-registry/attestations)