@toon-protocol/connector 2.6.1 → 3.3.1

package/dist/core/connector-node.js

@@ -1,1322 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConnectorNode = void 0;
-const tslib_1 = require("tslib");
-const fs_1 = require("fs");
-const nodePath = tslib_1.__importStar(require("path"));
-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 types_1 = require("../config/types");
-const transport_1 = require("../transport");
-const payment_handler_1 = require("./payment-handler");
-const types_2 = 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 metrics_registry_1 = require("../observability/metrics-registry");
-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 claim_receiver_1 = require("../settlement/claim-receiver");
-const claim_receiver_db_schema_1 = require("../settlement/claim-receiver-db-schema");
-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 chain_provider_registry_1 = require("../settlement/provider/chain-provider-registry");
-const evm_payment_channel_provider_1 = require("../settlement/provider/evm-payment-channel-provider");
-const claim_sender_db_schema_1 = require("../settlement/claim-sender-db-schema");
-const inbound_claim_validator_1 = require("../btp/inbound-claim-validator");
-const nip59_claim_wrapper_1 = require("../settlement/privacy/nip59-claim-wrapper");
-const utils_1 = require("@noble/hashes/utils");
-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';
-    _ilpMetrics;
-    _startTime = new Date();
-    _btpServerStarted = false;
-    _defaultSettlementTokenId = 'M2M';
-    _transportProvider = null;
-    _transportProviderReady = false;
-    _transportType = null;
-    _lastTransportHealthy = true;
-    _transportHealthInterval = null;
-    _transportHealthIntervalMs;
-    get defaultSettlementTokenId() {
-        return this._defaultSettlementTokenId;
-    }
-    constructor(config, logger, opts) {
-        this._transportHealthIntervalMs = opts?.transportHealthIntervalMs ?? 30000;
-        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._btpClientManager.setAgentFactory((peerUrl) => this._transportProvider?.createAgent(peerUrl));
-        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._ilpMetrics = new metrics_registry_1.IlpMetricsRegistry({ collectDefaults: false });
-        for (const peer of resolvedConfig.peers) {
-            this._ilpMetrics.registerPeer(peer.id);
-        }
-        this._packetHandler.setIlpMetrics(this._ilpMetrics);
-        this._healthServer = new health_server_1.HealthServer(logger.child({ component: 'HealthServer' }), this, {
-            metricsMiddleware: this._ilpMetrics.createMetricsMiddleware(),
-        });
-        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,
-            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 {
-            (0, types_1.validateChainProviders)(this._config, this._logger);
-            const createdProvider = this._createTransportProvider(this._config.transport);
-            this._transportProvider = createdProvider;
-            this._transportType =
-                this._config.transport === undefined ? 'direct' : this._config.transport.type;
-            try {
-                await createdProvider.start();
-            }
-            catch (err) {
-                this._transportProvider = null;
-                this._transportType = null;
-                this._transportProviderReady = false;
-                throw err;
-            }
-            this._transportProviderReady = true;
-            this._lastTransportHealthy = true;
-            this._transportHealthInterval = setInterval(() => {
-                const provider = this._transportProvider;
-                if (!provider || !this._transportProviderReady)
-                    return;
-                provider
-                    .healthCheck()
-                    .then((healthy) => {
-                    if (this._transportProviderReady && this._transportProvider === provider) {
-                        this._lastTransportHealthy = healthy;
-                    }
-                })
-                    .catch(() => {
-                    if (this._transportProviderReady && this._transportProvider === provider) {
-                        this._lastTransportHealthy = false;
-                    }
-                });
-            }, this._transportHealthIntervalMs);
-            this._transportHealthInterval.unref?.();
-            const evmProviderConfig = this._config.chainProviders?.find((p) => p.chainType === 'evm');
-            const legacySettlementVars = [
-                'BASE_L2_RPC_URL',
-                'SETTLEMENT_ENABLED',
-                'TOKEN_NETWORK_REGISTRY',
-                'M2M_TOKEN_ADDRESS',
-                'TREASURY_EVM_PRIVATE_KEY',
-            ];
-            const detectedLegacyVars = legacySettlementVars.filter((v) => process.env[v]);
-            if (detectedLegacyVars.length > 0) {
-                this._logger.warn({ event: 'legacy_env_vars_detected', vars: detectedLegacyVars }, 'Detected legacy settlement env vars -- these are no longer used. Configure chainProviders with an EVM entry instead.');
-            }
-            const baseRpcUrl = evmProviderConfig?.rpcUrl;
-            const registryAddress = evmProviderConfig?.registryAddress;
-            const m2mTokenAddress = evmProviderConfig?.tokenAddress;
-            const treasuryPrivateKey = evmProviderConfig?.keyId;
-            if (evmProviderConfig &&
-                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 = evmProviderConfig.settlementOptions?.settlementTimeoutSecs ?? 86400;
-                    const initialDepositMultiplier = evmProviderConfig.settlementOptions?.initialDepositMultiplier ?? 1;
-                    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(evmProviderConfig.settlementOptions?.threshold ?? '1000000');
-                    this._logger.info({
-                        event: 'settlement_monitor_config',
-                        peerIds,
-                        threshold: settlementThreshold.toString(),
-                    }, 'Initializing event-driven settlement monitor with peer list');
-                    const settlementMonitor = new settlement_monitor_1.SettlementMonitor({
-                        thresholds: {
-                            defaultThreshold: settlementThreshold,
-                        },
-                        peers: peerIds,
-                        tokenIds: [this._defaultSettlementTokenId],
-                    }, this._logger);
-                    this._settlementMonitor = settlementMonitor;
-                    const chainProviderChainId = this._config.chainProviders?.find((cp) => cp.chainType === 'evm')?.chainId;
-                    const primaryChainIdStr = primaryChainId
-                        ? `evm:${primaryChainId}`
-                        : (chainProviderChainId ?? 'evm:unknown');
-                    const chainRegistry = new chain_provider_registry_1.ChainProviderRegistry();
-                    const evmProvider = new evm_payment_channel_provider_1.EVMPaymentChannelProvider(this._paymentChannelSDK, primaryChainIdStr, m2mTokenAddress, this._logger);
-                    chainRegistry.register(evmProvider);
-                    const peerIdToChainMap = new Map();
-                    for (const peer of this._config.peers) {
-                        if (peer.chain) {
-                            peerIdToChainMap.set(peer.id, peer.chain);
-                        }
-                        else if (peerIdToAddressMap.has(peer.id)) {
-                            peerIdToChainMap.set(peer.id, primaryChainIdStr);
-                        }
-                    }
-                    for (const peerId of peerIdToAddressMap.keys()) {
-                        if (!peerIdToChainMap.has(peerId)) {
-                            peerIdToChainMap.set(peerId, primaryChainIdStr);
-                        }
-                    }
-                    const nip59Enabled = this._config.nip59?.enabled ?? false;
-                    const nip59Wrapper = new nip59_claim_wrapper_1.NIP59ClaimWrapper({
-                        nip59Enabled,
-                        logger: this._logger,
-                    });
-                    const nodeSecp256k1PrivKey = treasuryPrivateKey
-                        ? (0, utils_1.hexToBytes)(treasuryPrivateKey.replace(/^0x/, ''))
-                        : undefined;
-                    const peerIdToNip59PubKey = new Map();
-                    for (const peer of this._config.peers) {
-                        if (peer.nip59PublicKey) {
-                            peerIdToNip59PubKey.set(peer.id, (0, utils_1.hexToBytes)(peer.nip59PublicKey));
-                        }
-                    }
-                    if (nip59Enabled) {
-                        this._logger.info({ event: 'nip59_enabled', peerCount: peerIdToNip59PubKey.size }, 'NIP-59 transport privacy enabled for claim wrapping');
-                    }
-                    this._settlementExecutor = new settlement_executor_1.SettlementExecutor({
-                        nodeId: this._config.nodeId,
-                        defaultSettlementTimeout,
-                        initialDepositMultiplier,
-                        minDepositThreshold: 0.5,
-                        maxRetries: 3,
-                        retryDelayMs: 5000,
-                        tokenAddressMap,
-                        peerIdToAddressMap,
-                        peerIdToChainMap,
-                    }, accountManager, chainRegistry, settlementMonitor, this._logger);
-                    this._settlementExecutor.start();
-                    this._logger.info({ event: 'settlement_executor_started' }, 'Automatic settlement execution enabled');
-                    settlementMonitor.start();
-                    this._logger.info({
-                        event: 'settlement_monitor_started',
-                        threshold: settlementThreshold.toString(),
-                        peerCount: peerIds.length,
-                    }, 'Event-driven settlement monitoring started');
-                    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._settlementExecutor.setChannelManager(this._channelManager);
-                    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(chainRegistry, this._channelManager, claimDb, this._logger, this._config.nodeId, peerIdToChainMap, nip59Wrapper, nodeSecp256k1PrivKey, peerIdToNip59PubKey);
-                            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;
-                        }
-                    }
-                    const inboundClaimValidator = new inbound_claim_validator_1.InboundClaimValidator(this._paymentChannelSDK, this._config.nodeId, this._logger, this._channelManager ?? undefined, nip59Wrapper, nodeSecp256k1PrivKey);
-                    this._btpServer.setInboundClaimValidator((protocolData, ilpPacket, peerId) => inboundClaimValidator.validate(protocolData, ilpPacket, peerId));
-                    this._logger.info({ event: 'inbound_claim_validator_enabled' }, 'Inbound claim validator wired to BTP server');
-                    if (this._paymentChannelSDK) {
-                        try {
-                            const BetterSqlite3Module = await (0, optional_require_1.requireOptional)('better-sqlite3', 'claim receiver persistence');
-                            const BetterSqlite3 = BetterSqlite3Module.default;
-                            const receivedClaimDbPath = `./data/received-claims-${this._config.nodeId}.db`;
-                            const receivedClaimDb = new BetterSqlite3(receivedClaimDbPath);
-                            (0, claim_receiver_db_schema_1.initializeClaimReceiverSchema)(receivedClaimDb);
-                            const claimReceiver = new claim_receiver_1.ClaimReceiver(receivedClaimDb, chainRegistry, this._logger, this._channelManager ?? undefined, peerIdToAddressMap, nip59Wrapper, nodeSecp256k1PrivKey);
-                            claimReceiver.registerWithBTPServer(this._btpServer);
-                            if (this._settlementMonitor) {
-                                this._settlementMonitor.setClaimReceiver(claimReceiver);
-                                this._settlementMonitor.stop();
-                                this._settlementMonitor.start();
-                            }
-                            this._settlementExecutor?.setClaimReceiver(claimReceiver);
-                            this._logger.info({ event: 'claim_receiver_enabled' }, 'ClaimReceiver wired to BTP server and SettlementMonitor');
-                        }
-                        catch (error) {
-                            const errorMessage = error instanceof Error ? error.message : String(error);
-                            this._logger.error({ event: 'claim_receiver_init_failed', error: errorMessage }, 'Failed to initialize ClaimReceiver');
-                        }
-                    }
-                    if (accountManager) {
-                        const settlementConfig = {
-                            connectorFeePercentage: this._config.settlement?.connectorFeePercentage ?? 0.1,
-                            enableSettlement: true,
-                            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,
-                    metricsRegistry: this._ilpMetrics,
-                });
-                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 peerConfig = this._config.peers.find((p) => p.id === peerId);
-                            const peerChain = peerConfig?.chain;
-                            const channelId = await this._channelManager.ensureChannelExists(peerId, tokenId, peerChain ? { chain: peerChain } : undefined);
-                            this._logger.info({ event: 'payment_channel_ready', peerId, channelId, chain: peerChain }, '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');
-            if (this._transportHealthInterval) {
-                clearInterval(this._transportHealthInterval);
-                this._transportHealthInterval = null;
-            }
-            if (this._transportProvider) {
-                this._transportProviderReady = false;
-                try {
-                    await this._transportProvider.stop();
-                }
-                catch (stopErr) {
-                    const stopMsg = stopErr instanceof Error ? stopErr.message : String(stopErr);
-                    this._logger.warn({ event: 'transport_rollback_stop_failed', error: stopMsg }, 'Transport provider stop() failed during start() rollback; continuing');
-                }
-                finally {
-                    this._transportProvider = null;
-                    this._transportType = null;
-                }
-            }
-            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();
-            if (this._transportHealthInterval) {
-                clearInterval(this._transportHealthInterval);
-                this._transportHealthInterval = null;
-            }
-            if (this._transportProvider) {
-                this._transportProviderReady = false;
-                try {
-                    await this._transportProvider.stop();
-                }
-                finally {
-                    this._transportProvider = null;
-                    this._transportType = null;
-                }
-            }
-            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,
-        };
-        if (this._transportProviderReady && this._transportProvider && this._transportType) {
-            healthStatus.transport = {
-                type: this._transportType,
-                healthy: this._transportType === 'direct' ? true : this._lastTransportHealthy,
-            };
-        }
-        return healthStatus;
-    }
-    get routingTable() {
-        return this._routingTable;
-    }
-    get btpClientManager() {
-        return this._btpClientManager;
-    }
-    get transportProvider() {
-        return this._transportProviderReady ? this._transportProvider : null;
-    }
-    _createTransportProvider(cfg) {
-        if (cfg === undefined || cfg.type === 'direct') {
-            const externalUrl = `ws://localhost:${this._config.btpServerPort}`;
-            this._logger.debug({ event: 'direct_transport_external_url_synthesized', externalUrl }, 'DirectTransportProvider externalUrl synthesized from btpServerPort (local placeholder)');
-            return new transport_1.DirectTransportProvider(externalUrl);
-        }
-        if (cfg.type === 'socks5') {
-            let managedClient;
-            let externalUrl = cfg.externalUrl;
-            if (cfg.managed === true) {
-                let cachedFactory;
-                let prewarmError;
-                const prewarmPromise = (0, transport_1.createDefaultAnonFactory)().then((f) => {
-                    cachedFactory = f;
-                }, (err) => {
-                    prewarmError = err;
-                });
-                const anonFactory = (opts) => {
-                    if (cachedFactory) {
-                        return cachedFactory(opts);
-                    }
-                    if (prewarmError) {
-                        if (prewarmError.code === 'MODULE_NOT_FOUND') {
-                            throw prewarmError;
-                        }
-                        throw new Error(`Failed to load optional dependency "@anyone-protocol/anyone-client": ` +
-                            `${prewarmError.message ?? String(prewarmError)}`, { cause: prewarmError });
-                    }
-                    try {
-                        const pkg = '@anyone-protocol/anyone-client';
-                        const mod = require(pkg);
-                        const AnonCtor = mod?.Anon ?? mod?.default?.Anon ?? mod?.default;
-                        if (typeof AnonCtor !== 'function') {
-                            throw new Error('@anyone-protocol/anyone-client did not export an `Anon` constructor');
-                        }
-                        cachedFactory = (o) => new AnonCtor(o);
-                        return cachedFactory(opts);
-                    }
-                    catch (err) {
-                        const cause = err;
-                        if (cause?.code === 'MODULE_NOT_FOUND') {
-                            throw cause;
-                        }
-                        if (cause?.code === 'ERR_REQUIRE_ESM') {
-                            throw new Error(`@anyone-protocol/anyone-client is an ESM-only package; ` +
-                                `the async lazy-import pre-warm had not completed when the factory ` +
-                                `was invoked. This is a timing bug — please file an issue.`, { cause });
-                        }
-                        throw new Error(`Failed to load optional dependency "@anyone-protocol/anyone-client": ` +
-                            `${cause?.message ?? String(err)}`, { cause });
-                    }
-                };
-                void prewarmPromise;
-                managedClient = new transport_1.ManagedAnonClient({
-                    socksProxy: cfg.socksProxy,
-                    hiddenServiceDir: cfg.managedOptions?.hiddenServiceDir,
-                    hiddenServicePort: cfg.managedOptions?.hiddenServicePort,
-                    binaryPath: cfg.managedOptions?.binaryPath,
-                    startupTimeoutMs: cfg.managedOptions?.startupTimeoutMs,
-                    stopTimeoutMs: cfg.managedOptions?.stopTimeoutMs,
-                    logger: this._logger,
-                    anonFactory,
-                });
-                if (externalUrl === 'auto') {
-                    externalUrl = 'wss://pending.invalid/btp';
-                }
-            }
-            else if (externalUrl === 'auto') {
-                throw new Error('_createTransportProvider: transport.externalUrl "auto" requires managed: true');
-            }
-            let resolveExternalUrlOnStart;
-            if (cfg.externalUrl === 'auto') {
-                const hsDir = cfg.managedOptions?.hiddenServiceDir;
-                if (!hsDir) {
-                    throw new Error('_createTransportProvider: transport.externalUrl "auto" requires managedOptions.hiddenServiceDir');
-                }
-                const hostnameReadDeadlineMs = cfg.managedOptions?.startupTimeoutMs ?? 30_000;
-                const HIDDEN_SERVICE_HOSTNAME_RE = /^[a-z2-7]{16}(?:[a-z2-7]{40})?\.(?:anon|onion)$/;
-                resolveExternalUrlOnStart = async () => {
-                    const hostnameFile = nodePath.join(hsDir, 'hostname');
-                    const deadline = Date.now() + hostnameReadDeadlineMs;
-                    let lastErr;
-                    while (Date.now() < deadline) {
-                        try {
-                            const raw = await fs_1.promises.readFile(hostnameFile, 'utf8');
-                            const firstLine = raw.split(/\r?\n/, 1)[0]?.trim() ?? '';
-                            const hostname = firstLine;
-                            if (!hostname) {
-                                lastErr = new Error('hostname file is empty');
-                            }
-                            else if (!HIDDEN_SERVICE_HOSTNAME_RE.test(hostname)) {
-                                lastErr = new Error(`hostname file contents did not match the expected hidden service format ` +
-                                    `(length=${hostname.length}); ignoring and retrying`);
-                            }
-                            else {
-                                return `wss://${hostname}/btp`;
-                            }
-                        }
-                        catch (err) {
-                            lastErr = err;
-                        }
-                        await new Promise((r) => setTimeout(r, 250));
-                    }
-                    const reason = lastErr instanceof Error ? lastErr.message : String(lastErr ?? 'unknown');
-                    throw new Error(`hidden service hostname file "${hostnameFile}" did not become readable ` +
-                        `within ${hostnameReadDeadlineMs}ms (last error: ${reason})`);
-                };
-            }
-            return new transport_1.SocksTransportProvider({
-                socksProxy: cfg.socksProxy,
-                externalUrl,
-                logger: this._logger,
-                managedClient,
-                resolveExternalUrlOnStart,
-            });
-        }
-        const _exhaustive = cfg;
-        throw new Error(`Unsupported transport type: ${JSON.stringify(_exhaustive)} ` +
-            '(Story 35.4 _createTransportProvider exhaustiveness guard)');
-    }
-    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 evmProvider = this._config.chainProviders?.find((p) => p.chainType === 'evm');
-        const snapshotPath = evmProvider?.settlementOptions?.ledgerSnapshotPath ?? './data/ledger-snapshot.json';
-        const persistIntervalMs = evmProvider?.settlementOptions?.ledgerPersistIntervalMs ?? 30000;
-        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)');
-        }
-        const PLAIN_WS_PREFIX = 'ws' + '://';
-        const SECURE_WS_PREFIX = 'wss' + '://';
-        if (!config.url.startsWith(PLAIN_WS_PREFIX) && !config.url.startsWith(SECURE_WS_PREFIX)) {
-            throw new Error(`URL must start with ${PLAIN_WS_PREFIX} or ${SECURE_WS_PREFIX}`);
-        }
-        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._ilpMetrics.registerPeer(config.id);
-            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._ilpMetrics.unregisterPeer(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('No EVM chain provider configured -- openChannel requires a chainProviders entry with chainType: "evm"');
-        }
-        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_2.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('No EVM chain provider configured -- openChannel requires a chainProviders entry with chainType: "evm"');
-        }
-        const metadata = this._channelManager.getChannelById(channelId);
-        if (!metadata) {
-            throw new Error(`Channel not found: ${channelId}`);
-        }
-        return {
-            channelId: metadata.channelId,
-            status: (0, types_2.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