@olane/o-node 0.7.12-alpha.21 → 0.7.12-alpha.23

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

@@ -0,0 +1,116 @@
+import { CoreUtils, oError, oErrorCodes, oRequest, ChildJoinedEvent, } from '@olane/o-core';
+import { isAsyncGenerator, processStream } from '../../o-core/src/utils/streaming.utils.js';
+import { oTool } from '@olane/o-tool';
+import { oServerNode } from './nodes/server.node.js';
+import { oNodeTransport } from './router/o-node.transport.js';
+import { oNodeAddress } from './router/o-node.address.js';
+import { Libp2pStreamTransport } from './streaming/libp2p-stream-transport.js';
+import { NodeStreamHandler } from './streaming/node-stream-handler.js';
+/**
+ * oTool is a mixin that extends the base class and implements the oTool interface
+ * @param Base - The base class to extend
+ * @returns A new class that extends the base class and implements the oTool interface
+ */
+export class oNodeTool extends oTool(oServerNode) {
+    async handleProtocol(address) {
+        this.logger.debug('Handling protocol: ' + address.protocol);
+        await this.p2pNode.handle(address.protocol, this.handleStream.bind(this), {
+            maxInboundStreams: Infinity,
+            maxOutboundStreams: Infinity,
+        });
+    }
+    async initialize() {
+        await super.initialize();
+        await this.handleProtocol(this.address);
+        if (this.staticAddress &&
+            this.staticAddress?.toString() !== this.address.toString()) {
+            await this.handleProtocol(this.staticAddress);
+        }
+    }
+    async handleStream(stream, connection) {
+        // CRITICAL: Attach message listener immediately to prevent buffer overflow (libp2p v3)
+        // Per libp2p migration guide: "If no message event handler is added, streams will
+        // buffer incoming data until a pre-configured limit is reached, after which the stream will be reset."
+        const messageHandler = async (event) => {
+            if (!event.data) {
+                this.logger.warn('Malformed event data');
+                return;
+            }
+            const requestConfig = await processStream(event);
+            const request = new oRequest(requestConfig);
+            let success = true;
+            const result = await this.execute(request, stream).catch((error) => {
+                this.logger.error('Error executing tool: ', request.toString(), error, typeof error);
+                success = false;
+                const responseError = error instanceof oError
+                    ? error
+                    : new oError(oErrorCodes.UNKNOWN, error.message);
+                return {
+                    error: responseError.toJSON(),
+                };
+            });
+            // Check if result is a streaming AsyncGenerator
+            if (isAsyncGenerator(result)) {
+                this.logger.debug('Handling streaming response for: ' + request.method);
+                // Create stream transport and handler
+                const transport = new Libp2pStreamTransport(stream);
+                const streamHandler = new NodeStreamHandler(transport, {
+                    enableMetrics: true,
+                    trackSuccessCount: true,
+                    trackErrorCount: true,
+                });
+                try {
+                    // Handle the streaming using the new abstraction
+                    await streamHandler.handleStream(result, request);
+                    // Update metrics from the stream handler
+                    this.metrics.successCount += streamHandler.getSuccessCount();
+                }
+                catch (error) {
+                    this.logger.error('Error in streaming response: ', error);
+                    this.metrics.errorCount++;
+                }
+            }
+            else {
+                // Non-streaming response - original behavior
+                if (success) {
+                    this.metrics.successCount++;
+                }
+                else {
+                    this.metrics.errorCount++;
+                }
+                // compose the response & add the expected connection + request fields
+                const response = CoreUtils.buildResponse(request, result, result?.error);
+                // add the request method to the response
+                await CoreUtils.sendResponse(response, stream);
+            }
+        };
+        // Attach listener synchronously before any async operations
+        stream.addEventListener('message', messageHandler);
+    }
+    async _tool_identify() {
+        return {
+            address: this.address.toString(),
+            staticAddress: this.staticAddress?.toString(),
+            transports: this.transports.map((t) => t.toMultiaddr().toString()),
+        };
+    }
+    async _tool_child_register(request) {
+        this.logger.debug('Child register: ', request.params);
+        const { address, transports } = request.params;
+        const childAddress = new oNodeAddress(address, transports.map((t) => new oNodeTransport(t)));
+        // Add child to hierarchy
+        this.hierarchyManager.addChild(childAddress);
+        // Emit child joined event
+        if (this.notificationManager) {
+            this.notificationManager.emit(new ChildJoinedEvent({
+                source: this.address,
+                childAddress,
+                parentAddress: this.address,
+            }));
+        }
+        return {
+            message: `Child node registered with parent! ${childAddress.toString()}`,
+            parentTransports: this.parentTransports.map((t) => t.toString()),
+        };
+    }
+}

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

@@ -0,0 +1,6 @@
+export * from './o-node.address.js';
+export * from './o-node.router.js';
+export * from './o-node.transport.js';
+export * from './resolvers/index.js';
+export * from './route.request.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/router/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC"}

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

@@ -0,0 +1,5 @@
+export * from './o-node.address.js';
+export * from './o-node.router.js';
+export * from './o-node.transport.js';
+export * from './resolvers/index.js';
+export * from './route.request.js';

package/dist/o-node/src/router/interfaces/o-node-router.config.d.ts

@@ -0,0 +1,3 @@
+export interface oNodeRouterConfig {
+}
+//# sourceMappingURL=o-node-router.config.d.ts.map

package/dist/o-node/src/router/interfaces/o-node-router.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"o-node-router.config.d.ts","sourceRoot":"","sources":["../../../../../src/router/interfaces/o-node-router.config.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,iBAAiB;CAAG"}

package/dist/o-node/src/router/interfaces/o-node-router.config.js

@@ -0,0 +1 @@
+export {};

package/dist/o-node/src/router/interfaces/o-node-router.response.d.ts

@@ -0,0 +1,8 @@
+import { oNodeAddress } from '../o-node.address';
+import { oRouterRequest, RouteResponse } from '@olane/o-core';
+export interface oNodeRouterResponse extends RouteResponse {
+    nextHopAddress: oNodeAddress;
+    targetAddress: oNodeAddress;
+    requestOverride?: oRouterRequest;
+}
+//# sourceMappingURL=o-node-router.response.d.ts.map

package/dist/o-node/src/router/interfaces/o-node-router.response.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"o-node-router.response.d.ts","sourceRoot":"","sources":["../../../../../src/router/interfaces/o-node-router.response.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAE9D,MAAM,WAAW,mBAAoB,SAAQ,aAAa;IACxD,cAAc,EAAE,YAAY,CAAC;IAC7B,aAAa,EAAE,YAAY,CAAC;IAC5B,eAAe,CAAC,EAAE,cAAc,CAAC;CAClC"}

package/dist/o-node/src/router/interfaces/o-node-router.response.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,18 @@
+import { Multiaddr } from '@olane/o-config';
+import { oNodeTransport } from './o-node.transport.js';
+import { oAddress } from '@olane/o-core';
+export declare class oNodeAddress extends oAddress {
+    readonly value: string;
+    transports: oNodeTransport[];
+    constructor(value: string, transports?: oNodeTransport[]);
+    static fromJSON(json: {
+        value: string;
+        transports: string[] | Multiaddr[];
+    }): oNodeAddress;
+    get libp2pTransports(): oNodeTransport[];
+    get customTransports(): oNodeTransport[];
+    toString(): string;
+    toMultiaddr(): Multiaddr;
+    static fromMultiaddr(ma: Multiaddr): oAddress;
+}
+//# sourceMappingURL=o-node.address.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"o-node.address.d.ts","sourceRoot":"","sources":["../../../../src/router/o-node.address.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAa,MAAM,iBAAiB,CAAC;AAEvD,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAqB,QAAQ,EAAiB,MAAM,eAAe,CAAC;AAE3E,qBAAa,YAAa,SAAQ,QAAQ;aAItB,KAAK,EAAE,MAAM;IAHxB,UAAU,EAAE,cAAc,EAAE,CAAM;gBAGvB,KAAK,EAAE,MAAM,EAC7B,UAAU,GAAE,cAAc,EAAO;IAMnC,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE;QACpB,KAAK,EAAE,MAAM,CAAC;QACd,UAAU,EAAE,MAAM,EAAE,GAAG,SAAS,EAAE,CAAC;KACpC,GAAG,YAAY;IAShB,IAAI,gBAAgB,IAAI,cAAc,EAAE,CAEvC;IAED,IAAI,gBAAgB,IAAI,cAAc,EAAE,CAEvC;IAED,QAAQ,IAAI,MAAM;IAIlB,WAAW,IAAI,SAAS;IAIxB,MAAM,CAAC,aAAa,CAAC,EAAE,EAAE,SAAS,GAAG,QAAQ;CAG9C"}

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

@@ -0,0 +1,29 @@
+import { multiaddr } from '@olane/o-config';
+import { oNodeTransport } from './o-node.transport.js';
+import { oAddress, TransportType } from '@olane/o-core';
+export class oNodeAddress extends oAddress {
+    constructor(value, transports = []) {
+        super(value);
+        this.value = value;
+        this.transports = [];
+        this.transports = transports;
+    }
+    static fromJSON(json) {
+        return new oNodeAddress(json.value, json.transports.map((t) => new oNodeTransport(t)));
+    }
+    get libp2pTransports() {
+        return this.transports.filter((t) => t.type === TransportType.LIBP2P) || [];
+    }
+    get customTransports() {
+        return this.transports.filter((t) => t.type === TransportType.CUSTOM) || [];
+    }
+    toString() {
+        return this.value;
+    }
+    toMultiaddr() {
+        return multiaddr(this.protocol);
+    }
+    static fromMultiaddr(ma) {
+        return new oAddress(ma.toString().replace('/o/', 'o://'));
+    }
+}

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

@@ -0,0 +1,45 @@
+import { oNodeAddress } from './o-node.address.js';
+import { oRouterRequest, RouteResponse } from '@olane/o-core';
+import type { oNode } from '../o-node.js';
+import { oToolRouter } from '@olane/o-tool';
+export declare class oNodeRouter extends oToolRouter {
+    private routingPolicy;
+    constructor();
+    /**
+     * Forwards a request to the specified address via libp2p transport.
+     * Handles self-routing (local execution) and destination detection.
+     *
+     * @param address The next hop address to forward to
+     * @param request The router request to forward
+     * @param node The current node context
+     * @returns The response from the forwarded request
+     */
+    protected forward(address: oNodeAddress, request: oRouterRequest, node: oNode): Promise<any>;
+    /**
+     * Executes a request locally when routing to self.
+     */
+    private executeSelfRouting;
+    /**
+     * Checks if the next hop is the final destination address.
+     */
+    private isDestinationAddress;
+    /**
+     * Unwraps the routing envelope when we've reached the destination.
+     */
+    private unwrapDestinationRequest;
+    /**
+     * Dials a remote node and transmits the request via libp2p.
+     */
+    private dialAndTransmit;
+    /**
+     * Translates an address to determine the next hop and target addresses.
+     * First checks routing policy for external routing, then applies resolver chain.
+     */
+    translate(address: oNodeAddress, node: oNode): Promise<RouteResponse>;
+    /**
+     * Determines if an address is internal to this node's hierarchy.
+     * Delegates to the routing policy for the decision.
+     */
+    isInternal(addressWithTransports: oNodeAddress, node: oNode): boolean;
+}
+//# sourceMappingURL=o-node.router.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"o-node.router.d.ts","sourceRoot":"","sources":["../../../../src/router/o-node.router.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAML,cAAc,EACd,aAAa,EACd,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAK5C,qBAAa,WAAY,SAAQ,WAAW;IAC1C,OAAO,CAAC,aAAa,CAAqB;;IAO1C;;;;;;;;OAQG;cACa,OAAO,CACrB,OAAO,EAAE,YAAY,EACrB,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,KAAK,GACV,OAAO,CAAC,GAAG,CAAC;IA0Bf;;OAEG;YACW,kBAAkB;IAgBhC;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAS5B;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAUhC;;OAEG;YACW,eAAe;IA2B7B;;;OAGG;IACG,SAAS,CAAC,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,KAAK,GAAG,OAAO,CAAC,aAAa,CAAC;IAyB3E;;;OAGG;IACH,UAAU,CAAC,qBAAqB,EAAE,YAAY,EAAE,IAAI,EAAE,KAAK,GAAG,OAAO;CAGtE"}

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

@@ -0,0 +1,125 @@
+import { oAddress, oError, oErrorCodes, oRequest, } from '@olane/o-core';
+import { oToolRouter } from '@olane/o-tool';
+import { oNodeConnection } from '../connection/o-node-connection.js';
+import { oNodeRoutingPolicy } from './o-node.routing-policy.js';
+export class oNodeRouter extends oToolRouter {
+    constructor() {
+        super();
+        this.routingPolicy = new oNodeRoutingPolicy();
+    }
+    /**
+     * Forwards a request to the specified address via libp2p transport.
+     * Handles self-routing (local execution) and destination detection.
+     *
+     * @param address The next hop address to forward to
+     * @param request The router request to forward
+     * @param node The current node context
+     * @returns The response from the forwarded request
+     */
+    async forward(address, request, node) {
+        if (!request.stream) {
+            throw new oError(oErrorCodes.INVALID_REQUEST, 'Stream is required');
+        }
+        let nextHopRequest = new oRequest({
+            method: request.method,
+            params: request.params,
+            id: request.id,
+        });
+        // Handle self-routing: execute locally instead of dialing
+        if (this.routingPolicy.isSelfAddress(address, node)) {
+            return this.executeSelfRouting(request, node);
+        }
+        // Check if we've reached the final destination
+        const isDestination = this.isDestinationAddress(address, request);
+        if (isDestination) {
+            nextHopRequest = this.unwrapDestinationRequest(request);
+        }
+        // Dial and transmit to remote node
+        return this.dialAndTransmit(address, nextHopRequest, node);
+    }
+    /**
+     * Executes a request locally when routing to self.
+     */
+    async executeSelfRouting(request, node) {
+        const { payload } = request.params;
+        const params = payload.params;
+        const localRequest = new oRequest({
+            method: payload.method,
+            params: { ...params },
+            id: request.id,
+        });
+        const result = await node.execute(localRequest);
+        return result;
+    }
+    /**
+     * Checks if the next hop is the final destination address.
+     */
+    isDestinationAddress(address, request) {
+        return address
+            ?.toStaticAddress()
+            .equals(new oAddress(request?.params?.address).toStaticAddress());
+    }
+    /**
+     * Unwraps the routing envelope when we've reached the destination.
+     */
+    unwrapDestinationRequest(request) {
+        const { payload } = request.params;
+        const params = payload.params;
+        return new oRequest({
+            method: payload.method,
+            params: { ...params },
+            id: request.id,
+        });
+    }
+    /**
+     * Dials a remote node and transmits the request via libp2p.
+     */
+    async dialAndTransmit(address, request, node) {
+        try {
+            const connection = await node.p2pNode.dial(address.libp2pTransports.map((t) => t.toMultiaddr()));
+            const nodeConnection = new oNodeConnection({
+                p2pConnection: connection,
+                nextHopAddress: address,
+                address: node.address,
+                callerAddress: node.address,
+            });
+            const response = await nodeConnection.transmit(request);
+            return response.result.data;
+        }
+        catch (error) {
+            if (error?.name === 'UnsupportedProtocolError') {
+                throw new oError(oErrorCodes.NOT_FOUND, 'Address not found');
+            }
+            throw error;
+        }
+    }
+    /**
+     * Translates an address to determine the next hop and target addresses.
+     * First checks routing policy for external routing, then applies resolver chain.
+     */
+    async translate(address, node) {
+        // Check if external routing is needed
+        const externalRoute = this.routingPolicy.getExternalRoutingStrategy(address, node);
+        if (externalRoute) {
+            return externalRoute;
+        }
+        // Apply resolver chain for internal routing
+        const { nextHopAddress, targetAddress, requestOverride } = await this.addressResolution.resolve({
+            address,
+            node,
+            targetAddress: address,
+        });
+        return {
+            nextHopAddress,
+            targetAddress: targetAddress,
+            requestOverride,
+        };
+    }
+    /**
+     * Determines if an address is internal to this node's hierarchy.
+     * Delegates to the routing policy for the decision.
+     */
+    isInternal(addressWithTransports, node) {
+        return this.routingPolicy.isInternalAddress(addressWithTransports, node);
+    }
+}

package/dist/o-node/src/router/o-node.routing-policy.d.ts

@@ -0,0 +1,30 @@
+import { oAddress, oRoutingPolicy, RouteResponse } from '@olane/o-core';
+import type { oNode } from '../o-node.js';
+/**
+ * Routing policy implementation for oNode that handles internal/external routing decisions
+ * and leader-based routing strategies.
+ */
+export declare class oNodeRoutingPolicy extends oRoutingPolicy {
+    /**
+     * Determines if an address is internal to the current node's hierarchy.
+     * An address is considered internal if:
+     * 1. It doesn't have leader references, OR
+     * 2. Its leader references match our known leaders
+     *
+     * @param address The address to check
+     * @param node The current node context
+     * @returns True if the address is internal to this hierarchy
+     */
+    isInternalAddress(address: oAddress, node: oNode): boolean;
+    /**
+     * Determines the routing strategy for external addresses.
+     * External addresses are routed to the leader of the external OS using
+     * the address's libp2p transports.
+     *
+     * @param address The address to evaluate
+     * @param node The current node context
+     * @returns RouteResponse if external routing is needed, null if internal
+     */
+    getExternalRoutingStrategy(address: oAddress, node: oNode): RouteResponse | null;
+}
+//# sourceMappingURL=o-node.routing-policy.d.ts.map

package/dist/o-node/src/router/o-node.routing-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"o-node.routing-policy.d.ts","sourceRoot":"","sources":["../../../../src/router/o-node.routing-policy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACxE,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAG1C;;;GAGG;AACH,qBAAa,kBAAmB,SAAQ,cAAc;IACpD;;;;;;;;;OASG;IACH,iBAAiB,CAAC,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,KAAK,GAAG,OAAO;IAuB1D;;;;;;;;OAQG;IACH,0BAA0B,CACxB,OAAO,EAAE,QAAQ,EACjB,IAAI,EAAE,KAAK,GACV,aAAa,GAAG,IAAI;CAmBxB"}

package/dist/o-node/src/router/o-node.routing-policy.js

@@ -0,0 +1,57 @@
+import { oAddress, oRoutingPolicy } from '@olane/o-core';
+import { oNodeAddress } from './o-node.address.js';
+/**
+ * Routing policy implementation for oNode that handles internal/external routing decisions
+ * and leader-based routing strategies.
+ */
+export class oNodeRoutingPolicy extends oRoutingPolicy {
+    /**
+     * Determines if an address is internal to the current node's hierarchy.
+     * An address is considered internal if:
+     * 1. It doesn't have leader references, OR
+     * 2. Its leader references match our known leaders
+     *
+     * @param address The address to check
+     * @param node The current node context
+     * @returns True if the address is internal to this hierarchy
+     */
+    isInternalAddress(address, node) {
+        const nodeAddress = address;
+        // if we are trying to connect to a parent, it's internal
+        if (node.hierarchyManager.parents.some((p) => p.equals(address))) {
+            return true;
+        }
+        if (nodeAddress.paths.indexOf(oAddress.leader().paths) !== -1 && // if the address has a leader
+            nodeAddress.libp2pTransports?.length > 0) {
+            // transports are provided, let's see if they match our known leaders
+            const isLeaderRef = nodeAddress.toString() === oAddress.leader().toString();
+            const isOurLeaderRef = node.address.equals(nodeAddress) ||
+                node.hierarchyManager.leaders.some((l) => l.equals(nodeAddress));
+            return isLeaderRef || isOurLeaderRef;
+        }
+        return true;
+    }
+    /**
+     * Determines the routing strategy for external addresses.
+     * External addresses are routed to the leader of the external OS using
+     * the address's libp2p transports.
+     *
+     * @param address The address to evaluate
+     * @param node The current node context
+     * @returns RouteResponse if external routing is needed, null if internal
+     */
+    getExternalRoutingStrategy(address, node) {
+        const nodeAddress = address;
+        const isInternal = this.isInternalAddress(address, node);
+        if (!isInternal) {
+            // external address, so we need to route
+            this.logger.debug('Address is external, routing...', nodeAddress);
+            // route to leader of external OS
+            return {
+                nextHopAddress: new oNodeAddress(oAddress.leader().toString(), nodeAddress.libp2pTransports),
+                targetAddress: nodeAddress,
+            };
+        }
+        return null;
+    }
+}

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

@@ -0,0 +1,11 @@
+import { Multiaddr } from '@olane/o-config';
+import { oTransport, TransportType } from '@olane/o-core';
+export declare class oNodeTransport extends oTransport {
+    readonly type: TransportType;
+    value: Multiaddr | string;
+    constructor(value: Multiaddr | string);
+    toMultiaddr(): Multiaddr;
+    toString(): string;
+    toPeerId(): string;
+}
+//# sourceMappingURL=o-node.transport.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"o-node.transport.d.ts","sourceRoot":"","sources":["../../../../src/router/o-node.transport.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACvD,OAAO,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAE1D,qBAAa,cAAe,SAAQ,UAAU;IAC5C,SAAgB,IAAI,EAAE,aAAa,CAAwB;IACpD,KAAK,EAAE,SAAS,GAAG,MAAM,CAAC;gBAErB,KAAK,EAAE,SAAS,GAAG,MAAM;IAKrC,WAAW,IAAI,SAAS;IAIxB,QAAQ,IAAI,MAAM;IAIlB,QAAQ,IAAI,MAAM;CAGnB"}

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

@@ -0,0 +1,18 @@
+import { multiaddr } from '@olane/o-config';
+import { oTransport, TransportType } from '@olane/o-core';
+export class oNodeTransport extends oTransport {
+    constructor(value) {
+        super(value);
+        this.type = TransportType.LIBP2P;
+        this.value = value;
+    }
+    toMultiaddr() {
+        return multiaddr(this.toString());
+    }
+    toString() {
+        return this.value.toString();
+    }
+    toPeerId() {
+        return this.value.toString().split('/p2p/')[1];
+    }
+}

package/dist/o-node/src/router/resolvers/index.d.ts

@@ -0,0 +1,4 @@
+export * from './o-node.search-resolver.js';
+export * from './o-node.resolver.js';
+export * from './o-node.leader-resolver-fallback.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/o-node/src/router/resolvers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/router/resolvers/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,sBAAsB,CAAC;AACrC,cAAc,sCAAsC,CAAC"}

package/dist/o-node/src/router/resolvers/index.js

@@ -0,0 +1,3 @@
+export * from './o-node.search-resolver.js';
+export * from './o-node.resolver.js';
+export * from './o-node.leader-resolver-fallback.js';

package/dist/o-node/src/router/resolvers/o-node.leader-resolver-fallback.d.ts

@@ -0,0 +1,8 @@
+import { oAddress, oAddressResolver, oTransport, ResolveRequest, RouteResponse } from '@olane/o-core';
+export declare class oLeaderResolverFallback extends oAddressResolver {
+    protected readonly address: oAddress;
+    constructor(address: oAddress);
+    get customTransports(): oTransport[];
+    resolve(request: ResolveRequest): Promise<RouteResponse>;
+}
+//# sourceMappingURL=o-node.leader-resolver-fallback.d.ts.map

package/dist/o-node/src/router/resolvers/o-node.leader-resolver-fallback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"o-node.leader-resolver-fallback.d.ts","sourceRoot":"","sources":["../../../../../src/router/resolvers/o-node.leader-resolver-fallback.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,gBAAgB,EAEhB,UAAU,EACV,cAAc,EAEd,aAAa,EAEd,MAAM,eAAe,CAAC;AAIvB,qBAAa,uBAAwB,SAAQ,gBAAgB;IAC/C,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,QAAQ;gBAAjB,OAAO,EAAE,QAAQ;IAIhD,IAAI,gBAAgB,IAAI,UAAU,EAAE,CAEnC;IAEK,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC;CA4B/D"}

package/dist/o-node/src/router/resolvers/o-node.leader-resolver-fallback.js

@@ -0,0 +1,35 @@
+import { oAddressResolver, oCustomTransport, } from '@olane/o-core';
+export class oLeaderResolverFallback extends oAddressResolver {
+    constructor(address) {
+        super(address);
+        this.address = address;
+    }
+    get customTransports() {
+        return [new oCustomTransport('/fallback/leader')];
+    }
+    async resolve(request) {
+        const { address, node, request: resolveRequest, targetAddress } = request;
+        // check to see if something odd was attempted where the leader transports were applied to a different address
+        if (node.leader &&
+            address.transports.some((t) => node.leader?.transports.includes(t))) {
+            return {
+                nextHopAddress: node.leader,
+                targetAddress: targetAddress,
+                requestOverride: resolveRequest,
+            };
+        }
+        // if already has transports, return the address
+        if (address.transports.length > 0) {
+            return {
+                nextHopAddress: address,
+                targetAddress: targetAddress,
+                requestOverride: resolveRequest,
+            };
+        }
+        return {
+            nextHopAddress: node.leader,
+            targetAddress: targetAddress,
+            requestOverride: resolveRequest,
+        };
+    }
+}

package/dist/o-node/src/router/resolvers/o-node.resolver.d.ts

@@ -0,0 +1,11 @@
+import { oAddressResolver, TransportType } from '@olane/o-core';
+import { oNodeAddress } from '../o-node.address.js';
+import { oNodeRouterResponse } from '../interfaces/o-node-router.response.js';
+import { ResolveRequest } from '@olane/o-core';
+export declare class oNodeResolver extends oAddressResolver {
+    protected readonly address: oNodeAddress;
+    constructor(address: oNodeAddress);
+    get supportedTransports(): TransportType[];
+    resolve(routeRequest: ResolveRequest): Promise<oNodeRouterResponse>;
+}
+//# sourceMappingURL=o-node.resolver.d.ts.map

package/dist/o-node/src/router/resolvers/o-node.resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"o-node.resolver.d.ts","sourceRoot":"","sources":["../../../../../src/router/resolvers/o-node.resolver.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAEhB,aAAa,EAEd,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AAEpD,OAAO,EAAE,mBAAmB,EAAE,MAAM,yCAAyC,CAAC;AAC9E,OAAO,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAE/C,qBAAa,aAAc,SAAQ,gBAAgB;IACrC,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,YAAY;gBAArB,OAAO,EAAE,YAAY;IAIpD,IAAI,mBAAmB,IAAI,aAAa,EAAE,CAEzC;IAEK,OAAO,CAAC,YAAY,EAAE,cAAc,GAAG,OAAO,CAAC,mBAAmB,CAAC;CAsC1E"}

package/dist/o-node/src/router/resolvers/o-node.resolver.js

@@ -0,0 +1,41 @@
+import { oAddressResolver, TransportType, } from '@olane/o-core';
+import { oNodeAddress } from '../o-node.address.js';
+export class oNodeResolver extends oAddressResolver {
+    constructor(address) {
+        super(address);
+        this.address = address;
+    }
+    get supportedTransports() {
+        return [TransportType.LIBP2P];
+    }
+    async resolve(routeRequest) {
+        const { address, node, request, targetAddress } = routeRequest;
+        // get the next node & check for child address existence
+        const remainingPath = targetAddress.paths.replace(node.address.paths + '/', '');
+        // ensure this is going down in the hierarchy
+        if (remainingPath === targetAddress.paths && node.isLeader === false) {
+            return {
+                nextHopAddress: address,
+                targetAddress: targetAddress,
+                requestOverride: request,
+            };
+        }
+        // next term resolver
+        const parts = remainingPath.split('/');
+        const nextNode = new oNodeAddress(`o://${parts.shift()}`);
+        const childAddress = node?.hierarchyManager.getChild(nextNode);
+        // get the child address from hierarchy (which includes transports)
+        if (childAddress) {
+            return {
+                nextHopAddress: childAddress,
+                targetAddress: targetAddress,
+                requestOverride: request,
+            };
+        }
+        return {
+            nextHopAddress: address,
+            targetAddress: targetAddress,
+            requestOverride: request,
+        };
+    }
+}