@olane/o-node 0.7.1

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

@@ -0,0 +1,58 @@
+import { oAddressResolver, TransportType, } from '@olane/o-core';
+export class oNodeChildResolver extends oAddressResolver {
+    constructor(address) {
+        super(address);
+        this.address = address;
+    }
+    get supportedTransports() {
+        return [TransportType.LIBP2P];
+    }
+    async resolve(routeRequest) {
+        const { address, node, request } = routeRequest;
+        if (!node) {
+            return {
+                nextHopAddress: address,
+                targetAddress: address,
+                requestOverride: request,
+            };
+        }
+        // if we are the same address, return the address
+        if (address.toStaticAddress().equals(node.address.toStaticAddress())) {
+            return {
+                nextHopAddress: node.address,
+                targetAddress: node.address,
+                requestOverride: request,
+            };
+        }
+        // get the next node & check for child address existence
+        const remainingPath = address.protocol.replace(node.address.protocol + '/', '');
+        // ensure this is going down in the hierarchy
+        if (remainingPath === address.protocol && node.isLeader === false) {
+            return {
+                nextHopAddress: node.address,
+                targetAddress: address,
+                requestOverride: request,
+            };
+        }
+        // static resolver
+        this.logger.debug(`[${node?.address}]: Next node: ${address.toString()}`);
+        const childAddress = node?.hierarchyManager.getChild(address);
+        this.logger.debug(`[${node?.address}]: Children: ${node?.hierarchyManager.children.map((c) => c.toString()).join(', ')}`);
+        this.logger.debug(`[${node?.address}]: Resolving address: ${address.toString()} and child address: ${childAddress?.toString()}`);
+        this.logger.debug('Child transports: ' +
+            childAddress?.transports.map((t) => t.toString()).join(', '));
+        // get the child address from hierarchy (which includes transports)
+        if (childAddress) {
+            return {
+                nextHopAddress: childAddress,
+                targetAddress: address,
+                requestOverride: request,
+            };
+        }
+        return {
+            nextHopAddress: address,
+            targetAddress: address,
+            requestOverride: request,
+        };
+    }
+}

package/dist/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/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/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/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/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/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,
+        };
+    }
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"o-node.search-resolver.d.ts","sourceRoot":"","sources":["../../../../src/router/resolvers/o-node.search-resolver.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,gBAAgB,EAEhB,UAAU,EACV,cAAc,EAEd,aAAa,EAEd,MAAM,eAAe,CAAC;AAGvB,qBAAa,eAAgB,SAAQ,gBAAgB;IACvC,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;CAiE/D"}

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

@@ -0,0 +1,60 @@
+import { oAddress, oAddressResolver, oCustomTransport, RestrictedAddresses, } from '@olane/o-core';
+import { oNodeTransport } from '../o-node.transport.js';
+export class oSearchResolver extends oAddressResolver {
+    constructor(address) {
+        super(address);
+        this.address = address;
+    }
+    get customTransports() {
+        return [new oCustomTransport('/search')];
+    }
+    async resolve(request) {
+        const { address, node, request: resolveRequest, targetAddress } = request;
+        if (address.transports.length > 0) {
+            return {
+                nextHopAddress: address,
+                targetAddress: targetAddress,
+                requestOverride: resolveRequest,
+            };
+        }
+        // search the leader registry for the address
+        const extraParams = address
+            .toString()
+            .replace(address.toRootAddress().toString(), '');
+        const params = {
+            staticAddress: address.toRootAddress().toString(),
+            address: address.toString(),
+        };
+        const registrySearchResults = await node.use(new oAddress(RestrictedAddresses.REGISTRY), {
+            method: 'search',
+            params: params,
+        });
+        // if there are results, return the first one
+        const registrySearchResultsArray = registrySearchResults.result.data.filter(
+        // filter out the items that may cause infinite looping
+        (result) => result.staticAddress !== RestrictedAddresses.REGISTRY &&
+            result.address !== node.address);
+        if (registrySearchResultsArray.length > 0) {
+            const registrySearchResult = registrySearchResultsArray[0];
+            // we know the final destination, so let's return it + the next hop
+            const targetAddress = new oAddress(registrySearchResult.address + extraParams);
+            const nextHopAddress = oAddress.next(node.address, targetAddress);
+            const targetTransports = registrySearchResult.transports.map((t) => new oNodeTransport(t.value));
+            const childAddress = node?.hierarchyManager.getChild(nextHopAddress);
+            nextHopAddress.setTransports(nextHopAddress.value === RestrictedAddresses.LEADER
+                ? node.leader?.transports
+                : childAddress?.transports || targetTransports);
+            targetAddress.setTransports(targetTransports);
+            return {
+                nextHopAddress: nextHopAddress,
+                targetAddress: targetAddress,
+                requestOverride: resolveRequest,
+            };
+        }
+        return {
+            nextHopAddress: address,
+            targetAddress: targetAddress,
+            requestOverride: resolveRequest,
+        };
+    }
+}

package/dist/src/router/route.request.d.ts

@@ -0,0 +1,14 @@
+import { RequestParams } from '@olane/o-protocol';
+import { oRequest } from '@olane/o-core';
+import { Stream } from '@olane/o-config';
+export interface RouteRequest extends oRequest {
+    stream: Stream;
+    params: RequestParams & {
+        address: string;
+        payload: {
+            method: string;
+            params: RequestParams;
+        };
+    };
+}
+//# sourceMappingURL=route.request.d.ts.map

package/dist/src/router/route.request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"route.request.d.ts","sourceRoot":"","sources":["../../../src/router/route.request.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAEzC,MAAM,WAAW,YAAa,SAAQ,QAAQ;IAC5C,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,aAAa,GAAG;QACtB,OAAO,EAAE,MAAM,CAAC;QAChB,OAAO,EAAE;YACP,MAAM,EAAE,MAAM,CAAC;YACf,MAAM,EAAE,aAAa,CAAC;SACvB,CAAC;KACH,CAAC;CACH"}

package/dist/src/router/route.request.js

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

package/dist/src/utils/network.utils.d.ts

@@ -0,0 +1,20 @@
+import { Libp2p, Multiaddr } from '@olane/o-config';
+import { oObject } from '@olane/o-core';
+import { CID } from 'multiformats';
+import { oNodeAddress } from '../router/o-node.address.js';
+export declare class NetworkUtils extends oObject {
+    static findProviders(p2pNode: Libp2p, cid: CID): Promise<{
+        transports: Multiaddr[];
+        staticAddress: string;
+        absoluteAddress: string;
+    }>;
+    static findNode(p2pNode: Libp2p, address: oNodeAddress): Promise<{
+        transports: Multiaddr[];
+        staticAddress: string;
+        absoluteAddress: string;
+    }>;
+    static advertiseValueToNetwork(value: CID, p2pNode: Libp2p): Promise<void>;
+    static dhtProvide(value: CID, p2pNode: Libp2p): Promise<void>;
+    static advertiseToNetwork(address: oNodeAddress, staticAddress: oNodeAddress, p2pNode: Libp2p): Promise<void>;
+}
+//# sourceMappingURL=network.utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"network.utils.d.ts","sourceRoot":"","sources":["../../../src/utils/network.utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AACpD,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AACxC,OAAO,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AACnC,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAE3D,qBAAa,YAAa,SAAQ,OAAO;WACnB,aAAa,CAC/B,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,GAAG,GACP,OAAO,CAAC;QACT,UAAU,EAAE,SAAS,EAAE,CAAC;QACxB,aAAa,EAAE,MAAM,CAAC;QACtB,eAAe,EAAE,MAAM,CAAC;KACzB,CAAC;WA2BkB,QAAQ,CAC1B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,YAAY,GACpB,OAAO,CAAC;QACT,UAAU,EAAE,SAAS,EAAE,CAAC;QACxB,aAAa,EAAE,MAAM,CAAC;QACtB,eAAe,EAAE,MAAM,CAAC;KACzB,CAAC;WAiBkB,uBAAuB,CAAC,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM;WAgBnD,UAAU,CAAC,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM;WAYtC,kBAAkB,CACpC,OAAO,EAAE,YAAY,EACrB,aAAa,EAAE,YAAY,EAC3B,OAAO,EAAE,MAAM;CAoClB"}

package/dist/src/utils/network.utils.js

@@ -0,0 +1,74 @@
+import { oObject } from '@olane/o-core';
+import { oNodeAddress } from '../router/o-node.address.js';
+export class NetworkUtils extends oObject {
+    static async findProviders(p2pNode, cid) {
+        let peer = null;
+        let multiaddrs = [];
+        for await (const event of p2pNode.services.dht.findProviders(cid)) {
+            // Look for events that contain actual provider information
+            if (event.name === 'PEER_RESPONSE') {
+                if (event.providers?.length === 0) {
+                    NetworkUtils.log('No providers found');
+                    break;
+                }
+                peer = event.providers[0].id;
+                multiaddrs = event.providers[0].multiaddrs;
+                break;
+            }
+            if (event.name === 'PATH_ENDED' || event.name === 'QUERY_ERROR') {
+                break;
+            }
+        }
+        return {
+            transports: multiaddrs,
+            staticAddress: '',
+            absoluteAddress: '',
+        };
+    }
+    static async findNode(p2pNode, address) {
+        const cid = await address.toCID();
+        return await Promise.race([
+            new Promise((_, reject) => setTimeout(() => reject(new Error('Content routing provide timeout')), 5000)),
+            this.findProviders(p2pNode, cid),
+        ]);
+    }
+    static async advertiseValueToNetwork(value, p2pNode) {
+        NetworkUtils.log('Advertising value to network: ', value.toString());
+        const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error('Advertise Content routing provide timeout')), 5000));
+        await Promise.race([
+            NetworkUtils.dhtProvide(value, p2pNode),
+            timeoutPromise,
+        ]);
+        NetworkUtils.log('Advertise complete!');
+    }
+    static async dhtProvide(value, p2pNode) {
+        for await (const event of p2pNode.services.dht.provide(value)) {
+            if (event.name === 'PATH_ENDED' ||
+                event.name === 'QUERY_ERROR' ||
+                event.name === 'PEER_RESPONSE') {
+                break;
+            }
+        }
+    }
+    static async advertiseToNetwork(address, staticAddress, p2pNode) {
+        NetworkUtils.log('Advertising to network our static and absolute addresses...');
+        // advertise the absolute address to the network with timeout
+        const add = new oNodeAddress(address.toString());
+        const absoluteAddressCid = await add.toCID();
+        // Add timeout to prevent hanging
+        NetworkUtils.advertiseValueToNetwork(absoluteAddressCid, p2pNode)
+            .then((d) => {
+            NetworkUtils.log(`${address.toString()} - Successfully advertised absolute address`);
+        })
+            .catch((error) => {
+            NetworkUtils.log(`${address.toString()} - Failed to advertise absolute address (this is normal for isolated nodes):`, error.message);
+        });
+        // advertise the static address to the network with timeout
+        const staticAdd = new oNodeAddress(staticAddress.toString());
+        const staticAddressCid = await staticAdd.toCID();
+        // Add timeout to prevent hanging
+        NetworkUtils.advertiseValueToNetwork(staticAddressCid, p2pNode).catch((error) => {
+            NetworkUtils.log('Failed to advertise absolute address (this is normal for isolated nodes):', error.message);
+        });
+    }
+}

package/dist/test/o-node.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=o-node.spec.d.ts.map

package/dist/test/o-node.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"o-node.spec.d.ts","sourceRoot":"","sources":["../../test/o-node.spec.ts"],"names":[],"mappings":""}

package/dist/test/o-node.spec.js

@@ -0,0 +1,20 @@
+import { NodeState } from '@olane/o-core';
+import { expect } from 'chai';
+import { oNode } from '../src/index.js';
+import { oNodeAddress } from '../src/router/o-node.address.js';
+describe('in-process @memory', () => {
+    it('should be able to start a single node with no leader', async () => {
+        const node = new oNode({
+            address: new oNodeAddress('o://test'),
+            leader: null,
+            parent: null,
+        });
+        await node.start();
+        expect(node.state).to.equal(NodeState.RUNNING);
+        const transports = node.transports;
+        // expect(transports.length).to.equal(1);
+        // expect(transports[0].toString()).to.contain('/memory');
+        await node.stop();
+        expect(node.state).to.equal(NodeState.STOPPED);
+    });
+});

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@olane/o-node",
+  "version": "0.7.1",
+  "type": "module",
+  "main": "dist/src/index.js",
+  "types": "dist/src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "default": "./dist/src/index.js"
+    }
+  },
+  "files": [
+    "dist/**/*",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "aegir test",
+    "test:node": "aegir test -t node",
+    "test:browser": "aegir test -t browser",
+    "dev": "DEBUG=o-protocol:* npx tsx src/tests/index.ts",
+    "build": "tsc",
+    "deep:clean": "rm -rf node_modules && rm package-lock.json",
+    "start:prod": "node dist/index.js",
+    "prepublishOnly": "npm run build",
+    "update:lib": "npm install @olane/o-core@latest",
+    "update:peers": "npm install @olane/o-core@latest @olane/o-config@latest @olane/o-protocol@latest @olane/o-tool@latest --save-peer",
+    "lint": "eslint src/**/*.ts"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/olane-labs/olane.git"
+  },
+  "author": "oLane Inc.",
+  "license": "ISC",
+  "description": "oLane p2p node used to host agentic functionality",
+  "devDependencies": {
+    "@eslint/eslintrc": "^3.3.1",
+    "@eslint/js": "^9.29.0",
+    "@tsconfig/node20": "^20.1.6",
+    "@types/jest": "^30.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.34.1",
+    "@typescript-eslint/parser": "^8.34.1",
+    "aegir": "^47.0.21",
+    "eslint": "^9.29.0",
+    "eslint-config-prettier": "^10.1.6",
+    "eslint-plugin-prettier": "^5.5.0",
+    "globals": "^16.2.0",
+    "jest": "^30.0.0",
+    "prettier": "^3.5.3",
+    "ts-jest": "^29.4.0",
+    "ts-node": "^10.9.2",
+    "tsconfig-paths": "^4.2.0",
+    "tsx": "^4.20.3",
+    "typescript": "5.4.5"
+  },
+  "peerDependencies": {
+    "@olane/o-config": "^0.7.0",
+    "@olane/o-core": "^0.7.0",
+    "@olane/o-protocol": "^0.7.0",
+    "@olane/o-tool": "^0.7.0"
+  },
+  "dependencies": {
+    "debug": "^4.4.1",
+    "dotenv": "^16.5.0"
+  }
+}