@olane/o-node 0.7.1

package/dist/src/o-node.js

@@ -0,0 +1,242 @@
+import { bootstrap, 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 { NetworkUtils } from './utils/network.utils.js';
+import { oMethodResolver, oToolBase } from '@olane/o-tool';
+import { oLeaderResolverFallback } from './router/index.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 this.config.network || defaultLibp2pConfig;
+    }
+    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();
+    }
+    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() {
+        if (this.type === NodeType.LEADER) {
+            this.logger.debug('Skipping unregistration, node is leader');
+            return;
+        }
+        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 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...');
+        }
+        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);
+        this.logger.debug('Registration successful');
+    }
+    extractMethod(address) {
+        return address.protocol.split('/').pop() || '';
+    }
+    async start() {
+        await super.start();
+        await NetworkUtils.advertiseToNetwork(this.address, this.staticAddress, this.p2pNode);
+    }
+    async validateJoinRequest(request) {
+        return true;
+    }
+    /**
+     * Configure the libp2p node
+     * @returns The libp2p config
+     */
+    async configure() {
+        const params = {
+            ...this.networkConfig,
+            transports: this.configureTransports(),
+            connectionManager: {
+                ...(this.networkConfig.connectionManager || {}),
+            },
+            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);
+            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 = {
+                // 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;
+                    }
+                    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.logger.debug('Encapsulating address: ' + this.address.toString(), parentAddress.toString());
+            this.address = CoreUtils.childAddress(parentAddress, this.address);
+            this.logger.debug('Encapsulated address: ' + this.address.toString());
+        }
+        return params;
+    }
+    async connect(nextHopAddress, targetAddress) {
+        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({
+            address: targetAddress,
+            nextHopAddress,
+            callerAddress: this.address,
+        })
+            .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 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');
+        }
+        const params = await this.configure();
+        this.p2pNode = await createNode(params);
+        await this.initializeRouter();
+        this.logger.debug('Node initialized!', this.transports.map((t) => t.toString()));
+        this.address.setTransports(this.transports);
+        this.peerId = this.p2pNode.peerId;
+        // initialize connection manager
+        this.connectionManager = new oNodeConnectionManager({
+            p2pNode: this.p2pNode,
+        });
+        // 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));
+        }
+    }
+    async teardown() {
+        await super.teardown();
+        if (this.p2pNode) {
+            await this.p2pNode.stop();
+        }
+    }
+}

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

@@ -0,0 +1,16 @@
+import { oAddress } from '@olane/o-core';
+import { IncomingStreamData } from '@olane/o-config';
+import { oServerNode } from './nodes/server.node.js';
+declare const oNodeTool_base: typeof oServerNode;
+/**
+ * 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 declare class oNodeTool extends oNodeTool_base {
+    handleProtocol(address: oAddress): Promise<void>;
+    initialize(): Promise<void>;
+    handleStream(streamData: IncomingStreamData): Promise<void>;
+}
+export {};
+//# sourceMappingURL=o-node.tool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"o-node.tool.d.ts","sourceRoot":"","sources":["../../src/o-node.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAKT,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAErD,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;;AAErD;;;;GAIG;AACH,qBAAa,SAAU,SAAQ,cAAkB;IACzC,cAAc,CAAC,OAAO,EAAE,QAAQ;IAKhC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAW3B,YAAY,CAAC,UAAU,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;CAgClE"}

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

@@ -0,0 +1,48 @@
+import { CoreUtils, oError, oErrorCodes, oRequest, } from '@olane/o-core';
+import { oTool } from '@olane/o-tool';
+import { oServerNode } from './nodes/server.node.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));
+    }
+    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(streamData) {
+        const { stream } = streamData;
+        const requestConfig = await CoreUtils.processStream(stream);
+        const request = new oRequest(requestConfig);
+        let success = true;
+        const result = await this.execute(request, stream).catch((error) => {
+            this.logger.error('Error executing tool: ', error, typeof error);
+            success = false;
+            const responseError = error instanceof oError
+                ? error
+                : new oError(oErrorCodes.UNKNOWN, error.message);
+            return {
+                error: responseError.toJSON(),
+            };
+        });
+        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
+        return CoreUtils.sendResponse(response, stream);
+    }
+}

package/dist/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/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/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/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/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/src/router/interfaces/o-node-router.config.js

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

package/dist/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/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/src/router/interfaces/o-node-router.response.js

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

package/dist/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/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/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/src/router/o-node.router.d.ts

@@ -0,0 +1,12 @@
+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 {
+    constructor();
+    protected forward(address: oNodeAddress, request: oRouterRequest, node: oNode): Promise<any>;
+    private handleExternalAddress;
+    translate(address: oNodeAddress, node: oNode): Promise<RouteResponse>;
+    isInternal(addressWithTransports: oNodeAddress, node: oNode): boolean;
+}
+//# sourceMappingURL=o-node.router.d.ts.map

package/dist/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,EAOL,cAAc,EACd,aAAa,EACd,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAI5C,qBAAa,WAAY,SAAQ,WAAW;;cAK1B,OAAO,CACrB,OAAO,EAAE,YAAY,EACrB,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,KAAK,GACV,OAAO,CAAC,GAAG,CAAC;IAgFf,OAAO,CAAC,qBAAqB;IAsBvB,SAAS,CAAC,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,KAAK,GAAG,OAAO,CAAC,aAAa,CAAC;IAoB3E,UAAU,CAAC,qBAAqB,EAAE,YAAY,EAAE,IAAI,EAAE,KAAK,GAAG,OAAO;CAetE"}

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

@@ -0,0 +1,109 @@
+import { oNodeAddress } from './o-node.address.js';
+import { CoreUtils, oAddress, oError, oErrorCodes, oRequest, } from '@olane/o-core';
+import { oToolRouter } from '@olane/o-tool';
+import { pipe, pushable } from '@olane/o-config';
+export class oNodeRouter extends oToolRouter {
+    constructor() {
+        super();
+    }
+    async forward(address, request, node) {
+        if (!request.stream) {
+            throw new oError(oErrorCodes.INVALID_REQUEST, 'Stream is required');
+        }
+        const stream = request.stream;
+        let nextHopRequest = new oRequest({
+            method: request.method,
+            params: request.params,
+            id: request.id,
+        });
+        // are we dialing self?
+        if (node.address.toString() === address.toString()) {
+            const { payload } = request.params;
+            const params = payload.params;
+            nextHopRequest = new oRequest({
+                method: payload.method,
+                params: {
+                    ...params,
+                },
+                id: request.id,
+            });
+            const result = await node.execute(nextHopRequest);
+            const response = CoreUtils.buildResponse(nextHopRequest, result, result?.error);
+            // add the request method to the response
+            return CoreUtils.sendResponse(response, stream);
+        }
+        // next hop is the destination address
+        if (address
+            ?.toStaticAddress()
+            .equals(new oAddress(request?.params?.address).toStaticAddress())) {
+            // reached destination, so change from route to actual request
+            const { payload } = request.params;
+            const params = payload.params;
+            nextHopRequest = new oRequest({
+                method: payload.method,
+                params: {
+                    ...params,
+                },
+                id: request.id,
+            });
+        }
+        // dial the target
+        try {
+            const targetStream = await node?.p2pNode.dialProtocol(address.libp2pTransports.map((t) => t.toMultiaddr()), address.protocol);
+            if (!targetStream) {
+                throw new oError(oErrorCodes.FAILED_TO_DIAL_TARGET, 'Failed to dial target');
+            }
+            const pushableStream = pushable();
+            pushableStream.push(new TextEncoder().encode(nextHopRequest.toString()));
+            pushableStream.end();
+            await targetStream.sink(pushableStream);
+            await pipe(targetStream.source, stream?.sink);
+        }
+        catch (error) {
+            if (error?.name === 'UnsupportedProtocolError') {
+                throw new oError(oErrorCodes.NOT_FOUND, 'Address not found');
+            }
+            throw error;
+        }
+    }
+    handleExternalAddress(address, node) {
+        // determine if this is external
+        const isInternal = this.isInternal(address, node);
+        if (!isInternal) {
+            // external address, so we need to route
+            this.logger.debug('Address is external, routing...', address);
+            // route to leader of external OS
+            return {
+                nextHopAddress: new oNodeAddress(oAddress.leader().toString(), address.libp2pTransports),
+                targetAddress: address,
+            };
+        }
+        return null;
+    }
+    async translate(address, node) {
+        const externalRoute = this.handleExternalAddress(address, node);
+        if (externalRoute) {
+            return externalRoute;
+        }
+        const { nextHopAddress, targetAddress, requestOverride } = await this.addressResolution.resolve({
+            address,
+            node,
+            targetAddress: address,
+        });
+        return {
+            nextHopAddress,
+            targetAddress: targetAddress,
+            requestOverride,
+        };
+    }
+    isInternal(addressWithTransports, node) {
+        if (addressWithTransports.paths.indexOf(oAddress.leader().paths) !== -1 && // if the address has a leader
+            addressWithTransports.libp2pTransports?.length > 0) {
+            // transports are provided, let's see if they match our known leaders
+            const isLeaderRef = addressWithTransports.toString() === oAddress.leader().toString();
+            const isOurLeaderRef = node.hierarchyManager.leaders.some((l) => l.equals(addressWithTransports));
+            return isLeaderRef || isOurLeaderRef;
+        }
+        return true;
+    }
+}

package/dist/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/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/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/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/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/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/src/router/resolvers/o-node.child-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 oNodeChildResolver extends oAddressResolver {
+    protected readonly address: oNodeAddress;
+    constructor(address: oNodeAddress);
+    get supportedTransports(): TransportType[];
+    resolve(routeRequest: ResolveRequest): Promise<oNodeRouterResponse>;
+}
+//# sourceMappingURL=o-node.child-resolver.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"o-node.child-resolver.d.ts","sourceRoot":"","sources":["../../../../src/router/resolvers/o-node.child-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,kBAAmB,SAAQ,gBAAgB;IAC1C,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;CA4D1E"}