Trust Registry Functions

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;
}

from web3 import Web3
from eth_abi import encode

def create_attestation(recipient, verified):
    w3 = Web3(Web3.HTTPProvider('https://mainnet.infura.io/v3/YOUR_KEY'))
    
    contract = w3.eth.contract(
        address='0x4567890123456789012345678901234567890123',
        abi=TRUST_REGISTRY_ABI
    )
    
    account = w3.eth.account.from_key('YOUR_PRIVATE_KEY')
    
    # Schema: "bool verified,uint256 timestamp"
    schema_uid = b'...'  # Your schema UID
    
    # Encode attestation data
    import time
    attestation_data = encode(
        ['bool', 'uint256'],
        [verified, int(time.time())]
    )
    
    # Build attestation request
    attestation_request = (
        schema_uid,
        (
            recipient,
            0,  # No expiration
            True,  # Revocable
            bytes(32),  # No reference
            attestation_data
        )
    )
    
    tx = contract.functions.attest(attestation_request).buildTransaction({
        'from': account.address,
        'gas': 150000,
        'gasPrice': w3.eth.gas_price,
        'nonce': w3.eth.get_transaction_count(account.address)
    })
    
    signed_tx = w3.eth.account.sign_transaction(tx, account.key)
    tx_hash = w3.eth.send_raw_transaction(signed_tx.rawTransaction)
    
    receipt = w3.eth.wait_for_transaction_receipt(tx_hash)
    
    # Get UID from event
    event = contract.events.Attested().processReceipt(receipt)[0]
    uid = event['args']['uid']
    
    print(f"Attestation created: {uid.hex()}")
    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`);
}

def revoke_attestation(uid, schema):
    w3 = Web3(Web3.HTTPProvider('https://mainnet.infura.io/v3/YOUR_KEY'))
    
    contract = w3.eth.contract(
        address='0x4567890123456789012345678901234567890123',
        abi=TRUST_REGISTRY_ABI
    )
    
    account = w3.eth.account.from_key('YOUR_PRIVATE_KEY')
    
    revocation_request = (
        schema,
        (uid, 0)
    )
    
    tx = contract.functions.revoke(revocation_request).buildTransaction({
        'from': account.address,
        'gas': 60000,
        'gasPrice': w3.eth.gas_price,
        'nonce': w3.eth.get_transaction_count(account.address)
    })
    
    signed_tx = w3.eth.account.sign_transaction(tx, account.key)
    tx_hash = w3.eth.send_raw_transaction(signed_tx.rawTransaction)
    
    receipt = w3.eth.wait_for_transaction_receipt(tx_hash)
    
    print(f"Attestation {uid.hex()} 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;
}

def get_attestation_details(uid):
    w3 = Web3(Web3.HTTPProvider('https://mainnet.infura.io/v3/YOUR_KEY'))
    
    contract = w3.eth.contract(
        address='0x4567890123456789012345678901234567890123',
        abi=TRUST_REGISTRY_ABI
    )
    
    attestation = contract.functions.getAttestation(uid).call()
    
    print('Attestation:', {
        'uid': attestation[0].hex(),
        'schema': attestation[1].hex(),
        'attester': attestation[2],
        'recipient': attestation[3],
        'time': attestation[4],
        'expirationTime': attestation[5],
        'revocable': attestation[6],
        'revoked': attestation[9],
        'data': attestation[8].hex()
    })
    
    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

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
);

def register_new_schema(schema_string, revocable):
    w3 = Web3(Web3.HTTPProvider('https://mainnet.infura.io/v3/YOUR_KEY'))
    
    contract = w3.eth.contract(
        address='0x4567890123456789012345678901234567890123',
        abi=TRUST_REGISTRY_ABI
    )
    
    account = w3.eth.account.from_key('YOUR_PRIVATE_KEY')
    
    tx = contract.functions.registerSchema(
        schema_string,
        '0x0000000000000000000000000000000000000000',  # No resolver
        revocable
    ).buildTransaction({
        'from': account.address,
        'gas': 100000,
        'gasPrice': w3.eth.gas_price,
        'nonce': w3.eth.get_transaction_count(account.address)
    })
    
    signed_tx = w3.eth.account.sign_transaction(tx, account.key)
    tx_hash = w3.eth.send_raw_transaction(signed_tx.rawTransaction)
    
    receipt = w3.eth.wait_for_transaction_receipt(tx_hash)
    
    # Get schema UID from event
    event = contract.events.SchemaRegistered().processReceipt(receipt)[0]
    schema_uid = event['args']['uid']
    
    print(f"Schema registered: {schema_uid.hex()}")
    print(f"Definition: {schema_string}")
    print(f"Revocable: {revocable}")
    
    return schema_uid

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

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

Error	Description	Solution
`"InvalidSchema"`	Schema doesn’t exist	Verify schema UID
`"NotAttester"`	Caller is not the attester	Use correct account
`"NotRevocable"`	Attestation cannot be revoked	Check revocable flag
`"AlreadyRevoked"`	Attestation already revoked	Check revocation status
`"Expired"`	Attestation has expired	Check expiration time
`"InvalidResolver"`	Schema resolver validation failed	Check 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]
);

Contract Overview - Contract architecture
Events Reference - Event documentation
Integration Guide - Integration examples
Trust Modules - Module development
Privacy Guide - Privacy features

Smart Contracts

IdentitySBT

ScoreCalculator

AchievementRegistry

TrustRegistry

ProtocolRegistry

Contract Examples

Overview

Attestation Functions

attest

multiAttest

revoke

Query Functions

getAttestation

isAttestationValid

getReceivedAttestationUIDs

getSentAttestationUIDs

Schema Functions

registerSchema

getSchema

Trust Module Functions

evaluateTrust

registerTrustModule

Error Handling

Common Errors

Error Handling Example

Gas Optimization Tips

Batch Attestations

Optimize Data Encoding

​Overview

​Attestation Functions

​attest

​multiAttest

​revoke

​Query Functions

​getAttestation

​isAttestationValid

​getReceivedAttestationUIDs

​getSentAttestationUIDs

​Schema Functions

​registerSchema

​getSchema

​Trust Module Functions

​evaluateTrust

​registerTrustModule

​Error Handling

​Common Errors

​Error Handling Example

​Gas Optimization Tips

​Batch Attestations

​Optimize Data Encoding

​Related Documentation

Overview

Attestation Functions

attest

multiAttest

revoke

Query Functions

getAttestation

isAttestationValid

getReceivedAttestationUIDs

getSentAttestationUIDs

Schema Functions

registerSchema

getSchema

Trust Module Functions

evaluateTrust

registerTrustModule

Error Handling

Common Errors

Error Handling Example

Gas Optimization Tips

Batch Attestations

Optimize Data Encoding

Related Documentation