Trust Layer V1

{
  "attester": "0x1234...",
  "subject": "0x5678...",
  "schema": "defi_experience_v1",
  "data": {
    "protocols_used": ["Uniswap", "Aave", "Compound"],
    "total_volume": "1000000",
    "experience_months": 24,
    "risk_level": "medium"
  },
  "expires_at": "2025-12-31T23:59:59Z",
  "issued_at": "2024-01-15T10:30:00Z"
}

const attestation = await client.createAttestation({
  schemaId: 'defi_experience_v1',
  recipient: '0x5678...',
  data: {
    protocols_used: ['Uniswap', 'Aave'],
    total_volume: '500000',
    experience_months: 12
  },
  expiresAt: new Date('2025-12-31')
});

// Create attestation directly on-chain
ITrustRegistry(trustRegistry).createAttestation(
  schemaId,
  recipient,
  data,
  expirationTime
);

{
  "id": "defi_access_policy_v1",
  "name": "DeFi Access Policy",
  "description": "Grants access to DeFi protocols based on experience",
  "version": "1.0.0",
  "conditions": [
    {
      "type": "attestation_exists",
      "schema": "defi_experience_v1",
      "required": true
    },
    {
      "type": "data_condition",
      "field": "experience_months",
      "operator": "gte",
      "value": 6
    },
    {
      "type": "data_condition", 
      "field": "risk_level",
      "operator": "in",
      "value": ["low", "medium"]
    }
  ],
  "decision": {
    "type": "allow",
    "metadata": {
      "access_level": "standard",
      "max_amount": "100000"
    }
  }
}

const policy = await client.createPolicy({
  name: "DeFi Access Policy",
  description: "Standard DeFi access requirements",
  conditions: [
    {
      type: "attestation_exists",
      schema: "defi_experience_v1",
      required: true
    },
    {
      type: "data_condition",
      field: "experience_months", 
      operator: "gte",
      value: 6
    }
  ],
  decision: {
    type: "allow",
    metadata: { access_level: "standard" }
  }
});

const result = await client.evaluatePolicy({
  policyId: "defi_access_policy_v1",
  subject: "0x5678...",
  context: {
    requested_amount: "50000",
    protocol: "aave"
  }
});

if (result.passed) {
  console.log("Access granted:", result.metadata);
} else {
  console.log("Access denied:", result.reasons);
}

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

// Create attestation schema
const schema = await attesterClient.createSchema({
  name: 'defi_experience_v1',
  fields: [
    { name: 'protocols_used', type: 'string[]', required: true },
    { name: 'total_volume', type: 'string', required: true },
    { name: 'experience_months', type: 'number', required: true },
    { name: 'risk_level', type: 'string', enum: ['low', 'medium', 'high'] }
  ]
});

// Custom module for gaming achievements
const gamingModule = {
  id: 'gaming_achievements_v1',
  name: 'Gaming Achievement Module',
  version: '1.0.0',
  evaluate: (attestations, context) => {
    const gamingAttestations = attestations.filter(
      a => a.schema.startsWith('gaming_')
    );
    
    let score = 0;
    gamingAttestations.forEach(attestation => {
      switch (attestation.schema) {
        case 'gaming_level_100':
          score += 100;
          break;
        case 'gaming_achievement_rare':
          score += 50;
          break;
        case 'gaming_community_leader':
          score += 75;
          break;
      }
    });
    
    return {
      score,
      metadata: {
        total_achievements: gamingAttestations.length,
        max_score: 1000
      }
    };
  }
};

// Check user trust before allowing access
const checkAccess = async (userAddress, requiredLevel) => {
  const trustScore = await client.getTrustScore(userAddress);
  const attestations = await client.getAttestations(userAddress);
  
  // Evaluate against policy
  const policyResult = await client.evaluatePolicy({
    policyId: 'app_access_policy',
    subject: userAddress,
    context: { required_level: requiredLevel }
  });
  
  return policyResult.passed;
};

// Use in your application
app.get('/premium-feature', async (req, res) => {
  const hasAccess = await checkAccess(req.user.address, 'premium');
  
  if (!hasAccess) {
    return res.status(403).json({ 
      error: 'Insufficient trust level for premium features' 
    });
  }
  
  // Grant access to premium feature
  res.json({ data: premiumData });
});

// Calculate loan terms based on trust
const calculateLoanTerms = async (borrowerAddress, requestedAmount) => {
  const trustScore = await client.getTrustScore(borrowerAddress);
  const defiAttestations = await client.getAttestations(borrowerAddress, {
    schema: 'defi_experience_v1'
  });
  
  let interestRate = 0.12; // Base rate 12%
  let maxAmount = requestedAmount;
  
  // Adjust based on trust score
  if (trustScore.total > 800) {
    interestRate = 0.08; // 8% for high trust
    maxAmount = requestedAmount * 2; // Double the limit
  } else if (trustScore.total > 500) {
    interestRate = 0.10; // 10% for medium trust
    maxAmount = requestedAmount * 1.5; // 1.5x the limit
  }
  
  // Adjust based on DeFi experience
  if (defiAttestations.length > 0) {
    const experience = defiAttestations[0].data.experience_months;
    if (experience > 24) {
      interestRate *= 0.9; // 10% discount for experience
    }
  }
  
  return {
    approved: maxAmount >= requestedAmount,
    interestRate,
    maxAmount,
    term: '12 months'
  };
};

// Calculate voting power based on trust
const calculateVotingPower = async (voterAddress) => {
  const trustScore = await client.getTrustScore(voterAddress);
  const governanceAttestations = await client.getAttestations(voterAddress, {
    schema: 'governance_participation_v1'
  });
  
  let basePower = 1;
  
  // Trust score multiplier
  if (trustScore.total > 800) basePower = 3;
  else if (trustScore.total > 600) basePower = 2;
  else if (trustScore.total > 400) basePower = 1.5;
  
  // Governance participation bonus
  const participationBonus = Math.min(governanceAttestations.length * 0.2, 1.0);
  
  return Math.floor(basePower * (1 + participationBonus));
};