Module 5: Advanced Topics and Use Cases

5.1 Integration with External Systems

Hyperledger Fabric networks often need to interact with external systems to provide complete business solutions. This section explores various integration approaches and patterns.

Integration Patterns

When integrating Hyperledger Fabric with external systems, several patterns can be employed:

API-Based Integration

The most common integration pattern is through APIs, where Fabric exposes or consumes services via REST or GraphQL interfaces.

Client Application Integration:

// Example Node.js application using Fabric SDK
const { Gateway, Wallets } = require('fabric-network');
const path = require('path');
const fs = require('fs');

async function main() {
    try {
        // Load the network configuration
        const ccpPath = path.resolve(__dirname, 'connection-org1.json');
        const ccp = JSON.parse(fs.readFileSync(ccpPath, 'utf8'));

        // Create a new file system based wallet for managing identities
        const walletPath = path.join(process.cwd(), 'wallet');
        const wallet = await Wallets.newFileSystemWallet(walletPath);

        // Check to see if we've already enrolled the user
        const identity = await wallet.get('appUser');
        if (!identity) {
            console.log('An identity for the user "appUser" does not exist in the wallet');
            console.log('Run the registerUser.js application before retrying');
            return;
        }

        // Create a new gateway for connecting to our peer node
        const gateway = new Gateway();
        await gateway.connect(ccp, { 
            wallet, 
            identity: 'appUser', 
            discovery: { enabled: true, asLocalhost: true } 
        });

        // Get the network (channel) our contract is deployed to
        const network = await gateway.getNetwork('mychannel');

        // Get the contract from the network
        const contract = network.getContract('fabcar');

        // Submit the transaction
        await contract.submitTransaction('createCar', 'CAR12', 'Honda', 'Accord', 'Black', 'Tom');
        console.log('Transaction has been submitted');

        // Disconnect from the gateway
        await gateway.disconnect();

    } catch (error) {
        console.error(`Failed to submit transaction: ${error}`);
        process.exit(1);
    }
}

main();

REST API Gateway:

// Example Express.js REST API for Fabric
const express = require('express');
const { Gateway, Wallets } = require('fabric-network');
const path = require('path');
const fs = require('fs');

const app = express();
app.use(express.json());

// Connect to the Fabric network
async function connectToNetwork() {
    const ccpPath = path.resolve(__dirname, 'connection-org1.json');
    const ccp = JSON.parse(fs.readFileSync(ccpPath, 'utf8'));

    const walletPath = path.join(process.cwd(), 'wallet');
    const wallet = await Wallets.newFileSystemWallet(walletPath);

    const identity = await wallet.get('appUser');
    if (!identity) {
        throw new Error('User identity not found in wallet');
    }

    const gateway = new Gateway();
    await gateway.connect(ccp, { 
        wallet, 
        identity: 'appUser', 
        discovery: { enabled: true, asLocalhost: true } 
    });

    return gateway;
}

// API endpoint to query assets
app.get('/api/assets/:id', async (req, res) => {
    try {
        const gateway = await connectToNetwork();
        const network = await gateway.getNetwork('mychannel');
        const contract = network.getContract('assetcontract');

        const result = await contract.evaluateTransaction('ReadAsset', req.params.id);
        res.json(JSON.parse(result.toString()));

        gateway.disconnect();
    } catch (error) {
        res.status(500).json({ error: error.message });
    }
});

// API endpoint to create assets
app.post('/api/assets', async (req, res) => {
    try {
        const { id, color, size, owner, value } = req.body;

        const gateway = await connectToNetwork();
        const network = await gateway.getNetwork('mychannel');
        const contract = network.getContract('assetcontract');

        await contract.submitTransaction('CreateAsset', id, color, size.toString(), owner, value.toString());
        res.status(201).json({ message: 'Asset created successfully' });

        gateway.disconnect();
    } catch (error) {
        res.status(500).json({ error: error.message });
    }
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
    console.log(`Server running on port ${PORT}`);
});

Event-Based Integration

Fabric can emit events that external systems can subscribe to, enabling real-time updates and reactions.

// Example of subscribing to chaincode events
const { Gateway, Wallets } = require('fabric-network');
const path = require('path');
const fs = require('fs');

async function main() {
    try {
        // Connect to the network
        const ccpPath = path.resolve(__dirname, 'connection-org1.json');
        const ccp = JSON.parse(fs.readFileSync(ccpPath, 'utf8'));

        const walletPath = path.join(process.cwd(), 'wallet');
        const wallet = await Wallets.newFileSystemWallet(walletPath);

        const identity = await wallet.get('appUser');
        if (!identity) {
            throw new Error('User identity not found in wallet');
        }

        const gateway = new Gateway();
        await gateway.connect(ccp, { 
            wallet, 
            identity: 'appUser', 
            discovery: { enabled: true, asLocalhost: true } 
        });

        const network = await gateway.getNetwork('mychannel');
        const contract = network.getContract('assetcontract');

        // Listen for chaincode events
        const listener = await contract.addContractListener('asset-listener', 'AssetTransferred', (event) => {
            const eventPayload = JSON.parse(event.payload.toString('utf8'));
            console.log(`Asset ${eventPayload.id} transferred from ${eventPayload.oldOwner} to ${eventPayload.newOwner}`);

            // Here you can trigger external system actions
            // For example, send an email, update a database, etc.
        });

        console.log('Listening for AssetTransferred events...');

        // Keep the application running to receive events
        process.on('SIGINT', async () => {
            await listener.unregister();
            await gateway.disconnect();
            process.exit(0);
        });

    } catch (error) {
        console.error(`Failed to listen for events: ${error}`);
        process.exit(1);
    }
}

main();

Off-Chain Data Storage

For large datasets or data that doesn't need to be on the blockchain, off-chain storage can be used in conjunction with Fabric.

// Example of storing data off-chain with references on-chain
const { Gateway, Wallets } = require('fabric-network');
const { MongoClient } = require('mongodb');
const crypto = require('crypto');
const path = require('path');
const fs = require('fs');

// Connect to MongoDB
async function connectToMongoDB() {
    const uri = "mongodb://localhost:27017";
    const client = new MongoClient(uri);
    await client.connect();
    return client.db("offchain_storage");
}

// Store data in MongoDB and return a reference hash
async function storeOffChain(data) {
    const db = await connectToMongoDB();
    const collection = db.collection('assets');

    // Generate a hash of the data as a reference
    const hash = crypto.createHash('sha256').update(JSON.stringify(data)).digest('hex');

    // Store the data with the hash as an identifier
    await collection.insertOne({
        _id: hash,
        data: data,
        timestamp: new Date()
    });

    return hash;
}

// Retrieve data from MongoDB using the reference hash
async function retrieveOffChain(hash) {
    const db = await connectToMongoDB();
    const collection = db.collection('assets');

    const result = await collection.findOne({ _id: hash });
    return result ? result.data : null;
}

// Store asset data off-chain and reference it on-chain
async function createAssetWithOffChainData(assetId, assetData) {
    try {
        // Store detailed data off-chain
        const offChainHash = await storeOffChain(assetData);

        // Connect to Fabric
        const ccpPath = path.resolve(__dirname, 'connection-org1.json');
        const ccp = JSON.parse(fs.readFileSync(ccpPath, 'utf8'));

        const walletPath = path.join(process.cwd(), 'wallet');
        const wallet = await Wallets.newFileSystemWallet(walletPath);

        const identity = await wallet.get('appUser');
        if (!identity) {
            throw new Error('User identity not found in wallet');
        }

        const gateway = new Gateway();
        await gateway.connect(ccp, { 
            wallet, 
            identity: 'appUser', 
            discovery: { enabled: true, asLocalhost: true } 
        });

        const network = await gateway.getNetwork('mychannel');
        const contract = network.getContract('assetcontract');

        // Store only essential data and the reference hash on-chain
        await contract.submitTransaction(
            'CreateAssetReference', 
            assetId, 
            assetData.owner, 
            offChainHash
        );

        console.log(`Asset ${assetId} created with off-chain reference ${offChainHash}`);
        gateway.disconnect();

        return { assetId, offChainHash };

    } catch (error) {
        console.error(`Failed to create asset with off-chain data: ${error}`);
        throw error;
    }
}

// Example usage
createAssetWithOffChainData('asset123', {
    owner: 'Alice',
    description: 'Detailed asset description...',
    images: ['base64_encoded_image_1', 'base64_encoded_image_2'],
    documents: ['base64_encoded_document_1'],
    history: [
        { date: '2023-01-01', action: 'created', by: 'Manufacturer' },
        { date: '2023-02-15', action: 'inspected', by: 'Inspector' }
    ]
});

Oracle Integration

Oracles provide external data to blockchain networks, enabling smart contracts to access real-world information.

Chaincode Oracle Pattern

// Example of a chaincode that interacts with an oracle
package main

import (
    "encoding/json"
    "fmt"
    "time"

    "github.com/hyperledger/fabric-contract-api-go/contractapi"
)

// SmartContract provides functions for oracle integration
type SmartContract struct {
    contractapi.Contract
}

// OracleRequest represents a request for external data
type OracleRequest struct {
    ID        string    `json:"id"`
    Query     string    `json:"query"`
    Status    string    `json:"status"`
    Timestamp time.Time `json:"timestamp"`
    Result    string    `json:"result"`
}

// CreateOracleRequest creates a new request for external data
func (s *SmartContract) CreateOracleRequest(ctx contractapi.TransactionContextInterface, id string, query string) error {
    request := OracleRequest{
        ID:        id,
        Query:     query,
        Status:    "PENDING",
        Timestamp: time.Now(),
        Result:    "",
    }

    requestJSON, err := json.Marshal(request)
    if err != nil {
        return fmt.Errorf("failed to marshal oracle request: %v", err)
    }

    err = ctx.GetStub().PutState(id, requestJSON)
    if err != nil {
        return fmt.Errorf("failed to put oracle request in world state: %v", err)
    }

    // Emit an event that the oracle service will listen for
    err = ctx.GetStub().SetEvent("OracleRequest", requestJSON)
    if err != nil {
        return fmt.Errorf("failed to emit oracle request event: %v", err)
    }

    return nil
}

// UpdateOracleResult updates the result of an oracle request (called by the oracle service)
func (s *SmartContract) UpdateOracleResult(ctx contractapi.TransactionContextInterface, id string, result string) error {
    // Verify that the caller has the oracle role
    clientOrgID, err := ctx.GetClientIdentity().GetMSPID()
    if err != nil {
        return fmt.Errorf("failed to get client MSP ID: %v", err)
    }

    if clientOrgID != "OracleMSP" {
        return fmt.Errorf("client is not authorized to update oracle results")
    }

    // Get the current request
    requestJSON, err := ctx.GetStub().GetState(id)
    if err != nil {
        return fmt.Errorf("failed to read oracle request: %v", err)
    }
    if requestJSON == nil {
        return fmt.Errorf("oracle request %s does not exist", id)
    }

    var request OracleRequest
    err = json.Unmarshal(requestJSON, &request)
    if err != nil {
        return fmt.Errorf("failed to unmarshal oracle request: %v", err)
    }

    // Update the request with the result
    request.Result = result
    request.Status = "COMPLETED"

    updatedRequestJSON, err := json.Marshal(request)
    if err != nil {
        return fmt.Errorf("failed to marshal updated oracle request: %v", err)
    }

    err = ctx.GetStub().PutState(id, updatedRequestJSON)
    if err != nil {
        return fmt.Errorf("failed to update oracle request in world state: %v", err)
    }

    // Emit an event that the request has been fulfilled
    err = ctx.GetStub().SetEvent("OracleRequestFulfilled", updatedRequestJSON)
    if err != nil {
        return fmt.Errorf("failed to emit oracle request fulfilled event: %v", err)
    }

    return nil
}

// GetOracleRequest retrieves an oracle request by ID
func (s *SmartContract) GetOracleRequest(ctx contractapi.TransactionContextInterface, id string) (*OracleRequest, error) {
    requestJSON, err := ctx.GetStub().GetState(id)
    if err != nil {
        return nil, fmt.Errorf("failed to read oracle request: %v", err)
    }
    if requestJSON == nil {
        return nil, fmt.Errorf("oracle request %s does not exist", id)
    }

    var request OracleRequest
    err = json.Unmarshal(requestJSON, &request)
    if err != nil {
        return nil, fmt.Errorf("failed to unmarshal oracle request: %v", err)
    }

    return &request, nil
}

func main() {
    chaincode, err := contractapi.NewChaincode(&SmartContract{})
    if err != nil {
        fmt.Printf("Error creating oracle chaincode: %v\n", err)
        return
    }

    if err := chaincode.Start(); err != nil {
        fmt.Printf("Error starting oracle chaincode: %v\n", err)
    }
}

Oracle Service Implementation

// Example of an oracle service that listens for requests and provides data
const { Gateway, Wallets } = require('fabric-network');
const axios = require('axios');
const path = require('path');
const fs = require('fs');

// Function to get external data based on the query
async function getExternalData(query) {
    try {
        // This is a simplified example. In a real-world scenario,
        // you would implement proper parsing and API selection based on the query.
        if (query.startsWith('price:')) {
            const symbol = query.split(':')[1];
            const response = await axios.get(`https://api.example.com/prices/${symbol}`);
            return response.data.price.toString();
        } else if (query.startsWith('weather:')) {
            const location = query.split(':')[1];
            const response = await axios.get(`https://api.example.com/weather/${location}`);
            return JSON.stringify(response.data);
        } else {
            return 'Unsupported query type';
        }
    } catch (error) {
        console.error(`Error fetching external data: ${error}`);
        return 'Error: ' + error.message;
    }
}

async function main() {
    try {
        // Connect to the network as the oracle identity
        const ccpPath = path.resolve(__dirname, 'connection-oracle.json');
        const ccp = JSON.parse(fs.readFileSync(ccpPath, 'utf8'));

        const walletPath = path.join(process.cwd(), 'oracle-wallet');
        const wallet = await Wallets.newFileSystemWallet(walletPath);

        const identity = await wallet.get('oracle');
        if (!identity) {
            throw new Error('Oracle identity not found in wallet');
        }

        const gateway = new Gateway();
        await gateway.connect(ccp, { 
            wallet, 
            identity: 'oracle', 
            discovery: { enabled: true, asLocalhost: true } 
        });

        const network = await gateway.getNetwork('mychannel');
        const contract = network.getContract('oraclecontract');

        // Listen for OracleRequest events
        const listener = await contract.addContractListener('oracle-listener', 'OracleRequest', async (event) => {
            try {
                const eventPayload = JSON.parse(event.payload.toString('utf8'));
                console.log(`Received oracle request: ${JSON.stringify(eventPayload)}`);

                // Get the external data based on the query
                const result = await getExternalData(eventPayload.query);
                console.log(`External data result: ${result}`);

                // Update the oracle request with the result
                await contract.submitTransaction('UpdateOracleResult', eventPayload.id, result);
                console.log(`Updated oracle request ${eventPayload.id} with result`);
            } catch (error) {
                console.error(`Error processing oracle request: ${error}`);
            }
        });

        console.log('Oracle service is listening for requests...');

        // Keep the service running
        process.on('SIGINT', async () => {
            await listener.unregister();
            await gateway.disconnect();
            process.exit(0);
        });

    } catch (error) {
        console.error(`Failed to start oracle service: ${error}`);
        process.exit(1);
    }
}

main();

Enterprise Integration Patterns

When integrating Fabric with enterprise systems, several established patterns can be applied:

Message Queue Integration

// Example of using RabbitMQ to integrate with Fabric
const { Gateway, Wallets } = require('fabric-network');
const amqp = require('amqplib');
const path = require('path');
const fs = require('fs');

// Connect to RabbitMQ
async function connectToRabbitMQ() {
    const connection = await amqp.connect('amqp://localhost');
    const channel = await connection.createChannel();

    // Ensure queues exist
    await channel.assertQueue('fabric-requests', { durable: true });
    await channel.assertQueue('fabric-responses', { durable: true });

    return { connection, channel };
}

// Connect to Fabric network
async function connectToFabric() {
    const ccpPath = path.resolve(__dirname, 'connection-org1.json');
    const ccp = JSON.parse(fs.readFileSync(ccpPath, 'utf8'));

    const walletPath = path.join(process.cwd(), 'wallet');
    const wallet = await Wallets.newFileSystemWallet(walletPath);

    const identity = await wallet.get('appUser');
    if (!identity) {
        throw new Error('User identity not found in wallet');
    }

    const gateway = new Gateway();
    await gateway.connect(ccp, { 
        wallet, 
        identity: 'appUser', 
        discovery: { enabled: true, asLocalhost: true } 
    });

    return gateway;
}

// Process messages from the request queue
async function processRequestQueue() {
    try {
        const { channel } = await connectToRabbitMQ();
        const gateway = await connectToFabric();
        const network = await gateway.getNetwork('mychannel');
        const contract = network.getContract('assetcontract');

        console.log('Waiting for messages in fabric-requests queue');

        channel.consume('fabric-requests', async (msg) => {
            if (msg !== null) {
                try {
                    const request = JSON.parse(msg.content.toString());
                    console.log(`Received request: ${JSON.stringify(request)}`);

                    let result;

                    // Process the request based on the action
                    switch (request.action) {
                        case 'createAsset':
                            await contract.submitTransaction(
                                'CreateAsset',
                                request.id,
                                request.color,
                                request.size.toString(),
                                request.owner,
                                request.value.toString()
                            );
                            result = { success: true, message: 'Asset created successfully' };
                            break;

                        case 'readAsset':
                            const assetBuffer = await contract.evaluateTransaction('ReadAsset', request.id);
                            const asset = JSON.parse(assetBuffer.toString());
                            result = { success: true, data: asset };
                            break;

                        default:
                            result = { success: false, message: 'Unknown action' };
                    }

                    // Send the response back
                    channel.sendToQueue(
                        'fabric-responses',
                        Buffer.from(JSON.stringify({
                            correlationId: request.correlationId,
                            result: result
                        })),
                        { persistent: true }
                    );

                    // Acknowledge the message
                    channel.ack(msg);

                } catch (error) {
                    console.error(`Error processing request: ${error}`);

                    // Send error response
                    channel.sendToQueue(
                        'fabric-responses',
                        Buffer.from(JSON.stringify({
                            correlationId: JSON.parse(msg.content.toString()).correlationId,
                            result: { success: false, error: error.message }
                        })),
                        { persistent: true }
                    );

                    // Acknowledge the message even if there was an error
                    channel.ack(msg);
                }
            }
        });

    } catch (error) {
        console.error(`Failed to process request queue: ${error}`);
    }
}

// Start the integration service
processRequestQueue();

ETL (Extract, Transform, Load) Integration

// Example of an ETL process to sync data between Fabric and a database
const { Gateway, Wallets } = require('fabric-network');
const { Pool } = require('pg');
const path = require('path');
const fs = require('fs');
const cron = require('node-cron');

// Connect to PostgreSQL
async function connectToDatabase() {
    const pool = new Pool({
        user: 'postgres',
        host: 'localhost',
        database: 'fabricdata',
        password: 'password',
        port: 5432,
    });

    return pool;
}

// Connect to Fabric network
async function connectToFabric() {
    const ccpPath = path.resolve(__dirname, 'connection-org1.json');
    const ccp = JSON.parse(fs.readFileSync(ccpPath, 'utf8'));

    const walletPath = path.join(process.cwd(), 'wallet');
    const wallet = await Wallets.newFileSystemWallet(walletPath);

    const identity = await wallet.get('appUser');
    if (!identity) {
        throw new Error('User identity not found in wallet');
    }

    const gateway = new Gateway();
    await gateway.connect(ccp, { 
        wallet, 
        identity: 'appUser', 
        discovery: { enabled: true, asLocalhost: true } 
    });

    return gateway;
}

// Extract assets from Fabric
async function extractAssetsFromFabric() {
    const gateway = await connectToFabric();
    const network = await gateway.getNetwork('mychannel');
    const contract = network.getContract('assetcontract');

    const result = await contract.evaluateTransaction('GetAllAssets');
    const assets = JSON.parse(result.toString());

    gateway.disconnect();

    return assets;
}

// Transform asset data if needed
function transformAssets(assets) {
    return assets.map(asset => ({
        id: asset.ID,
        color: asset.Color,
        size: parseInt(asset.Size),
        owner: asset.Owner,
        value: parseInt(asset.Value),
        last_updated: new Date()
    }));
}

// Load assets into the database
async function loadAssetsIntoDatabase(assets) {
    const pool = await connectToDatabase();
    const client = await pool.connect();

    try {
        await client.query('BEGIN');

        // Create a temporary table for the new data
        await client.query(`
            CREATE TEMP TABLE temp_assets (
                id VARCHAR(50) PRIMARY KEY,
                color VARCHAR(50),
                size INTEGER,
                owner VARCHAR(50),
                value INTEGER,
                last_updated TIMESTAMP
            )
        `);

        // Insert the new data into the temporary table
        for (const asset of assets) {
            await client.query(
                `INSERT INTO temp_assets (id, color, size, owner, value, last_updated) 
                 VALUES ($1, $2, $3, $4, $5, $6)`,
                [asset.id, asset.color, asset.size, asset.owner, asset.value, asset.last_updated]
            );
        }

        // Upsert the data into the main table
        await client.query(`
            INSERT INTO assets (id, color, size, owner, value, last_updated)
            SELECT id, color, size, owner, value, last_updated FROM temp_assets
            ON CONFLICT (id) DO UPDATE SET
                color = EXCLUDED.color,
                size = EXCLUDED.size,
                owner = EXCLUDED.owner,
                value = EXCLUDED.value,
                last_updated = EXCLUDED.last_updated
        `);

        // Drop the temporary table
        await client.query('DROP TABLE temp_assets');

        await client.query('COMMIT');
        console.log(`Successfully synced ${assets.length} assets to the database`);
    } catch (error) {
        await client.query('ROLLBACK');
        throw error;
    } finally {
        client.release();
    }
}

// Run the ETL process
async function runETLProcess() {
    try {
        console.log('Starting ETL process...');

        const assets = await extractAssetsFromFabric();
        console.log(`Extracted ${assets.length} assets from Fabric`);

        const transformedAssets = transformAssets(assets);
        console.log('Transformed asset data');

        await loadAssetsIntoDatabase(transformedAssets);
        console.log('ETL process completed successfully');
    } catch (error) {
        console.error(`ETL process failed: ${error}`);
    }
}

// Schedule the ETL process to run every hour
cron.schedule('0 * * * *', () => {
    runETLProcess();
});

// Run immediately on startup
runETLProcess();

IoT Integration

Hyperledger Fabric can be integrated with IoT devices to create trusted supply chains and asset tracking systems.

// Example of an IoT gateway that sends data to Fabric
const { Gateway, Wallets } = require('fabric-network');
const mqtt = require('mqtt');
const path = require('path');
const fs = require('fs');

// Connect to MQTT broker
function connectToMQTT() {
    const client = mqtt.connect('mqtt://localhost:1883');

    client.on('connect', () => {
        console.log('Connected to MQTT broker');
        client.subscribe('iot/sensors/#', (err) => {
            if (!err) {
                console.log('Subscribed to sensor topics');
            }
        });
    });

    return client;
}

// Connect to Fabric network
async function connectToFabric() {
    const ccpPath = path.resolve(__dirname, 'connection-org1.json');
    const ccp = JSON.parse(fs.readFileSync(ccpPath, 'utf8'));

    const walletPath = path.join(process.cwd(), 'wallet');
    const wallet = await Wallets.newFileSystemWallet(walletPath);

    const identity = await wallet.get('iotGateway');
    if (!identity) {
        throw new Error('IoT Gateway identity not found in wallet');
    }

    const gateway = new Gateway();
    await gateway.connect(ccp, { 
        wallet, 
        identity: 'iotGateway', 
        discovery: { enabled: true, asLocalhost: true } 
    });

    return gateway;
}

// Process sensor data and record it on the blockchain
async function processSensorData(topic, message) {
    try {
        const topicParts = topic.split('/');
        const sensorType = topicParts[1];
        const sensorId = topicParts[2];

        const data = JSON.parse(message.toString());
        console.log(`Received data from sensor ${sensorId}: ${JSON.stringify(data)}`);

        // Connect to Fabric
        const gateway = await connectToFabric();
        const network = await gateway.getNetwork('iotchannel');
        const contract = network.getContract('iotcontract');

        // Record the sensor reading on the blockchain
        await contract.submitTransaction(
            'RecordSensorReading',
            sensorId,
            sensorType,
            JSON.stringify(data),
            new Date().toISOString()
        );

        console.log(`Recorded sensor reading from ${sensorId} on the blockchain`);
        gateway.disconnect();

    } catch (error) {
        console.error(`Error processing sensor data: ${error}`);
    }
}

// Start the IoT gateway
async function startIoTGateway() {
    try {
        const mqttClient = connectToMQTT();

        mqttClient.on('message', (topic, message) => {
            processSensorData(topic, message);
        });

        console.log('IoT gateway is running...');
    } catch (error) {
        console.error(`Failed to start IoT gateway: ${error}`);
    }
}

startIoTGateway();

Integration Best Practices

When integrating Hyperledger Fabric with external systems, follow these best practices:

Security:
Use mutual TLS for all communications
Implement proper authentication and authorization
Validate all inputs before submitting to the blockchain
Protect API keys and credentials
Performance:
Batch transactions when possible
Use caching for frequently accessed data
Implement connection pooling
Consider asynchronous processing for non-critical operations
Reliability:
Implement retry mechanisms with exponential backoff
Use circuit breakers to prevent cascading failures
Implement proper error handling and logging
Set up monitoring and alerting
Maintainability:
Use a modular architecture
Document all integration points
Implement versioning for APIs
Create comprehensive test suites
Scalability:
Design for horizontal scaling
Use load balancers for API endpoints
Implement rate limiting
Consider microservices architecture for complex integrations

By following these integration patterns and best practices, you can create robust connections between Hyperledger Fabric and external systems, enabling comprehensive business solutions that leverage the strengths of blockchain technology while integrating with existing enterprise systems.