Skip to main content

​
Overview

This document provides a comprehensive reference for all functions available in the ZKScore Trust Registry contract. Each function includes detailed parameter descriptions, return values, gas estimates, and usage examples.
All functions that modify state require a transaction and will consume gas. View functions are free to call and return data immediately.

​
Attestation Functions

​
attest

Create a new attestation for a recipient. 
function attest(AttestationRequest calldata request) 
    external 
    payable 
    returns (bytes32);
Parameters:
  • request (AttestationRequest): Attestation request data
    • schema (bytes32): Schema identifier
    • data (AttestationRequestData): Attestation data
      • recipient (address): Attestation recipient
      • expirationTime (uint64): Expiration timestamp (0 = no expiration)
      • revocable (bool): Whether attestation can be revoked
      • refUID (bytes32): Reference to another attestation
      • data (bytes): Encoded attestation data
Returns:
  • bytes32: Unique attestation ID (UID)
Gas Estimate: ~120,000 gas Events Emitted:
  • Attested(address indexed recipient, address indexed attester, bytes32 uid, bytes32 indexed schema)
Example Usage: 
const { ethers } = require('ethers');

async function createAttestation(recipient, verified) {
  const provider = new ethers.providers.JsonRpcProvider('https://mainnet.infura.io/v3/YOUR_KEY');
  const signer = provider.getSigner();
  
  const contract = new ethers.Contract(
    '0x4567890123456789012345678901234567890123',
    TRUST_REGISTRY_ABI,
    signer
  );
  
  // Schema: "bool verified,uint256 timestamp"
  const schemaUID = '0x...'; // Your schema UID
  
  // Encode attestation data
  const attestationData = ethers.utils.defaultAbiCoder.encode(
    ['bool', 'uint256'],
    [verified, Math.floor(Date.now() / 1000)]
  );
  
  const attestationRequest = {
    schema: schemaUID,
    data: {
      recipient: recipient,
      expirationTime: 0, // No expiration
      revocable: true,
      refUID: ethers.constants.HashZero,
      data: attestationData
    }
  };
  
  const tx = await contract.attest(attestationRequest);
  const receipt = await tx.wait();
  
  // Get UID from event
  const event = receipt.events.find(e => e.event === 'Attested');
  const uid = event.args.uid;
  
  console.log(`Attestation created: ${uid}`);
  return uid;
}

​
multiAttest

Create multiple attestations in a single transaction. 
function multiAttest(MultiAttestationRequest[] calldata requests) 
    external 
    payable 
    returns (bytes32[] memory);
Parameters:
  • requests (MultiAttestationRequest[]): Array of attestation requests
    • schema (bytes32): Schema identifier
    • data (AttestationRequestData[]): Array of attestation data
Returns:
  • bytes32[]: Array of attestation UIDs
Gas Estimate: ~100,000 + (120,000 × number of attestations) Example Usage: 
async function createMultipleAttestations(recipients, schema) {
  const provider = new ethers.providers.JsonRpcProvider('https://mainnet.infura.io/v3/YOUR_KEY');
  const signer = provider.getSigner();
  
  const contract = new ethers.Contract(
    '0x4567890123456789012345678901234567890123',
    TRUST_REGISTRY_ABI,
    signer
  );
  
  const attestationData = recipients.map(recipient => ({
    recipient: recipient,
    expirationTime: 0,
    revocable: true,
    refUID: ethers.constants.HashZero,
    data: ethers.utils.defaultAbiCoder.encode(
      ['bool', 'uint256'],
      [true, Math.floor(Date.now() / 1000)]
    )
  }));
  
  const multiRequest = [{
    schema: schema,
    data: attestationData
  }];
  
  const tx = await contract.multiAttest(multiRequest);
  const receipt = await tx.wait();
  
  // Get all UIDs from events
  const uids = receipt.events
    .filter(e => e.event === 'Attested')
    .map(e => e.args.uid);
  
  console.log(`${uids.length} attestations created`);
  return uids;
}

​
revoke

Revoke an existing attestation. 
function revoke(RevocationRequest calldata request) external payable;
Parameters:
  • request (RevocationRequest): Revocation request data
    • schema (bytes32): Schema identifier
    • data (RevocationRequestData): Revocation data
      • uid (bytes32): Attestation UID to revoke
      • value (uint256): ETH value (if required by schema)
Returns: None Gas Estimate: ~40,000 gas Requirements:
  • Caller must be the attester
  • Attestation must be revocable
  • Attestation must not already be revoked
Events Emitted:
  • Revoked(address indexed recipient, address indexed attester, bytes32 uid, bytes32 indexed schema)
Example Usage: 
async function revokeAttestation(uid, schema) {
  const provider = new ethers.providers.JsonRpcProvider('https://mainnet.infura.io/v3/YOUR_KEY');
  const signer = provider.getSigner();
  
  const contract = new ethers.Contract(
    '0x4567890123456789012345678901234567890123',
    TRUST_REGISTRY_ABI,
    signer
  );
  
  const revocationRequest = {
    schema: schema,
    data: {
      uid: uid,
      value: 0
    }
  };
  
  const tx = await contract.revoke(revocationRequest);
  await tx.wait();
  
  console.log(`Attestation ${uid} revoked`);
}

​
Query Functions

​
getAttestation

Get detailed information about an attestation. 
function getAttestation(bytes32 uid) 
    external 
    view 
    returns (Attestation memory);
Parameters:
  • uid (bytes32): Attestation unique identifier
Returns:
  • Attestation: Complete attestation data
Gas Estimate: ~5,000 gas (view function) Example Usage: 
async function getAttestationDetails(uid) {
  const provider = new ethers.providers.JsonRpcProvider('https://mainnet.infura.io/v3/YOUR_KEY');
  
  const contract = new ethers.Contract(
    '0x4567890123456789012345678901234567890123',
    TRUST_REGISTRY_ABI,
    provider
  );
  
  const attestation = await contract.getAttestation(uid);
  
  console.log('Attestation:', {
    uid: attestation.uid,
    schema: attestation.schema,
    attester: attestation.attester,
    recipient: attestation.recipient,
    time: new Date(attestation.time * 1000).toISOString(),
    expirationTime: attestation.expirationTime > 0 
      ? new Date(attestation.expirationTime * 1000).toISOString() 
      : 'Never',
    revocable: attestation.revocable,
    revoked: attestation.revoked,
    data: attestation.data
  });
  
  return attestation;
}

​
isAttestationValid

Check if an attestation is currently valid. 
function isAttestationValid(bytes32 uid) 
    external 
    view 
    returns (bool);
Parameters:
  • uid (bytes32): Attestation UID
Returns:
  • bool: True if valid, false otherwise
Gas Estimate: ~3,000 gas (view function)

​
getReceivedAttestationUIDs

Get all attestation UIDs received by an address. 
function getReceivedAttestationUIDs(
    address recipient,
    bytes32 schema,
    uint256 start,
    uint256 length,
    bool reverseOrder
) external view returns (bytes32[] memory);
Parameters:
  • recipient (address): Attestation recipient
  • schema (bytes32): Schema filter (0 = all schemas)
  • start (uint256): Starting index
  • length (uint256): Number of results
  • reverseOrder (bool): Return in reverse chronological order
Returns:
  • bytes32[]: Array of attestation UIDs
Gas Estimate: ~5,000 + (500 × number of results) (view function)

​
getSentAttestationUIDs

Get all attestation UIDs sent by an address. 
function getSentAttestationUIDs(
    address attester,
    bytes32 schema,
    uint256 start,
    uint256 length,
    bool reverseOrder
) external view returns (bytes32[] memory);
Parameters:
  • attester (address): Attestation sender
  • schema (bytes32): Schema filter
  • start (uint256): Starting index
  • length (uint256): Number of results
  • reverseOrder (bool): Return in reverse order
Returns:
  • bytes32[]: Array of attestation UIDs
Gas Estimate: ~5,000 + (500 × number of results) (view function)

​
Schema Functions

​
registerSchema

Register a new attestation schema. 
function registerSchema(
    string calldata schema,
    ISchemaResolver resolver,
    bool revocable
) external returns (bytes32);
Parameters:
  • schema (string): Schema definition (e.g., “bool verified,uint256 level”)
  • resolver (ISchemaResolver): Schema resolver contract (0 = no resolver)
  • revocable (bool): Whether attestations are revocable
Returns:
  • bytes32: Schema UID
Gas Estimate: ~80,000 gas Events Emitted:
  • SchemaRegistered(bytes32 indexed uid, address indexed registerer)
Example Usage: 
async function registerNewSchema(schemaString, revocable) {
  const provider = new ethers.providers.JsonRpcProvider('https://mainnet.infura.io/v3/YOUR_KEY');
  const signer = provider.getSigner();
  
  const contract = new ethers.Contract(
    '0x4567890123456789012345678901234567890123',
    TRUST_REGISTRY_ABI,
    signer
  );
  
  const tx = await contract.registerSchema(
    schemaString,
    ethers.constants.AddressZero, // No resolver
    revocable
  );
  
  const receipt = await tx.wait();
  
  // Get schema UID from event
  const event = receipt.events.find(e => e.event === 'SchemaRegistered');
  const schemaUID = event.args.uid;
  
  console.log(`Schema registered: ${schemaUID}`);
  console.log(`Definition: ${schemaString}`);
  console.log(`Revocable: ${revocable}`);
  
  return schemaUID;
}

// Example: Register identity verification schema
const schemaUID = await registerNewSchema(
  "bool verified,uint8 level,uint256 timestamp",
  true
);

​
getSchema

Get schema information. 
function getSchema(bytes32 uid) 
    external 
    view 
    returns (SchemaRecord memory);
Parameters:
  • uid (bytes32): Schema UID
Returns:
  • SchemaRecord: Schema data including definition, resolver, and revocability
Gas Estimate: ~3,000 gas (view function)

​
Trust Module Functions

​
evaluateTrust

Evaluate trust score for a subject using a specific module. 
function evaluateTrust(
    address module,
    address subject,
    bytes calldata context
) external view returns (uint256);
Parameters:
  • module (address): Trust module contract address
  • subject (address): Address to evaluate
  • context (bytes): Module-specific context data
Returns:
  • uint256: Trust score (0-1000)
Gas Estimate: Varies by module (~10,000-50,000 gas)

​
registerTrustModule

Register a new trust evaluation module. 
function registerTrustModule(
    address module,
    string calldata name
) external;
Parameters:
  • module (address): Module contract address
  • name (string): Module name
Returns: None Gas Estimate: ~60,000 gas Requirements:
  • Caller must have MODULE_REGISTRAR_ROLE
  • Module must implement ITrustModule interface

​
Error Handling

​
Common Errors

ErrorDescriptionSolution
"InvalidSchema"Schema doesn’t existVerify schema UID
"NotAttester"Caller is not the attesterUse correct account
"NotRevocable"Attestation cannot be revokedCheck revocable flag
"AlreadyRevoked"Attestation already revokedCheck revocation status
"Expired"Attestation has expiredCheck expiration time
"InvalidResolver"Schema resolver validation failedCheck resolver logic

​
Error Handling Example

async function safeAttest(request) {
  try {
    // Check schema exists
    const schema = await contract.getSchema(request.schema);
    if (!schema.uid) {
      throw new Error('Schema does not exist');
    }
    
    // Create attestation
    const tx = await contract.attest(request);
    const receipt = await tx.wait();
    
    return receipt;
  } catch (error) {
    if (error.message.includes('InvalidSchema')) {
      console.error('Invalid schema - please register first');
    } else if (error.message.includes('InvalidResolver')) {
      console.error('Schema resolver rejected the attestation');
    } else {
      console.error('Attestation failed:', error.message);
    }
    throw error;
  }
}

​
Gas Optimization Tips

​
Batch Attestations

// Instead of individual attestations
for (const recipient of recipients) {
  await contract.attest(createRequest(recipient));
}

// Use batch attestation
await contract.multiAttest([{
  schema: schemaUID,
  data: recipients.map(r => createRequestData(r))
}]);

​
Optimize Data Encoding

// Use packed encoding when possible
const packedData = ethers.utils.solidityPack(
  ['bool', 'uint8', 'uint32'],
  [true, 5, timestamp]
);

// Instead of default encoding
const defaultData = ethers.utils.defaultAbiCoder.encode(
  ['bool', 'uint256', 'uint256'],
  [true, 5, timestamp]
);