@olane/o-node 0.7.43 → 0.7.45

package/dist/src/connection/o-node-connection.manager.d.ts

@@ -7,27 +7,35 @@ export declare class oNodeConnectionManager extends oConnectionManager {
     protected p2pNode: Libp2p;
     private defaultReadTimeoutMs?;
     private defaultDrainTimeoutMs?;
-    private connectionsByTransportKey;
-    private pendingDialsByTransportKey;
+    private connectionsByAddress;
+    private pendingDialsByAddress;
     constructor(config: oNodeConnectionManagerConfig);
     /**
      * Set up listeners to maintain connection cache state
      */
     private setupConnectionListeners;
     /**
-     * Build a stable cache key from the libp2p transports on an address.
+     * Build a stable cache key from an address.
      *
-     * We intentionally key the cache by transports (multiaddrs) instead of peer IDs
-     * to avoid ambiguity when multiple peers may share a peer ID or when addresses
-     * change but the libp2p transports are the true dial targets.
+     * We key the cache by address value (e.g., "o://my-tool") to maintain
+     * a simple one-to-one mapping between addresses and connections.
      */
-    private getTransportKeyFromAddress;
+    private getAddressKey;
     /**
      * Extract peer ID string from an address
      * @param address - The address to extract peer ID from
      * @returns The peer ID string or null if not found
      */
     private getPeerIdFromAddress;
+    /**
+     * Select the best connection from an array of connections.
+     * Prioritizes connections with active streams, then by direction based on context.
+     *
+     * @param connections - Array of connections to choose from
+     * @param reuseContext - If true, prefer inbound connections; otherwise prefer outbound
+     * @returns The best connection or null if none are suitable
+     */
+    private selectBestConnection;
     getOrCreateConnection(nextHopAddress: oAddress, address: oAddress): Promise<Connection>;
     private performDial;
     answer(config: oConnectionConfig & {
@@ -57,11 +65,13 @@ export declare class oNodeConnectionManager extends oConnectionManager {
      * @returns Object containing cache statistics
      */
     getCacheStats(): {
-        cachedConnections: number;
+        cachedAddresses: number;
+        totalCachedConnections: number;
         pendingDials: number;
         connectionsByPeer: Array<{
             peerId: string;
             status: string;
+            addressKey: string;
         }>;
     };
     /**

package/dist/src/connection/o-node-connection.manager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"o-node-connection.manager.d.ts","sourceRoot":"","sources":["../../../src/connection/o-node-connection.manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAChF,OAAO,EAAE,MAAM,EAAE,UAAU,EAAU,MAAM,iBAAiB,CAAC;AAC7D,OAAO,EAAE,4BAA4B,EAAE,MAAM,kDAAkD,CAAC;AAEhG,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAGzD,qBAAa,sBAAuB,SAAQ,kBAAkB;IAQhD,QAAQ,CAAC,MAAM,EAAE,4BAA4B;IAPzD,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC;IAC1B,OAAO,CAAC,oBAAoB,CAAC,CAAS;IACtC,OAAO,CAAC,qBAAqB,CAAC,CAAS;IACvC,OAAO,CAAC,yBAAyB,CAAsC;IACvE,OAAO,CAAC,0BAA0B,CACtB;gBAES,MAAM,EAAE,4BAA4B;IAWzD;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAsBhC;;;;;;OAMG;IACH,OAAO,CAAC,0BAA0B;IAiBlC;;;;OAIG;IACH,OAAO,CAAC,oBAAoB;IAatB,qBAAqB,CACzB,cAAc,EAAE,QAAQ,EACxB,OAAO,EAAE,QAAQ,GAChB,OAAO,CAAC,UAAU,CAAC;YA+DR,WAAW;IAwBnB,MAAM,CACV,MAAM,EAAE,iBAAiB,GAAG;QAAE,aAAa,EAAE,UAAU,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,GACzE,OAAO,CAAC,eAAe,CAAC;IAmC3B;;;;OAIG;IACG,OAAO,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,eAAe,CAAC;IA8BlE;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO;IAwCpC;;;;OAIG;IACH,yBAAyB,CAAC,OAAO,EAAE,QAAQ,GAAG,UAAU,GAAG,IAAI;IA+C/D;;;OAGG;IACH,aAAa,IAAI;QACf,iBAAiB,EAAE,MAAM,CAAC;QAC1B,YAAY,EAAE,MAAM,CAAC;QACrB,iBAAiB,EAAE,KAAK,CAAC;YAAE,MAAM,EAAE,MAAM,CAAC;YAAC,MAAM,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;KAC9D;IAaD;;;OAGG;IACH,uBAAuB,IAAI,MAAM;CAgBlC"}
+{"version":3,"file":"o-node-connection.manager.d.ts","sourceRoot":"","sources":["../../../src/connection/o-node-connection.manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AAChF,OAAO,EAAE,MAAM,EAAE,UAAU,EAAU,MAAM,iBAAiB,CAAC;AAC7D,OAAO,EAAE,4BAA4B,EAAE,MAAM,kDAAkD,CAAC;AAEhG,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAGzD,qBAAa,sBAAuB,SAAQ,kBAAkB;IAQhD,QAAQ,CAAC,MAAM,EAAE,4BAA4B;IAPzD,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC;IAC1B,OAAO,CAAC,oBAAoB,CAAC,CAAS;IACtC,OAAO,CAAC,qBAAqB,CAAC,CAAS;IACvC,OAAO,CAAC,oBAAoB,CAAwC;IACpE,OAAO,CAAC,qBAAqB,CACjB;gBAES,MAAM,EAAE,4BAA4B;IAWzD;;OAEG;IACH,OAAO,CAAC,wBAAwB;IA8BhC;;;;;OAKG;IACH,OAAO,CAAC,aAAa;IASrB;;;;OAIG;IACH,OAAO,CAAC,oBAAoB;IAa5B;;;;;;;OAOG;IACH,OAAO,CAAC,oBAAoB;IA6DtB,qBAAqB,CACzB,cAAc,EAAE,QAAQ,EACxB,OAAO,EAAE,QAAQ,GAChB,OAAO,CAAC,UAAU,CAAC;YA+ER,WAAW;IAwBnB,MAAM,CACV,MAAM,EAAE,iBAAiB,GAAG;QAAE,aAAa,EAAE,UAAU,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,GACzE,OAAO,CAAC,eAAe,CAAC;IAwC3B;;;;OAIG;IACG,OAAO,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,eAAe,CAAC;IA8BlE;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO;IA8CpC;;;;OAIG;IACH,yBAAyB,CAAC,OAAO,EAAE,QAAQ,GAAG,UAAU,GAAG,IAAI;IA0D/D;;;OAGG;IACH,aAAa,IAAI;QACf,eAAe,EAAE,MAAM,CAAC;QACxB,sBAAsB,EAAE,MAAM,CAAC;QAC/B,YAAY,EAAE,MAAM,CAAC;QACrB,iBAAiB,EAAE,KAAK,CAAC;YACvB,MAAM,EAAE,MAAM,CAAC;YACf,MAAM,EAAE,MAAM,CAAC;YACf,UAAU,EAAE,MAAM,CAAC;SACpB,CAAC,CAAC;KACJ;IAyBD;;;OAGG;IACH,uBAAuB,IAAI,MAAM;CAuBlC"}

package/dist/src/connection/o-node-connection.manager.js

@@ -4,8 +4,8 @@ export class oNodeConnectionManager extends oConnectionManager {
     constructor(config) {
         super(config);
         this.config = config;
-        this.connectionsByTransportKey = new Map();
-        this.pendingDialsByTransportKey = new Map();
+        this.connectionsByAddress = new Map();
+        this.pendingDialsByAddress = new Map();
         this.p2pNode = config.p2pNode;
         this.defaultReadTimeoutMs = config.defaultReadTimeoutMs;
         this.defaultDrainTimeoutMs = config.defaultDrainTimeoutMs;
@@ -22,34 +22,34 @@ export class oNodeConnectionManager extends oConnectionManager {
             if (!connection) {
                 return;
             }
-            for (const [transportKey, cachedConnection,] of this.connectionsByTransportKey.entries()) {
-                if (cachedConnection === connection) {
-                    this.logger.debug('Connection closed, removing from cache for transport key:', transportKey);
-                    this.connectionsByTransportKey.delete(transportKey);
+            for (const [addressKey, cachedConnections,] of this.connectionsByAddress.entries()) {
+                const index = cachedConnections.indexOf(connection);
+                if (index !== -1) {
+                    this.logger.debug('Connection closed, removing from cache for address:', addressKey);
+                    cachedConnections.splice(index, 1);
+                    // Remove the address key entirely if no connections remain
+                    if (cachedConnections.length === 0) {
+                        this.connectionsByAddress.delete(addressKey);
+                    }
+                    else {
+                        this.connectionsByAddress.set(addressKey, cachedConnections);
+                    }
                 }
             }
         });
     }
     /**
-     * Build a stable cache key from the libp2p transports on an address.
+     * Build a stable cache key from an address.
      *
-     * We intentionally key the cache by transports (multiaddrs) instead of peer IDs
-     * to avoid ambiguity when multiple peers may share a peer ID or when addresses
-     * change but the libp2p transports are the true dial targets.
+     * We key the cache by address value (e.g., "o://my-tool") to maintain
+     * a simple one-to-one mapping between addresses and connections.
      */
-    getTransportKeyFromAddress(address) {
+    getAddressKey(address) {
         try {
-            const nodeAddress = address;
-            const transports = nodeAddress.libp2pTransports;
-            if (!transports?.length) {
-                return null;
-            }
-            // Sort to ensure deterministic keys regardless of transport ordering.
-            const parts = transports.map((t) => t.toString()).sort();
-            return parts.join('|');
+            return address.value || null;
         }
         catch (error) {
-            this.logger.debug('Error extracting transport key from address:', error);
+            this.logger.debug('Error extracting address key from address:', error);
             return null;
         }
     }
@@ -71,60 +71,125 @@ export class oNodeConnectionManager extends oConnectionManager {
             return null;
         }
     }
+    /**
+     * Select the best connection from an array of connections.
+     * Prioritizes connections with active streams, then by direction based on context.
+     *
+     * @param connections - Array of connections to choose from
+     * @param reuseContext - If true, prefer inbound connections; otherwise prefer outbound
+     * @returns The best connection or null if none are suitable
+     */
+    selectBestConnection(connections, reuseContext = false) {
+        // Filter to only open connections
+        const openConnections = connections.filter((c) => c.status === 'open');
+        if (openConnections.length === 0) {
+            return null;
+        }
+        // Priority 1: Connections with active o-protocol streams
+        const connectionsWithStreams = openConnections
+            .map((conn) => ({
+            conn,
+            activeStreamCount: conn.streams.filter((s) => s.protocol.includes('/o/') &&
+                s.status === 'open' &&
+                s.writeStatus === 'writable' &&
+                s.remoteReadStatus === 'readable').length,
+        }))
+            .filter((item) => item.activeStreamCount > 0)
+            .sort((a, b) => b.activeStreamCount - a.activeStreamCount);
+        if (connectionsWithStreams.length > 0) {
+            this.logger.debug('Selected connection with active streams', {
+                streamCount: connectionsWithStreams[0].activeStreamCount,
+            });
+            return connectionsWithStreams[0].conn;
+        }
+        // Priority 2: Based on reuse context
+        if (reuseContext) {
+            // Prefer inbound connections
+            const inbound = openConnections.find((c) => c.direction === 'inbound' ||
+                !c.direction);
+            if (inbound) {
+                this.logger.debug('Selected inbound connection (reuse context)');
+                return inbound;
+            }
+        }
+        else {
+            // Prefer outbound connections
+            const outbound = openConnections.find((c) => c.direction === 'outbound');
+            if (outbound) {
+                this.logger.debug('Selected outbound connection (non-reuse context)');
+                return outbound;
+            }
+        }
+        // Priority 3: Return first open connection
+        this.logger.debug('Selected first available open connection');
+        return openConnections[0];
+    }
     async getOrCreateConnection(nextHopAddress, address) {
         if (!nextHopAddress) {
             throw new Error('Invalid address passed');
         }
-        // Build a transport-based cache key from the next hop address
-        const transportKey = this.getTransportKeyFromAddress(nextHopAddress);
-        if (!transportKey) {
-            throw new Error(`Unable to extract libp2p transports from address: ${nextHopAddress.toString()}`);
+        // Build an address-based cache key from the next hop address
+        const addressKey = this.getAddressKey(nextHopAddress);
+        if (!addressKey) {
+            throw new Error(`Unable to extract address key from address: ${nextHopAddress.toString()}`);
         }
-        // Check if we have a cached connection by transport key
-        const cachedConnection = this.connectionsByTransportKey.get(transportKey);
-        if (cachedConnection && cachedConnection.status === 'open') {
-            this.logger.debug('Reusing cached connection for transports:', nextHopAddress?.value);
-            return cachedConnection;
+        // Check if we have cached connections by address key
+        const cachedConnections = this.connectionsByAddress.get(addressKey) || [];
+        const bestConnection = this.selectBestConnection(cachedConnections, false);
+        if (bestConnection) {
+            this.logger.debug('Reusing cached connection for address:', nextHopAddress?.value);
+            return bestConnection;
         }
-        // Clean up stale connection if it exists but is not open
-        if (cachedConnection && cachedConnection.status !== 'open') {
-            this.logger.debug('Removing stale connection for transports:', transportKey);
-            this.connectionsByTransportKey.delete(transportKey);
+        // Clean up stale connections if they exist but are not open
+        if (cachedConnections.length > 0) {
+            const openConnections = cachedConnections.filter((c) => c.status === 'open');
+            if (openConnections.length === 0) {
+                this.logger.debug('Removing all stale connections for address:', addressKey);
+                this.connectionsByAddress.delete(addressKey);
+            }
+            else if (openConnections.length < cachedConnections.length) {
+                this.logger.debug('Cleaning up some stale connections for address:', addressKey);
+                this.connectionsByAddress.set(addressKey, openConnections);
+            }
         }
         // Check if libp2p has an active connection for this address
         const libp2pConnection = this.getCachedLibp2pConnection(nextHopAddress);
         if (libp2pConnection && libp2pConnection.status === 'open') {
-            this.logger.debug('Caching existing libp2p connection for transports:', transportKey);
-            this.connectionsByTransportKey.set(transportKey, libp2pConnection);
+            this.logger.debug('Caching existing libp2p connection for address:', addressKey);
+            const connections = this.connectionsByAddress.get(addressKey) || [];
+            connections.push(libp2pConnection);
+            this.connectionsByAddress.set(addressKey, connections);
             return libp2pConnection;
         }
-        // Check if dial is already in progress for this transport key
-        const pendingDial = this.pendingDialsByTransportKey.get(transportKey);
+        // Check if dial is already in progress for this address key
+        const pendingDial = this.pendingDialsByAddress.get(addressKey);
         if (pendingDial) {
-            this.logger.debug('Awaiting existing dial for transports:', transportKey);
+            this.logger.debug('Awaiting existing dial for address:', addressKey);
             return pendingDial;
         }
-        // Start new dial and cache the promise by transport key
-        const dialPromise = this.performDial(nextHopAddress, transportKey);
-        this.pendingDialsByTransportKey.set(transportKey, dialPromise);
+        // Start new dial and cache the promise by address key
+        const dialPromise = this.performDial(nextHopAddress, addressKey);
+        this.pendingDialsByAddress.set(addressKey, dialPromise);
         try {
             const connection = await dialPromise;
-            // Cache the established connection by transport key
-            this.connectionsByTransportKey.set(transportKey, connection);
+            // Add the established connection to the cache array
+            const connections = this.connectionsByAddress.get(addressKey) || [];
+            connections.push(connection);
+            this.connectionsByAddress.set(addressKey, connections);
             return connection;
         }
         finally {
-            this.pendingDialsByTransportKey.delete(transportKey);
+            this.pendingDialsByAddress.delete(addressKey);
         }
     }
-    async performDial(nextHopAddress, transportKey) {
+    async performDial(nextHopAddress, addressKey) {
         this.logger.debug('Dialing new connection', {
             address: nextHopAddress.value,
-            transportKey,
+            addressKey,
         });
         const connection = await this.p2pNode.dial(nextHopAddress.libp2pTransports.map((ma) => ma.toMultiaddr()));
         this.logger.debug('Successfully dialed connection', {
-            transportKey,
+            addressKey,
             status: connection.status,
             remotePeer: connection.remotePeer?.toString(),
         });
@@ -145,12 +210,17 @@ export class oNodeConnectionManager extends oConnectionManager {
             requestHandler: config.requestHandler ?? undefined,
             reusePolicy: reuse ? 'reuse' : 'none',
         });
-        const transportKey = this.getTransportKeyFromAddress(nextHopAddress);
-        if (transportKey) {
-            this.connectionsByTransportKey.set(transportKey, p2pConnection);
+        const addressKey = this.getAddressKey(nextHopAddress);
+        if (addressKey) {
+            const connections = this.connectionsByAddress.get(addressKey) || [];
+            // Only add if not already in the cache
+            if (!connections.includes(p2pConnection)) {
+                connections.push(p2pConnection);
+                this.connectionsByAddress.set(addressKey, connections);
+            }
         }
         else {
-            this.logger.error('Should not happen! Failed to generate a transport key for address:', nextHopAddress);
+            this.logger.error('Should not happen! Failed to generate an address key for address:', nextHopAddress);
         }
         return connection;
     }
@@ -183,13 +253,14 @@ export class oNodeConnectionManager extends oConnectionManager {
      */
     isCached(address) {
         try {
-            const transportKey = this.getTransportKeyFromAddress(address);
-            if (!transportKey) {
+            const addressKey = this.getAddressKey(address);
+            if (!addressKey) {
                 return false;
             }
-            // Check our transport-based cache first
-            const cachedConnection = this.connectionsByTransportKey.get(transportKey);
-            if (cachedConnection?.status === 'open') {
+            // Check our address-based cache first
+            const cachedConnections = this.connectionsByAddress.get(addressKey) || [];
+            const bestConnection = this.selectBestConnection(cachedConnections, false);
+            if (bestConnection) {
                 return true;
             }
             // Fall back to checking libp2p's connections
@@ -202,7 +273,11 @@ export class oNodeConnectionManager extends oConnectionManager {
             if (hasOpenConnection) {
                 const openConnection = connections.find((conn) => conn.status === 'open');
                 if (openConnection) {
-                    this.connectionsByTransportKey.set(transportKey, openConnection);
+                    const existingConnections = this.connectionsByAddress.get(addressKey) || [];
+                    if (!existingConnections.includes(openConnection)) {
+                        existingConnections.push(openConnection);
+                        this.connectionsByAddress.set(addressKey, existingConnections);
+                    }
                 }
             }
             return hasOpenConnection;
@@ -219,14 +294,15 @@ export class oNodeConnectionManager extends oConnectionManager {
      */
     getCachedLibp2pConnection(address) {
         try {
-            const transportKey = this.getTransportKeyFromAddress(address);
-            if (!transportKey) {
+            const addressKey = this.getAddressKey(address);
+            if (!addressKey) {
                 return null;
             }
-            // Check transport-based cache first
-            const cachedConnection = this.connectionsByTransportKey.get(transportKey);
-            if (cachedConnection?.status === 'open') {
-                return cachedConnection;
+            // Check address-based cache first
+            const cachedConnections = this.connectionsByAddress.get(addressKey) || [];
+            const bestConnection = this.selectBestConnection(cachedConnections, false);
+            if (bestConnection) {
+                return bestConnection;
             }
             const peerId = this.getPeerIdFromAddress(address);
             if (!peerId) {
@@ -235,16 +311,23 @@ export class oNodeConnectionManager extends oConnectionManager {
             // Query libp2p for connections to this peer
             const connections = this.p2pNode.getConnections();
             const filteredConnections = connections.filter((conn) => conn.remotePeer?.toString() === peerId);
-            // Find the first open connection
-            const openConnection = filteredConnections.find((conn) => conn.status === 'open');
-            // If we found an open connection in libp2p, cache it by transport key
-            if (openConnection) {
-                this.connectionsByTransportKey.set(transportKey, openConnection);
-                return openConnection;
+            // Find open connections
+            const openConnections = filteredConnections.filter((conn) => conn.status === 'open');
+            // If we found open connections in libp2p, add them to cache and select best
+            if (openConnections.length > 0) {
+                const existingConnections = this.connectionsByAddress.get(addressKey) || [];
+                // Add any new connections that aren't already cached
+                for (const conn of openConnections) {
+                    if (!existingConnections.includes(conn)) {
+                        existingConnections.push(conn);
+                    }
+                }
+                this.connectionsByAddress.set(addressKey, existingConnections);
+                return this.selectBestConnection(existingConnections, false);
             }
-            // Clean up stale cache entry if connection is no longer open
-            if (cachedConnection) {
-                this.connectionsByTransportKey.delete(transportKey);
+            // Clean up stale cache entries if connections are no longer open
+            if (cachedConnections.length > 0) {
+                this.connectionsByAddress.delete(addressKey);
             }
             return null;
         }
@@ -258,13 +341,21 @@ export class oNodeConnectionManager extends oConnectionManager {
      * @returns Object containing cache statistics
      */
     getCacheStats() {
+        const allConnections = [];
+        for (const [addressKey, connections] of this.connectionsByAddress.entries()) {
+            for (const conn of connections) {
+                allConnections.push({
+                    peerId: conn.remotePeer?.toString() ?? 'unknown',
+                    status: conn.status,
+                    addressKey,
+                });
+            }
+        }
         return {
-            cachedConnections: this.connectionsByTransportKey.size,
-            pendingDials: this.pendingDialsByTransportKey.size,
-            connectionsByPeer: Array.from(this.connectionsByTransportKey.values()).map((conn) => ({
-                peerId: conn.remotePeer?.toString() ?? 'unknown',
-                status: conn.status,
-            })),
+            cachedAddresses: this.connectionsByAddress.size,
+            totalCachedConnections: allConnections.length,
+            pendingDials: this.pendingDialsByAddress.size,
+            connectionsByPeer: allConnections,
         };
     }
     /**
@@ -273,10 +364,19 @@ export class oNodeConnectionManager extends oConnectionManager {
      */
     cleanupStaleConnections() {
         let removed = 0;
-        for (const [transportKey, connection,] of this.connectionsByTransportKey.entries()) {
-            if (connection.status !== 'open') {
-                this.connectionsByTransportKey.delete(transportKey);
-                removed++;
+        for (const [addressKey, connections] of this.connectionsByAddress.entries()) {
+            const openConnections = connections.filter((conn) => conn.status === 'open');
+            const staleCount = connections.length - openConnections.length;
+            if (staleCount > 0) {
+                removed += staleCount;
+                if (openConnections.length === 0) {
+                    // Remove the entire entry if no connections remain
+                    this.connectionsByAddress.delete(addressKey);
+                }
+                else {
+                    // Keep only the open connections
+                    this.connectionsByAddress.set(addressKey, openConnections);
+                }
             }
         }
         if (removed > 0) {

package/dist/src/utils/connection.utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"connection.utils.d.ts","sourceRoot":"","sources":["../../../src/utils/connection.utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAA2B,MAAM,iBAAiB,CAAC;AACtE,OAAO,EAAuB,OAAO,EAAE,MAAM,eAAe,CAAC;AAI7D,qBAAa,eAAgB,SAAQ,OAAO;WACtB,qBAAqB,CAAC,OAAO,EAAE;QACjD,WAAW,EAAE,GAAG,CAAC;QACjB,UAAU,EAAE,UAAU,CAAC;KACxB;CAmEF"}
+{"version":3,"file":"connection.utils.d.ts","sourceRoot":"","sources":["../../../src/utils/connection.utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAA2B,MAAM,iBAAiB,CAAC;AACtE,OAAO,EAAuB,OAAO,EAAE,MAAM,eAAe,CAAC;AAI7D,qBAAa,eAAgB,SAAQ,OAAO;WACtB,qBAAqB,CAAC,OAAO,EAAE;QACjD,WAAW,EAAE,GAAG,CAAC;QACjB,UAAU,EAAE,UAAU,CAAC;KACxB;CA+DF"}

package/dist/src/utils/connection.utils.js

@@ -4,12 +4,13 @@ import { oNodeTransport } from '../router/o-node.transport.js';
 export class ConnectionUtils extends oObject {
     static async addressFromConnection(options) {
         try {
-            console.log('[ConnectionUtils] addressFromConnection');
             const { currentNode, connection } = options;
             const p2pNode = currentNode.p2pNode;
             // Extract the actual olane address from the peer store
             const peers = await p2pNode.peerStore.all();
-            const remotePeer = peers.find((peer) => peer.id.toString() === connection.remotePeer.toString());
+            const remotePeer = peers.find((peer) => {
+                return peer.id.toString() === connection.remotePeer.toString();
+            });
             if (!remotePeer) {
                 console.log('Failed to find peer:', remotePeer);
                 throw new Error(`Failed to extract remote address, peer ${connection.remotePeer.toString()} not found in peer store.`);
@@ -19,8 +20,7 @@ export class ConnectionUtils extends oObject {
             if (!originAddress) {
                 throw new Error('Origin address is not configured');
             }
-            const originProtocol = originAddress.toString();
-            const oProtocol = remotePeer.protocols.find((p) => p.startsWith('/o/') && p.startsWith(originProtocol) === false);
+            const oProtocol = remotePeer.protocols.find((p) => p.startsWith('/o/'));
             if (!oProtocol) {
                 throw new Error('Failed to extract remote address, could not find o-protocol in peer protocols.');
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@olane/o-node",
-  "version": "0.7.43",
+  "version": "0.7.45",
   "type": "module",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",
@@ -40,7 +40,7 @@
   "devDependencies": {
     "@eslint/eslintrc": "^3.3.1",
     "@eslint/js": "^9.29.0",
-    "@olane/o-test": "0.7.43",
+    "@olane/o-test": "0.7.45",
     "@tsconfig/node20": "^20.1.6",
     "@types/jest": "^30.0.0",
     "@types/json5": "^2.2.0",
@@ -60,13 +60,13 @@
     "typescript": "5.4.5"
   },
   "dependencies": {
-    "@olane/o-config": "0.7.43",
-    "@olane/o-core": "0.7.43",
-    "@olane/o-protocol": "0.7.43",
-    "@olane/o-tool": "0.7.43",
+    "@olane/o-config": "0.7.45",
+    "@olane/o-core": "0.7.45",
+    "@olane/o-protocol": "0.7.45",
+    "@olane/o-tool": "0.7.45",
     "debug": "^4.4.1",
     "dotenv": "^16.5.0",
     "json5": "^2.2.3"
   },
-  "gitHead": "12e63fad2b09173fbcf455d881276b7ca7b3344d"
+  "gitHead": "d336869dfa3105b453d2249ae388870088b17343"
 }