@toon-protocol/connector 3.20.0 → 3.28.6

package/dist/core/connector-node.js

@@ -3,7 +3,6 @@ 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 relation_route_validator_1 = require("../routing/relation-route-validator");
 const btp_client_manager_1 = require("../btp/btp-client-manager");
@@ -11,7 +10,10 @@ 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 route_upstream_registry_1 = require("./route-upstream-registry");
+const http_proxy_handler_1 = require("./handlers/http-proxy-handler");
 const transport_1 = require("../transport");
+const http_peer_transport_1 = require("../transport/http-peer-transport");
 const payment_handler_1 = require("./payment-handler");
 const types_2 = require("../settlement/types");
 const admin_api_1 = require("../http/admin-api");
@@ -42,14 +44,20 @@ const solana_payment_channel_provider_1 = require("../settlement/provider/solana
 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 mnemonic_keys_1 = require("../wallet/mnemonic-keys");
+const self_announce_service_1 = require("../discovery/self-announce-service");
+const self_announce_publish_1 = require("../discovery/self-announce-publish");
 const utils_1 = require("@noble/hashes/utils");
+const SELF_ANNOUNCE_PREPARE_TIMEOUT_MS = 30_000;
 const dns_1 = require("dns");
 const package_json_1 = tslib_1.__importDefault(require("../../package.json"));
 class ConnectorNode {
     _config;
     _logger;
     _routingTable;
+    _routeTerminationRegistry;
     _btpClientManager;
+    _httpPeerClientManager;
     _packetHandler;
     _btpServer;
     _healthServer;
@@ -73,17 +81,21 @@ class ConnectorNode {
     _btpServerStarted = false;
     _defaultSettlementTokenId = 'M2M';
     _transportProvider = null;
-    _managedAnonClient = null;
     _transportProviderReady = false;
     _transportType = null;
     _lastTransportHealthy = true;
     _transportHealthInterval = null;
     _transportHealthIntervalMs;
+    _mnemonicOverride;
+    _mnemonicAccountIndex;
+    _selfAnnounceService = null;
     get defaultSettlementTokenId() {
         return this._defaultSettlementTokenId;
     }
     constructor(config, logger, opts) {
         this._transportHealthIntervalMs = opts?.transportHealthIntervalMs ?? 30000;
+        this._mnemonicOverride = opts?.mnemonic;
+        this._mnemonicAccountIndex = opts?.mnemonicAccountIndex;
         let resolvedConfig;
         try {
             if (typeof config === 'string') {
@@ -115,22 +127,22 @@ class ConnectorNode {
             priority: route.priority,
         }));
         this._routingTable = new routing_table_1.RoutingTable(routingTableEntries, logger.child({ component: 'RoutingTable' }));
+        this._routeTerminationRegistry = new route_upstream_registry_1.RouteTerminationRegistry(resolvedConfig.routes.map((route) => ({
+            prefix: route.prefix,
+            termination: (0, types_1.toRouteTermination)(route),
+        })));
         this._btpClientManager = new btp_client_manager_1.BTPClientManager(resolvedConfig.nodeId, logger.child({ component: 'BTPClientManager' }));
-        this._btpClientManager.setAgentFactory((peer) => {
-            const effective = peer.transport ?? this._transportType ?? 'direct';
-            if (effective === 'socks5' &&
-                (!this._transportProvider || this._transportType !== 'socks5')) {
-                this._logger.error({
-                    event: 'btp_agent_factory_invariant_violation',
-                    peerId: peer.id,
-                    requestedTransport: 'socks5',
-                    connectorTransport: this._transportType,
-                }, 'Peer requested SOCKS5 transport but connector has no SOCKS5 provider — refusing to fall through to direct dial');
-                throw new Error('SOCKS5 transport requested for peer but no SOCKS5 provider configured');
-            }
-            return effective === 'socks5' ? this._transportProvider.createAgent(peer.url) : undefined;
-        });
+        this._btpClientManager.setAgentFactory(() => undefined);
+        const httpEgressTransport = {
+            createAgent: () => undefined,
+            getExternalUrl: () => this._transportProvider?.getExternalUrl() ?? '',
+            start: async () => { },
+            stop: async () => { },
+            healthCheck: async () => this._transportProvider?.healthCheck() ?? true,
+        };
+        this._httpPeerClientManager = new http_peer_transport_1.HttpPeerClientManager(resolvedConfig.nodeId, logger.child({ component: 'HttpPeerClientManager' }), httpEgressTransport);
         this._packetHandler = new packet_handler_1.PacketHandler(this._routingTable, this._btpClientManager, resolvedConfig.nodeId, logger.child({ component: 'PacketHandler' }));
+        this._packetHandler.setHttpEgress(this._httpPeerClientManager);
         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';
@@ -146,11 +158,35 @@ class ConnectorNode {
             };
             this._packetHandler.setLocalDelivery(localDeliveryConfig);
         }
+        if (this._routeTerminationRegistry.size > 0) {
+            if (localDeliveryEnabled) {
+                this._logger.warn({
+                    event: 'route_termination_proxy_skipped',
+                    terminatedRoutes: this._routeTerminationRegistry.size,
+                    reason: 'global_local_delivery_handler_configured',
+                }, 'Terminated routes are configured but a global localDelivery.handlerUrl ' +
+                    'is also enabled; preserving the existing handlerUrl path and NOT ' +
+                    'installing the per-route HTTP proxy (requires PacketHandler fall-through — human decision)');
+            }
+            else {
+                const proxy = new http_proxy_handler_1.HttpProxyHandler({
+                    upstreamResolver: this._routeTerminationRegistry.resolveUpstream,
+                    logger: this._logger,
+                });
+                this.setLocalDeliveryHandler(proxy.handler);
+                this._logger.info({
+                    event: 'route_termination_proxy_installed',
+                    terminatedRoutes: this._routeTerminationRegistry.size,
+                    prefixes: this._routeTerminationRegistry.prefixes(),
+                }, 'HttpProxyHandler installed as local-delivery handler for terminated routes');
+            }
+        }
         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.setPeerRelation(peer.id, peer.relation ?? 'peer');
+            this._packetHandler.setPeerProtocol(peer.id, peer.peerProtocol ?? 'btp');
         }
         this._packetHandler.setIlpMetrics(this._ilpMetrics);
         this._healthServer = new health_server_1.HealthServer(logger.child({ component: 'HealthServer' }), this, {
@@ -234,6 +270,118 @@ class ConnectorNode {
             };
         }
     }
+    _applyMnemonicSigningMode() {
+        const mnemonic = this._mnemonicOverride ?? process.env.TOON_MNEMONIC;
+        if (!mnemonic) {
+            return;
+        }
+        const providers = this._config.chainProviders;
+        if (!providers || providers.length === 0) {
+            this._logger.warn({ event: 'mnemonic_mode_no_chain_providers' }, 'TOON_MNEMONIC is set but no chainProviders are configured; no settlement keys to derive');
+            return;
+        }
+        const keys = (0, mnemonic_keys_1.deriveChainKeysFromMnemonic)(mnemonic, this._mnemonicAccountIndex ?? 0);
+        let evmInjected = false;
+        let solanaInjected = false;
+        let minaInjected = false;
+        for (const provider of providers) {
+            switch (provider.chainType) {
+                case 'evm':
+                    provider.keyId = keys.evm.privateKey;
+                    evmInjected = true;
+                    break;
+                case 'solana':
+                    provider.keyId = keys.solana.privateKey;
+                    solanaInjected = true;
+                    break;
+                case 'mina':
+                    provider.keyId = keys.mina.privateKey;
+                    minaInjected = true;
+                    break;
+            }
+        }
+        this._logger.info({
+            event: 'mnemonic_signing_mode_enabled',
+            evm: evmInjected,
+            solana: solanaInjected,
+            mina: minaInjected,
+            evmAddress: evmInjected ? keys.evm.address : undefined,
+            solanaAddress: solanaInjected ? keys.solana.address : undefined,
+        }, 'Mnemonic signing mode active: derived per-chain settlement keys from TOON_MNEMONIC');
+    }
+    _resolveNostrSecretKey() {
+        const evmProvider = this._config.chainProviders?.find((p) => p.chainType === 'evm');
+        const keyId = evmProvider?.keyId;
+        if (keyId && /^(0x)?[0-9a-fA-F]{64}$/.test(keyId)) {
+            return (0, utils_1.hexToBytes)(keyId.replace(/^0x/, ''));
+        }
+        const mnemonic = this._mnemonicOverride ?? process.env.TOON_MNEMONIC;
+        if (mnemonic) {
+            try {
+                const keys = (0, mnemonic_keys_1.deriveChainKeysFromMnemonic)(mnemonic, this._mnemonicAccountIndex ?? 0);
+                return (0, utils_1.hexToBytes)(keys.evm.privateKey.replace(/^0x/, ''));
+            }
+            catch (err) {
+                this._logger.warn({
+                    event: 'self_announce_key_derive_failed',
+                    err: err instanceof Error ? err.message : String(err),
+                }, 'Failed to derive Nostr key for self-announce');
+                return null;
+            }
+        }
+        return null;
+    }
+    _startSelfAnnounce() {
+        const selfAnnounce = this._config.selfAnnounce;
+        if (!selfAnnounce?.enabled) {
+            return;
+        }
+        const secretKey = this._resolveNostrSecretKey();
+        if (!secretKey) {
+            this._logger.warn({ event: 'self_announce_no_identity' }, 'selfAnnounce.enabled but no Nostr signing identity (set TOON_MNEMONIC or an EVM keyId); not announcing');
+            return;
+        }
+        try {
+            this._selfAnnounceService = new self_announce_service_1.SelfAnnounceService({
+                config: this._config,
+                selfAnnounce,
+                secretKey,
+                publish: (event) => this._publishAnnouncement(event),
+                logger: this._logger,
+            });
+            this._selfAnnounceService.start();
+        }
+        catch (err) {
+            this._selfAnnounceService = null;
+            this._logger.warn({
+                event: 'self_announce_start_failed',
+                err: err instanceof Error ? err.message : String(err),
+            }, 'Failed to start self-announce service; continuing without it');
+        }
+    }
+    async _publishAnnouncement(event) {
+        const selfAnnounce = this._config.selfAnnounce;
+        const announceTo = selfAnnounce.announceTo;
+        const isLocallyTerminated = this._routeTerminationRegistry.match(announceTo) !== undefined;
+        const plan = (0, self_announce_publish_1.planAnnouncePublish)({
+            announceTo,
+            event,
+            isLocallyTerminated,
+            ...(selfAnnounce.announcePrice ? { remotePriceAtomic: selfAnnounce.announcePrice } : {}),
+        });
+        const expiresAt = new Date(Date.now() + SELF_ANNOUNCE_PREPARE_TIMEOUT_MS);
+        const response = await this.sendPacket({
+            destination: plan.destination,
+            amount: plan.amount,
+            expiresAt,
+            data: plan.data,
+        });
+        if (response.type === shared_1.PacketType.FULFILL) {
+            return { mode: plan.mode, ok: true };
+        }
+        const reject = response;
+        return { mode: plan.mode, ok: false, detail: `${reject.code}: ${reject.message ?? ''}`.trim() };
+    }
     async start() {
         this._logger.info({
             event: 'connector_starting',
@@ -243,6 +391,7 @@ class ConnectorNode {
         }, 'Starting connector node');
         try {
             (0, types_1.validateChainProviders)(this._config, this._logger);
+            this._applyMnemonicSigningMode();
             const createdProvider = this._createTransportProvider(this._config.transport);
             this._transportProvider = createdProvider;
             this._transportType =
@@ -716,6 +865,15 @@ class ConnectorNode {
             else {
                 this._logger.info({ event: 'payment_channels_disabled' }, 'Payment channel infrastructure disabled (missing configuration)');
             }
+            const terminationChainIds = {};
+            for (const cp of this._config.chainProviders ?? []) {
+                if (cp.chainType === 'evm' && !terminationChainIds.evm) {
+                    terminationChainIds.evm = cp.chainId;
+                }
+                else if (cp.chainType === 'solana' && !terminationChainIds.solana) {
+                    terminationChainIds.solana = cp.chainId;
+                }
+            }
             const ilpHttpAdapter = new ilp_http_adapter_1.IlpHttpAdapter({
                 logger: this._logger,
                 nodeId: this._config.nodeId,
@@ -724,6 +882,8 @@ class ConnectorNode {
                 recordClaim: this._claimReceiver
                     ? (peerId, protocolData) => this._claimReceiver.ingestProtocolData(peerId, protocolData)
                     : undefined,
+                resolveTermination: (prepare) => this._routeTerminationRegistry.match(prepare.destination) ?? null,
+                terminationChainIds,
             });
             this._btpServer.setIlpHttpHandler((req, res) => ilpHttpAdapter.handle(req, res));
             await this._btpServer.start(this._config.btpServerPort);
@@ -763,11 +923,12 @@ class ConnectorNode {
                     packetSender: (params) => this.sendPacket(params),
                     isReady: () => this._btpServerStarted,
                     metricsRegistry: this._ilpMetrics,
-                    managedAnonClient: this._managedAnonClient ?? undefined,
-                    transportType: this._transportType ?? 'direct',
                     setPeerRelation: (peerId, relation) => this._packetHandler.setPeerRelation(peerId, relation),
                     getPeerRelation: (peerId) => this._packetHandler.getPeerRelation(peerId),
                     registryStore: this._registryStore ?? undefined,
+                    httpPeerEgress: this._httpPeerClientManager,
+                    setPeerProtocol: (peerId, protocol) => this._packetHandler.setPeerProtocol(peerId, protocol),
+                    routeTerminationRegistry: this._routeTerminationRegistry,
                 });
                 await this._adminServer.start();
                 this._logger.info({
@@ -782,6 +943,17 @@ class ConnectorNode {
             }
             const peerConnections = [];
             for (const peerConfig of this._config.peers) {
+                if (peerConfig.peerProtocol === 'ilp-http') {
+                    const httpPeer = {
+                        id: peerConfig.id,
+                        httpUrl: peerConfig.httpUrl,
+                        httpPath: peerConfig.httpPath,
+                        authToken: peerConfig.authToken,
+                        httpTimeoutMs: peerConfig.httpTimeoutMs,
+                    };
+                    peerConnections.push(this._httpPeerClientManager.addPeer(httpPeer));
+                    continue;
+                }
                 const peer = {
                     id: peerConfig.id,
                     url: peerConfig.url,
@@ -829,6 +1001,7 @@ class ConnectorNode {
                 await Promise.allSettled(channelCreationPromises);
                 this._logger.info({ event: 'payment_channels_initialized' }, 'Payment channel creation completed');
             }
+            this._startSelfAnnounce();
             this._updateHealthStatus();
             this._logger.info({
                 event: 'connector_ready',
@@ -877,6 +1050,10 @@ class ConnectorNode {
             nodeId: this._config.nodeId,
         }, 'Stopping connector node');
         try {
+            if (this._selfAnnounceService) {
+                this._selfAnnounceService.stop();
+                this._selfAnnounceService = null;
+            }
             if (this._settlementMonitor) {
                 await this._settlementMonitor.stop();
                 this._logger.info({ event: 'settlement_monitor_stopped' }, 'Settlement monitor stopped');
@@ -987,133 +1164,19 @@ class ConnectorNode {
     get routingTable() {
         return this._routingTable;
     }
+    get routeTerminationRegistry() {
+        return this._routeTerminationRegistry;
+    }
     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,
-                    controlPort: cfg.managedOptions?.controlPort,
-                    binaryPath: cfg.managedOptions?.binaryPath,
-                    startupTimeoutMs: cfg.managedOptions?.startupTimeoutMs,
-                    stopTimeoutMs: cfg.managedOptions?.stopTimeoutMs,
-                    logger: this._logger,
-                    anonFactory,
-                });
-                this._managedAnonClient = managedClient;
-                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)');
+    _createTransportProvider(_cfg) {
+        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);
     }
     get paymentChannelSDK() {
         return this._paymentChannelSDK;
@@ -1226,29 +1289,38 @@ class ConnectorNode {
         if (!this._btpServerStarted) {
             throw new config_loader_1.ConnectorNotStartedError('Connector is not started. Call start() before registerPeer().');
         }
+        const peerProtocol = config.peerProtocol ?? 'btp';
+        if (peerProtocol !== 'btp' && peerProtocol !== 'ilp-http') {
+            throw new Error(`Invalid peerProtocol: must be 'btp' or 'ilp-http' (got '${peerProtocol}')`);
+        }
         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 (peerProtocol === 'ilp-http') {
+            if (!config.httpUrl || typeof config.httpUrl !== 'string') {
+                throw new Error("peerProtocol 'ilp-http' requires httpUrl (http(s) endpoint)");
+            }
+            if (!/^https?:\/\/.+/.test(config.httpUrl)) {
+                throw new Error('httpUrl must start with http:// or https://');
+            }
         }
-        if (config.transport !== undefined &&
-            config.transport !== 'direct' &&
-            config.transport !== 'socks5') {
-            throw new Error(`Invalid transport: must be 'direct' or 'socks5' (got '${config.transport}')`);
+        else {
+            if (!config.url || typeof config.url !== 'string') {
+                throw new Error('Missing or invalid peer url');
+            }
+            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.transport === 'socks5' && this._transportType !== 'socks5') {
-            throw new Error("transport: 'socks5' requires connector-level transport.type 'socks5'");
+        if (config.transport !== undefined && config.transport !== 'direct') {
+            throw new Error(`Invalid transport: must be 'direct' (got '${String(config.transport)}')`);
         }
         if (config.relation !== undefined &&
             config.relation !== 'parent' &&
@@ -1286,33 +1358,53 @@ class ConnectorNode {
                 throw new Error(relationValidation.error);
             }
         }
-        const existingPeers = this._btpClientManager.getPeerIds();
+        const existingPeers = peerProtocol === 'ilp-http'
+            ? this._httpPeerClientManager.getPeerIds()
+            : 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(),
-                transport: config.transport,
-            };
-            await this._btpClientManager.addPeer(peer);
-            this._ilpMetrics.registerPeer(config.id);
-            this._logger.info({
-                event: 'peer_registered',
-                peerId: config.id,
-                url: config.url,
-                transport: config.transport ?? null,
-            }, `Registered peer: ${config.id}`);
+            if (peerProtocol === 'ilp-http') {
+                const httpPeer = {
+                    id: config.id,
+                    httpUrl: config.httpUrl,
+                    httpPath: config.httpPath,
+                    authToken: config.authToken,
+                    httpTimeoutMs: config.httpTimeoutMs,
+                };
+                await this._httpPeerClientManager.addPeer(httpPeer);
+                this._ilpMetrics.registerPeer(config.id);
+                this._logger.info({ event: 'peer_registered', peerId: config.id, peerProtocol, httpUrl: config.httpUrl }, `Registered ILP-over-HTTP peer: ${config.id}`);
+            }
+            else {
+                const peer = {
+                    id: config.id,
+                    url: config.url,
+                    authToken: config.authToken,
+                    connected: false,
+                    lastSeen: new Date(),
+                    transport: config.transport,
+                };
+                await this._btpClientManager.addPeer(peer);
+                this._ilpMetrics.registerPeer(config.id);
+                this._logger.info({
+                    event: 'peer_registered',
+                    peerId: config.id,
+                    url: config.url,
+                    transport: config.transport ?? null,
+                }, `Registered peer: ${config.id}`);
+            }
         }
         else {
             this._logger.info({
                 event: 'peer_reregistered',
                 peerId: config.id,
-                transport: this._btpClientManager.getPeerTransport(config.id) ?? null,
+                peerProtocol,
+                transport: peerProtocol === 'ilp-http'
+                    ? null
+                    : (this._btpClientManager.getPeerTransport(config.id) ?? null),
             }, `Re-registering peer: ${config.id}`);
         }
+        this._packetHandler.setPeerProtocol(config.id, peerProtocol);
         if (effectiveRoutes) {
             for (const route of effectiveRoutes) {
                 this._routingTable.addRoute(route.prefix, config.id, route.priority ?? 0);
@@ -1334,7 +1426,9 @@ class ConnectorNode {
         });
         const routes = this._routingTable.getAllRoutes();
         const peerRoutes = routes.filter((r) => r.nextHop === config.id);
-        const connected = this._btpClientManager.isConnected(config.id);
+        const connected = peerProtocol === 'ilp-http'
+            ? this._httpPeerClientManager.isConnected(config.id)
+            : this._btpClientManager.isConnected(config.id);
         const peerInfo = {
             id: config.id,
             connected,
@@ -1498,11 +1592,13 @@ class ConnectorNode {
             });
         }
         for (const route of this._config.routes) {
+            const termination = (0, types_1.toRouteTermination)(route);
             this._registryStore.saveRoute({
                 prefix: route.prefix,
                 nextHop: route.nextHop,
                 priority: route.priority ?? 0,
                 source: 'config',
+                terminationJson: termination ? JSON.stringify(termination) : undefined,
             });
         }
         const existingPeerIds = new Set(this._btpClientManager.getPeerIds());
@@ -1544,6 +1640,18 @@ class ConnectorNode {
                     nextHop: route.nextHop,
                     priority: route.priority,
                 });
+                if (route.terminationJson) {
+                    try {
+                        this._routeTerminationRegistry.set(route.prefix, JSON.parse(route.terminationJson));
+                    }
+                    catch (parseError) {
+                        this._logger.warn({
+                            event: 'registry_route_termination_replay_failed',
+                            prefix: route.prefix,
+                            error: parseError instanceof Error ? parseError.message : String(parseError),
+                        }, `Failed to restore persisted route termination: ${route.prefix}`);
+                    }
+                }
                 replayedRoutes++;
             }
             catch (error) {