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

# Trust Registry Functions

> Complete reference for all Trust Registry contract 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.

<Tip>
  All functions that modify state require a transaction and will consume gas. View functions are free to call and return data immediately.
</Tip>

## Attestation Functions

### attest

Create a new attestation for a recipient.

```solidity theme={null}
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:**

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

  ```python Python theme={null}
  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
  ```
</CodeGroup>

### multiAttest

Create multiple attestations in a single transaction.

```solidity theme={null}
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:**

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

### revoke

Revoke an existing attestation.

```solidity theme={null}
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:**

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

  ```python Python theme={null}
  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")
  ```
</CodeGroup>

## Query Functions

### getAttestation

Get detailed information about an attestation.

```solidity theme={null}
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:**

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

  ```python Python theme={null}
  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
  ```
</CodeGroup>

### isAttestationValid

Check if an attestation is currently valid.

```solidity theme={null}
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.

```solidity theme={null}
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.

```solidity theme={null}
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.

```solidity theme={null}
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:**

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

  ```python Python theme={null}
  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
  ```
</CodeGroup>

### getSchema

Get schema information.

```solidity theme={null}
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.

```solidity theme={null}
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.

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

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

## Gas Optimization Tips

### Batch Attestations

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

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

## Related Documentation

* [Contract Overview](/contracts/trust-registry/overview) - Contract architecture
* [Events Reference](/contracts/trust-registry/events) - Event documentation
* [Integration Guide](/contracts/trust-registry/integration) - Integration examples
* [Trust Modules](/contracts/trust-registry/modules) - Module development
* [Privacy Guide](/contracts/trust-registry/privacy) - Privacy features