@olane/o-node 0.7.47 → 0.7.49

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

@@ -1 +1 @@
-{"version":3,"file":"o-node-connection.d.ts","sourceRoot":"","sources":["../../../src/connection/o-node-connection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAU,MAAM,iBAAiB,CAAC;AACrD,OAAO,EAEL,WAAW,EAGX,QAAQ,EACR,SAAS,EACV,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,qBAAqB,EAAE,MAAM,0CAA0C,CAAC;AACjF,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,KAAK,EAEV,iBAAiB,EAClB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAGtE,qBAAa,eAAgB,SAAQ,WAAW;IAKlC,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,qBAAqB;IAJrD,aAAa,EAAE,UAAU,CAAC;IACjC,SAAS,CAAC,aAAa,EAAE,aAAa,CAAC;IACvC,SAAS,CAAC,WAAW,EAAE,iBAAiB,CAAC;gBAEV,MAAM,EAAE,qBAAqB;IAQ5D,IAAI,YAAY,qCAEf;IAED,IAAI,UAAU,wCAEb;IAED;;OAEG;IACH,IAAI,gBAAgB,IAAI,qBAAqB,CAE5C;IAED,eAAe,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO;IAMzC,iBAAiB,IAAI,OAAO,CAAC,qBAAqB,CAAC;IAkBnD,YAAY,IAAI,OAAO,CAAC,qBAAqB,CAAC;IA6BpD,IAAI,OAAO,IAAI,qBAAqB,EAAE,CAcrC;IAEK,QAAQ,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,SAAS,CAAC;IA6C/C,YAAY,CAAC,MAAM,EAAE,qBAAqB;IAI1C,KAAK,CAAC,KAAK,EAAE,KAAK;IAMlB,KAAK;CAKZ"}
+{"version":3,"file":"o-node-connection.d.ts","sourceRoot":"","sources":["../../../src/connection/o-node-connection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAU,MAAM,iBAAiB,CAAC;AACrD,OAAO,EAEL,WAAW,EAGX,QAAQ,EACR,SAAS,EACV,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,qBAAqB,EAAE,MAAM,0CAA0C,CAAC;AACjF,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,KAAK,EAEV,iBAAiB,EAClB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAGtE,qBAAa,eAAgB,SAAQ,WAAW;IAKlC,SAAS,CAAC,QAAQ,CAAC,MAAM,EAAE,qBAAqB;IAJrD,aAAa,EAAE,UAAU,CAAC;IACjC,SAAS,CAAC,aAAa,EAAE,aAAa,CAAC;IACvC,SAAS,CAAC,WAAW,EAAE,iBAAiB,CAAC;gBAEV,MAAM,EAAE,qBAAqB;IAO5D,IAAI,YAAY,qCAEf;IAED,IAAI,UAAU,wCAEb;IAED;;OAEG;IACH,IAAI,gBAAgB,IAAI,qBAAqB,CAE5C;IAED,eAAe,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO;IAMzC,iBAAiB,IAAI,OAAO,CAAC,qBAAqB,CAAC;IAiBnD,YAAY,IAAI,OAAO,CAAC,qBAAqB,CAAC;IA6BpD,IAAI,OAAO,IAAI,qBAAqB,EAAE,CAcrC;IAEK,QAAQ,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO,CAAC,SAAS,CAAC;IA6C/C,YAAY,CAAC,MAAM,EAAE,qBAAqB;IAI1C,KAAK,CAAC,KAAK,EAAE,KAAK;IAMlB,KAAK;CAKZ"}

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

@@ -8,7 +8,6 @@ export class oNodeConnection extends oConnection {
         this.p2pConnection = config.p2pConnection;
         this.streamHandler = new StreamHandler(this.logger);
         this.reusePolicy = config.reusePolicy ?? 'none';
-        console.log('oNodeConnection constructor', this.reusePolicy);
     }
     get remotePeerId() {
         return this.p2pConnection.remotePeer;
@@ -28,7 +27,6 @@ export class oNodeConnection extends oConnection {
         });
     }
     async getOrCreateStream() {
-        console.log('getOrCreateStream', this.reusePolicy);
         if (this.reusePolicy === 'reuse') {
             this.logger.debug('Reusing stream...');
             // search for streams that allow re-use

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

@@ -5,58 +5,55 @@ import { oNodeConnection } from './o-node-connection.js';
 export declare class oNodeConnectionManager extends oConnectionManager {
     readonly config: oNodeConnectionManagerConfig;
     protected p2pNode: Libp2p;
-    private defaultReadTimeoutMs?;
-    private defaultDrainTimeoutMs?;
-    private connectionsByAddress;
-    private pendingDialsByAddress;
-    /** Cache of oNodeConnection instances keyed by p2p connection ID */
-    private nodeConnectionByConnectionId;
+    protected defaultReadTimeoutMs?: number;
+    protected defaultDrainTimeoutMs?: number;
+    /** Single cache of oNodeConnection instances keyed by address */
+    protected cachedConnections: Map<string, oNodeConnection[]>;
+    protected pendingDialsByAddress: Map<string, Promise<Connection>>;
     constructor(config: oNodeConnectionManagerConfig);
     /**
      * Set up listeners to maintain connection cache state
      */
-    private setupConnectionListeners;
+    protected setupConnectionListeners(): void;
     /**
      * Build a stable cache key from an address.
      *
      * 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 getAddressKey;
+    protected getAddressKey(address: oAddress): string | null;
     /**
      * 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;
+    protected getPeerIdFromAddress(address: oAddress): string | null;
     /**
-     * Select the best connection from an array of connections.
-     * Prioritizes connections with active streams, then by direction based on context.
+     * Get the first valid (open) connection for the given address key.
+     * Cleans up stale connections from the cache automatically.
      *
-     * @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;
-    /**
-     * Get a cached oNodeConnection for the given p2p connection if it exists and is valid.
-     * @param p2pConnection - The p2p connection to look up
+     * @param addressKey - The address key to look up
      * @returns A valid oNodeConnection or null if none found
      */
-    private getCachedNodeConnection;
+    protected getValidConnection(addressKey: string): oNodeConnection | null;
     /**
-     * Cache an oNodeConnection by its p2p connection ID for potential reuse.
+     * Cache an oNodeConnection by its address key.
      * @param conn - The oNodeConnection to cache
+     * @param addressKey - The address key to cache under
+     */
+    protected cacheConnection(conn: oNodeConnection, addressKey: string): void;
+    /**
+     * Get or create a raw p2p connection to the given address.
+     * Subclasses can override connect() and use this method to get the underlying p2p connection.
      */
-    private cacheNodeConnection;
-    getOrCreateConnection(nextHopAddress: oAddress, address: oAddress): Promise<Connection>;
-    private performDial;
+    protected getOrCreateP2pConnection(nextHopAddress: oAddress, addressKey: string): Promise<Connection>;
+    protected performDial(nextHopAddress: oAddress, addressKey: string): Promise<Connection>;
     answer(config: oConnectionConfig & {
         p2pConnection: Connection;
         reuse?: boolean;
     }): Promise<oNodeConnection>;
     /**
-     * Connect to a given address, reusing oNodeConnection and libp2p connections when possible
+     * Connect to a given address, reusing oNodeConnection when possible
      * @param config - Connection configuration
      * @returns The connection object
      */
@@ -68,11 +65,11 @@ export declare class oNodeConnectionManager extends oConnectionManager {
      */
     isCached(address: oAddress): boolean;
     /**
-     * Get an existing connection to the target peer (from cache or libp2p)
+     * Get an existing cached oNodeConnection for the target address
      * @param address - The address to get a connection for
-     * @returns The Connection object or null if not found
+     * @returns The oNodeConnection or null if not found
      */
-    getCachedLibp2pConnection(address: oAddress): Connection | null;
+    getCachedConnection(address: oAddress): oNodeConnection | null;
     /**
      * Get cache statistics for monitoring and debugging
      * @returns Object containing cache statistics
@@ -81,7 +78,6 @@ export declare class oNodeConnectionManager extends oConnectionManager {
         cachedAddresses: number;
         totalCachedConnections: number;
         pendingDials: number;
-        cachedNodeConnections: number;
         connectionsByPeer: Array<{
             peerId: string;
             status: string;
@@ -93,10 +89,5 @@ export declare class oNodeConnectionManager extends oConnectionManager {
      * @returns Number of connections removed
      */
     cleanupStaleConnections(): number;
-    /**
-     * Clean up all stale oNodeConnections from cache
-     * @returns Number of oNodeConnections removed
-     */
-    cleanupStaleNodeConnections(): number;
 }
 //# sourceMappingURL=o-node-connection.manager.d.ts.map

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;IAUhD,QAAQ,CAAC,MAAM,EAAE,4BAA4B;IATzD,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,CAA+C;IAC5E,oEAAoE;IACpE,OAAO,CAAC,4BAA4B,CACxB;gBAES,MAAM,EAAE,4BAA4B;IAWzD;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAyChC;;;;;OAKG;IACH,OAAO,CAAC,aAAa;IASrB;;;;OAIG;IACH,OAAO,CAAC,oBAAoB;IAa5B;;;;;;;OAOG;IACH,OAAO,CAAC,oBAAoB;IA8D5B;;;;OAIG;IACH,OAAO,CAAC,uBAAuB;IAc/B;;;OAGG;IACH,OAAO,CAAC,mBAAmB;IAIrB,qBAAqB,CACzB,cAAc,EAAE,QAAQ,EACxB,OAAO,EAAE,QAAQ,GAChB,OAAO,CAAC,UAAU,CAAC;YAgFR,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;IA2C3B;;;;OAIG;IACG,OAAO,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,eAAe,CAAC;IA6ClE;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO;IAiDpC;;;;OAIG;IACH,yBAAyB,CAAC,OAAO,EAAE,QAAQ,GAAG,UAAU,GAAG,IAAI;IA6D/D;;;OAGG;IACH,aAAa,IAAI;QACf,eAAe,EAAE,MAAM,CAAC;QACxB,sBAAsB,EAAE,MAAM,CAAC;QAC/B,YAAY,EAAE,MAAM,CAAC;QACrB,qBAAqB,EAAE,MAAM,CAAC;QAC9B,iBAAiB,EAAE,KAAK,CAAC;YACvB,MAAM,EAAE,MAAM,CAAC;YACf,MAAM,EAAE,MAAM,CAAC;YACf,UAAU,EAAE,MAAM,CAAC;SACpB,CAAC,CAAC;KACJ;IA6BD;;;OAGG;IACH,uBAAuB,IAAI,MAAM;IA6BjC;;;OAGG;IACH,2BAA2B,IAAI,MAAM;CAgBtC"}
+{"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,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,EAAE,4BAA4B,EAAE,MAAM,kDAAkD,CAAC;AAEhG,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAEzD,qBAAa,sBAAuB,SAAQ,kBAAkB;IAQhD,QAAQ,CAAC,MAAM,EAAE,4BAA4B;IAPzD,SAAS,CAAC,OAAO,EAAE,MAAM,CAAC;IAC1B,SAAS,CAAC,oBAAoB,CAAC,EAAE,MAAM,CAAC;IACxC,SAAS,CAAC,qBAAqB,CAAC,EAAE,MAAM,CAAC;IACzC,iEAAiE;IACjE,SAAS,CAAC,iBAAiB,EAAE,GAAG,CAAC,MAAM,EAAE,eAAe,EAAE,CAAC,CAAa;IACxE,SAAS,CAAC,qBAAqB,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,UAAU,CAAC,CAAC,CAAa;gBAEzD,MAAM,EAAE,4BAA4B;IAWzD;;OAEG;IACH,SAAS,CAAC,wBAAwB,IAAI,IAAI;IA+B1C;;;;;OAKG;IACH,SAAS,CAAC,aAAa,CAAC,OAAO,EAAE,QAAQ,GAAG,MAAM,GAAG,IAAI;IASzD;;;;OAIG;IACH,SAAS,CAAC,oBAAoB,CAAC,OAAO,EAAE,QAAQ,GAAG,MAAM,GAAG,IAAI;IAahE;;;;;;OAMG;IACH,SAAS,CAAC,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,eAAe,GAAG,IAAI;IAkBxE;;;;OAIG;IACH,SAAS,CAAC,eAAe,CAAC,IAAI,EAAE,eAAe,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI;IAY1E;;;OAGG;cACa,wBAAwB,CACtC,cAAc,EAAE,QAAQ,EACxB,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,UAAU,CAAC;cAoCN,WAAW,CACzB,cAAc,EAAE,QAAQ,EACxB,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,UAAU,CAAC;IAqBhB,MAAM,CACV,MAAM,EAAE,iBAAiB,GAAG;QAAE,aAAa,EAAE,UAAU,CAAC;QAAC,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,GACzE,OAAO,CAAC,eAAe,CAAC;IAqD3B;;;;OAIG;IACG,OAAO,CAAC,MAAM,EAAE,iBAAiB,GAAG,OAAO,CAAC,eAAe,CAAC;IAyDlE;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,QAAQ,GAAG,OAAO;IAcpC;;;;OAIG;IACH,mBAAmB,CAAC,OAAO,EAAE,QAAQ,GAAG,eAAe,GAAG,IAAI;IAc9D;;;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,10 +4,9 @@ export class oNodeConnectionManager extends oConnectionManager {
     constructor(config) {
         super(config);
         this.config = config;
-        this.connectionsByAddress = new Map();
+        /** Single cache of oNodeConnection instances keyed by address */
+        this.cachedConnections = new Map();
         this.pendingDialsByAddress = new Map();
-        /** Cache of oNodeConnection instances keyed by p2p connection ID */
-        this.nodeConnectionByConnectionId = new Map();
         this.p2pNode = config.p2pNode;
         this.defaultReadTimeoutMs = config.defaultReadTimeoutMs;
         this.defaultDrainTimeoutMs = config.defaultDrainTimeoutMs;
@@ -24,31 +23,18 @@ export class oNodeConnectionManager extends oConnectionManager {
             if (!connection) {
                 return;
             }
-            // Clean up libp2p connection cache
-            // 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);
-            //     }
-            //   }
-            // }
-            // Clean up oNodeConnection cache by connection ID
             const connectionId = connection.id;
-            if (this.nodeConnectionByConnectionId.has(connectionId)) {
-                this.logger.debug('Connection closed, removing oNodeConnection for connection ID:', connectionId);
-                this.nodeConnectionByConnectionId.delete(connectionId);
+            // Clean up cached connections by filtering out the closed connection
+            for (const [key, conns] of this.cachedConnections.entries()) {
+                const filtered = conns.filter((c) => c.p2pConnection.id !== connectionId);
+                if (filtered.length === 0) {
+                    this.logger.debug('Connection closed, removing all cached connections for address:', key);
+                    this.cachedConnections.delete(key);
+                }
+                else if (filtered.length !== conns.length) {
+                    this.logger.debug('Connection closed, updating cached connections for address:', key);
+                    this.cachedConnections.set(key, filtered);
+                }
             }
         });
     }
@@ -86,117 +72,53 @@ export class oNodeConnectionManager extends oConnectionManager {
         }
     }
     /**
-     * Select the best connection from an array of connections.
-     * Prioritizes connections with active streams, then by direction based on context.
+     * Get the first valid (open) connection for the given address key.
+     * Cleans up stale connections from the cache automatically.
      *
-     * @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
+     * @param addressKey - The address key to look up
+     * @returns A valid oNodeConnection or null if none found
      */
-    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;
+    getValidConnection(addressKey) {
+        const connections = this.cachedConnections.get(addressKey) || [];
+        // Filter to open connections
+        const valid = connections.filter((c) => c.p2pConnection?.status === 'open');
+        // Update cache if we cleaned any stale connections
+        if (valid.length !== connections.length) {
+            if (valid.length === 0) {
+                this.cachedConnections.delete(addressKey);
             }
-        }
-        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;
+            else {
+                this.cachedConnections.set(addressKey, valid);
             }
         }
-        // Priority 3: Return first open connection
-        this.logger.debug('Selected first available open connection', connectionsWithStreams);
-        return openConnections[0];
+        return valid[0] ?? null;
     }
     /**
-     * Get a cached oNodeConnection for the given p2p connection if it exists and is valid.
-     * @param p2pConnection - The p2p connection to look up
-     * @returns A valid oNodeConnection or null if none found
+     * Cache an oNodeConnection by its address key.
+     * @param conn - The oNodeConnection to cache
+     * @param addressKey - The address key to cache under
      */
-    getCachedNodeConnection(p2pConnection) {
-        const cached = this.nodeConnectionByConnectionId.get(p2pConnection.id);
-        if (cached && cached.p2pConnection?.status === 'open') {
-            return cached;
-        }
-        // Clean up stale entry if connection is no longer open
-        if (cached) {
-            this.nodeConnectionByConnectionId.delete(p2pConnection.id);
-        }
-        return null;
+    cacheConnection(conn, addressKey) {
+        this.logger.debug('Caching connection for address:', addressKey, conn.p2pConnection.id, conn.p2pConnection.direction);
+        const existing = this.cachedConnections.get(addressKey) || [];
+        existing.push(conn);
+        this.cachedConnections.set(addressKey, existing);
     }
     /**
-     * Cache an oNodeConnection by its p2p connection ID for potential reuse.
-     * @param conn - The oNodeConnection to cache
+     * Get or create a raw p2p connection to the given address.
+     * Subclasses can override connect() and use this method to get the underlying p2p connection.
      */
-    cacheNodeConnection(conn) {
-        this.nodeConnectionByConnectionId.set(conn.p2pConnection.id, conn);
-    }
-    async getOrCreateConnection(nextHopAddress, address) {
-        if (!nextHopAddress) {
-            throw new Error('Invalid address passed');
-        }
-        // 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 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, bestConnection.id);
-            return bestConnection;
-        }
-        // 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);
+    async getOrCreateP2pConnection(nextHopAddress, addressKey) {
+        // Check if libp2p already has an active connection for this peer
+        const peerId = this.getPeerIdFromAddress(nextHopAddress);
+        if (peerId) {
+            const connections = this.p2pNode.getConnections();
+            const existingConnection = connections.find((conn) => conn.remotePeer?.toString() === peerId && conn.status === 'open');
+            if (existingConnection) {
+                this.logger.debug('Found existing libp2p connection for address:', addressKey);
+                return existingConnection;
             }
         }
-        // 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 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 address key
         const pendingDial = this.pendingDialsByAddress.get(addressKey);
         if (pendingDial) {
@@ -207,12 +129,7 @@ export class oNodeConnectionManager extends oConnectionManager {
         const dialPromise = this.performDial(nextHopAddress, addressKey);
         this.pendingDialsByAddress.set(addressKey, dialPromise);
         try {
-            const connection = await dialPromise;
-            // Add the established connection to the cache array
-            const connections = this.connectionsByAddress.get(addressKey) || [];
-            connections.push(connection);
-            this.connectionsByAddress.set(addressKey, connections);
-            return connection;
+            return await dialPromise;
         }
         finally {
             this.pendingDialsByAddress.delete(addressKey);
@@ -233,6 +150,17 @@ export class oNodeConnectionManager extends oConnectionManager {
     }
     async answer(config) {
         const { address, nextHopAddress, callerAddress, readTimeoutMs, drainTimeoutMs, p2pConnection, reuse, } = config;
+        const addressKey = this.getAddressKey(nextHopAddress);
+        if (!addressKey) {
+            this.logger.error('Failed to generate an address key for address:', nextHopAddress);
+            throw new Error(`Unable to extract address key from address: ${nextHopAddress.toString()}`);
+        }
+        // Check if we already have a cached connection for this address
+        const existingConnection = this.getValidConnection(addressKey);
+        if (existingConnection) {
+            this.logger.debug('Reusing cached connection for answer:', addressKey, existingConnection.p2pConnection.id);
+            return existingConnection;
+        }
         const connection = new oNodeConnection({
             nextHopAddress: nextHopAddress,
             address: address,
@@ -246,38 +174,33 @@ export class oNodeConnectionManager extends oConnectionManager {
             requestHandler: config.requestHandler ?? undefined,
             reusePolicy: reuse ? 'reuse' : 'none',
         });
-        // Cache the new connection by its p2p connection ID
-        this.cacheNodeConnection(connection);
-        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 an address key for address:', nextHopAddress);
-        }
+        // Cache the new connection
+        this.cacheConnection(connection, addressKey);
         return connection;
     }
     /**
-     * Connect to a given address, reusing oNodeConnection and libp2p connections when possible
+     * Connect to a given address, reusing oNodeConnection when possible
      * @param config - Connection configuration
      * @returns The connection object
      */
     async connect(config) {
         const { address, nextHopAddress, callerAddress, readTimeoutMs, drainTimeoutMs, } = config;
-        // First get or create the underlying p2p connection
-        const p2pConnection = await this.getOrCreateConnection(nextHopAddress, address);
-        // Check for existing valid oNodeConnection for this p2p connection
-        const existingConnection = this.getCachedNodeConnection(p2pConnection);
+        if (!nextHopAddress) {
+            throw new Error('Invalid address passed');
+        }
+        const addressKey = this.getAddressKey(nextHopAddress);
+        if (!addressKey) {
+            throw new Error(`Unable to extract address key from address: ${nextHopAddress.toString()}`);
+        }
+        // Check for existing valid cached connection
+        const existingConnection = this.getValidConnection(addressKey);
         if (existingConnection) {
-            this.logger.debug('Reusing cached oNodeConnection for connection ID:', p2pConnection.id);
+            this.logger.debug('Reusing cached connection for address:', addressKey, existingConnection.p2pConnection.id);
             return existingConnection;
         }
-        // No valid cached connection, create new one
+        // Get or create the underlying p2p connection
+        const p2pConnection = await this.getOrCreateP2pConnection(nextHopAddress, addressKey);
+        // Create new oNodeConnection
         const connection = new oNodeConnection({
             nextHopAddress: nextHopAddress,
             address: address,
@@ -290,8 +213,8 @@ export class oNodeConnectionManager extends oConnectionManager {
             runOnLimitedConnection: this.config.runOnLimitedConnection ?? false,
             requestHandler: config.requestHandler ?? undefined,
         });
-        // Cache the new connection by its p2p connection ID
-        this.cacheNodeConnection(connection);
+        // Cache the new connection
+        this.cacheConnection(connection, addressKey);
         return connection;
     }
     /**
@@ -305,30 +228,7 @@ export class oNodeConnectionManager extends oConnectionManager {
             if (!addressKey) {
                 return false;
             }
-            // 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
-            const peerId = this.getPeerIdFromAddress(address);
-            // the following works since the peer id param is not really required: https://github.com/libp2p/js-libp2p/blob/0bbf5021b53938b2bffcffca6c13c479a95c2a60/packages/libp2p/src/connection-manager/index.ts#L508
-            const connections = this.p2pNode.getConnections(peerId); // ignore since converting to a proper peer id breaks the browser implementation
-            // Check if we have at least one open connection
-            const hasOpenConnection = connections.some((conn) => conn.status === 'open');
-            // If libp2p has an open connection, update our cache
-            if (hasOpenConnection) {
-                const openConnection = connections.find((conn) => conn.status === 'open');
-                if (openConnection) {
-                    const existingConnections = this.connectionsByAddress.get(addressKey) || [];
-                    if (!existingConnections.includes(openConnection)) {
-                        existingConnections.push(openConnection);
-                        this.connectionsByAddress.set(addressKey, existingConnections);
-                    }
-                }
-            }
-            return hasOpenConnection;
+            return this.getValidConnection(addressKey) !== null;
         }
         catch (error) {
             this.logger.debug('Error checking cached connection:', error);
@@ -336,48 +236,17 @@ export class oNodeConnectionManager extends oConnectionManager {
         }
     }
     /**
-     * Get an existing connection to the target peer (from cache or libp2p)
+     * Get an existing cached oNodeConnection for the target address
      * @param address - The address to get a connection for
-     * @returns The Connection object or null if not found
+     * @returns The oNodeConnection or null if not found
      */
-    getCachedLibp2pConnection(address) {
+    getCachedConnection(address) {
         try {
             const addressKey = this.getAddressKey(address);
             if (!addressKey) {
                 return null;
             }
-            // 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) {
-                return null;
-            }
-            // Query libp2p for connections to this peer
-            const connections = this.p2pNode.getConnections();
-            const filteredConnections = connections.filter((conn) => conn.remotePeer?.toString() === peerId);
-            // 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 entries if connections are no longer open
-            if (cachedConnections.length > 0) {
-                this.connectionsByAddress.delete(addressKey);
-            }
-            return null;
+            return this.getValidConnection(addressKey);
         }
         catch (error) {
             this.logger.debug('Error getting cached connection:', error);
@@ -390,20 +259,19 @@ export class oNodeConnectionManager extends oConnectionManager {
      */
     getCacheStats() {
         const allConnections = [];
-        for (const [addressKey, connections,] of this.connectionsByAddress.entries()) {
+        for (const [addressKey, connections] of this.cachedConnections.entries()) {
             for (const conn of connections) {
                 allConnections.push({
-                    peerId: conn.remotePeer?.toString() ?? 'unknown',
-                    status: conn.status,
+                    peerId: conn.p2pConnection?.remotePeer?.toString() ?? 'unknown',
+                    status: conn.p2pConnection?.status ?? 'unknown',
                     addressKey,
                 });
             }
         }
         return {
-            cachedAddresses: this.connectionsByAddress.size,
+            cachedAddresses: this.cachedConnections.size,
             totalCachedConnections: allConnections.length,
             pendingDials: this.pendingDialsByAddress.size,
-            cachedNodeConnections: this.nodeConnectionByConnectionId.size,
             connectionsByPeer: allConnections,
         };
     }
@@ -413,18 +281,16 @@ export class oNodeConnectionManager extends oConnectionManager {
      */
     cleanupStaleConnections() {
         let removed = 0;
-        for (const [addressKey, connections,] of this.connectionsByAddress.entries()) {
-            const openConnections = connections.filter((conn) => conn.status === 'open');
+        for (const [addressKey, connections] of this.cachedConnections.entries()) {
+            const openConnections = connections.filter((conn) => conn.p2pConnection?.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);
+                    this.cachedConnections.delete(addressKey);
                 }
                 else {
-                    // Keep only the open connections
-                    this.connectionsByAddress.set(addressKey, openConnections);
+                    this.cachedConnections.set(addressKey, openConnections);
                 }
             }
         }
@@ -433,21 +299,4 @@ export class oNodeConnectionManager extends oConnectionManager {
         }
         return removed;
     }
-    /**
-     * Clean up all stale oNodeConnections from cache
-     * @returns Number of oNodeConnections removed
-     */
-    cleanupStaleNodeConnections() {
-        let removed = 0;
-        for (const [connectionId, conn,] of this.nodeConnectionByConnectionId.entries()) {
-            if (conn.p2pConnection?.status !== 'open') {
-                this.nodeConnectionByConnectionId.delete(connectionId);
-                removed++;
-            }
-        }
-        if (removed > 0) {
-            this.logger.debug(`Cleaned up ${removed} stale oNodeConnections`);
-        }
-        return removed;
-    }
 }

package/dist/src/interfaces/i-reconnectable-node.d.ts

@@ -1,6 +1,7 @@
 import { oAddress, NodeState, oNotificationManager } from '@olane/o-core';
 import { oNodeAddress } from '../router/o-node.address.js';
 import { oNodeConfig } from './o-node.config.js';
+import { oRegistrationManager } from '../managers/o-registration.manager.js';
 /**
  * Interface for nodes that support reconnection management.
  * This interface defines the contract that oReconnectionManager needs
@@ -23,10 +24,18 @@ export interface IReconnectableNode {
      * The notification manager for subscribing to events
      */
     notificationManager: oNotificationManager;
+    /**
+     * The registration manager for tracking registration state
+     */
+    registrationManager: oRegistrationManager;
     /**
      * Register with the parent node
      */
     registerParent(): Promise<void>;
+    /**
+     * Register with the leader's global registry
+     */
+    registerLeader(): Promise<void>;
     /**
      * Register with the leader's global registry
      */

package/dist/src/interfaces/i-reconnectable-node.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"i-reconnectable-node.d.ts","sourceRoot":"","sources":["../../../src/interfaces/i-reconnectable-node.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,SAAS,EACT,oBAAoB,EAErB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEjD;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IACjC;;OAEG;IACH,MAAM,EAAE,WAAW,CAAC;IAEpB;;OAEG;IACH,OAAO,EAAE,YAAY,CAAC;IAEtB;;OAEG;IACH,KAAK,EAAE,SAAS,CAAC;IAEjB;;OAEG;IACH,mBAAmB,EAAE,oBAAoB,CAAC;IAE1C;;OAEG;IACH,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAEhC;;OAEG;IACH,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAE1B,OAAO,CAAC,OAAO,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IAErC;;OAEG;IACH,GAAG,CACD,OAAO,EAAE,QAAQ,EACjB,IAAI,CAAC,EAAE;QACL,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,MAAM,CAAC,EAAE;YAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;SAAE,CAAC;QAChC,EAAE,CAAC,EAAE,MAAM,CAAC;KACb,GACA,OAAO,CAAC,GAAG,CAAC,CAAC;CACjB"}
+{"version":3,"file":"i-reconnectable-node.d.ts","sourceRoot":"","sources":["../../../src/interfaces/i-reconnectable-node.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,SAAS,EACT,oBAAoB,EAErB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAC3D,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,oBAAoB,EAAE,MAAM,uCAAuC,CAAC;AAE7E;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IACjC;;OAEG;IACH,MAAM,EAAE,WAAW,CAAC;IAEpB;;OAEG;IACH,OAAO,EAAE,YAAY,CAAC;IAEtB;;OAEG;IACH,KAAK,EAAE,SAAS,CAAC;IAEjB;;OAEG;IACH,mBAAmB,EAAE,oBAAoB,CAAC;IAE1C;;OAEG;IACH,mBAAmB,EAAE,oBAAoB,CAAC;IAE1C;;OAEG;IACH,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAEhC;;OAEG;IACH,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAEhC;;OAEG;IACH,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAE1B,OAAO,CAAC,OAAO,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IAErC;;OAEG;IACH,GAAG,CACD,OAAO,EAAE,QAAQ,EACjB,IAAI,CAAC,EAAE;QACL,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,MAAM,CAAC,EAAE;YAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;SAAE,CAAC;QAChC,EAAE,CAAC,EAAE,MAAM,CAAC;KACb,GACA,OAAO,CAAC,GAAG,CAAC,CAAC;CACjB"}