@hsuite/smart-network-types - Smart Network Type Definitions

🌐 Comprehensive TypeScript type system for Smart Network ecosystem with Web3 integration and NFT standards compliance

Enterprise-grade type definitions and validation library providing robust interfaces, models, and runtime validation for network operations, membership management, operator controls, and smart node functionality with full Swagger/OpenAPI documentation support.

📚 Table of Contents

✨ Quick Start

Installation

npm install @hsuite/smart-network-types

Basic Setup

import { ISmartNetwork, SmartNetwork } from '@hsuite/smart-network-types';

// Interface-based type definitions
const networkConfig: ISmartNetwork.INetwork.IEntity = {
  membership: {
    walletId: "0x123...",
    operator: { id: "op_123", role: "VALIDATOR" },
    status: ISmartNetwork.IMembership.IStatus.ACTIVE,
    details: { /* membership details */ }
  },
  type: "operator",
  clusters: [],
  dkgId: "dkg-123456"
};

// Model-based runtime validation
const membership = new SmartNetwork.Membership.Web3.Entity(
  "0x1234567890abcdef",
  operatorEntity,
  ISmartNetwork.IMembership.IStatus.ACTIVE,
  details
);

NestJS Integration

import { SmartNetwork } from '@hsuite/smart-network-types';

@Controller('network')
export class NetworkController {
  @Post('membership')
  @ApiResponse({ type: SmartNetwork.Membership.Web3.Entity })
  async createMembership(@Body() data: any): Promise<SmartNetwork.Membership.Web3.Entity> {
    return new SmartNetwork.Membership.Web3.Entity(
      data.walletId,
      data.operator,
      data.status,
      data.details
    );
  }
}

🏗️ Architecture

Dual Namespace System

The library provides a comprehensive dual-namespace architecture:

🔧 ISmartNetwork Namespace (Interfaces)

  • Type Definitions - Pure TypeScript interfaces for type safety

  • Network Operations - Network entity and configuration interfaces

  • Membership Management - Web3 membership and lifecycle interfaces

  • Operator Controls - Role and permission management interfaces

  • Smart Node Operations - Node management and monitoring interfaces

🏛️ SmartNetwork Namespace (Models)

  • Runtime Validation - Concrete classes with built-in validation

  • Swagger Integration - Complete API documentation decorators

  • Configuration Models - System configuration and setup classes

  • NFT Compliance - ERC721/HIP412 metadata standards support

Domain Components

🌐 Network Domain

  • Entity Management - Core network participant tracking

  • Cluster Operations - Network cluster organization and status

  • Configuration - Network-wide settings and parameters

  • Fee Structures - Network fee calculation and management

👥 Membership Domain

  • Web3 Integration - Blockchain-based membership with NFT support

  • Lifecycle Management - Complete status tracking from PENDING to EXITED

  • Transaction Tracking - Full audit trail of blockchain operations

  • Metadata Management - NFT-compatible metadata with IPFS integration

⚡ Operator Domain

  • Role Management - Operator role definitions and permissions

  • Cluster Operations - Operator-cluster relationship management

  • Performance Tracking - Activity and performance metrics

  • Access Control - Permission-based operation authorization

🖥️ Smart Node Domain

  • Node Management - Smart node configuration and lifecycle

  • Performance Monitoring - Health and performance tracking

  • Resource Management - System resource allocation

  • Diagnostics - Node troubleshooting and analysis

Module Structure

src/
├── index.ts                           # Main exports and documentation
├── interfaces/                        # ISmartNetwork namespace
│   ├── smart-network.namespace.ts     # Central interface hub
│   ├── shared-types/                  # Common enums and utilities
│   ├── network/                       # Network interfaces
│   ├── membership/                    # Membership interfaces
│   ├── operator/                      # Operator interfaces
│   └── smart-node/                    # Smart node interfaces
└── models/                            # SmartNetwork namespace  
    ├── smart-network.namespace.ts     # Central model hub
    ├── network/                       # Network models
    ├── membership/                    # Membership models
    ├── operator/                      # Operator models
    └── smart-node/                    # Smart node models

🔧 API Reference

ISmartNetwork Namespace

Core Interface Structure

namespace ISmartNetwork {
  INetwork: _INetwork;      // Network management interfaces
  IMembership: _IMembership; // Membership lifecycle interfaces
  IOperator: _IOperator;     // Operator management interfaces
  ISmartNode: _ISmartNode;   // Smart node interfaces
}

Network Interfaces

ISmartNetwork.INetwork.IEntity

  • Description: Core network entity interface

  • Properties: membership, type, clusters, dkgId

  • Usage: Network participant identification and management

ISmartNetwork.INetwork.ICluster

  • Description: Network cluster management interface

  • Properties: type, status, configuration

  • Usage: Cluster organization and status tracking

ISmartNetwork.INetwork.IConfig

  • Description: Network configuration interface

  • Properties: settings, options, utilities

  • Usage: Network-wide parameter management

Membership Interfaces

ISmartNetwork.IMembership.IStatus

enum IStatus {
  PENDING = 'pending',      // Initial state, awaiting approval
  PROCESSING = 'processing', // Being processed by system
  MINTED = 'minted',        // NFT successfully created
  DELIVERED = 'delivered',   // NFT transferred to member
  ACTIVE = 'active',        // Fully operational state
  EXITING = 'exiting',      // Graceful termination in progress
  EXITED = 'exited',        // Successfully terminated
  FAILED = 'failed',        // Operation error occurred
  BANNED = 'banned'         // Forcefully terminated
}

ISmartNetwork.IMembership.IWeb3

  • Description: Web3 membership management interface

  • Properties: entity, metadata, details, configuration

  • Usage: Blockchain-based membership operations

Operator Interfaces

ISmartNetwork.IOperator.IEntity

  • Description: Operator entity management interface

  • Properties: id, role, permissions, clusters

  • Usage: Operator identification and role management

Smart Node Interfaces

ISmartNetwork.ISmartNode.IState

  • Description: Smart node state and health interface

  • Properties: status, health, performance, resources

  • Usage: Node monitoring and diagnostics

SmartNetwork Namespace

Core Model Structure

namespace SmartNetwork {
  Network: _Network;           // Network models and configuration
  Membership: _Membership;     // Membership models with Web3 support
  Operator: _Operator;         // Operator management models
  SmartNode: _SmartNode;       // Smart node operational models
}

Network Models

SmartNetwork.Network.Entity

  • Constructor: (membership, type, clusters, dkgId)

  • Validation: Runtime validation of all parameters

  • Decorators: Complete Swagger API documentation

  • Usage: Network entity creation with validation

Membership Models

SmartNetwork.Membership.Web3.Entity

  • Constructor: (walletId, operator, status, details)

  • Validation: Wallet address format, operator structure validation

  • Features: Complete Web3 membership with NFT support

  • Decorators: Full Swagger documentation with examples

SmartNetwork.Membership.Web3.Metadata

  • Constructor: (name, description, creator, image, type, format, files, properties, attributes)

  • Standards: ERC721/HIP412 NFT metadata compliance

  • IPFS: Integrated IPFS content addressing

  • Validation: Metadata format and standard compliance

SmartNetwork.Membership.Web3.Details

  • Constructor: (transactionDetails)

  • Features: Complete transaction audit trail

  • Properties: stake, unstake, mint, burn, activate, freeze operations

  • Tracking: Full blockchain transaction tracking

Configuration Models

SmartNetwork.Membership.Config.Options

  • Constructor: (enabled, utilities, network, redis, entity)

  • Features: Comprehensive membership system configuration

  • Validation: Configuration parameter validation

  • Integration: Redis integration for caching and session management

📖 Guides

Network Entity Setup Guide

Configure network entities and cluster management for Smart Network operations. Complete setup instructions for network membership entities, operator configuration, DKG cluster integration, and blockchain-based validation systems with comprehensive monitoring and management capabilities.

Web3 Membership Guide

Implement blockchain-based memberships with NFT standards compliance. Detailed guide covering Web3 membership lifecycle management, HIP412 NFT metadata creation, staking mechanisms, minting processes, and activation workflows with complete transaction tracking and validation.

Operator Management Guide

Set up operator roles, permissions, and cluster associations. Comprehensive guide for operator entity management including role-based access control, permission systems, cluster assignments, and network governance with complete audit trails and security controls.

Smart Node Configuration Guide

Configure and monitor smart nodes with performance tracking. Advanced configuration guide covering smart node deployment, performance monitoring, network integration, health checks, and optimization strategies for enterprise-grade blockchain operations.

🎯 Examples

Network Entity Management

import { SmartNetwork, ISmartNetwork } from '@hsuite/smart-network-types';

@Injectable()
export class NetworkEntityService {
  
  async createNetworkEntity(entityData: any) {
    try {
      // Create operator entity
      const operator = new SmartNetwork.Operator.Entity(
        entityData.operatorId,
        entityData.role,
        entityData.permissions,
        entityData.clusters
      );

      // Create membership details with transaction tracking
      const membershipDetails = new SmartNetwork.Membership.Web3.Details({
        metadata: this.createNFTMetadata(entityData.metadata),
        stake: {
          txHash: entityData.stakeTransaction,
          amount: entityData.stakeAmount
        },
        mint: {
          txHash: entityData.mintTransaction,
          tokenId: entityData.tokenId
        },
        activate: {
          txHash: entityData.activateTransaction,
          status: 'active'
        }
      });

      // Create Web3 membership
      const membership = new SmartNetwork.Membership.Web3.Entity(
        entityData.walletId,
        operator,
        ISmartNetwork.IMembership.IStatus.ACTIVE,
        membershipDetails
      );

      // Create network entity
      const networkEntity = new SmartNetwork.Network.Entity(
        membership,
        entityData.type,
        entityData.clusters,
        entityData.dkgId
      );

      return {
        success: true,
        entity: networkEntity,
        entityId: networkEntity.membership.walletId,
        status: networkEntity.membership.status,
        createdAt: new Date().toISOString()
      };
    } catch (error) {
      throw new Error(`Network entity creation failed: ${error.message}`);
    }
  }

  private createNFTMetadata(metadataConfig: any) {
    return new SmartNetwork.Membership.Web3.Metadata(
      metadataConfig.name,
      metadataConfig.description,
      metadataConfig.creator,
      metadataConfig.image,
      metadataConfig.type,
      'HIP412',  // NFT standard
      metadataConfig.files || [],
      metadataConfig.properties || {},
      metadataConfig.attributes || []
    );
  }

  async validateNetworkEntity(entity: SmartNetwork.Network.Entity): Promise<boolean> {
    // Validate membership status
    if (entity.membership.status !== ISmartNetwork.IMembership.IStatus.ACTIVE) {
      return false;
    }

    // Validate wallet address format
    const walletRegex = /^0x[a-fA-F0-9]{40}$/;
    if (!walletRegex.test(entity.membership.walletId)) {
      return false;
    }

    // Validate operator permissions
    if (!entity.membership.operator.permissions.length) {
      return false;
    }

    return true;
  }
}

Web3 Membership Lifecycle Management

import { SmartNetwork, ISmartNetwork } from '@hsuite/smart-network-types';

@Injectable()
export class MembershipLifecycleService {
  
  async initiateMembership(membershipRequest: any) {
    try {
      // Create initial membership in PENDING status
      const membership = new SmartNetwork.Membership.Web3.Entity(
        membershipRequest.walletId,
        membershipRequest.operator,
        ISmartNetwork.IMembership.IStatus.PENDING,
        null // Details will be added as operations complete
      );

      return {
        membershipId: membership.walletId,
        status: membership.status,
        nextAction: 'process_application',
        estimatedTime: '5-10 minutes'
      };
    } catch (error) {
      throw new Error(`Membership initiation failed: ${error.message}`);
    }
  }

  async processStaking(membershipId: string, stakeData: any) {
    try {
      // Update status to PROCESSING
      const updatedDetails = new SmartNetwork.Membership.Web3.Details({
        stake: {
          txHash: stakeData.transactionHash,
          amount: stakeData.amount,
          timestamp: Date.now()
        }
      });

      return {
        membershipId,
        status: ISmartNetwork.IMembership.IStatus.PROCESSING,
        stakeConfirmed: true,
        nextAction: 'mint_nft',
        transactionHash: stakeData.transactionHash
      };
    } catch (error) {
      throw new Error(`Staking process failed: ${error.message}`);
    }
  }

  async mintMembershipNFT(membershipId: string, nftData: any) {
    try {
      // Create NFT metadata
      const metadata = new SmartNetwork.Membership.Web3.Metadata(
        nftData.name,
        nftData.description,
        'SmartNetwork DAO',
        nftData.imageUrl,
        'VALIDATOR',
        'HIP412',
        nftData.additionalFiles || [],
        { tier: nftData.tier, stakeAmount: nftData.stakeAmount },
        [
          { trait_type: 'Tier', value: nftData.tier },
          { trait_type: 'Stake Amount', value: nftData.stakeAmount },
          { trait_type: 'Join Date', value: new Date().toISOString().split('T')[0] }
        ]
      );

      // Update membership details with mint information
      const updatedDetails = new SmartNetwork.Membership.Web3.Details({
        metadata,
        mint: {
          txHash: nftData.mintTransaction,
          tokenId: nftData.tokenId,
          timestamp: Date.now()
        }
      });

      return {
        membershipId,
        status: ISmartNetwork.IMembership.IStatus.MINTED,
        tokenId: nftData.tokenId,
        metadataUrl: `ipfs://${nftData.metadataCid}`,
        nextAction: 'deliver_nft'
      };
    } catch (error) {
      throw new Error(`NFT minting failed: ${error.message}`);
    }
  }

  async deliverNFT(membershipId: string, deliveryData: any) {
    try {
      return {
        membershipId,
        status: ISmartNetwork.IMembership.IStatus.DELIVERED,
        deliveryTransaction: deliveryData.transactionHash,
        nextAction: 'activate_membership'
      };
    } catch (error) {
      throw new Error(`NFT delivery failed: ${error.message}`);
    }
  }

  async activateMembership(membershipId: string, activationData: any) {
    try {
      return {
        membershipId,
        status: ISmartNetwork.IMembership.IStatus.ACTIVE,
        activationTransaction: activationData.transactionHash,
        activatedAt: new Date().toISOString(),
        privileges: ['network_participation', 'governance_voting', 'reward_distribution']
      };
    } catch (error) {
      throw new Error(`Membership activation failed: ${error.message}`);
    }
  }

  async exitMembership(membershipId: string, exitReason: string) {
    try {
      // Initiate graceful exit
      const exitDetails = {
        reason: exitReason,
        initiatedAt: Date.now(),
        status: ISmartNetwork.IMembership.IStatus.EXITING
      };

      return {
        membershipId,
        status: ISmartNetwork.IMembership.IStatus.EXITING,
        exitReason,
        estimatedCompletionTime: '24-48 hours',
        nextSteps: ['unstake_tokens', 'burn_nft', 'final_settlement']
      };
    } catch (error) {
      throw new Error(`Membership exit initiation failed: ${error.message}`);
    }
  }

  async completeMembershipExit(membershipId: string, exitData: any) {
    try {
      return {
        membershipId,
        status: ISmartNetwork.IMembership.IStatus.EXITED,
        unstakeTransaction: exitData.unstakeTransaction,
        burnTransaction: exitData.burnTransaction,
        finalSettlement: exitData.settlementAmount,
        completedAt: new Date().toISOString()
      };
    } catch (error) {
      throw new Error(`Membership exit completion failed: ${error.message}`);
    }
  }
}

Operator Management System

import { SmartNetwork, ISmartNetwork } from '@hsuite/smart-network-types';

@Injectable()
export class OperatorManagementService {
  
  async createOperator(operatorData: any) {
    try {
      const operator = new SmartNetwork.Operator.Entity(
        operatorData.id,
        operatorData.role,
        operatorData.permissions,
        operatorData.clusters
      );

      return {
        success: true,
        operatorId: operator.id,
        role: operator.role,
        permissions: operator.permissions,
        assignedClusters: operator.clusters.length,
        createdAt: new Date().toISOString()
      };
    } catch (error) {
      throw new Error(`Operator creation failed: ${error.message}`);
    }
  }

  async assignOperatorToClusters(operatorId: string, clusterIds: string[]) {
    try {
      const assignments = [];

      for (const clusterId of clusterIds) {
        // Validate cluster assignment
        const assignment = {
          operatorId,
          clusterId,
          assignedAt: new Date().toISOString(),
          status: 'active',
          permissions: ['read', 'monitor', 'operate']
        };

        assignments.push(assignment);
      }

      return {
        operatorId,
        newAssignments: assignments.length,
        totalClusters: clusterIds.length,
        assignments
      };
    } catch (error) {
      throw new Error(`Cluster assignment failed: ${error.message}`);
    }
  }

  async updateOperatorPermissions(operatorId: string, newPermissions: string[]) {
    try {
      // Validate permissions
      const validPermissions = [
        'network:read', 'network:write', 'network:admin',
        'cluster:read', 'cluster:operate', 'cluster:manage',
        'node:monitor', 'node:control', 'node:configure',
        'membership:view', 'membership:approve', 'membership:revoke'
      ];

      const invalidPermissions = newPermissions.filter(
        permission => !validPermissions.includes(permission)
      );

      if (invalidPermissions.length > 0) {
        throw new Error(`Invalid permissions: ${invalidPermissions.join(', ')}`);
      }

      return {
        operatorId,
        previousPermissions: [], // Would get from existing operator
        newPermissions,
        updatedAt: new Date().toISOString(),
        effectiveImmediately: true
      };
    } catch (error) {
      throw new Error(`Permission update failed: ${error.message}`);
    }
  }

  async getOperatorPerformanceMetrics(operatorId: string, timeRange: string) {
    try {
      // Mock performance data - in real implementation, this would come from monitoring
      const metrics = {
        operatorId,
        timeRange,
        metrics: {
          uptime: '99.9%',
          averageResponseTime: '45ms',
          operationsCompleted: 1247,
          errorsEncountered: 3,
          clustersManaged: 5,
          activeMemberships: 23
        },
        performance: {
          excellent: ['uptime', 'response_time'],
          good: ['operations_completed'],
          needsAttention: ['error_rate']
        },
        generatedAt: new Date().toISOString()
      };

      return metrics;
    } catch (error) {
      throw new Error(`Performance metrics retrieval failed: ${error.message}`);
    }
  }
}

Smart Node Configuration and Monitoring

import { SmartNetwork, ISmartNetwork } from '@hsuite/smart-network-types';

@Injectable()
export class SmartNodeService {
  
  async configureSmartNode(nodeConfig: any) {
    try {
      const nodeState = {
        nodeId: nodeConfig.id,
        status: 'initializing',
        health: 'unknown',
        configuration: {
          resources: {
            cpu: nodeConfig.resources.cpu,
            memory: nodeConfig.resources.memory,
            storage: nodeConfig.resources.storage,
            network: nodeConfig.resources.network
          },
          services: {
            consensus: nodeConfig.services.consensus,
            storage: nodeConfig.services.storage,
            networking: nodeConfig.services.networking
          },
          security: {
            encryption: nodeConfig.security.encryption,
            authentication: nodeConfig.security.authentication,
            authorization: nodeConfig.security.authorization
          }
        },
        configuredAt: new Date().toISOString()
      };

      return {
        success: true,
        nodeId: nodeState.nodeId,
        configuration: nodeState.configuration,
        nextStep: 'start_services',
        estimatedStartTime: '2-3 minutes'
      };
    } catch (error) {
      throw new Error(`Smart node configuration failed: ${error.message}`);
    }
  }

  async monitorNodeHealth(nodeId: string) {
    try {
      // Mock health data - real implementation would gather actual metrics
      const healthMetrics = {
        nodeId,
        timestamp: new Date().toISOString(),
        status: 'operational',
        health: 'healthy',
        metrics: {
          cpu: { usage: '23%', temperature: '42°C', cores: 8 },
          memory: { usage: '67%', total: '32GB', available: '10.5GB' },
          storage: { usage: '45%', total: '1TB', available: '550GB' },
          network: { 
            latency: '12ms', 
            throughput: '850 Mbps', 
            connections: 42,
            errors: 0
          }
        },
        services: {
          consensus: { status: 'active', uptime: '99.8%', lastBlock: 1234567 },
          storage: { status: 'active', uptime: '99.9%', operations: 2341 },
          networking: { status: 'active', uptime: '99.7%', peers: 15 }
        },
        alerts: []
      };

      return healthMetrics;
    } catch (error) {
      throw new Error(`Node health monitoring failed: ${error.message}`);
    }
  }

  async performNodeDiagnostics(nodeId: string) {
    try {
      const diagnostics = {
        nodeId,
        testSuite: 'comprehensive',
        executedAt: new Date().toISOString(),
        tests: [
          {
            name: 'CPU Performance',
            status: 'passed',
            score: 95,
            details: 'All cores operating within normal parameters'
          },
          {
            name: 'Memory Integrity',
            status: 'passed', 
            score: 98,
            details: 'No memory leaks or corruption detected'
          },
          {
            name: 'Storage I/O',
            status: 'passed',
            score: 92,
            details: 'Read/write operations within expected ranges'
          },
          {
            name: 'Network Connectivity',
            status: 'warning',
            score: 85,
            details: 'Intermittent latency spikes detected on peer connections'
          },
          {
            name: 'Consensus Participation',
            status: 'passed',
            score: 97,
            details: 'Successfully participating in consensus rounds'
          }
        ],
        overallScore: 93,
        recommendations: [
          'Monitor network connectivity for consistent performance',
          'Consider upgrading network infrastructure if latency issues persist'
        ]
      };

      return diagnostics;
    } catch (error) {
      throw new Error(`Node diagnostics failed: ${error.message}`);
    }
  }

  async updateNodeConfiguration(nodeId: string, configUpdates: any) {
    try {
      const updateResult = {
        nodeId,
        updatedAt: new Date().toISOString(),
        changes: {
          previous: {}, // Would contain previous configuration
          current: configUpdates
        },
        restartRequired: false,
        status: 'configuration_updated'
      };

      // Check if restart is required based on updates
      const restartRequiredChanges = ['consensus', 'security', 'networking'];
      const requiresRestart = Object.keys(configUpdates).some(key => 
        restartRequiredChanges.includes(key)
      );

      if (requiresRestart) {
        updateResult.restartRequired = true;
        updateResult.status = 'restart_pending';
      }

      return updateResult;
    } catch (error) {
      throw new Error(`Node configuration update failed: ${error.message}`);
    }
  }
}

Configuration Management

import { SmartNetwork } from '@hsuite/smart-network-types';

@Injectable()
export class ConfigurationService {
  
  async setupMembershipConfiguration(configData: any) {
    try {
      // Create network configuration
      const networkConfig = new SmartNetwork.Membership.Config.Network({
        type: configData.network.type,
        endpoints: configData.network.endpoints
      });

      // Create entity configuration
      const entityConfig = new SmartNetwork.Membership.Config.Entity({
        tokenId: configData.entity.tokenId,
        price: configData.entity.price,
        metadata: {
          content: {
            name: configData.entity.metadata.name,
            description: configData.entity.metadata.description,
            creator: configData.entity.metadata.creator,
            type: configData.entity.metadata.type,
            format: 'HIP412',
            files: configData.entity.metadata.files || [],
            properties: configData.entity.metadata.properties || {},
            attributes: configData.entity.metadata.attributes || [],
            image: configData.entity.metadata.image
          },
          cid: configData.entity.metadata.cid
        }
      });

      // Create main configuration
      const membershipConfig = new SmartNetwork.Membership.Config.Options({
        enabled: true,
        utilities: configData.utilities || [],
        network: networkConfig,
        redis: {
          host: configData.redis.host || 'localhost',
          port: configData.redis.port || 6379,
          ttl: configData.redis.ttl || 3600,
          prefix: configData.redis.prefix || 'membership:'
        },
        entity: entityConfig
      });

      return {
        success: true,
        configuration: membershipConfig,
        features: {
          web3Integration: true,
          nftSupport: true,
          redisCache: true,
          utilities: membershipConfig.utilities.length
        },
        configuredAt: new Date().toISOString()
      };
    } catch (error) {
      throw new Error(`Membership configuration setup failed: ${error.message}`);
    }
  }

  async setupNetworkConfiguration(networkData: any) {
    try {
      const networkSettings = new SmartNetwork.NetworkConfig.Settings({
        protocol: networkData.protocol || 'v2',
        chainId: networkData.chainId || 1,
        consensus: networkData.consensus || 'PoS'
      });

      const networkOptions = new SmartNetwork.NetworkConfig.Options({
        enabled: true,
        settings: networkSettings,
        endpoints: networkData.endpoints || []
      });

      return {
        success: true,
        settings: networkSettings,
        options: networkOptions,
        endpoints: networkData.endpoints.length,
        configuredAt: new Date().toISOString()
      };
    } catch (error) {
      throw new Error(`Network configuration setup failed: ${error.message}`);
    }
  }

  validateConfiguration(config: any): { isValid: boolean; errors: string[] } {
    const errors = [];

    // Validate network configuration
    if (!config.network || !config.network.endpoints || !config.network.endpoints.length) {
      errors.push('Network endpoints are required');
    }

    // Validate membership configuration
    if (config.membership && !config.membership.tokenId) {
      errors.push('Membership token ID is required');
    }

    // Validate Redis configuration
    if (config.redis && (!config.redis.host || !config.redis.port)) {
      errors.push('Redis host and port are required');
    }

    return {
      isValid: errors.length === 0,
      errors
    };
  }
}

Type-Safe Development Patterns

import { ISmartNetwork, SmartNetwork } from '@hsuite/smart-network-types';

@Injectable()
export class TypeSafeDevelopmentService {
  
  // Interface-first development for type safety
  processNetworkData(network: ISmartNetwork.INetwork.IEntity): void {
    // Type-safe operations with intellisense support
    if (network.membership.status === ISmartNetwork.IMembership.IStatus.ACTIVE) {
      this.handleActiveNetwork(network);
    }
  }

  // Model-based validation for runtime safety
  createValidatedMembership(data: any): SmartNetwork.Membership.Web3.Entity {
    try {
      return new SmartNetwork.Membership.Web3.Entity(
        data.walletId,
        data.operator,
        data.status,
        data.details
      );
    } catch (error) {
      // Descriptive validation errors
      throw new Error(`Membership validation failed: ${error.message}`);
    }
  }

  // Comprehensive error handling
  async handleMembershipOperation(
    operation: 'create' | 'update' | 'delete',
    data: any
  ): Promise<{ success: boolean; result?: any; error?: string }> {
    try {
      switch (operation) {
        case 'create':
          const membership = this.createValidatedMembership(data);
          return { success: true, result: membership };
        
        case 'update':
          // Update logic with validation
          return { success: true, result: 'updated' };
        
        case 'delete':
          // Delete logic with validation
          return { success: true, result: 'deleted' };
        
        default:
          throw new Error(`Unsupported operation: ${operation}`);
      }
    } catch (error) {
      return { 
        success: false, 
        error: error.message 
      };
    }
  }

  // Status lifecycle management
  getNextValidStatuses(currentStatus: ISmartNetwork.IMembership.IStatus): ISmartNetwork.IMembership.IStatus[] {
    const transitions = {
      [ISmartNetwork.IMembership.IStatus.PENDING]: [
        ISmartNetwork.IMembership.IStatus.PROCESSING,
        ISmartNetwork.IMembership.IStatus.FAILED
      ],
      [ISmartNetwork.IMembership.IStatus.PROCESSING]: [
        ISmartNetwork.IMembership.IStatus.MINTED,
        ISmartNetwork.IMembership.IStatus.FAILED
      ],
      [ISmartNetwork.IMembership.IStatus.MINTED]: [
        ISmartNetwork.IMembership.IStatus.DELIVERED,
        ISmartNetwork.IMembership.IStatus.FAILED
      ],
      [ISmartNetwork.IMembership.IStatus.DELIVERED]: [
        ISmartNetwork.IMembership.IStatus.ACTIVE,
        ISmartNetwork.IMembership.IStatus.FAILED
      ],
      [ISmartNetwork.IMembership.IStatus.ACTIVE]: [
        ISmartNetwork.IMembership.IStatus.EXITING,
        ISmartNetwork.IMembership.IStatus.BANNED
      ],
      [ISmartNetwork.IMembership.IStatus.EXITING]: [
        ISmartNetwork.IMembership.IStatus.EXITED,
        ISmartNetwork.IMembership.IStatus.FAILED
      ]
    };

    return transitions[currentStatus] || [];
  }
}

🔗 Integration

Required Dependencies

{
  "@nestjs/common": "^10.4.2",
  "@nestjs/core": "^10.4.2",
  "@hsuite/nestjs-swagger": "^1.0.3",
  "@hsuite/did-sdk-js": "^1.0.3",
  "@hsuite/vc-sl-sdk-js": "^1.0.3",
  "@compodoc/compodoc": "^1.1.23"
}

TypeScript Configuration

{
  "compilerOptions": {
    "declaration": true,
    "outDir": "../../dist/libs/smart-network-types",
    "types": ["node"],
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true,
    "experimentalDecorators": true,
    "emitDecoratorMetadata": true
  }
}

Module Integration

import { Module } from '@nestjs/common';
import { SmartNetwork, ISmartNetwork } from '@hsuite/smart-network-types';

@Module({
  providers: [
    NetworkEntityService,
    MembershipLifecycleService,
    OperatorManagementService,
    SmartNodeService
  ],
  exports: [
    NetworkEntityService,
    MembershipLifecycleService,
    OperatorManagementService,
    SmartNodeService
  ]
})
export class SmartNetworkModule {}

Documentation Generation

# Generate comprehensive documentation
npm run compodoc

# Generate documentation with coverage report
npm run compodoc:coverage

Integration with HSuite Ecosystem

// Complete integration with other HSuite modules
import { SmartNetwork, ISmartNetwork } from '@hsuite/smart-network-types';
import { AuthModule } from '@hsuite/auth';
import { ValidatorsModule } from '@hsuite/validators';
import { HashgraphModule } from '@hsuite/hashgraph';

@Module({
  imports: [
    AuthModule,
    ValidatorsModule,
    HashgraphModule
  ]
})
export class SmartNetworkEcosystemModule {}

@Injectable()
export class IntegratedSmartNetworkService {
  constructor(
    private authService: AuthService,
    private validatorsService: ValidatorsService,
    private hashgraphService: HashgraphService
  ) {}

  async createSecureNetworkEntity(
    entityData: any,
    session: IAuth.ICredentials.IWeb3.IEntity
  ): Promise<SmartNetwork.Network.Entity> {
    // 1. Validate permissions
    const hasPermission = await this.authService.validatePermission(
      session,
      'network:entity:create'
    );

    if (!hasPermission) {
      throw new Error('Insufficient permissions for network entity creation');
    }

    // 2. Validate with network validators
    const validationResult = await this.validatorsService.validateNetworkEntity(entityData);
    
    if (!validationResult.isValid) {
      throw new Error(`Validation failed: ${validationResult.errors.join(', ')}`);
    }

    // 3. Create entity with type safety
    const networkEntity = new SmartNetwork.Network.Entity(
      entityData.membership,
      entityData.type,
      entityData.clusters,
      entityData.dkgId
    );

    return networkEntity;
  }
}

🌐 Enterprise Type System: Comprehensive TypeScript definitions with runtime validation and Web3 integration for Smart Network operations.

👥 NFT-Compliant Memberships: Full ERC721/HIP412 standards support with IPFS metadata and complete transaction tracking.

⚡ Developer Experience: Type-safe development with comprehensive documentation, validation, and seamless NestJS integration.

Built with ❤️ by the HbarSuite Team Copyright © 2024 HbarSuite. All rights reserved.

Previous@hsuite/smart-ledgers - Multi-Ledger ManagementNext@hsuite/smart-transaction-types - Smart Transaction Type Definitions

Last updated