@toon-protocol/connector 1.7.1

package/dist/core/connector-node.js

@@ -0,0 +1,1036 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectorNode = void 0;
+const tslib_1 = require("tslib");
+const routing_table_1 = require("../routing/routing-table");
+const btp_client_manager_1 = require("../btp/btp-client-manager");
+const btp_server_1 = require("../btp/btp-server");
+const packet_handler_1 = require("./packet-handler");
+const shared_1 = require("@toon-protocol/shared");
+const payment_handler_1 = require("./payment-handler");
+const types_1 = require("../settlement/types");
+const admin_api_1 = require("../http/admin-api");
+const config_loader_1 = require("../config/config-loader");
+const health_server_1 = require("../http/health-server");
+const admin_server_1 = require("../http/admin-server");
+const payment_channel_sdk_1 = require("../settlement/payment-channel-sdk");
+const channel_manager_1 = require("../settlement/channel-manager");
+const settlement_executor_1 = require("../settlement/settlement-executor");
+const account_manager_1 = require("../settlement/account-manager");
+const settlement_monitor_1 = require("../settlement/settlement-monitor");
+const key_manager_1 = require("../security/key-manager");
+const optional_require_1 = require("../utils/optional-require");
+const tigerbeetle_client_1 = require("../settlement/tigerbeetle-client");
+const in_memory_ledger_client_1 = require("../settlement/in-memory-ledger-client");
+const per_packet_claim_service_1 = require("../settlement/per-packet-claim-service");
+const claim_sender_db_schema_1 = require("../settlement/claim-sender-db-schema");
+const dns_1 = require("dns");
+const package_json_1 = tslib_1.__importDefault(require("../../package.json"));
+class ConnectorNode {
+    _config;
+    _logger;
+    _routingTable;
+    _btpClientManager;
+    _packetHandler;
+    _btpServer;
+    _healthServer;
+    _adminServer = null;
+    _paymentChannelSDK = null;
+    _chainSDKs = new Map();
+    _channelManager = null;
+    _accountManager = null;
+    _settlementMonitor = null;
+    _settlementExecutor = null;
+    _tigerBeetleClient = null;
+    _inMemoryLedgerClient = null;
+    _settlementPeers = new Map();
+    _healthStatus = 'starting';
+    _startTime = new Date();
+    _btpServerStarted = false;
+    _defaultSettlementTokenId = 'M2M';
+    get defaultSettlementTokenId() {
+        return this._defaultSettlementTokenId;
+    }
+    constructor(config, logger) {
+        let resolvedConfig;
+        try {
+            if (typeof config === 'string') {
+                resolvedConfig = config_loader_1.ConfigLoader.loadConfig(config);
+            }
+            else {
+                resolvedConfig = config_loader_1.ConfigLoader.validateConfig(config);
+            }
+        }
+        catch (error) {
+            if (error instanceof config_loader_1.ConfigurationError) {
+                const logContext = typeof config === 'string'
+                    ? { event: 'config_load_failed', filePath: config, error: error.message }
+                    : { event: 'config_load_failed', source: 'object', error: error.message };
+                logger.error(logContext, 'Failed to load configuration');
+                throw error;
+            }
+            throw error;
+        }
+        this._config = resolvedConfig;
+        this._logger = logger.child({ component: 'ConnectorNode', nodeId: resolvedConfig.nodeId });
+        const loadedLogContext = typeof config === 'string'
+            ? { event: 'config_loaded', filePath: config, nodeId: resolvedConfig.nodeId }
+            : { event: 'config_loaded', source: 'object', nodeId: resolvedConfig.nodeId };
+        this._logger.info(loadedLogContext, 'Configuration loaded successfully');
+        const routingTableEntries = resolvedConfig.routes.map((route) => ({
+            prefix: route.prefix,
+            nextHop: route.nextHop,
+            priority: route.priority,
+        }));
+        this._routingTable = new routing_table_1.RoutingTable(routingTableEntries, logger.child({ component: 'RoutingTable' }));
+        this._btpClientManager = new btp_client_manager_1.BTPClientManager(resolvedConfig.nodeId, logger.child({ component: 'BTPClientManager' }));
+        this._packetHandler = new packet_handler_1.PacketHandler(this._routingTable, this._btpClientManager, resolvedConfig.nodeId, logger.child({ component: 'PacketHandler' }));
+        this._btpServer = new btp_server_1.BTPServer(logger.child({ component: 'BTPServer' }), this._packetHandler);
+        this._packetHandler.setBTPServer(this._btpServer);
+        const localDeliveryEnabled = resolvedConfig.localDelivery?.enabled || process.env.LOCAL_DELIVERY_ENABLED === 'true';
+        if (localDeliveryEnabled) {
+            const localDeliveryConfig = {
+                enabled: true,
+                handlerUrl: resolvedConfig.localDelivery?.handlerUrl || process.env.LOCAL_DELIVERY_URL || '',
+                timeout: resolvedConfig.localDelivery?.timeout ||
+                    parseInt(process.env.LOCAL_DELIVERY_TIMEOUT || '30000', 10),
+                authToken: resolvedConfig.localDelivery?.authToken || process.env.LOCAL_DELIVERY_AUTH_TOKEN,
+                perHopNotification: resolvedConfig.localDelivery?.perHopNotification ??
+                    process.env.LOCAL_DELIVERY_PER_HOP_NOTIFICATION === 'true',
+            };
+            this._packetHandler.setLocalDelivery(localDeliveryConfig);
+        }
+        this._btpClientManager.setPacketHandler(this._packetHandler);
+        this._healthServer = new health_server_1.HealthServer(logger.child({ component: 'HealthServer' }), this);
+        this._logger.info({
+            event: 'connector_initialized',
+            nodeId: resolvedConfig.nodeId,
+            peersCount: resolvedConfig.peers.length,
+            routesCount: resolvedConfig.routes.length,
+        }, 'Connector node initialized');
+    }
+    setLocalDeliveryHandler(handler) {
+        this._logger.info({ event: 'local_delivery_handler_set', hasHandler: handler !== null }, handler
+            ? 'Local delivery function handler registered'
+            : 'Local delivery function handler cleared');
+        this._packetHandler.setLocalDeliveryHandler(handler);
+    }
+    setPacketHandler(handler) {
+        this._logger.info({ event: 'packet_handler_set', hasHandler: handler !== null }, handler ? 'Packet handler registered' : 'Packet handler cleared');
+        if (handler) {
+            const adapter = (0, payment_handler_1.createPaymentHandlerAdapter)(handler, this._logger);
+            this._packetHandler.setLocalDeliveryHandler(adapter);
+        }
+        else {
+            this._packetHandler.setLocalDeliveryHandler(null);
+        }
+    }
+    getDeploymentMode() {
+        if (this._config.deploymentMode) {
+            return this._config.deploymentMode;
+        }
+        const hasLocalDelivery = this._config.localDelivery?.enabled === true;
+        const hasAdminApi = this._config.adminApi?.enabled === true;
+        if (hasLocalDelivery && hasAdminApi) {
+            return 'standalone';
+        }
+        if (!hasLocalDelivery && !hasAdminApi) {
+            return 'embedded';
+        }
+        return 'embedded';
+    }
+    isEmbedded() {
+        return this.getDeploymentMode() === 'embedded';
+    }
+    isStandalone() {
+        return this.getDeploymentMode() === 'standalone';
+    }
+    async sendPacket(params) {
+        if (!this._btpServerStarted) {
+            throw new config_loader_1.ConnectorNotStartedError();
+        }
+        const packet = {
+            type: shared_1.PacketType.PREPARE,
+            destination: params.destination,
+            amount: params.amount,
+            executionCondition: params.executionCondition,
+            expiresAt: params.expiresAt,
+            data: params.data ?? Buffer.alloc(0),
+        };
+        this._logger.info({
+            event: 'send_packet',
+            destination: params.destination,
+            amount: params.amount.toString(),
+            expiresAt: params.expiresAt.toISOString(),
+        }, 'Sending packet via public API');
+        try {
+            return await this._packetHandler.handlePreparePacket(packet, this._config.nodeId);
+        }
+        catch (error) {
+            this._logger.error({
+                event: 'send_packet_error',
+                destination: params.destination,
+                error: error instanceof Error ? error.message : String(error),
+            }, 'Unexpected error sending packet');
+            return {
+                type: shared_1.PacketType.REJECT,
+                code: shared_1.ILPErrorCode.T00_INTERNAL_ERROR,
+                triggeredBy: this._config.nodeId,
+                message: 'Internal connector error',
+                data: Buffer.alloc(0),
+            };
+        }
+    }
+    async start() {
+        this._logger.info({
+            event: 'connector_starting',
+            nodeId: this._config.nodeId,
+            peersCount: this._config.peers.length,
+            routesCount: this._config.routes.length,
+        }, 'Starting connector node');
+        try {
+            const settlementEnabled = this._config.settlementInfra?.enabled ?? process.env.SETTLEMENT_ENABLED === 'true';
+            const baseRpcUrl = this._config.settlementInfra?.rpcUrl ?? process.env.BASE_L2_RPC_URL;
+            const registryAddress = this._config.settlementInfra?.registryAddress ?? process.env.TOKEN_NETWORK_REGISTRY;
+            const m2mTokenAddress = this._config.settlementInfra?.tokenAddress ?? process.env.M2M_TOKEN_ADDRESS;
+            const treasuryPrivateKey = this._config.settlementInfra?.privateKey ?? process.env.TREASURY_EVM_PRIVATE_KEY;
+            if (settlementEnabled &&
+                baseRpcUrl &&
+                registryAddress &&
+                m2mTokenAddress &&
+                treasuryPrivateKey) {
+                try {
+                    const keyManager = new key_manager_1.KeyManager({
+                        backend: 'env',
+                        nodeId: this._config.nodeId,
+                        evmPrivateKey: treasuryPrivateKey,
+                    }, this._logger);
+                    const evmKeyId = 'evm';
+                    const { ethers } = await (0, optional_require_1.requireOptional)('ethers', 'EVM settlement');
+                    const provider = new ethers.JsonRpcProvider(baseRpcUrl);
+                    this._paymentChannelSDK = new payment_channel_sdk_1.PaymentChannelSDK(provider, keyManager, evmKeyId, registryAddress, this._logger);
+                    try {
+                        const resolvedSymbol = await this._paymentChannelSDK.getTokenSymbol(m2mTokenAddress);
+                        if (resolvedSymbol) {
+                            this._defaultSettlementTokenId = resolvedSymbol;
+                            this._logger.info({
+                                event: 'token_symbol_resolved',
+                                symbol: resolvedSymbol,
+                                tokenAddress: m2mTokenAddress,
+                            }, `Resolved on-chain token symbol: ${resolvedSymbol}`);
+                        }
+                        else {
+                            this._logger.warn({ event: 'token_symbol_empty', tokenAddress: m2mTokenAddress }, 'ERC-20 symbol() returned empty string, falling back to M2M');
+                        }
+                    }
+                    catch (symbolError) {
+                        this._logger.warn({
+                            event: 'token_symbol_resolution_failed',
+                            tokenAddress: m2mTokenAddress,
+                            error: symbolError instanceof Error ? symbolError.message : String(symbolError),
+                        }, 'Failed to resolve on-chain token symbol, falling back to M2M');
+                    }
+                    const primaryChainId = this._config.blockchain?.base?.chainId ?? this._config.blockchain?.arbitrum?.chainId;
+                    if (primaryChainId) {
+                        this._chainSDKs.set(primaryChainId, this._paymentChannelSDK);
+                    }
+                    const enabledChains = [];
+                    if (this._config.blockchain?.base?.enabled && this._config.blockchain.base) {
+                        enabledChains.push({ name: 'Base', config: this._config.blockchain.base });
+                    }
+                    if (this._config.blockchain?.arbitrum?.enabled && this._config.blockchain.arbitrum) {
+                        enabledChains.push({ name: 'Arbitrum', config: this._config.blockchain.arbitrum });
+                    }
+                    for (const chain of enabledChains) {
+                        if (this._chainSDKs.has(chain.config.chainId)) {
+                            continue;
+                        }
+                        const chainRpcUrl = chain.config.rpcUrl;
+                        const chainRegistryAddress = chain.config.registryAddress ?? registryAddress;
+                        const chainPrivateKey = chain.config.privateKey ?? treasuryPrivateKey;
+                        const chainKeyManager = chainPrivateKey !== treasuryPrivateKey
+                            ? new key_manager_1.KeyManager({ backend: 'env', nodeId: this._config.nodeId, evmPrivateKey: chainPrivateKey }, this._logger)
+                            : keyManager;
+                        const chainProvider = new ethers.JsonRpcProvider(chainRpcUrl);
+                        const chainSDK = new payment_channel_sdk_1.PaymentChannelSDK(chainProvider, chainKeyManager, evmKeyId, chainRegistryAddress, this._logger);
+                        this._chainSDKs.set(chain.config.chainId, chainSDK);
+                        this._logger.info({
+                            event: 'chain_sdk_initialized',
+                            chain: chain.name,
+                            chainId: chain.config.chainId,
+                            rpcUrl: chainRpcUrl,
+                        }, `PaymentChannelSDK initialized for ${chain.name} (chainId: ${chain.config.chainId})`);
+                    }
+                    const peerIdToAddressMap = new Map();
+                    for (const peer of this._config.peers) {
+                        if (peer.evmAddress) {
+                            peerIdToAddressMap.set(peer.id, peer.evmAddress);
+                            this._logger.debug({ peerId: peer.id, address: peer.evmAddress }, 'Loaded peer EVM address from config');
+                        }
+                    }
+                    for (let i = 1; i <= 10; i++) {
+                        const peerAddress = process.env[`PEER${i}_EVM_ADDRESS`];
+                        const peerId = `peer${i}`;
+                        if (peerAddress && !peerIdToAddressMap.has(peerId)) {
+                            peerIdToAddressMap.set(peerId, peerAddress);
+                            this._logger.debug({ peerId, address: peerAddress }, 'Loaded peer EVM address from env var (fallback)');
+                        }
+                    }
+                    const tokenAddressMap = new Map();
+                    tokenAddressMap.set(this._defaultSettlementTokenId, m2mTokenAddress);
+                    tokenAddressMap.set(m2mTokenAddress, m2mTokenAddress);
+                    const defaultSettlementTimeout = this._config.settlementInfra?.settlementTimeoutSecs ?? 86400;
+                    const initialDepositMultiplier = this._config.settlementInfra?.initialDepositMultiplier ??
+                        parseInt(process.env.INITIAL_DEPOSIT_MULTIPLIER ?? '1', 10);
+                    let accountManager;
+                    const tigerBeetleClusterId = process.env.TIGERBEETLE_CLUSTER_ID;
+                    const tigerBeetleReplicas = process.env.TIGERBEETLE_REPLICAS;
+                    if (tigerBeetleClusterId && tigerBeetleReplicas) {
+                        try {
+                            const rawAddresses = tigerBeetleReplicas.split(',').map((s) => s.trim());
+                            const resolvedAddresses = await Promise.all(rawAddresses.map(async (addr) => {
+                                const parts = addr.split(':');
+                                const hostOrIp = parts[0] || addr;
+                                const port = parts[1] || '3000';
+                                if (/^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(hostOrIp)) {
+                                    return addr;
+                                }
+                                try {
+                                    const result = await dns_1.promises.lookup(hostOrIp);
+                                    this._logger.debug({ hostname: hostOrIp, ip: result.address }, 'Resolved TigerBeetle hostname to IP');
+                                    return `${result.address}:${port}`;
+                                }
+                                catch (dnsError) {
+                                    this._logger.warn({ hostname: hostOrIp, error: dnsError }, 'Failed to resolve TigerBeetle hostname, using as-is');
+                                    return addr;
+                                }
+                            }));
+                            const tbOperationTimeout = parseInt(process.env.TIGERBEETLE_OPERATION_TIMEOUT ?? '15000', 10);
+                            const tigerBeetleClient = new tigerbeetle_client_1.TigerBeetleClient({
+                                clusterId: parseInt(tigerBeetleClusterId, 10),
+                                replicaAddresses: resolvedAddresses,
+                                connectionTimeout: 5000,
+                                operationTimeout: tbOperationTimeout,
+                            }, this._logger);
+                            await tigerBeetleClient.initialize();
+                            this._tigerBeetleClient = tigerBeetleClient;
+                            accountManager = new account_manager_1.AccountManager({ nodeId: this._config.nodeId }, tigerBeetleClient, this._logger);
+                            this._accountManager = accountManager;
+                            this._logger.info({
+                                event: 'tigerbeetle_account_manager_initialized',
+                                clusterId: tigerBeetleClusterId,
+                                replicas: tigerBeetleReplicas,
+                            }, `Accounting backend: TigerBeetle (cluster: ${tigerBeetleClusterId}, replicas: ${tigerBeetleReplicas})`);
+                        }
+                        catch (error) {
+                            const errorMessage = error instanceof Error ? error.message : String(error);
+                            this._logger.warn({
+                                event: 'tigerbeetle_init_failed',
+                                error: errorMessage,
+                                clusterId: tigerBeetleClusterId,
+                                replicas: tigerBeetleReplicas,
+                            }, 'TigerBeetle initialization failed, using in-memory ledger');
+                            accountManager = await this._createInMemoryAccountManager();
+                            this._accountManager = accountManager;
+                        }
+                    }
+                    else {
+                        this._logger.info({ event: 'tigerbeetle_not_configured' }, 'TigerBeetle not configured (TIGERBEETLE_CLUSTER_ID or TIGERBEETLE_REPLICAS not set), using in-memory ledger');
+                        accountManager = await this._createInMemoryAccountManager();
+                        this._accountManager = accountManager;
+                    }
+                    const peerIds = Array.from(peerIdToAddressMap.keys());
+                    const settlementThreshold = BigInt(this._config.settlementInfra?.threshold ?? process.env.SETTLEMENT_THRESHOLD ?? '1000000');
+                    const settlementPollingInterval = this._config.settlementInfra?.pollingIntervalMs ??
+                        parseInt(process.env.SETTLEMENT_POLLING_INTERVAL ?? '30000', 10);
+                    this._logger.info({
+                        event: 'settlement_monitor_config',
+                        peerIds,
+                        threshold: settlementThreshold.toString(),
+                        pollingInterval: settlementPollingInterval,
+                    }, 'Initializing settlement monitor with peer list');
+                    const settlementMonitor = new settlement_monitor_1.SettlementMonitor({
+                        thresholds: {
+                            defaultThreshold: settlementThreshold,
+                            pollingInterval: settlementPollingInterval,
+                        },
+                        peers: peerIds,
+                        tokenIds: [this._defaultSettlementTokenId],
+                    }, accountManager, this._logger);
+                    this._settlementMonitor = settlementMonitor;
+                    this._settlementExecutor = new settlement_executor_1.SettlementExecutor({
+                        nodeId: this._config.nodeId,
+                        defaultSettlementTimeout,
+                        initialDepositMultiplier,
+                        minDepositThreshold: 0.5,
+                        maxRetries: 3,
+                        retryDelayMs: 5000,
+                        tokenAddressMap,
+                        peerIdToAddressMap,
+                        registryAddress,
+                        rpcUrl: baseRpcUrl,
+                        privateKey: treasuryPrivateKey,
+                    }, accountManager, this._paymentChannelSDK, settlementMonitor, this._logger);
+                    this._settlementExecutor.start();
+                    this._logger.info({ event: 'settlement_executor_started' }, 'Automatic settlement execution enabled');
+                    setTimeout(async () => {
+                        try {
+                            await settlementMonitor.start();
+                            this._logger.info({
+                                event: 'settlement_monitor_started',
+                                threshold: settlementThreshold.toString(),
+                                peerCount: peerIds.length,
+                                pollingInterval: settlementPollingInterval,
+                            }, 'Settlement threshold monitoring started');
+                        }
+                        catch (error) {
+                            const errorMessage = error instanceof Error ? error.message : String(error);
+                            this._logger.error({ event: 'settlement_monitor_start_failed', error: errorMessage }, 'Failed to start settlement monitor');
+                        }
+                    }, 5000);
+                    this._channelManager = new channel_manager_1.ChannelManager({
+                        nodeId: this._config.nodeId,
+                        defaultSettlementTimeout,
+                        initialDepositMultiplier,
+                        idleChannelThreshold: 86400,
+                        minDepositThreshold: 0.5,
+                        idleCheckInterval: 3600,
+                        tokenAddressMap,
+                        peerIdToAddressMap,
+                        registryAddress,
+                        rpcUrl: baseRpcUrl,
+                        privateKey: treasuryPrivateKey,
+                    }, this._paymentChannelSDK, this._settlementExecutor, this._logger);
+                    this._logger.info({
+                        event: 'payment_channel_sdk_initialized',
+                        registryAddress,
+                        tokenAddress: m2mTokenAddress,
+                        peerCount: peerIdToAddressMap.size,
+                    }, 'Payment channel infrastructure initialized');
+                    if (this._channelManager && this._paymentChannelSDK) {
+                        try {
+                            const BetterSqlite3Module = await (0, optional_require_1.requireOptional)('better-sqlite3', 'per-packet claims persistence');
+                            const BetterSqlite3 = BetterSqlite3Module.default;
+                            const claimDbPath = `./data/claims-${this._config.nodeId}.db`;
+                            const claimDb = new BetterSqlite3(claimDbPath);
+                            claimDb.exec(claim_sender_db_schema_1.SENT_CLAIMS_TABLE_SCHEMA);
+                            for (const indexSql of claim_sender_db_schema_1.SENT_CLAIMS_INDEXES) {
+                                claimDb.exec(indexSql);
+                            }
+                            const perPacketClaimService = new per_packet_claim_service_1.PerPacketClaimService(this._paymentChannelSDK, this._channelManager, claimDb, this._logger, this._config.nodeId);
+                            this._packetHandler.setPerPacketClaimService(perPacketClaimService);
+                            this._settlementExecutor?.setPerPacketClaimService(perPacketClaimService);
+                            this._logger.info({ event: 'per_packet_claims_enabled' }, 'Per-packet claim service wired to PacketHandler and SettlementExecutor');
+                        }
+                        catch (error) {
+                            const errorMessage = error instanceof Error ? error.message : String(error);
+                            this._logger.error({ event: 'per_packet_claims_init_failed', error: errorMessage }, 'Failed to initialize per-packet claim service');
+                            throw error;
+                        }
+                    }
+                    if (accountManager) {
+                        const settlementConfig = {
+                            connectorFeePercentage: this._config.settlement?.connectorFeePercentage ?? 0.1,
+                            enableSettlement: settlementEnabled,
+                            tigerBeetleClusterId: tigerBeetleClusterId ? parseInt(tigerBeetleClusterId, 10) : 0,
+                            tigerBeetleReplicas: tigerBeetleReplicas
+                                ? tigerBeetleReplicas.split(',').map((s) => s.trim())
+                                : [],
+                        };
+                        this._packetHandler.setSettlement(accountManager, settlementConfig, this._defaultSettlementTokenId);
+                    }
+                }
+                catch (error) {
+                    const errorMessage = error instanceof Error ? error.message : String(error);
+                    this._logger.error({ event: 'payment_channel_init_failed', error: errorMessage }, 'Failed to initialize payment channel infrastructure (connector continues without channels)');
+                }
+            }
+            else {
+                this._logger.info({ event: 'payment_channels_disabled' }, 'Payment channel infrastructure disabled (missing configuration)');
+            }
+            await this._btpServer.start(this._config.btpServerPort);
+            this._btpServerStarted = true;
+            this._logger.info({
+                event: 'btp_server_started',
+                port: this._config.btpServerPort,
+            }, 'BTP server started');
+            const healthCheckPort = this._config.healthCheckPort || 8080;
+            await this._healthServer.start(healthCheckPort);
+            this._logger.info({
+                event: 'health_server_started',
+                port: healthCheckPort,
+            }, 'Health server started');
+            const adminApiEnabled = this._config.adminApi?.enabled || process.env.ADMIN_API_ENABLED === 'true';
+            if (adminApiEnabled) {
+                const adminConfig = {
+                    enabled: true,
+                    port: this._config.adminApi?.port ?? parseInt(process.env.ADMIN_API_PORT || '8081', 10),
+                    host: this._config.adminApi?.host ?? process.env.ADMIN_API_HOST ?? '0.0.0.0',
+                    apiKey: this._config.adminApi?.apiKey ?? process.env.ADMIN_API_KEY,
+                };
+                this._adminServer = new admin_server_1.AdminServer({
+                    routingTable: this._routingTable,
+                    btpClientManager: this._btpClientManager,
+                    nodeId: this._config.nodeId,
+                    config: adminConfig,
+                    logger: this._logger,
+                    settlementPeers: this._settlementPeers,
+                    channelManager: this._channelManager ?? undefined,
+                    paymentChannelSDK: this._paymentChannelSDK ?? undefined,
+                    accountManager: this._accountManager ?? undefined,
+                    settlementMonitor: this._settlementMonitor ?? undefined,
+                    defaultSettlementTokenId: this._defaultSettlementTokenId,
+                    packetSender: (params) => this.sendPacket(params),
+                    isReady: () => this._btpServerStarted,
+                });
+                await this._adminServer.start();
+                this._logger.info({
+                    event: 'admin_server_started',
+                    port: adminConfig.port,
+                    host: adminConfig.host,
+                    apiKeyConfigured: !!adminConfig.apiKey,
+                }, 'Admin API server started');
+            }
+            else {
+                this._logger.debug({ event: 'admin_api_disabled' }, 'Admin API disabled (set ADMIN_API_ENABLED=true or adminApi.enabled=true to enable)');
+            }
+            const peerConnections = [];
+            for (const peerConfig of this._config.peers) {
+                const peer = {
+                    id: peerConfig.id,
+                    url: peerConfig.url,
+                    authToken: peerConfig.authToken,
+                    connected: false,
+                    lastSeen: new Date(),
+                };
+                peerConnections.push(this._btpClientManager.addPeer(peer));
+            }
+            const peerResults = await Promise.allSettled(peerConnections);
+            const failedPeers = peerResults.filter((r) => r.status === 'rejected');
+            if (failedPeers.length > 0) {
+                this._logger.warn({
+                    event: 'peer_connection_failures',
+                    failedCount: failedPeers.length,
+                    totalPeers: this._config.peers.length,
+                }, 'Some peer connections failed during startup (will retry in background)');
+            }
+            const connectedPeers = this._btpClientManager.getPeerStatus();
+            const connectedCount = Array.from(connectedPeers.values()).filter(Boolean).length;
+            if (this._channelManager && this._paymentChannelSDK) {
+                this._logger.info({ event: 'creating_payment_channels', connectedCount }, 'Creating payment channels for connected peers');
+                const channelCreationPromises = [];
+                for (const [peerId, connected] of connectedPeers.entries()) {
+                    if (!connected) {
+                        continue;
+                    }
+                    const channelPromise = (async () => {
+                        try {
+                            const tokenId = this._defaultSettlementTokenId;
+                            const channelId = await this._channelManager.ensureChannelExists(peerId, tokenId);
+                            this._logger.info({ event: 'payment_channel_ready', peerId, channelId }, 'Payment channel ready for peer');
+                        }
+                        catch (error) {
+                            const errorMessage = error instanceof Error ? error.message : String(error);
+                            this._logger.warn({ event: 'payment_channel_creation_failed', peerId, error: errorMessage }, 'Failed to create payment channel for peer (will retry on-demand)');
+                        }
+                    })();
+                    channelCreationPromises.push(channelPromise);
+                }
+                await Promise.allSettled(channelCreationPromises);
+                this._logger.info({ event: 'payment_channels_initialized' }, 'Payment channel creation completed');
+            }
+            this._updateHealthStatus();
+            this._logger.info({
+                event: 'connector_ready',
+                nodeId: this._config.nodeId,
+                connectedPeers: connectedCount,
+                totalPeers: this._config.peers.length,
+                healthStatus: this._healthStatus,
+            }, 'Connector node ready');
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this._logger.error({
+                event: 'connector_start_failed',
+                nodeId: this._config.nodeId,
+                error: errorMessage,
+            }, 'Failed to start connector node');
+            this._healthStatus = 'unhealthy';
+            throw error;
+        }
+    }
+    async stop() {
+        if (!this._btpServerStarted && !this._adminServer) {
+            this._logger.debug({ event: 'connector_already_stopped' }, 'Connector already stopped, ignoring');
+            return;
+        }
+        this._logger.info({
+            event: 'connector_stopping',
+            nodeId: this._config.nodeId,
+        }, 'Stopping connector node');
+        try {
+            if (this._settlementMonitor) {
+                await this._settlementMonitor.stop();
+                this._logger.info({ event: 'settlement_monitor_stopped' }, 'Settlement monitor stopped');
+                this._settlementMonitor = null;
+            }
+            if (this._settlementExecutor) {
+                await this._settlementExecutor.stop();
+                this._logger.info({ event: 'settlement_executor_stopped' }, 'Settlement executor stopped');
+                this._settlementExecutor = null;
+            }
+            if (this._channelManager) {
+                this._channelManager.stop();
+                this._logger.info({ event: 'channel_manager_stopped' }, 'Channel manager stopped');
+                this._channelManager = null;
+            }
+            for (const [chainId, sdk] of this._chainSDKs.entries()) {
+                sdk.removeAllListeners();
+                this._logger.debug({ event: 'chain_sdk_stopped', chainId }, `Chain SDK stopped (chainId: ${chainId})`);
+            }
+            this._chainSDKs.clear();
+            if (this._paymentChannelSDK) {
+                this._logger.info({ event: 'payment_channel_sdk_stopped' }, 'Payment channel SDK stopped');
+                this._paymentChannelSDK = null;
+            }
+            if (this._tigerBeetleClient) {
+                await this._tigerBeetleClient.close();
+                this._logger.info({ event: 'tigerbeetle_client_closed' }, 'TigerBeetle client closed');
+                this._tigerBeetleClient = null;
+            }
+            if (this._inMemoryLedgerClient) {
+                await this._inMemoryLedgerClient.close();
+                this._logger.info({ event: 'in_memory_ledger_closed' }, 'In-memory ledger client closed');
+                this._inMemoryLedgerClient = null;
+            }
+            this._accountManager = null;
+            const peerIds = this._btpClientManager.getPeerIds();
+            for (const peerId of peerIds) {
+                await this._btpClientManager.removePeer(peerId);
+            }
+            if (this._adminServer) {
+                await this._adminServer.stop();
+                this._logger.info({ event: 'admin_server_stopped' }, 'Admin API server stopped');
+                this._adminServer = null;
+            }
+            await this._healthServer.stop();
+            await this._btpServer.stop();
+            this._logger.info({
+                event: 'connector_stopped',
+                nodeId: this._config.nodeId,
+            }, 'Connector node stopped');
+            this._healthStatus = 'starting';
+            this._btpServerStarted = false;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this._logger.error({
+                event: 'connector_stop_failed',
+                nodeId: this._config.nodeId,
+                error: errorMessage,
+            }, 'Failed to stop connector node gracefully');
+            throw error;
+        }
+    }
+    getHealthStatus() {
+        const peerStatus = this._btpClientManager.getPeerStatus();
+        const peersConnected = Array.from(peerStatus.values()).filter(Boolean).length;
+        const totalPeers = this._config.peers.length;
+        const uptime = Math.floor((Date.now() - this._startTime.getTime()) / 1000);
+        const healthStatus = {
+            status: this._healthStatus,
+            uptime,
+            peersConnected,
+            totalPeers,
+            timestamp: new Date().toISOString(),
+            nodeId: this._config.nodeId,
+            version: package_json_1.default.version,
+        };
+        return healthStatus;
+    }
+    get routingTable() {
+        return this._routingTable;
+    }
+    get btpClientManager() {
+        return this._btpClientManager;
+    }
+    get paymentChannelSDK() {
+        return this._paymentChannelSDK;
+    }
+    get channelManager() {
+        return this._channelManager;
+    }
+    get accountManager() {
+        return this._accountManager;
+    }
+    getPaymentChannelSDKForChain(chainId) {
+        return this._chainSDKs.get(chainId) ?? null;
+    }
+    async _createInMemoryAccountManager() {
+        const snapshotPath = this._config.settlementInfra?.ledgerSnapshotPath ??
+            process.env.LEDGER_SNAPSHOT_PATH ??
+            './data/ledger-snapshot.json';
+        const persistIntervalMs = this._config.settlementInfra?.ledgerPersistIntervalMs ??
+            parseInt(process.env.LEDGER_PERSIST_INTERVAL_MS || '30000', 10);
+        let inMemoryClient;
+        try {
+            inMemoryClient = new in_memory_ledger_client_1.InMemoryLedgerClient({
+                snapshotPath,
+                persistIntervalMs,
+            }, this._logger);
+            await inMemoryClient.initialize();
+            this._logger.info({
+                event: 'in_memory_ledger_initialized',
+                snapshotPath,
+                persistIntervalMs,
+            }, `Accounting backend: in-memory ledger (snapshot: ${snapshotPath})`);
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            this._logger.warn({
+                event: 'in_memory_ledger_snapshot_restore_failed',
+                error: errorMessage,
+                snapshotPath,
+            }, 'Failed to restore from snapshot, starting with fresh in-memory ledger');
+            try {
+                inMemoryClient = new in_memory_ledger_client_1.InMemoryLedgerClient({
+                    snapshotPath: `${snapshotPath}.fresh-${Date.now()}`,
+                    persistIntervalMs,
+                }, this._logger);
+                await inMemoryClient.initialize();
+                this._logger.info({
+                    event: 'in_memory_ledger_fresh_start',
+                    snapshotPath,
+                }, 'In-memory ledger started with empty state');
+            }
+            catch (freshInitError) {
+                const freshErrorMessage = freshInitError instanceof Error ? freshInitError.message : String(freshInitError);
+                this._logger.error({
+                    event: 'in_memory_ledger_fresh_init_failed',
+                    error: freshErrorMessage,
+                }, 'Critical: Fresh in-memory ledger initialization failed');
+                throw freshInitError;
+            }
+        }
+        this._inMemoryLedgerClient = inMemoryClient;
+        const accountManager = new account_manager_1.AccountManager({ nodeId: this._config.nodeId }, inMemoryClient, this._logger);
+        return accountManager;
+    }
+    _updateHealthStatus() {
+        if (!this._btpServerStarted) {
+            if (this._healthStatus !== 'starting') {
+                this._logger.info({
+                    event: 'health_status_changed',
+                    oldStatus: this._healthStatus,
+                    newStatus: 'starting',
+                    reason: 'BTP server not started',
+                }, 'Health status changed');
+                this._healthStatus = 'starting';
+            }
+            return;
+        }
+        const totalPeers = this._config.peers.length;
+        if (totalPeers === 0) {
+            if (this._healthStatus !== 'healthy') {
+                this._logger.info({
+                    event: 'health_status_changed',
+                    oldStatus: this._healthStatus,
+                    newStatus: 'healthy',
+                    reason: 'No peers configured (standalone mode)',
+                }, 'Health status changed');
+                this._healthStatus = 'healthy';
+            }
+            return;
+        }
+        const peerStatus = this._btpClientManager.getPeerStatus();
+        const connectedCount = Array.from(peerStatus.values()).filter(Boolean).length;
+        const connectionPercentage = (connectedCount / totalPeers) * 100;
+        let newStatus;
+        let reason;
+        if (connectionPercentage < 50) {
+            newStatus = 'unhealthy';
+            reason = `Only ${connectedCount}/${totalPeers} peers connected (<50%)`;
+        }
+        else {
+            newStatus = 'healthy';
+            reason = `${connectedCount}/${totalPeers} peers connected (≥50%)`;
+        }
+        if (this._healthStatus !== newStatus) {
+            this._logger.info({ event: 'health_status_changed', oldStatus: this._healthStatus, newStatus, reason }, 'Health status changed');
+            this._healthStatus = newStatus;
+        }
+    }
+    async registerPeer(config) {
+        if (!this._btpServerStarted) {
+            throw new config_loader_1.ConnectorNotStartedError('Connector is not started. Call start() before registerPeer().');
+        }
+        if (!config.id || typeof config.id !== 'string') {
+            throw new Error('Missing or invalid peer id');
+        }
+        if (!config.url || typeof config.url !== 'string') {
+            throw new Error('Missing or invalid peer url');
+        }
+        if (config.authToken === undefined ||
+            config.authToken === null ||
+            typeof config.authToken !== 'string') {
+            throw new Error('authToken must be a string (can be empty for no auth)');
+        }
+        if (!config.url.startsWith('ws://') && !config.url.startsWith('wss://')) {
+            throw new Error('URL must start with ws:// or wss://');
+        }
+        if (config.routes) {
+            for (const route of config.routes) {
+                if (!route.prefix || typeof route.prefix !== 'string') {
+                    throw new Error('Invalid route: missing prefix');
+                }
+                if (!(0, shared_1.isValidILPAddress)(route.prefix)) {
+                    throw new Error(`Invalid ILP address prefix: ${route.prefix}`);
+                }
+            }
+        }
+        if (config.settlement) {
+            const settlementError = (0, admin_api_1.validateSettlementConfig)(config.settlement);
+            if (settlementError) {
+                throw new Error(settlementError);
+            }
+        }
+        const existingPeers = this._btpClientManager.getPeerIds();
+        const isUpdate = existingPeers.includes(config.id);
+        if (!isUpdate) {
+            const peer = {
+                id: config.id,
+                url: config.url,
+                authToken: config.authToken,
+                connected: false,
+                lastSeen: new Date(),
+            };
+            await this._btpClientManager.addPeer(peer);
+            this._logger.info({ event: 'peer_registered', peerId: config.id, url: config.url }, `Registered peer: ${config.id}`);
+        }
+        else {
+            this._logger.info({ event: 'peer_reregistered', peerId: config.id }, `Re-registering peer: ${config.id}`);
+        }
+        if (config.routes) {
+            for (const route of config.routes) {
+                this._routingTable.addRoute(route.prefix, config.id, route.priority ?? 0);
+                this._logger.info({ event: 'route_added', prefix: route.prefix, nextHop: config.id }, `Added route: ${route.prefix} -> ${config.id}`);
+            }
+        }
+        if (config.settlement) {
+            this._applySettlementConfig(config.id, config.settlement, config.routes, isUpdate);
+        }
+        const routes = this._routingTable.getAllRoutes();
+        const peerRoutes = routes.filter((r) => r.nextHop === config.id);
+        const connected = this._btpClientManager.isConnected(config.id);
+        const peerInfo = {
+            id: config.id,
+            connected,
+            ilpAddresses: peerRoutes.map((r) => r.prefix),
+            routeCount: peerRoutes.length,
+        };
+        const peerConfig = this._settlementPeers.get(config.id);
+        if (peerConfig) {
+            peerInfo.settlement = {
+                preference: peerConfig.settlementPreference,
+                evmAddress: peerConfig.evmAddress,
+                tokenAddress: peerConfig.tokenAddress,
+                chainId: peerConfig.chainId,
+            };
+        }
+        return peerInfo;
+    }
+    async removePeer(peerId, removeRoutes = true) {
+        if (!this._btpServerStarted) {
+            throw new config_loader_1.ConnectorNotStartedError('Connector is not started. Call start() before removePeer().');
+        }
+        const existingPeers = this._btpClientManager.getPeerIds();
+        if (!existingPeers.includes(peerId)) {
+            throw new Error(`Peer not found: ${peerId}`);
+        }
+        await this._btpClientManager.removePeer(peerId);
+        this._logger.info({ event: 'peer_removed', peerId }, `Removed peer: ${peerId}`);
+        if (this._settlementPeers.delete(peerId)) {
+            this._logger.info({ event: 'settlement_config_removed', peerId }, `Removed settlement config for peer: ${peerId}`);
+        }
+        const removedRoutes = [];
+        if (removeRoutes) {
+            const routes = this._routingTable.getAllRoutes();
+            for (const route of routes) {
+                if (route.nextHop === peerId) {
+                    this._routingTable.removeRoute(route.prefix);
+                    removedRoutes.push(route.prefix);
+                    this._logger.info({ event: 'route_removed', prefix: route.prefix }, `Removed route: ${route.prefix}`);
+                }
+            }
+        }
+        return { peerId, removedRoutes };
+    }
+    listPeers() {
+        const peerIds = this._btpClientManager.getPeerIds();
+        const peerStatus = this._btpClientManager.getPeerStatus();
+        const routes = this._routingTable.getAllRoutes();
+        return peerIds.map((peerId) => {
+            const peerRoutes = routes.filter((r) => r.nextHop === peerId);
+            const peerInfo = {
+                id: peerId,
+                connected: peerStatus.get(peerId) ?? false,
+                ilpAddresses: peerRoutes.map((r) => r.prefix),
+                routeCount: peerRoutes.length,
+            };
+            const peerConfig = this._settlementPeers.get(peerId);
+            if (peerConfig) {
+                peerInfo.settlement = {
+                    preference: peerConfig.settlementPreference,
+                    evmAddress: peerConfig.evmAddress,
+                    tokenAddress: peerConfig.tokenAddress,
+                    chainId: peerConfig.chainId,
+                };
+            }
+            return peerInfo;
+        });
+    }
+    async getBalance(peerId, tokenId = this._defaultSettlementTokenId) {
+        if (!this._accountManager) {
+            throw new Error('Account management not enabled');
+        }
+        const balance = await this._accountManager.getAccountBalance(peerId, tokenId);
+        return {
+            peerId,
+            balances: [
+                {
+                    tokenId,
+                    debitBalance: balance.debitBalance.toString(),
+                    creditBalance: balance.creditBalance.toString(),
+                    netBalance: balance.netBalance.toString(),
+                },
+            ],
+        };
+    }
+    listRoutes() {
+        const routes = this._routingTable.getAllRoutes();
+        return routes.map((r) => ({
+            prefix: r.prefix,
+            nextHop: r.nextHop,
+            priority: r.priority ?? 0,
+        }));
+    }
+    addRoute(route) {
+        if (!(0, shared_1.isValidILPAddress)(route.prefix)) {
+            throw new Error(`Invalid ILP address prefix: ${route.prefix}`);
+        }
+        if (!route.nextHop || typeof route.nextHop !== 'string') {
+            throw new Error('Missing or invalid nextHop');
+        }
+        const existingPeers = this._btpClientManager.getPeerIds();
+        if (!existingPeers.includes(route.nextHop)) {
+            this._logger.warn({ event: 'route_nextHop_unknown', prefix: route.prefix, nextHop: route.nextHop }, `Adding route with unknown nextHop peer: ${route.nextHop}`);
+        }
+        this._routingTable.addRoute(route.prefix, route.nextHop, route.priority ?? 0);
+        this._logger.info({ event: 'route_added', prefix: route.prefix, nextHop: route.nextHop }, `Added route: ${route.prefix} -> ${route.nextHop}`);
+    }
+    removeRoute(prefix) {
+        const routes = this._routingTable.getAllRoutes();
+        const exists = routes.some((r) => r.prefix === prefix);
+        if (!exists) {
+            throw new Error(`Route not found: ${prefix}`);
+        }
+        this._routingTable.removeRoute(prefix);
+        this._logger.info({ event: 'route_removed', prefix }, `Removed route: ${prefix}`);
+    }
+    async openChannel(params) {
+        if (!this._btpServerStarted) {
+            throw new config_loader_1.ConnectorNotStartedError('Connector is not started. Call start() before openChannel().');
+        }
+        if (!this._channelManager) {
+            throw new Error('Settlement infrastructure not enabled');
+        }
+        const existingPeers = this._btpClientManager.getPeerIds();
+        if (!existingPeers.includes(params.peerId)) {
+            throw new Error(`Peer '${params.peerId}' must be registered before opening channels`);
+        }
+        const tokenId = params.token ?? 'AGENT';
+        const peerAddress = params.peerAddress || this._settlementPeers.get(params.peerId)?.evmAddress;
+        if (!peerAddress) {
+            throw new Error('Peer EVM address must be provided in params or peer registration');
+        }
+        const existing = this._channelManager.getChannelForPeer(params.peerId, tokenId);
+        if (existing && existing.status !== 'closed') {
+            throw new Error(`Channel already exists for peer ${params.peerId} with token ${tokenId} on chain ${params.chain}`);
+        }
+        const channelId = await this._channelManager.ensureChannelExists(params.peerId, tokenId, {
+            initialDeposit: BigInt(params.initialDeposit ?? '0'),
+            settlementTimeout: params.settlementTimeout,
+            chain: params.chain,
+            peerAddress,
+        });
+        const metadata = this._channelManager.getChannelById(channelId);
+        const status = metadata ? (0, types_1.normalizeChannelStatus)(metadata.status, this._logger) : 'opening';
+        this._logger.info({ event: 'channel_opened', peerId: params.peerId, chain: params.chain, channelId }, 'Channel opened via direct API');
+        return { channelId, status };
+    }
+    async getChannelState(channelId) {
+        if (!this._btpServerStarted) {
+            throw new config_loader_1.ConnectorNotStartedError('Connector is not started. Call start() before getChannelState().');
+        }
+        if (!this._channelManager) {
+            throw new Error('Settlement infrastructure not enabled');
+        }
+        const metadata = this._channelManager.getChannelById(channelId);
+        if (!metadata) {
+            throw new Error(`Channel not found: ${channelId}`);
+        }
+        return {
+            channelId: metadata.channelId,
+            status: (0, types_1.normalizeChannelStatus)(metadata.status, this._logger),
+            chain: metadata.chain,
+        };
+    }
+    _applySettlementConfig(peerId, s, routes, isUpdate) {
+        const ilpAddress = routes && routes.length > 0 ? routes[0].prefix : '';
+        const settlementTokens = [];
+        if (s.tokenAddress) {
+            settlementTokens.push(s.tokenAddress);
+        }
+        else {
+            if (s.evmAddress)
+                settlementTokens.push('EVM');
+        }
+        const newConfig = {
+            peerId,
+            address: ilpAddress,
+            settlementPreference: s.preference,
+            settlementTokens,
+            evmAddress: s.evmAddress,
+            tokenAddress: s.tokenAddress,
+            tokenNetworkAddress: s.tokenNetworkAddress,
+            chainId: s.chainId,
+            channelId: s.channelId,
+            initialDeposit: s.initialDeposit,
+        };
+        if (isUpdate) {
+            const existingConfig = this._settlementPeers.get(peerId);
+            if (existingConfig) {
+                const mergedConfig = { ...existingConfig };
+                for (const [key, value] of Object.entries(newConfig)) {
+                    if (value !== undefined) {
+                        mergedConfig[key] = value;
+                    }
+                }
+                this._settlementPeers.set(peerId, mergedConfig);
+            }
+            else {
+                this._settlementPeers.set(peerId, newConfig);
+            }
+            this._logger.info({ event: 'settlement_config_merged', peerId, preference: s.preference }, `Merged settlement config for peer: ${peerId}`);
+        }
+        else {
+            this._settlementPeers.set(peerId, newConfig);
+            this._logger.info({ event: 'settlement_config_added', peerId, preference: s.preference }, `Added settlement config for peer: ${peerId}`);
+        }
+    }
+    getRoutingTable() {
+        return this._routingTable.getAllRoutes();
+    }
+}
+exports.ConnectorNode = ConnectorNode;
+//# sourceMappingURL=connector-node.js.map