The Impact Hub Registry provides a decentralized public infrastructure for registering digital domains, issuing verifiable credentials, and managing the lifecycle of tokenized claims and assets.

​
Core Components

Domain Registry

Register and resolve digital domain identifiers

Credential Registry

Issue and verify domain credentials

Claims Registry

Record and validate verifiable claims

Token Registry

Manage tokenized assets and credits

​
Registry Architecture

​
Domain Registration

import { Registry } from "@ixo/impactxclient-sdk";

// Register new domain
const domain = await Registry.createDomain({
  type: "DigitalDomain",
  controller: ownerAddress,
  capabilities: ["verification", "claims"],
  metadata: {
    name: "Example Domain",
    description: "Domain description"
  }
});

// Resolve domain
const resolved = await Registry.resolveDid(domain.did);

​
Claims Management

​
Registry Services

​
Integration Examples

​
Domain Registration Flow

async function registerVerifiedDomain() {
  // Create domain
  const domain = await Registry.createDomain({
    type: "DigitalDomain",
    controller: ownerAddress
  });

  // Setup verification
  const oracle = await Oracle.create({
    type: "DomainVerification"
  });

  // Verify domain
  const verification = await oracle.verify({
    subject: domain.did,
    context: domainContext
  });

  // Issue credential
  const credential = await Registry.issueCredential({
    type: "DomainVerification",
    subject: domain.did,
    evidence: verification
  });

  return { domain, credential };
}

​
Claims Processing

async function processVerifiedClaim() {
  // Submit claim
  const claim = await Registry.submitClaim({
    type: "VerifiableOutcome",
    subject: domain.did,
    value: claimData
  });

  // Verify claim
  const verification = await oracle.verifyClaim(claim);

  // Update claim status
  await Registry.updateClaimStatus(claim.id, {
    status: "verified",
    evidence: verification
  });

  // Tokenize if valid
  if (verification.isValid) {
    const token = await Registry.tokenizeClaim(claim.id);
    return token;
  }
}

​
Integration Patterns

​
Domain Lifecycle Management

async function createProjectDomain() {
  // Create project domain
  const project = await Registry.createDomain({
    type: "Project",
    class: "CleanCooking",
    capabilities: ["verification", "claims", "tokenization"],
    metadata: {
      standard: "GS_MMECD_1.0",
      methodology: "AMS-II.G"
    }
  });

  // Create data room
  const room = await matrix.createRoom({
    name: `Project ${project.did}`,
    encryption: true
  });

  // Link data room
  await Registry.linkService(project.did, {
    id: "#data",
    type: "MatrixRoom",
    serviceEndpoint: room.roomId
  });

  return project;
}

​
Verification Networks

// Create oracle network
const network = await Registry.createNetwork({
  type: "VerificationNetwork",
  members: [
    { did: "did:ixo:oracle/123", role: "validator" },
    { did: "did:ixo:oracle/456", role: "validator" },
    { did: "did:ixo:oracle/789", role: "coordinator" }
  ],
  policy: {
    threshold: 2,
    timeout: 3600
  }
});

// Submit for verification
const verification = await network.verify({
  subject: domain.did,
  claim: claim,
  context: {
    type: "ClaimVerification",
    standard: "GS_MMECD_1.0"
  }
});

// Process results
if (verification.consensus) {
  await Registry.updateClaimStatus(claim.id, {
    status: "verified",
    evidence: verification.results
  });
}

​
Token Lifecycle

// Create token collection
const collection = await Registry.createCollection({
  name: "Carbon Credits 2024",
  symbol: "CC24",
  standard: "cw721",
  metadata: {
    standard: "GS-VER",
    vintage: "2024"
  }
});

// Mint token from claim
const token = await Registry.mintToken(collection.address, {
  owner: domain.controller,
  metadata: {
    name: "Carbon Credit",
    claimId: claim.id,
    amount: "1000",
    unit: "tCO2e"
  }
});

// Transfer token
await Registry.transferToken(collection.address, {
  tokenId: token.id,
  from: domain.controller,
  to: "ixo1buyer..."
});

// Retire token
await Registry.retireToken(collection.address, {
  tokenId: token.id,
  reason: "Offset",
  evidence: {
    type: "RetirementClaim",
    beneficiary: "Organisation XYZ"
  }
});

​
Data Integration

// Store data in Matrix room
async function storeVerificationData(domain, verification) {
  const room = await Registry.resolveService(domain.did, "#data");
  
  // Store in encrypted room
  await matrix.sendEvent(room.serviceEndpoint, {
    type: "verification.result",
    content: {
      verificationId: verification.id,
      timestamp: Date.now(),
      result: verification.result,
      evidence: verification.evidence
    }
  });

  // Update registry
  await Registry.addEvidence(domain.did, {
    type: "VerificationResult",
    id: verification.id,
    serviceEndpoint: `matrix://${room.serviceEndpoint}`,
    hash: verification.hash
  });
}

​
Protocol Integration

// Instantiate protocol
const protocol = await Registry.instantiateProtocol({
  template: "CleanCookingProtocol",
  version: "1.0.0",
  params: {
    standard: "GS_MMECD_1.0",
    baselineEmissionFactor: 7.2,
    monitoringFrequency: 300
  }
});

// Create domain from protocol
const domain = await Registry.createFromProtocol(protocol.id, {
  controller: ownerAddress,
  metadata: {
    name: "Clean Cooking Project",
    location: "Region XYZ"
  }
});

// Validate against protocol
const validation = await protocol.validate(domain.did, {
  type: "ComplianceCheck",
  evidence: domainData
});

​
Best Practices

Follow these guidelines for reliable registry operations

​
Security

  • Validate all registry operations
  • Implement proper access control
  • Monitor credential status
  • Track token lifecycle

​
Performance

  • Batch registry updates
  • Cache resolution results
  • Handle network issues
  • Monitor chain state

​
Next Steps

Domain Guide

Learn domain registration

Claims Guide

Process verifiable claims

Token Guide

Manage tokenized assets