Trust Layer SDK

Overview

The Trust Layer SDK provides a flexible framework for creating, managing, and querying attestations. Build custom trust systems, KYC verification, community badges, and more with on-chain or off-chain attestations.

Get Attestations

Retrieve all attestations for an address:

const attestations = await sdk.trustLayer.getAttestations('0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb1');

console.log(attestations);
// [
//   {
//     id: "att_abc123",
//     schema: "kyc-verification",
//     attester: "0x987...",
//     subject: "0x742d35...",
//     data: {
//       verified: true,
//       level: "tier-2",
//       provider: "Synaps"
//     },
//     createdAt: "2024-01-15T10:30:00Z",
//     expiresAt: "2025-01-15T10:30:00Z",
//     revoked: false,
//     onChain: true,
//     txHash: "0xdef456..."
//   },
//   // ... more attestations
// ]

Parameters

address

string

required

Address to query attestations for

options

object

Query options

Show Options

schema

string

Filter by attestation schema

attester

string

Filter by attester address

includeRevoked

boolean

Include revoked attestations (default: false)

includeExpired

boolean

Include expired attestations (default: false)

Create Attestation

Issue a new attestation:

const attestation = await sdk.trustLayer.createAttestation({
  subject: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb1',
  schema: 'community-member',
  data: {
    role: 'contributor',
    joinedAt: new Date().toISOString(),
    reputation: 'trusted',
    contributions: 42,
  },
  expiresAt: new Date('2025-12-31').toISOString(),
  onChain: true,
});

console.log(attestation);
// {
//   id: "att_xyz789",
//   schema: "community-member",
//   attester: "0x123...",
//   subject: "0x742d35...",
//   data: { ... },
//   createdAt: "2024-10-23T14:30:00Z",
//   expiresAt: "2025-12-31T00:00:00Z",
//   revoked: false,
//   onChain: true,
//   txHash: "0xabc123..."
// }

Parameters

params

object

required

Attestation parameters

Show Parameters

subject

string

required

Address receiving the attestation

schema

string

required

Schema identifier (e.g., 'kyc', 'dao-member')

data

object

required

Attestation data (schema-dependent)

expiresAt

string

Expiration timestamp (ISO 8601)

onChain

boolean

Store on-chain or off-chain (default: false)

refUID

string

Reference another attestation UID

Creating on-chain attestations requires a wallet signature and gas fees.

Revoke Attestation

Revoke an existing attestation:

await sdk.trustLayer.revokeAttestation('att_abc123', {
  reason: 'User requested removal',
});

console.log('Attestation revoked');

Parameters

attestationId

string

required

ID of the attestation to revoke

options

object

Revocation options

Show Options

reason

string

Reason for revocation

onChain

boolean

Revoke on-chain (required for on-chain attestations)

Get Available Modules

List available trust modules and their schemas:

const modules = await sdk.trustLayer.getModules();

console.log(modules);
// [
//   {
//     id: "kyc",
//     name: "KYC Verification",
//     description: "Know Your Customer verification",
//     schema: {
//       verified: "boolean",
//       level: "string",
//       provider: "string",
//       completedAt: "timestamp"
//     },
//     attesters: ["0x123...", "0x456..."],
//     attestationCount: 15234
//   },
//   {
//     id: "dao-member",
//     name: "DAO Membership",
//     description: "DAO participation and role attestation",
//     schema: {
//       daoAddress: "address",
//       role: "string",
//       joinedAt: "timestamp",
//       votingPower: "number"
//     },
//     attesters: ["0x789..."],
//     attestationCount: 8901
//   },
//   // ... more modules
// ]

Evaluate Trust Policy

Check if an address meets specific trust criteria:

const evaluation = await sdk.trustLayer.evaluatePolicy('0x742d35...', {
  rules: [
    {
      schema: 'kyc-verification',
      required: true,
      conditions: {
        'data.verified': true,
        'data.level': ['tier-2', 'tier-3'],
      },
    },
    {
      schema: 'community-member',
      required: false,
      conditions: {
        'data.reputation': ['trusted', 'verified'],
      },
    },
  ],
  minAttestations: 1,
  maxAge: 30 * 24 * 60 * 60 * 1000, // 30 days
});

console.log(evaluation);
// {
//   passed: true,
//   score: 95,
//   results: [
//     {
//       schema: "kyc-verification",
//       passed: true,
//       attestations: [{ id: "att_abc123", ... }]
//     },
//     {
//       schema: "community-member",
//       passed: true,
//       attestations: [{ id: "att_def456", ... }]
//     }
//   ],
//   missingSchemas: [],
//   expiredAttestations: []
// }

Parameters

address

string

required

Address to evaluate

policy

object

required

Trust policy configuration

Show Policy

rules

array

required

Array of schema rules to check

minAttestations

number

Minimum number of attestations required

maxAge

number

Maximum attestation age in milliseconds

requireOnChain

boolean

Require on-chain attestations only

Advanced Examples

KYC Verification System

async function verifyKYC(userAddress: string, kycData: any) {
  // Create KYC attestation
  const attestation = await sdk.trustLayer.createAttestation({
    subject: userAddress,
    schema: 'kyc-verification',
    data: {
      verified: true,
      level: kycData.tier,
      provider: 'Synaps',
      documentType: kycData.documentType,
      country: kycData.country,
      completedAt: new Date().toISOString(),
    },
    expiresAt: new Date(Date.now() + 365 * 24 * 60 * 60 * 1000).toISOString(), // 1 year
    onChain: true,
  });

  console.log('KYC attestation created:', attestation.id);
  return attestation;
}

// Check KYC status
async function checkKYCStatus(userAddress: string) {
  const attestations = await sdk.trustLayer.getAttestations(userAddress, {
    schema: 'kyc-verification',
  });

  if (attestations.length === 0) {
    return { verified: false, message: 'No KYC attestation found' };
  }

  const kycAtt = attestations[0];

  if (kycAtt.revoked) {
    return { verified: false, message: 'KYC attestation revoked' };
  }

  if (new Date(kycAtt.expiresAt!) < new Date()) {
    return { verified: false, message: 'KYC attestation expired' };
  }

  return {
    verified: true,
    level: kycAtt.data.level,
    provider: kycAtt.data.provider,
  };
}

DAO Membership System

async function grantDAOMembership(
  daoAddress: string,
  memberAddress: string,
  role: string
) {
  const attestation = await sdk.trustLayer.createAttestation({
    subject: memberAddress,
    schema: 'dao-member',
    data: {
      daoAddress,
      role,
      joinedAt: new Date().toISOString(),
      votingPower: role === 'core' ? 10 : 1,
    },
    onChain: true,
  });

  return attestation;
}

async function getDAOMembers(daoAddress: string) {
  // This would require a custom API endpoint
  const allAttestations = await sdk.trustLayer.getAttestations(daoAddress, {
    schema: 'dao-member',
  });

  return allAttestations.filter(
    (att) => att.data.daoAddress === daoAddress && !att.revoked
  );
}

Multi-Signature Attestation

async function createMultiSigAttestation(
  subject: string,
  signers: string[],
  data: any
) {
  // First signer creates the attestation
  const baseAttestation = await sdk.trustLayer.createAttestation({
    subject,
    schema: 'multisig-attestation',
    data: {
      ...data,
      signers,
      signatures: 1,
      signedBy: [signers[0]],
    },
    onChain: true,
  });

  // Additional signers reference the base attestation
  const additionalSignatures = await Promise.all(
    signers.slice(1).map((signer) =>
      sdk.trustLayer.createAttestation({
        subject,
        schema: 'multisig-signature',
        data: {
          signer,
          signedAt: new Date().toISOString(),
        },
        refUID: baseAttestation.id,
        onChain: true,
      })
    )
  );

  return {
    baseAttestation,
    signatures: additionalSignatures,
  };
}

Skill Verification

async function attestSkill(
  developerAddress: string,
  skill: string,
  level: number
) {
  return await sdk.trustLayer.createAttestation({
    subject: developerAddress,
    schema: 'skill-verification',
    data: {
      skill,
      level, // 1-10
      verifiedBy: 'code-review',
      projects: ['project1', 'project2'],
      endorsements: 5,
    },
    onChain: false, // Off-chain for lower cost
  });
}

async function getDeveloperSkills(address: string) {
  const skills = await sdk.trustLayer.getAttestations(address, {
    schema: 'skill-verification',
  });

  return skills.map((att) => ({
    skill: att.data.skill,
    level: att.data.level,
    endorsements: att.data.endorsements,
  }));
}

Trust Score Calculator

async function calculateTrustScore(address: string) {
  const attestations = await sdk.trustLayer.getAttestations(address);

  let score = 0;

  // KYC verification: +30 points
  const hasKYC = attestations.some((att) => att.schema === 'kyc-verification');
  if (hasKYC) score += 30;

  // DAO memberships: +10 points each (max 30)
  const daoMemberships = attestations.filter(
    (att) => att.schema === 'dao-member'
  ).length;
  score += Math.min(daoMemberships * 10, 30);

  // Community attestations: +5 points each (max 20)
  const communityAtts = attestations.filter(
    (att) => att.schema === 'community-member'
  ).length;
  score += Math.min(communityAtts * 5, 20);

  // Skills: +2 points per level (max 20)
  const skillPoints = attestations
    .filter((att) => att.schema === 'skill-verification')
    .reduce((sum, att) => sum + (att.data.level || 0), 0);
  score += Math.min(skillPoints * 2, 20);

  return {
    score: Math.min(score, 100),
    breakdown: {
      kyc: hasKYC ? 30 : 0,
      dao: Math.min(daoMemberships * 10, 30),
      community: Math.min(communityAtts * 5, 20),
      skills: Math.min(skillPoints * 2, 20),
    },
  };
}

Attestation Expiry Monitor

async function monitorExpiringAttestations(address: string, daysThreshold: number = 30) {
  const attestations = await sdk.trustLayer.getAttestations(address);

  const now = new Date();
  const thresholdDate = new Date(now.getTime() + daysThreshold * 24 * 60 * 60 * 1000);

  const expiringSoon = attestations.filter((att) => {
    if (!att.expiresAt) return false;
    const expiryDate = new Date(att.expiresAt);
    return expiryDate > now && expiryDate < thresholdDate;
  });

  return expiringSoon.map((att) => ({
    id: att.id,
    schema: att.schema,
    expiresAt: att.expiresAt,
    daysRemaining: Math.floor(
      (new Date(att.expiresAt!).getTime() - now.getTime()) / (24 * 60 * 60 * 1000)
    ),
  }));
}

Schema Examples

Standard Schemas

// KYC Verification
{
  verified: boolean;
  level: 'tier-1' | 'tier-2' | 'tier-3';
  provider: string;
  completedAt: string;
}

// DAO Membership
{
  daoAddress: string;
  role: string;
  joinedAt: string;
  votingPower: number;
}

// Skill Verification
{
  skill: string;
  level: number; // 1-10
  verifiedBy: string;
  projects: string[];
  endorsements: number;
}

// Community Member
{
  role: string;
  reputation: string;
  contributions: number;
  joinedAt: string;
}

// Event Attendance
{
  eventName: string;
  eventDate: string;
  location: string;
  role: 'attendee' | 'speaker' | 'organizer';
}

Error Handling

try {
  const attestation = await sdk.trustLayer.createAttestation({
    subject: '0x742d35...',
    schema: 'kyc',
    data: { verified: true },
  });
} catch (error) {
  if (error.code === 'INVALID_SCHEMA') {
    console.log('Schema not found or invalid');
  } else if (error.code === 'UNAUTHORIZED') {
    console.log('Not authorized to create attestations');
  } else if (error.code === 'INSUFFICIENT_GAS') {
    console.log('Not enough gas for on-chain attestation');
  } else {
    console.error('Error creating attestation:', error);
  }
}

TypeScript Types

interface Attestation {
  id: string;
  schema: string;
  attester: string;
  subject: string;
  data: Record<string, any>;
  createdAt: string;
  expiresAt?: string;
  revoked: boolean;
  onChain: boolean;
  txHash?: string;
  refUID?: string;
}

interface TrustModule {
  id: string;
  name: string;
  description: string;
  schema: Record<string, string>;
  attesters: string[];
  attestationCount: number;
}

interface PolicyEvaluation {
  passed: boolean;
  score: number;
  results: PolicyResult[];
  missingSchemas: string[];
  expiredAttestations: string[];
}

Best Practices

Use On-Chain for Critical Trust: Store important attestations on-chain for immutability
Set Expiration Dates: Most attestations should expire and require renewal
Validate Schema: Ensure data matches the expected schema
Monitor Revocations: Check for revoked attestations before trusting
Multi-Sig for High Value: Require multiple attesters for critical verifications

Next Steps

ZK Proofs SDK

Generate privacy-preserving proofs

Trust Layer API

Explore the Trust API

Trust Gating Guide

Build trust-gated applications

Attesters Guide

Become an attester

SDK Overview

JavaScript SDK

React SDK

SDK Examples

Overview

Get Attestations

Parameters

Create Attestation

Parameters

Revoke Attestation

Parameters

Get Available Modules

Evaluate Trust Policy

Parameters

Advanced Examples

KYC Verification System

DAO Membership System

Multi-Signature Attestation

Skill Verification

Trust Score Calculator

Attestation Expiry Monitor

Schema Examples

Standard Schemas

Error Handling

TypeScript Types

Best Practices

Next Steps

ZK Proofs SDK

Trust Layer API

Trust Gating Guide

Attesters Guide

SDK Overview

JavaScript SDK

React SDK

SDK Examples

Documentation Index

​Overview

​Get Attestations

​Parameters

​Create Attestation

​Parameters

​Revoke Attestation

​Parameters

​Get Available Modules

​Evaluate Trust Policy

​Parameters

​Advanced Examples

​KYC Verification System

​DAO Membership System

​Multi-Signature Attestation

​Skill Verification

​Trust Score Calculator

​Attestation Expiry Monitor

​Schema Examples

​Standard Schemas

​Error Handling

​TypeScript Types

​Best Practices

​Next Steps

ZK Proofs SDK

Trust Layer API

Trust Gating Guide

Attesters Guide

Overview

Get Attestations

Parameters

Create Attestation

Parameters

Revoke Attestation

Parameters

Get Available Modules

Evaluate Trust Policy

Parameters

Advanced Examples

KYC Verification System

DAO Membership System

Multi-Signature Attestation

Skill Verification

Trust Score Calculator

Attestation Expiry Monitor

Schema Examples

Standard Schemas

Error Handling

TypeScript Types

Best Practices

Next Steps