Entity Domains

Create and manage digital domains for entities on the IXO Stack

Entity Domains provide a standardized way to register and manage digital twins of real-world entities on the IXO blockchain, with built-in support for decentralized identity, verifiable credentials, and relationship management.

Overview

Decentralized Identity Management

Create and manage decentralized identifiers (DIDs) for entities, enabling sovereign control and cryptographic verification of identity claims.

Verifiable Ownership and Control

Establish and verify ownership rights through cryptographic proofs, with support for multiple controllers and delegated authority.

Service Endpoint Configuration

Define and manage service endpoints that connect digital twins to external services, APIs, and data sources.

Resource and Claim Linking

Associate verifiable claims, documents, and other resources with entity domains to build comprehensive digital representations.

Relationship Mapping

Create and visualize connections between entities to model real-world relationships and dependencies.

Economic Account Management

Manage financial accounts and transactions associated with entities, enabling economic interactions within the ecosystem.

Domain Properties

Core Properties

interface DomainProperties {
  did: string;              // Decentralized identifier
  controller: string[];     // Domain controllers
  type: string;            // Entity type
  status: number;          // Domain status
  credentials: VerifiableCredential[]; // Domain credentials
}

Service Configuration

interface Service {
  id: string;              // Service identifier
  type: string;           // Service type
  serviceEndpoint: string; // Endpoint URL
  description?: string;    // Optional description
}

Linked Resources

interface LinkedResource {
  id: string;             // Resource identifier
  type: string;          // Resource type
  path: string;          // Resource location
  proof?: string;        // Optional cryptographic proof
}

Accorded Rights

interface AccordedRight {
  type: string; // Right type
  description?: string; // Optional description
}

Linked Claims

interface LinkedClaim {
  id: string; // Claim identifier
  type: string; // Claim type
}

Linked Entities

interface LinkedEntity {
  id: string; // Entity identifier
}

Domain Accounts

interface DomainAccount {
  id: string; // Account identifier
}

Domain Registration

Implementation

Create Domain

import { Entity } from '@ixo/client-sdk';

async function createEntityDomain(
  creator: string,
  entityType: string
) {
  const msg = {
    typeUrl: "/ixo.entity.v1beta1.MsgCreateEntity",
    value: {
      creator,
      entityType,
      entityStatus: 1
    }
  };

  return await Entity.broadcast(msg);
}

```python

```typescript Update Domain
async function updateEntityDomain(
  id: string,
  updates: DomainProperties
) {
  const msg = {
    typeUrl: "/ixo.entity.v1beta1.MsgUpdateEntity",
    value: {
      id,
      ...updates
    }
  };

  return await Entity.broadcast(msg);
}

Domain Management

Add Service

async function addDomainService(
  entityId: string,
  service: Service
) {
  const msg = {
    typeUrl: "/ixo.entity.v1beta1.MsgAddEntityService",
    value: {
      entityId,
      service
    }
  };

  return await Entity.broadcast(msg);
}

Link Resource

async function addLinkedResource(
  entityId: string,
  resource: LinkedResource
) {
  const msg = {
    typeUrl: "/ixo.entity.v1beta1.MsgAddEntityResource",
    value: {
      entityId,
      resource
    }
  };

  return await Entity.broadcast(msg);
}

Update Status

async function updateEntityStatus(
  entityId: string,
  status: number
) {
  const msg = {
    typeUrl: "/ixo.entity.v1beta1.MsgUpdateEntityStatus",
    value: {
      entityId,
      status
    }
  };

  return await Entity.broadcast(msg);
}

Best Practices

Identity Management

• Use strong verification methods
• Implement key rotation
• Maintain controller list
• Document access policies

Service Configuration

• Validate endpoints
• Monitor availability
• Update stale endpoints
• Document service types

Resource Management

• Verify resource integrity
• Maintain proof chains
• Update broken links
• Document dependencies

Security

• Implement access control
• Validate transactions
• Monitor activities
• Regular audits

Developer Resources

API Reference

Entity module API documentation

SDK and kit overview

Canonical SDK guide and routing map

Examples

Implementation examples

GitHub

Entity module source code

For technical support or questions about Entity Domains, join our Developer Community or contact our Developer Relations Team.