@olane/o-node 0.7.12-alpha.3 → 0.7.12-alpha.31

package/dist/o-node/src/nodes/index.js

@@ -0,0 +1,3 @@
+export * from './client.node.js';
+export * from './server.node.js';
+export * from './websocket.node.js';

package/dist/o-node/src/nodes/server.node.d.ts

@@ -0,0 +1,7 @@
+import { oNode } from '../o-node.js';
+import { oNodeConfig } from '../interfaces/o-node.config.js';
+export declare class oServerNode extends oNode {
+    constructor(config: oNodeConfig);
+    configureTransports(): any[];
+}
+//# sourceMappingURL=server.node.d.ts.map

package/dist/o-node/src/nodes/server.node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.node.d.ts","sourceRoot":"","sources":["../../../../src/nodes/server.node.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AACrC,OAAO,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAE7D,qBAAa,WAAY,SAAQ,KAAK;gBACxB,MAAM,EAAE,WAAW;IAc/B,mBAAmB,IAAI,GAAG,EAAE;CAG7B"}

package/dist/o-node/src/nodes/server.node.js

@@ -0,0 +1,20 @@
+import { defaultLibp2pConfig } from '@olane/o-config';
+import { oNode } from '../o-node.js';
+export class oServerNode extends oNode {
+    constructor(config) {
+        super({
+            ...config,
+            network: {
+                listeners: config.network?.listeners || [
+                    '/ip4/0.0.0.0/tcp/0', // Plain TCP
+                    '/ip4/0.0.0.0/tcp/0/ws', // WebSockets over TCP
+                    '/ip6/::/tcp/0', // IPv6 TCP
+                    '/ip6/::/tcp/0/ws', // IPv6 WebSockets
+                ],
+            },
+        });
+    }
+    configureTransports() {
+        return [...(defaultLibp2pConfig.transports || [])];
+    }
+}

package/dist/o-node/src/nodes/websocket.node.d.ts

@@ -0,0 +1,7 @@
+import { oNode } from '../o-node.js';
+import { oNodeConfig } from '../interfaces/o-node.config.js';
+export declare class oWebsocketNode extends oNode {
+    constructor(config: oNodeConfig);
+    configureTransports(): any[];
+}
+//# sourceMappingURL=websocket.node.d.ts.map

package/dist/o-node/src/nodes/websocket.node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocket.node.d.ts","sourceRoot":"","sources":["../../../../src/nodes/websocket.node.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AACrC,OAAO,EAAE,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAE7D,qBAAa,cAAe,SAAQ,KAAK;gBAC3B,MAAM,EAAE,WAAW;IAY/B,mBAAmB,IAAI,GAAG,EAAE;CAG7B"}

package/dist/o-node/src/nodes/websocket.node.js

@@ -0,0 +1,18 @@
+import { defaultLibp2pConfig } from '@olane/o-config';
+import { oNode } from '../o-node.js';
+export class oWebsocketNode extends oNode {
+    constructor(config) {
+        super({
+            ...config,
+            network: {
+                listeners: config.network?.listeners || [
+                    '/ip4/0.0.0.0/tcp/0/ws', // WebSockets over TCP
+                    '/ip6/::/tcp/0/ws', // IPv6 WebSockets
+                ],
+            },
+        });
+    }
+    configureTransports() {
+        return [...(defaultLibp2pConfig.transports || [])];
+    }
+}

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

@@ -0,0 +1,73 @@
+import { Libp2p, Libp2pConfig } from '@olane/o-config';
+import { PeerId } from '@olane/o-config';
+import { oNodeHierarchyManager } from './o-node.hierarchy-manager.js';
+import { oNodeConfig } from './interfaces/o-node.config.js';
+import { oNodeTransport } from './router/o-node.transport.js';
+import { oAddress, oRequest, oNotificationManager } from '@olane/o-core';
+import { oNodeAddress } from './router/o-node.address.js';
+import { oNodeConnection } from './connection/o-node-connection.js';
+import { oNodeConnectionManager } from './connection/o-node-connection.manager.js';
+import { oToolBase } from '@olane/o-tool';
+import { oConnectionHeartbeatManager } from './managers/o-connection-heartbeat.manager.js';
+import { oReconnectionManager } from './managers/o-reconnection.manager.js';
+import { LeaderRequestWrapper } from './utils/leader-request-wrapper.js';
+import { oNodeConnectionConfig } from './connection/index.js';
+export declare class oNode extends oToolBase {
+    peerId: PeerId;
+    p2pNode: Libp2p;
+    address: oNodeAddress;
+    config: oNodeConfig;
+    connectionManager: oNodeConnectionManager;
+    hierarchyManager: oNodeHierarchyManager;
+    connectionHeartbeatManager?: oConnectionHeartbeatManager;
+    reconnectionManager?: oReconnectionManager;
+    leaderRequestWrapper: LeaderRequestWrapper;
+    protected didRegister: boolean;
+    constructor(config: oNodeConfig);
+    get leader(): oNodeAddress | null;
+    get networkConfig(): Libp2pConfig;
+    get parentPeerId(): string | null;
+    configureTransports(): any[];
+    initializeRouter(): Promise<void>;
+    protected createNotificationManager(): oNotificationManager;
+    get staticAddress(): oNodeAddress;
+    get parentTransports(): oNodeTransport[];
+    get transports(): oNodeTransport[];
+    unregister(): Promise<void>;
+    registerParent(): Promise<void>;
+    registerLeader(): Promise<void>;
+    register(): Promise<void>;
+    extractMethod(address: oNodeAddress): string;
+    start(): Promise<void>;
+    validateJoinRequest(request: oRequest): Promise<any>;
+    /**
+     * Configure the libp2p node
+     * @returns The libp2p config
+     */
+    configure(): Promise<Libp2pConfig>;
+    protected createNode(): Promise<Libp2p>;
+    connect(config: oNodeConnectionConfig): Promise<oNodeConnection>;
+    initConnectionManager(): Promise<void>;
+    initReconnectionManager(): Promise<void>;
+    hookInitializeFinished(): Promise<void>;
+    hookStartFinished(): Promise<void>;
+    initialize(): Promise<void>;
+    /**
+     * Override use() to wrap leader/registry requests with retry logic
+     */
+    use(address: oAddress, data?: {
+        method?: string;
+        params?: {
+            [key: string]: any;
+        };
+        id?: string;
+    }, options?: {
+        noRouting?: boolean;
+    }): Promise<any>;
+    teardown(): Promise<void>;
+    getLeaders(): oNodeAddress[];
+    getParents(): oNodeAddress[];
+    getChildren(): oNodeAddress[];
+    removeChild(childAddress: oNodeAddress): void;
+}
+//# sourceMappingURL=o-node.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"o-node.d.ts","sourceRoot":"","sources":["../../../src/o-node.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,15 @@
+import { oHierarchyManager, oHierarchyManagerConfig } from '@olane/o-core';
+import { oNodeAddress } from './router/o-node.address.js';
+export interface oNodeHierarchyManagerConfig extends oHierarchyManagerConfig {
+    leaders: oNodeAddress[];
+    children: oNodeAddress[];
+    parents: oNodeAddress[];
+}
+export declare class oNodeHierarchyManager extends oHierarchyManager {
+    leaders: oNodeAddress[];
+    children: oNodeAddress[];
+    parents: oNodeAddress[];
+    constructor(config: oNodeHierarchyManagerConfig);
+    get leader(): oNodeAddress | null;
+}
+//# sourceMappingURL=o-node.hierarchy-manager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"o-node.hierarchy-manager.d.ts","sourceRoot":"","sources":["../../../src/o-node.hierarchy-manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAC;AAC3E,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAE1D,MAAM,WAAW,2BAA4B,SAAQ,uBAAuB;IAC1E,OAAO,EAAE,YAAY,EAAE,CAAC;IACxB,QAAQ,EAAE,YAAY,EAAE,CAAC;IACzB,OAAO,EAAE,YAAY,EAAE,CAAC;CACzB;AAED,qBAAa,qBAAsB,SAAQ,iBAAiB;IACnD,OAAO,EAAE,YAAY,EAAE,CAAM;IAC7B,QAAQ,EAAE,YAAY,EAAE,CAAM;IAC9B,OAAO,EAAE,YAAY,EAAE,CAAM;gBAExB,MAAM,EAAE,2BAA2B;IAO/C,IAAI,MAAM,IAAI,YAAY,GAAG,IAAI,CAEhC;CACF"}

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

@@ -0,0 +1,15 @@
+import { oHierarchyManager } from '@olane/o-core';
+export class oNodeHierarchyManager extends oHierarchyManager {
+    constructor(config) {
+        super(config);
+        this.leaders = [];
+        this.children = [];
+        this.parents = [];
+        this.leaders = config.leaders || [];
+        this.children = config.children || [];
+        this.parents = config.parents || [];
+    }
+    get leader() {
+        return this.leaders.length > 0 ? this.leaders[0] : null;
+    }
+}

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

@@ -0,0 +1,414 @@
+import { createNode, defaultLibp2pConfig, } from '@olane/o-config';
+import { v4 as uuidv4 } from 'uuid';
+import { oNodeRouter } from './router/o-node.router.js';
+import { oNodeHierarchyManager } from './o-node.hierarchy-manager.js';
+import { oNodeTransport } from './router/o-node.transport.js';
+import { CoreUtils, NodeState, NodeType, oAddress, RestrictedAddresses, } from '@olane/o-core';
+import { oNodeAddress } from './router/o-node.address.js';
+import { oNodeConnectionManager } from './connection/o-node-connection.manager.js';
+import { oNodeResolver } from './router/resolvers/o-node.resolver.js';
+import { oMethodResolver, oToolBase } from '@olane/o-tool';
+import { oLeaderResolverFallback } from './router/index.js';
+import { oNodeNotificationManager } from './o-node.notification-manager.js';
+import { oConnectionHeartbeatManager } from './managers/o-connection-heartbeat.manager.js';
+import { oReconnectionManager } from './managers/o-reconnection.manager.js';
+import { LeaderRequestWrapper } from './utils/leader-request-wrapper.js';
+export class oNode extends oToolBase {
+    constructor(config) {
+        super(config);
+        this.didRegister = false;
+        this.config = config;
+    }
+    get leader() {
+        return this.isLeader ? this.address : this.config?.leader || null;
+    }
+    get networkConfig() {
+        return {
+            ...defaultLibp2pConfig,
+            ...(this.config.network || {}),
+        };
+    }
+    get parentPeerId() {
+        if (!this.parent || this.parent?.transports?.length === 0) {
+            return null;
+        }
+        const transport = this.parent?.transports[0];
+        const peerId = transport.toPeerId();
+        return peerId;
+    }
+    configureTransports() {
+        return [...(defaultLibp2pConfig.transports || [])];
+    }
+    async initializeRouter() {
+        this.hierarchyManager = new oNodeHierarchyManager({
+            leaders: this.config.leader ? [this.config.leader] : [],
+            parents: this.config.parent ? [this.config.parent] : [],
+            children: [],
+        });
+        this.router = new oNodeRouter();
+    }
+    createNotificationManager() {
+        return new oNodeNotificationManager(this.p2pNode, this.hierarchyManager, this.address);
+    }
+    get staticAddress() {
+        return this.config.address;
+    }
+    get parentTransports() {
+        return this.config.parent?.transports || [];
+    }
+    get transports() {
+        return this.p2pNode
+            .getMultiaddrs()
+            .map((multiaddr) => new oNodeTransport(multiaddr.toString()));
+    }
+    async unregister() {
+        this.logger.debug('Unregistering node...');
+        if (this.type === NodeType.LEADER) {
+            this.logger.debug('Skipping unregistration, node is leader');
+            return;
+        }
+        // Notify parent we're stopping (best-effort, 2s timeout)
+        if (this.config.parent) {
+            try {
+                await Promise.race([
+                    this.use(this.config.parent, {
+                        method: 'notify',
+                        params: {
+                            eventType: 'node:stopping',
+                            eventData: {
+                                address: this.address.toString(),
+                                reason: 'graceful_shutdown',
+                                expectedDowntime: null,
+                            },
+                            source: this.address.toString(),
+                        },
+                    }),
+                    new Promise((_, reject) => setTimeout(() => reject(new Error('timeout')), 2000)),
+                ]);
+                this.logger.debug('Notified parent of shutdown');
+            }
+            catch (error) {
+                this.logger.warn('Failed to notify parent (will be detected by heartbeat):', error instanceof Error ? error.message : error);
+            }
+        }
+        if (!this.config.leader) {
+            this.logger.debug('No leader found, skipping unregistration');
+            return;
+        }
+        const address = new oNodeAddress(RestrictedAddresses.REGISTRY);
+        // attempt to unregister from the network
+        const params = {
+            method: 'remove',
+            params: {
+                peerId: this.peerId.toString(),
+            },
+        };
+        await this.use(address, params);
+    }
+    async registerParent() {
+        if (this.type === NodeType.LEADER) {
+            this.logger.debug('Skipping parent registration, node is leader');
+            return;
+        }
+        if (!this.parent?.libp2pTransports?.length) {
+            this.logger.debug('Parent has no transports, waiting for reconnection & leader ack');
+            if (this.parent?.toString() === oAddress.leader().toString()) {
+                this.parent.setTransports(this.leader?.libp2pTransports || []);
+            }
+            else {
+                this.logger.debug('Waiting for parent and reconnecting...');
+                await this.reconnectionManager?.waitForParentAndReconnect();
+            }
+        }
+        // if no parent transports, register with the parent to get them
+        // TODO: should we remove the transports check to make this more consistent?
+        if (this.config.parent) {
+            this.logger.debug('Registering node with parent...', this.config.parent);
+            await this.use(this.config.parent, {
+                method: 'child_register',
+                params: {
+                    address: this.address.toString(),
+                    transports: this.transports.map((t) => t.toString()),
+                    peerId: this.peerId.toString(),
+                    _token: this.config.joinToken,
+                },
+            });
+        }
+    }
+    async registerLeader() {
+        const address = oAddress.registry();
+        const params = {
+            method: 'commit',
+            params: {
+                peerId: this.peerId.toString(),
+                address: this.address.toString(),
+                protocols: this.p2pNode.getProtocols(),
+                transports: this.transports,
+                staticAddress: this.staticAddress.toString(),
+            },
+        };
+        await this.use(address, params);
+    }
+    async register() {
+        if (this.type === NodeType.LEADER) {
+            this.logger.debug('Skipping registration, node is leader');
+            return;
+        }
+        if (this.didRegister) {
+            this.logger.debug('Node already registered, skipping registration');
+            return;
+        }
+        this.didRegister = true;
+        this.logger.debug('Registering node...');
+        // register with the leader global registry
+        if (!this.config.leader) {
+            this.logger.warn('No leaders found, skipping registration');
+            return;
+        }
+        else {
+            this.logger.debug('Registering node with leader...');
+        }
+        await this.registerParent();
+        await this.registerLeader();
+        this.logger.debug('Registration successful');
+    }
+    extractMethod(address) {
+        return address.protocol.split('/').pop() || '';
+    }
+    async start() {
+        await super.start();
+        // Start heartbeat after node is running
+        if (this.connectionHeartbeatManager) {
+            await this.connectionHeartbeatManager.start();
+        }
+    }
+    async validateJoinRequest(request) {
+        return true;
+    }
+    /**
+     * Configure the libp2p node
+     * @returns The libp2p config
+     */
+    async configure() {
+        const params = {
+            ...defaultLibp2pConfig,
+            ...this.networkConfig,
+            transports: this.configureTransports(),
+            listeners: (this.config.network?.listeners ||
+                defaultLibp2pConfig.listeners ||
+                []).concat(`/memory/${uuidv4()}`), // ensure we allow for local in-memory communication
+        };
+        // if the seed is provided, use it to generate the private key
+        if (this.config.seed) {
+            this.logger.debug('Seed provided, generating private key...');
+            const privateKey = await CoreUtils.generatePrivateKey(this.config.seed);
+            params.privateKey = privateKey;
+        }
+        else {
+            this.logger.debug('No seed provided, generating private key...');
+            this.logger.debug('Without providing a seed, this node peer id will be destroyed after the node shuts down.');
+            // TODO: add a link to documentation about how to setup a seed
+        }
+        // this is a child node of the network, so communication is heavily restricted
+        if (this.parentTransports.length > 0) {
+            // peer discovery is only allowed through the parent transports
+            const transports = this.parentTransports.map((t) => t.toMultiaddr().toString()) || [];
+            // this.logger.debug('Parent transports: ', transports);
+            // this.logger.debug(
+            //   'Bootstrap transports: ',
+            //   transports.concat(
+            //     this.leader?.libp2pTransports.map((t) => t.toString()) || [],
+            //   ),
+            // );
+            // params.peerDiscovery = [
+            //   bootstrap({
+            //     list: transports.concat(
+            //       this.leader?.libp2pTransports.map((t) => t.toString()) || [],
+            //     ),
+            //   }),
+            //   ...(defaultLibp2pConfig.peerDiscovery || []),
+            // ];
+            //   // let's make sure we only allow communication through the parent transports
+            params.connectionGater = {
+                denyDialPeer: (peerId) => {
+                    // we can call the leader
+                    if (this.config.leader?.libp2pTransports.some((t) => t.toPeerId() === peerId.toString())) {
+                        return false;
+                    }
+                    // we can call our parent
+                    if (this.parentPeerId === peerId.toString()) {
+                        return false;
+                    }
+                    // we can call our children
+                    if (this.hierarchyManager.children.some((c) => c.libp2pTransports.some((t) => t.toPeerId() === peerId.toString()))) {
+                        return false;
+                    }
+                    return true;
+                },
+                // who can call us?
+                denyInboundEncryptedConnection: (peerId, maConn) => {
+                    // deny all inbound connections unless they are from a parent transport
+                    if (this.parentPeerId === peerId.toString()) {
+                        return false;
+                    }
+                    // allow connections from children (for ping)
+                    if (this.hierarchyManager.children.some((c) => c.libp2pTransports.some((t) => t.toPeerId() === peerId.toString()))) {
+                        return false;
+                    }
+                    // allow leader inbounds
+                    if (this.config.type === NodeType.LEADER) {
+                        return false;
+                    }
+                    // deny everything else
+                    return true;
+                },
+                // allow the user to override the default connection gater
+                ...(this.config.network?.connectionGater || {}),
+            };
+        }
+        // handle the address encapsulation
+        if (this.config.leader &&
+            !this.address.protocol.includes(this.config.leader.protocol)) {
+            const parentAddress = this.config.parent || this.config.leader;
+            this.address = CoreUtils.childAddress(parentAddress, this.address);
+        }
+        return params;
+    }
+    async createNode() {
+        const params = await this.configure();
+        this.p2pNode = await createNode(params);
+        return this.p2pNode;
+    }
+    async connect(config) {
+        if (!this.connectionManager) {
+            this.logger.error('Connection manager not initialized');
+            throw new Error('Node is not ready to connect to other nodes');
+        }
+        const connection = await this.connectionManager
+            .connect(config)
+            .catch((error) => {
+            // TODO: we need to handle this better and document
+            if (error.message === 'Can not dial self') {
+                this.logger.error('Make sure you are entering the network not directly through the leader node.');
+            }
+            throw error;
+        });
+        if (!connection) {
+            throw new Error('Connection failed');
+        }
+        return connection;
+    }
+    async initConnectionManager() {
+        this.connectionManager = new oNodeConnectionManager({
+            p2pNode: this.p2pNode,
+            defaultReadTimeoutMs: this.config.connectionTimeouts?.readTimeoutMs,
+            defaultDrainTimeoutMs: this.config.connectionTimeouts?.drainTimeoutMs,
+        });
+    }
+    async initReconnectionManager() {
+        // Initialize reconnection manager
+        if (this.config.reconnection?.enabled !== false) {
+            this.reconnectionManager = new oReconnectionManager(this, {
+                enabled: true,
+                maxAttempts: this.config.reconnection?.maxAttempts ?? 10,
+                baseDelayMs: this.config.reconnection?.baseDelayMs ?? 5000,
+                maxDelayMs: this.config.reconnection?.maxDelayMs ?? 60000,
+                useLeaderFallback: this.config.reconnection?.useLeaderFallback ?? true,
+                parentDiscoveryIntervalMs: this.config.reconnection?.parentDiscoveryIntervalMs ?? 10000,
+                parentDiscoveryMaxDelayMs: this.config.reconnection?.parentDiscoveryMaxDelayMs ?? 60000,
+            });
+        }
+    }
+    async hookInitializeFinished() { }
+    async hookStartFinished() {
+        // Initialize connection heartbeat manager
+        this.connectionHeartbeatManager = new oConnectionHeartbeatManager(this, {
+            enabled: this.config.connectionHeartbeat?.enabled ?? true,
+            intervalMs: this.config.connectionHeartbeat?.intervalMs ?? 15000,
+            timeoutMs: this.config.connectionHeartbeat?.timeoutMs ?? 15000,
+            failureThreshold: this.config.connectionHeartbeat?.failureThreshold ?? 3,
+            checkChildren: this.config.connectionHeartbeat?.checkChildren ?? false,
+            checkParent: this.config.connectionHeartbeat?.checkParent ?? true,
+            checkLeader: true,
+        });
+        this.logger.info(`Connection heartbeat config: leader=${this.connectionHeartbeatManager.getConfig().checkLeader}, ` +
+            `parent=${this.connectionHeartbeatManager.getConfig().checkParent}`);
+    }
+    async initialize() {
+        this.logger.debug('Initializing node...');
+        if (this.p2pNode && this.state !== NodeState.STOPPED) {
+            throw new Error('Node is not in a valid state to be initialized');
+        }
+        if (!this.address.validate()) {
+            throw new Error('Invalid address');
+        }
+        await this.createNode();
+        await this.initializeRouter();
+        // need to wait until our libpp2 node is initialized before calling super.initialize
+        await super.initialize();
+        this.logger.debug('Node initializedddd!', this.transports.map((t) => t.toString()));
+        this.address.setTransports(this.transports);
+        this.peerId = this.p2pNode.peerId;
+        // initialize connection manager
+        await this.initConnectionManager();
+        // Initialize leader request wrapper with circuit breaker
+        this.leaderRequestWrapper = new LeaderRequestWrapper({
+            enabled: this.config.leaderRetry?.enabled ?? true,
+            maxAttempts: this.config.leaderRetry?.maxAttempts ?? 20,
+            baseDelayMs: this.config.leaderRetry?.baseDelayMs ?? 2000,
+            maxDelayMs: this.config.leaderRetry?.maxDelayMs ?? 30000,
+            timeoutMs: this.config.leaderRetry?.timeoutMs ?? 120000,
+            circuitBreaker: {
+                enabled: this.config.leaderRetry?.circuitBreaker?.enabled ?? true,
+                failureThreshold: this.config.leaderRetry?.circuitBreaker?.failureThreshold ?? 3,
+                openTimeoutMs: this.config.leaderRetry?.circuitBreaker?.openTimeoutMs ?? 30000,
+                halfOpenMaxAttempts: this.config.leaderRetry?.circuitBreaker?.halfOpenMaxAttempts ?? 1,
+            },
+        });
+        this.logger.info(`Leader retry config: enabled=${this.leaderRequestWrapper.getConfig().enabled}, ` +
+            `maxAttempts=${this.leaderRequestWrapper.getConfig().maxAttempts}, ` +
+            `circuitBreaker.enabled=${this.leaderRequestWrapper.getConfig().circuitBreaker?.enabled}`);
+        // initialize address resolution
+        this.router.addResolver(new oMethodResolver(this.address));
+        this.router.addResolver(new oNodeResolver(this.address));
+        // setup a fallback resolver for non-leader nodes
+        if (this.isLeader === false) {
+            this.logger.debug('Adding leader resolver fallback...');
+            this.router.addResolver(new oLeaderResolverFallback(this.address));
+        }
+        // initialize reconnection manager
+        await this.initReconnectionManager();
+        await this.hookInitializeFinished();
+    }
+    /**
+     * Override use() to wrap leader/registry requests with retry logic
+     */
+    async use(address, data, options) {
+        // Wrap leader/registry requests with retry logic
+        return this.leaderRequestWrapper.execute(() => super.use(address, data, { noRouting: options?.noRouting ?? false }), address, data?.method);
+    }
+    async teardown() {
+        // Stop heartbeat before parent teardown
+        if (this.connectionHeartbeatManager) {
+            await this.connectionHeartbeatManager.stop();
+        }
+        await this.unregister();
+        await super.teardown();
+        if (this.p2pNode) {
+            await this.p2pNode.stop();
+        }
+    }
+    // IHeartbeatableNode interface methods
+    getLeaders() {
+        return [this.leader];
+    }
+    getParents() {
+        return this.hierarchyManager.getParents();
+    }
+    getChildren() {
+        return this.hierarchyManager.getChildren();
+    }
+    removeChild(childAddress) {
+        this.hierarchyManager.removeChild(childAddress);
+    }
+}

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

@@ -0,0 +1,52 @@
+import { Libp2p } from '@olane/o-config';
+import { oNotificationManager } from '@olane/o-core';
+import { oNodeAddress } from './router/o-node.address.js';
+import { oNodeHierarchyManager } from './o-node.hierarchy-manager.js';
+/**
+ * libp2p-specific implementation of oNotificationManager
+ * Wraps libp2p events and enriches them with Olane context
+ */
+export declare class oNodeNotificationManager extends oNotificationManager {
+    private p2pNode;
+    private hierarchyManager;
+    private address;
+    constructor(p2pNode: Libp2p, hierarchyManager: oNodeHierarchyManager, address: oNodeAddress);
+    /**
+     * Wire up libp2p event listeners
+     */
+    protected setupListeners(): void;
+    /**
+     * Handle peer connect event from libp2p
+     */
+    private handlePeerConnect;
+    /**
+     * Handle peer disconnect event from libp2p
+     */
+    private handlePeerDisconnect;
+    /**
+     * Handle peer discovery event from libp2p
+     */
+    private handlePeerDiscovery;
+    /**
+     * Handle connection open event from libp2p
+     */
+    private handleConnectionOpen;
+    /**
+     * Handle connection close event from libp2p
+     */
+    private handleConnectionClose;
+    /**
+     * Try to resolve a libp2p peer ID to an Olane address
+     * Checks hierarchy manager for known peers
+     */
+    private peerIdToAddress;
+    /**
+     * Check if an address is a direct child
+     */
+    private isChild;
+    /**
+     * Check if an address is a parent
+     */
+    private isParent;
+}
+//# sourceMappingURL=o-node.notification-manager.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"o-node.notification-manager.d.ts","sourceRoot":"","sources":["../../../src/o-node.notification-manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACzC,OAAO,EACL,oBAAoB,EAQrB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AAEtE;;;GAGG;AACH,qBAAa,wBAAyB,SAAQ,oBAAoB;IAE9D,OAAO,CAAC,OAAO;IACf,OAAO,CAAC,gBAAgB;IACxB,OAAO,CAAC,OAAO;gBAFP,OAAO,EAAE,MAAM,EACf,gBAAgB,EAAE,qBAAqB,EACvC,OAAO,EAAE,YAAY;IAK/B;;OAEG;IACH,SAAS,CAAC,cAAc,IAAI,IAAI;IAgChC;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAkDzB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAoD5B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAmB3B;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAI5B;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAI7B;;;OAGG;IACH,OAAO,CAAC,eAAe;IAkCvB;;OAEG;IACH,OAAO,CAAC,OAAO;IAMf;;OAEG;IACH,OAAO,CAAC,QAAQ;CAKjB"}