@hsuite/smartnode-sdk - SmartNode Software Development Kit
🚀 Comprehensive SDK for SmartNode services and multi-ledger blockchain operations
Enterprise-grade TypeScript SDK providing unified access to SmartNode network operations, validator management, and complete Hedera Hashgraph integration with extensible architecture for multi-blockchain support.
📚 Table of Contents
✨ Quick Start
Installation
npm install @hsuite/smartnode-sdk
Basic Setup
import { SmartNodeSdkModule } from '@hsuite/smartnode-sdk';
@Module({
imports: [
SmartNodeSdkModule.forRootAsync({
imports: [ConfigModule],
useFactory: (configService: ConfigService) => ({
client: {
baseUrl: configService.get('SMARTNODE_BASE_URL'),
timeout: configService.get('SMARTNODE_TIMEOUT', 30000),
headers: {
'Authorization': `Bearer ${configService.get('SMARTNODE_API_KEY')}`
}
}
}),
inject: [ConfigService]
})
]
})
export class AppModule {}
Basic Usage
@Injectable()
export class BlockchainService {
constructor(private smartNodeSdk: SmartNodeSdkService) {}
async getNetworkStatus() {
// Get SmartNode network status
const status = await this.smartNodeSdk.sdk.smartNode.general.getStatus();
const network = await this.smartNodeSdk.sdk.smartNode.general.getNetwork();
return { status, network };
}
async manageAccount(accountId: string) {
// Get account information via Hedera integration
const accountInfo = await this.smartNodeSdk.sdk.hashgraph.accounts.getInfo(accountId);
const balance = await this.smartNodeSdk.sdk.hashgraph.accounts.getQueryBalance(accountId);
return { accountInfo, balance };
}
}
🏗️ Architecture
Hierarchical SDK Structure
The SDK provides a comprehensive, hierarchical structure through the SmartNodeSdkService
:
sdk: {
smartNode: {
general: GeneralSdk; // Core SmartNode operations
validators: ValidatorsSdk; // Validator management
},
hashgraph: {
accounts: AccountsHashgraphSdk; // Account management
transactions: TransactionsHashgraphSdk; // Transaction operations
hcs: HcsHashgraphSdk; // Hedera Consensus Service
hts: HtsHashgraphSdk; // Hedera Token Service
},
ripple: {
// Future: Ripple blockchain integration
}
}
Core Components
🌐 SmartNode Services
General Operations - Node identification, status monitoring, network management
Validator Management - Consensus, token, and account validator operations
Network Coordination - Multi-node communication and coordination
⚡ Hedera Hashgraph Integration
Account Services - Complete account lifecycle management
Transaction Services - Transaction submission and monitoring
Consensus Service (HCS) - Topic management and messaging
Token Service (HTS) - Token operations and management
🔄 Extensible Architecture
Multi-Ledger Support - Ready for Ripple and other blockchain integrations
Modular Design - Independent service modules with clear separation
Type-Safe Configuration - Full TypeScript support with runtime validation
Module Structure
src/
├── smartnode-sdk.service.ts # Main SDK orchestration service
├── smartnode-sdk.module.ts # NestJS module configuration
├── sdk-options.interface.ts # Configuration interfaces
├── smart-nodes/
│ ├── base.smart-node.ts # Base SDK class
│ ├── general.smart-node.ts # General SmartNode operations
│ └── validators.smart-node.ts # Validator management
├── hashgraph/
│ ├── accounts.hashgraph.ts # Account operations
│ ├── transactions.hashgraph.ts # Transaction management
│ ├── hcs.hashgraph.ts # Consensus service
│ └── hts.hashgraph.ts # Token service
└── types/
├── interfaces/ # TypeScript interfaces
└── models/ # Implementation models
🔧 API Reference
SmartNodeSdkService
Core SDK Structure
class SmartNodeSdkService {
readonly sdk: {
smartNode: {
general: GeneralSdk;
validators: ValidatorsSdk;
};
hashgraph: {
accounts: AccountsHashgraphSdk;
transactions: TransactionsHashgraphSdk;
hcs: HcsHashgraphSdk;
hts: HtsHashgraphSdk;
};
ripple: {};
};
}
SmartNode Services
GeneralSdk - Core SmartNode Operations
getIdentifier(): Promise<ISmartNetwork.IOperator.IEntity>
Retrieves SmartNode operator entity details
Returns: Unique identifier and node details
Usage: Node identification in network operations
getStatus(): Promise<ISmartNetwork.ISmartNode.IState>
Gets current operational status and health metrics
Returns: Node status, uptime, performance metrics
Usage: Health monitoring and diagnostics
getNetwork(): Promise<Array<ISmartNetwork.INetwork.IEntity>>
Retrieves comprehensive list of whitelisted smart-nodes
Returns: Array of network entities with status and capabilities
Usage: Network topology and node discovery
getUtilities(): Promise<any>
Retrieves HSuite utility tokens and capabilities
Returns: Available utilities and their configurations
Usage: Feature discovery and capability assessment
ValidatorsSdk - Validator Management
Consensus Validators:
addConsensusValidator(params): Promise<string>
- Submit new consensus validatorreadConsensusValidator(timestamp): Promise<IValidators.IConsensus.IValidationParams>
- Retrieve consensus validator
Token Validators:
addTokenValidator(params): Promise<string>
- Submit new token validatorreadTokenValidator(timestamp): Promise<IValidators.IToken.IValidationParams>
- Retrieve token validator
Account Validators:
addAccountValidator(params): Promise<string>
- Submit new account validatorreadAccountValidator(timestamp): Promise<IValidators.IAccount.IValidationParams>
- Retrieve account validator
Hedera Hashgraph Services
AccountsHashgraphSdk - Account Management
Account Information:
getInfo(accountId): Promise<IHashgraph.ILedger.IAccounts.IResponse.IInfo>
- Account detailsgetKeys(accountId): Promise<any>
- Account public keysgetQueryBalance(accountId): Promise<any>
- Account balance query
Account Lifecycle:
createAccount(params): Promise<any>
- Create new accountupdateAccount(accountId, params): Promise<any>
- Update account propertiesdeleteAccount(accountId, params): Promise<any>
- Delete account
Transfer Operations:
transferHbar(params): Promise<any>
- HBAR transferstransferToken(params): Promise<any>
- Fungible token transferstransferNftToken(params): Promise<any>
- NFT transfers
TransactionsHashgraphSdk - Transaction Management
Transaction Operations:
Transaction submission and status monitoring
Transaction history and queries
Fee estimation and optimization
Batch transaction processing
HcsHashgraphSdk - Hedera Consensus Service
Topic Management:
Topic creation, update, and deletion
Topic configuration and permissions
Topic information retrieval
Message Operations:
Message submission to topics
Message retrieval and history
Subscription management
HtsHashgraphSdk - Hedera Token Service
Token Management:
Token creation and configuration
Token information queries
Supply management operations
Token Operations:
Token transfers and approvals
NFT minting and burning
Token association and dissociation
Configuration Interfaces
SDK Options Interface
interface ISdk.IOptions {
client: IClient.IOptions;
}
interface SmartNodeSdkModuleAsyncOptions {
imports?: Array<any>;
useClass?: Type<any>;
useFactory?: (...args: any[]) => Promise<ISdk.IOptions> | ISdk.IOptions;
inject?: any[];
}
📖 Guides
SmartNode Network Guide
Learn about SmartNode network operations and topology management. Comprehensive guide covering network architecture, node discovery, consensus mechanisms, validator management, and enterprise-grade SmartNode deployment and operations.
Validator Setup Guide
Configure and manage validators across different topics. Advanced configuration guide covering validator deployment, consensus topic management, validation rules, performance monitoring, and enterprise validator infrastructure management.
Hedera Integration Guide
Complete guide to using Hedera Hashgraph services through the SDK. Detailed integration guide covering Hedera account management, transaction processing, token operations, consensus service, and enterprise Hedera blockchain integration.
🎯 Examples
SmartNode Network Operations
import { SmartNodeSdkService } from '@hsuite/smartnode-sdk';
@Injectable()
export class NetworkMonitoringService {
constructor(private smartNodeSdk: SmartNodeSdkService) {}
async monitorNetworkHealth() {
try {
// Get current node status
const nodeStatus = await this.smartNodeSdk.sdk.smartNode.general.getStatus();
// Get network topology
const networkNodes = await this.smartNodeSdk.sdk.smartNode.general.getNetwork();
// Get node identifier
const nodeIdentifier = await this.smartNodeSdk.sdk.smartNode.general.getIdentifier();
// Get available utilities
const utilities = await this.smartNodeSdk.sdk.smartNode.general.getUtilities();
return {
currentNode: {
identifier: nodeIdentifier,
status: nodeStatus,
health: nodeStatus.health || 'unknown'
},
network: {
totalNodes: networkNodes.length,
activeNodes: networkNodes.filter(node => node.status === 'active').length,
nodes: networkNodes.map(node => ({
id: node.id,
status: node.status,
capabilities: node.capabilities
}))
},
utilities: utilities,
monitoredAt: new Date().toISOString()
};
} catch (error) {
throw new Error(`Network monitoring failed: ${error.message}`);
}
}
async getNetworkConnectivity() {
const network = await this.smartNodeSdk.sdk.smartNode.general.getNetwork();
const connectivityReport = {
totalNodes: network.length,
onlineNodes: 0,
offlineNodes: 0,
nodeDetails: []
};
for (const node of network) {
const isOnline = node.status === 'active' || node.status === 'online';
if (isOnline) {
connectivityReport.onlineNodes++;
} else {
connectivityReport.offlineNodes++;
}
connectivityReport.nodeDetails.push({
nodeId: node.id,
status: node.status,
lastSeen: node.lastSeen || 'unknown',
networkRole: node.role || 'participant'
});
}
return {
...connectivityReport,
networkHealth: (connectivityReport.onlineNodes / connectivityReport.totalNodes * 100).toFixed(2) + '%',
timestamp: new Date().toISOString()
};
}
}
Validator Management Operations
import { SmartNodeSdkService } from '@hsuite/smartnode-sdk';
import { IValidators } from '@hsuite/validators-types';
@Injectable()
export class ValidatorManagementService {
constructor(private smartNodeSdk: SmartNodeSdkService) {}
async setupConsensusValidator(validationConfig: any) {
try {
const validationParams: Omit<IValidators.IConsensus.IValidationParams, 'validateParams'> = {
conditions: {
requireSubmitKey: validationConfig.requireSubmitKey || true,
maxMessageSize: validationConfig.maxMessageSize || 1024,
allowPublicSubmission: validationConfig.allowPublicSubmission || false,
messageEncoding: validationConfig.messageEncoding || 'utf-8'
}
};
// Add consensus validator
const timestamp = await this.smartNodeSdk.sdk.smartNode.validators.addConsensusValidator(
validationParams
);
return {
success: true,
validatorTimestamp: timestamp,
validatorType: 'consensus',
configuration: validationParams,
message: 'Consensus validator added successfully'
};
} catch (error) {
throw new Error(`Consensus validator setup failed: ${error.message}`);
}
}
async setupTokenValidator(tokenValidationConfig: any) {
try {
const validationParams: Omit<IValidators.IToken.IValidationParams, 'validateParams'> = {
conditions: {
maxTransferAmount: tokenValidationConfig.maxTransferAmount || '1000000',
allowMinting: tokenValidationConfig.allowMinting !== false,
allowBurning: tokenValidationConfig.allowBurning !== false,
requireKyc: tokenValidationConfig.requireKyc || false,
freezeDefault: tokenValidationConfig.freezeDefault || false,
decimals: tokenValidationConfig.decimals || 18,
maxSupply: tokenValidationConfig.maxSupply || '10000000000'
}
};
const timestamp = await this.smartNodeSdk.sdk.smartNode.validators.addTokenValidator(
validationParams
);
return {
success: true,
validatorTimestamp: timestamp,
validatorType: 'token',
configuration: validationParams
};
} catch (error) {
throw new Error(`Token validator setup failed: ${error.message}`);
}
}
async setupAccountValidator(accountValidationConfig: any) {
try {
const validationParams: Omit<IValidators.IAccount.IValidationParams, 'validateParams'> = {
smartNodeSecurity: accountValidationConfig.securityLevel || 'partial',
updateConditions: {
values: accountValidationConfig.allowedUpdates || ['maxAutomaticTokenAssociations', 'accountMemo'],
controller: accountValidationConfig.updateController || 'owner'
},
actionsConditions: {
values: accountValidationConfig.allowedActions || ['transfer', 'update'],
controller: accountValidationConfig.actionController || 'owner'
},
tokenGates: {
fungibles: { tokens: accountValidationConfig.fungibleTokenGates || [] },
nonFungibles: { tokens: accountValidationConfig.nftTokenGates || [] },
timeRange: accountValidationConfig.tokenGateTimeRange || null
},
swapConditions: {
prices: accountValidationConfig.swapPrices || []
}
};
const timestamp = await this.smartNodeSdk.sdk.smartNode.validators.addAccountValidator(
validationParams
);
return {
success: true,
validatorTimestamp: timestamp,
validatorType: 'account',
configuration: validationParams
};
} catch (error) {
throw new Error(`Account validator setup failed: ${error.message}`);
}
}
async getValidatorStatus(validatorType: 'consensus' | 'token' | 'account', timestamp: string) {
try {
let validator;
switch (validatorType) {
case 'consensus':
validator = await this.smartNodeSdk.sdk.smartNode.validators.readConsensusValidator(timestamp);
break;
case 'token':
validator = await this.smartNodeSdk.sdk.smartNode.validators.readTokenValidator(timestamp);
break;
case 'account':
validator = await this.smartNodeSdk.sdk.smartNode.validators.readAccountValidator(timestamp);
break;
default:
throw new Error(`Unsupported validator type: ${validatorType}`);
}
return {
validatorType,
timestamp,
configuration: validator,
status: 'active',
retrievedAt: new Date().toISOString()
};
} catch (error) {
throw new Error(`Validator status retrieval failed: ${error.message}`);
}
}
}
Hedera Account Management
import { SmartNodeSdkService } from '@hsuite/smartnode-sdk';
import { IHashgraph } from '@hsuite/hashgraph-types';
@Injectable()
export class HederaAccountService {
constructor(private smartNodeSdk: SmartNodeSdkService) {}
async getCompleteAccountInfo(accountId: string) {
try {
// Get account information
const accountInfo = await this.smartNodeSdk.sdk.hashgraph.accounts.getInfo(accountId);
// Get account balance
const balance = await this.smartNodeSdk.sdk.hashgraph.accounts.getQueryBalance(accountId);
// Get account keys (if available)
let keys;
try {
keys = await this.smartNodeSdk.sdk.hashgraph.accounts.getKeys(accountId);
} catch (error) {
console.warn('Failed to retrieve account keys:', error.message);
keys = null;
}
return {
account: {
id: accountId,
balance: balance,
info: accountInfo,
keys: keys
},
status: 'active',
retrievedAt: new Date().toISOString()
};
} catch (error) {
throw new Error(`Account information retrieval failed: ${error.message}`);
}
}
async performAccountOperations(operations: any[]) {
const results = [];
for (const operation of operations) {
try {
let result;
switch (operation.type) {
case 'create':
result = await this.smartNodeSdk.sdk.hashgraph.accounts.createAccount(operation.params);
break;
case 'update':
result = await this.smartNodeSdk.sdk.hashgraph.accounts.updateAccount(
operation.accountId,
operation.params
);
break;
case 'delete':
result = await this.smartNodeSdk.sdk.hashgraph.accounts.deleteAccount(
operation.accountId,
operation.params
);
break;
case 'transferHbar':
result = await this.smartNodeSdk.sdk.hashgraph.accounts.transferHbar(operation.params);
break;
case 'transferToken':
result = await this.smartNodeSdk.sdk.hashgraph.accounts.transferToken(operation.params);
break;
case 'transferNft':
result = await this.smartNodeSdk.sdk.hashgraph.accounts.transferNftToken(operation.params);
break;
default:
throw new Error(`Unsupported operation type: ${operation.type}`);
}
results.push({
operation: operation.type,
success: true,
result: result,
executedAt: new Date().toISOString()
});
} catch (error) {
results.push({
operation: operation.type,
success: false,
error: error.message,
failedAt: new Date().toISOString()
});
}
}
return {
totalOperations: operations.length,
successful: results.filter(r => r.success).length,
failed: results.filter(r => !r.success).length,
results: results
};
}
async batchTransferHbar(transfers: Array<{from: string, to: string, amount: number}>) {
const transferResults = [];
for (const transfer of transfers) {
try {
const result = await this.smartNodeSdk.sdk.hashgraph.accounts.transferHbar({
from: transfer.from,
to: transfer.to,
amount: transfer.amount,
memo: `Batch transfer ${new Date().toISOString()}`
});
transferResults.push({
from: transfer.from,
to: transfer.to,
amount: transfer.amount,
success: true,
transactionResult: result
});
} catch (error) {
transferResults.push({
from: transfer.from,
to: transfer.to,
amount: transfer.amount,
success: false,
error: error.message
});
}
}
return {
batchSize: transfers.length,
successful: transferResults.filter(r => r.success).length,
failed: transferResults.filter(r => !r.success).length,
totalAmount: transfers.reduce((sum, t) => sum + t.amount, 0),
results: transferResults
};
}
}
Hedera Consensus Service Operations
import { SmartNodeSdkService } from '@hsuite/smartnode-sdk';
@Injectable()
export class HederaConsensusService {
constructor(private smartNodeSdk: SmartNodeSdkService) {}
async manageConsensusTopic(topicOperations: any) {
try {
const results = {};
// Create topic if requested
if (topicOperations.create) {
const createResult = await this.smartNodeSdk.sdk.hashgraph.hcs.createTopic(
topicOperations.create
);
results['create'] = createResult;
}
// Update topic if requested
if (topicOperations.update && topicOperations.topicId) {
const updateResult = await this.smartNodeSdk.sdk.hashgraph.hcs.updateTopic(
topicOperations.topicId,
topicOperations.update
);
results['update'] = updateResult;
}
// Submit message if requested
if (topicOperations.submitMessage && topicOperations.topicId) {
const messageResult = await this.smartNodeSdk.sdk.hashgraph.hcs.submitMessage({
topicId: topicOperations.topicId,
message: topicOperations.submitMessage.message,
signature: topicOperations.submitMessage.signature
});
results['submitMessage'] = messageResult;
}
// Get topic info if requested
if (topicOperations.getInfo && topicOperations.topicId) {
const infoResult = await this.smartNodeSdk.sdk.hashgraph.hcs.getTopicInfo(
topicOperations.topicId
);
results['info'] = infoResult;
}
return {
success: true,
topicId: topicOperations.topicId,
operations: Object.keys(results),
results: results,
completedAt: new Date().toISOString()
};
} catch (error) {
throw new Error(`Consensus topic management failed: ${error.message}`);
}
}
async subscribeToTopic(topicId: string, onMessage: (message: any) => void) {
try {
// Note: Actual subscription implementation would depend on the SDK method
const subscription = await this.smartNodeSdk.sdk.hashgraph.hcs.subscribeTo(
topicId,
onMessage
);
return {
success: true,
topicId: topicId,
subscriptionId: subscription.subscriptionId || 'unknown',
subscribedAt: new Date().toISOString()
};
} catch (error) {
throw new Error(`Topic subscription failed: ${error.message}`);
}
}
}
Hedera Token Service Operations
import { SmartNodeSdkService } from '@hsuite/smartnode-sdk';
@Injectable()
export class HederaTokenService {
constructor(private smartNodeSdk: SmartNodeSdkService) {}
async manageToken(tokenOperations: any) {
try {
const results = {};
// Create token if requested
if (tokenOperations.create) {
const createResult = await this.smartNodeSdk.sdk.hashgraph.hts.createToken(
tokenOperations.create
);
results['create'] = createResult;
}
// Update token if requested
if (tokenOperations.update && tokenOperations.tokenId) {
const updateResult = await this.smartNodeSdk.sdk.hashgraph.hts.updateToken(
tokenOperations.tokenId,
tokenOperations.update
);
results['update'] = updateResult;
}
// Mint tokens if requested
if (tokenOperations.mint && tokenOperations.tokenId) {
const mintResult = await this.smartNodeSdk.sdk.hashgraph.hts.mintToken(
tokenOperations.tokenId,
tokenOperations.mint
);
results['mint'] = mintResult;
}
// Burn tokens if requested
if (tokenOperations.burn && tokenOperations.tokenId) {
const burnResult = await this.smartNodeSdk.sdk.hashgraph.hts.burnToken(
tokenOperations.tokenId,
tokenOperations.burn
);
results['burn'] = burnResult;
}
// Get token info if requested
if (tokenOperations.getInfo && tokenOperations.tokenId) {
const infoResult = await this.smartNodeSdk.sdk.hashgraph.hts.getTokenInfo(
tokenOperations.tokenId
);
results['info'] = infoResult;
}
return {
success: true,
tokenId: tokenOperations.tokenId,
operations: Object.keys(results),
results: results,
completedAt: new Date().toISOString()
};
} catch (error) {
throw new Error(`Token management failed: ${error.message}`);
}
}
async performTokenTransfers(transfers: any[]) {
const transferResults = [];
for (const transfer of transfers) {
try {
let result;
if (transfer.type === 'fungible') {
result = await this.smartNodeSdk.sdk.hashgraph.accounts.transferToken({
tokenId: transfer.tokenId,
from: transfer.from,
to: transfer.to,
amount: transfer.amount
});
} else if (transfer.type === 'nft') {
result = await this.smartNodeSdk.sdk.hashgraph.accounts.transferNftToken({
tokenId: transfer.tokenId,
from: transfer.from,
to: transfer.to,
serialNumber: transfer.serialNumber
});
} else {
throw new Error(`Unsupported transfer type: ${transfer.type}`);
}
transferResults.push({
...transfer,
success: true,
result: result
});
} catch (error) {
transferResults.push({
...transfer,
success: false,
error: error.message
});
}
}
return {
totalTransfers: transfers.length,
successful: transferResults.filter(r => r.success).length,
failed: transferResults.filter(r => !r.success).length,
results: transferResults
};
}
}
Comprehensive SDK Integration
import { SmartNodeSdkService } from '@hsuite/smartnode-sdk';
import { Injectable } from '@nestjs/common';
@Injectable()
export class ComprehensiveBlockchainService {
constructor(private smartNodeSdk: SmartNodeSdkService) {}
async performComplexWorkflow(workflowConfig: any) {
const workflowResults = {
workflowId: workflowConfig.id || Date.now().toString(),
startedAt: new Date().toISOString(),
steps: [],
errors: []
};
try {
// Step 1: Check SmartNode network health
const networkStatus = await this.smartNodeSdk.sdk.smartNode.general.getStatus();
workflowResults.steps.push({
step: 'network_health_check',
success: true,
result: { health: networkStatus.health, status: 'operational' }
});
// Step 2: Setup validators if required
if (workflowConfig.setupValidators) {
const validatorTimestamp = await this.smartNodeSdk.sdk.smartNode.validators.addConsensusValidator(
workflowConfig.validatorConfig
);
workflowResults.steps.push({
step: 'validator_setup',
success: true,
result: { timestamp: validatorTimestamp }
});
}
// Step 3: Create Hedera account if required
if (workflowConfig.createAccount) {
const accountResult = await this.smartNodeSdk.sdk.hashgraph.accounts.createAccount(
workflowConfig.accountConfig
);
workflowResults.steps.push({
step: 'account_creation',
success: true,
result: accountResult
});
}
// Step 4: Create token if required
if (workflowConfig.createToken) {
const tokenResult = await this.smartNodeSdk.sdk.hashgraph.hts.createToken(
workflowConfig.tokenConfig
);
workflowResults.steps.push({
step: 'token_creation',
success: true,
result: tokenResult
});
}
// Step 5: Submit consensus message if required
if (workflowConfig.submitMessage) {
const messageResult = await this.smartNodeSdk.sdk.hashgraph.hcs.submitMessage({
topicId: workflowConfig.topicId,
message: workflowConfig.message
});
workflowResults.steps.push({
step: 'consensus_message',
success: true,
result: messageResult
});
}
workflowResults['completedAt'] = new Date().toISOString();
workflowResults['status'] = 'completed';
workflowResults['successfulSteps'] = workflowResults.steps.filter(s => s.success).length;
return workflowResults;
} catch (error) {
workflowResults.errors.push({
error: error.message,
occurredAt: new Date().toISOString()
});
workflowResults['status'] = 'failed';
workflowResults['failedAt'] = new Date().toISOString();
throw new Error(`Workflow execution failed: ${error.message}`);
}
}
async getSystemOverview() {
try {
// Get SmartNode information
const [nodeIdentifier, nodeStatus, network, utilities] = await Promise.allSettled([
this.smartNodeSdk.sdk.smartNode.general.getIdentifier(),
this.smartNodeSdk.sdk.smartNode.general.getStatus(),
this.smartNodeSdk.sdk.smartNode.general.getNetwork(),
this.smartNodeSdk.sdk.smartNode.general.getUtilities()
]);
return {
smartNode: {
identifier: nodeIdentifier.status === 'fulfilled' ? nodeIdentifier.value : null,
status: nodeStatus.status === 'fulfilled' ? nodeStatus.value : null,
network: network.status === 'fulfilled' ? network.value : null,
utilities: utilities.status === 'fulfilled' ? utilities.value : null
},
sdk: {
services: ['smartNode', 'hashgraph'],
smartNodeServices: ['general', 'validators'],
hashgraphServices: ['accounts', 'transactions', 'hcs', 'hts'],
futureServices: ['ripple']
},
timestamp: new Date().toISOString()
};
} catch (error) {
throw new Error(`System overview generation failed: ${error.message}`);
}
}
}
🔗 Integration
Required Dependencies
{
"@nestjs/common": "^10.4.2",
"@nestjs/core": "^10.4.2",
"@hsuite/client": "^2.1.2",
"@hsuite/hashgraph-types": "^2.0.3",
"@hsuite/smart-network-types": "^2.0.0",
"@hsuite/validators-types": "^2.0.0",
"@hsuite/nestjs-swagger": "^1.0.3",
"@hashgraph/sdk": "^2.62.0",
"@hsuite/helpers": "^2.1.0"
}
Environment Variables
# SmartNode Configuration
SMARTNODE_BASE_URL=https://api.smartnode.example.com
SMARTNODE_API_KEY=your_api_key_here
SMARTNODE_TIMEOUT=30000
# Network Configuration
SMARTNODE_NETWORK_ID=testnet
SMARTNODE_OPERATOR_ID=0.0.123456
SMARTNODE_OPERATOR_KEY=your_operator_key
# Client Configuration
HTTP_TIMEOUT=30000
MAX_RETRIES=3
ENABLE_LOGGING=true
Module Configuration
import { SmartNodeSdkModule } from '@hsuite/smartnode-sdk';
import { ConfigModule, ConfigService } from '@nestjs/config';
@Module({
imports: [
SmartNodeSdkModule.forRootAsync({
imports: [ConfigModule],
useFactory: (configService: ConfigService) => ({
client: {
baseUrl: configService.get('SMARTNODE_BASE_URL'),
timeout: configService.get('SMARTNODE_TIMEOUT', 30000),
headers: {
'Authorization': `Bearer ${configService.get('SMARTNODE_API_KEY')}`,
'Content-Type': 'application/json'
},
retries: configService.get('MAX_RETRIES', 3),
enableLogging: configService.get('ENABLE_LOGGING', true)
}
}),
inject: [ConfigService]
})
]
})
export class AppModule {}
Integration with HSuite Ecosystem
// Complete integration with other HSuite modules
@Module({
imports: [
AuthModule,
SmartNodeSdkModule,
ValidatorsModule,
HashgraphModule,
SmartConfigModule
]
})
export class BlockchainEcosystemModule {}
@Injectable()
export class IntegratedBlockchainService {
constructor(
private smartNodeSdk: SmartNodeSdkService,
private authService: AuthService,
private validatorsService: ValidatorsService
) {}
async executeSecureOperation(
operation: any,
session: IAuth.ICredentials.IWeb3.IEntity
) {
// 1. Validate permissions
const hasPermission = await this.authService.validatePermission(
session,
`smartnode:${operation.type}`
);
if (!hasPermission) {
throw new Error('Insufficient permissions for SmartNode operation');
}
// 2. Check network health
const networkStatus = await this.smartNodeSdk.sdk.smartNode.general.getStatus();
if (networkStatus.health !== 'healthy') {
throw new Error('SmartNode network is not healthy');
}
// 3. Execute operation via SDK
let result;
switch (operation.type) {
case 'account_create':
result = await this.smartNodeSdk.sdk.hashgraph.accounts.createAccount(operation.params);
break;
case 'token_create':
result = await this.smartNodeSdk.sdk.hashgraph.hts.createToken(operation.params);
break;
case 'validator_add':
result = await this.smartNodeSdk.sdk.smartNode.validators.addConsensusValidator(operation.params);
break;
default:
throw new Error(`Unsupported operation type: ${operation.type}`);
}
return {
success: true,
operation: operation.type,
result: result,
executedBy: session.walletId,
executedAt: new Date().toISOString()
};
}
}
🚀 Enterprise SDK: Comprehensive SmartNode integration with full TypeScript support and enterprise-grade reliability.
🌐 Multi-Ledger Ready: Extensible architecture supporting Hedera Hashgraph with planned Ripple integration.
⚡ Developer Focused: Type-safe APIs with comprehensive documentation and extensive example implementations.
Built with ❤️ by the HbarSuite Team Copyright © 2024 HbarSuite. All rights reserved.
Last updated