@oceanprotocol/lib 6.1.2 → 7.0.0-next.0

package/dist/types/services/providers/P2pProvider.d.ts

@@ -0,0 +1,180 @@
+import { type Libp2pOptions } from 'libp2p';
+import { Signer } from 'ethers';
+import { StorageObject, FileInfo, ComputeJob, ComputeOutput, ComputeAlgorithm, ComputeAsset, ComputeEnvironment, ProviderInitialize, ProviderComputeInitializeResults, UserCustomParameters, ComputeResourceRequest, ComputeJobMetadata, PolicyServerInitializeCommand, PolicyServerPassthroughCommand, dockerRegistryAuth, DownloadResponse, ComputeResultStream } from '../../@types/index.js';
+import { type DDO, type ValidateMetadata } from '@oceanprotocol/ddo-js';
+export declare const OCEAN_P2P_PROTOCOL = "/ocean/nodes/1.0.0";
+export interface P2PConfig {
+    /**
+     * Bootstrap peer multiaddrs for DHT peer discovery.
+     * Required when dialing bare peer IDs; defaults to Ocean Protocol's
+     * public bootstrap nodes. Ignored if `libp2p.peerDiscovery` is set.
+     */
+    bootstrapPeers?: string[];
+    /** Timeout per dial + stream operation in ms. Default: 10000 */
+    dialTimeout?: number;
+    /** Max retry attempts on connection errors. Default: 5 */
+    maxRetries?: number;
+    /** Base delay between retries in ms. Default: 1000 */
+    retryDelay?: number;
+    /**
+     * Timeout for DHT peer lookup when dialing a bare peer ID, in ms. Default: 60000.
+     * Intentionally separate from dialTimeout — DHT resolution needs more time than
+     * a direct dial. Once a peer is found and connected, subsequent calls skip this.
+     */
+    dhtLookupTimeout?: number;
+    /**
+     * mDNS discovery interval in ms. Set to 0 to disable. Default: 20000
+     * Useful for local development — discovers peers on the same LAN without bootstrap nodes.
+     */
+    mDNSInterval?: number;
+    /**
+     * Enable TCP transport in addition to WebSockets. Default: false.
+     * Required in Node.js/Electron environments to reach nodes over plain TCP.
+     * Do NOT enable in browser builds — TCP is not available in browsers.
+     */
+    enableTcp?: boolean;
+    /**
+     * Full libp2p node configuration. Fields provided here override ocean.js
+     * defaults (transports, encrypters, services, connectionManager, etc.).
+     * Unset fields keep ocean.js defaults.
+     */
+    libp2p?: Partial<Libp2pOptions>;
+}
+export declare class P2pProvider {
+    private p2pConfig;
+    private libp2pNode;
+    private discoveredNodes;
+    /**
+     * Configure the internal libp2p node used for P2P transport.
+     * Call this once before making P2P requests, e.g.:
+     *   ProviderInstance.setupP2P({ bootstrapPeers: ['/ip4/1.2.3.4/tcp/9000/ws/p2p/16Uiu2...'] })
+     *
+     * Required when using bare peer IDs as nodeUri — the bootstrap peers
+     * provide DHT entry points so the peer can be located.
+     */
+    setupP2P(config: P2PConfig): Promise<void>;
+    /** Returns all peers discovered via mDNS or DHT bootstrap. */
+    getDiscoveredNodes(): Array<{
+        peerId: string;
+        multiaddrs: string[];
+    }>;
+    private bufToHex;
+    private getOrCreateLibp2pNode;
+    private toUint8Array;
+    private getConnection;
+    protected getConsumerAddress(s: Signer | string): Promise<string>;
+    protected getSignature(s: Signer | string, nonce: string, command: string): Promise<string>;
+    private getNodePublicKey;
+    protected getAuthorization(s: Signer | string): string;
+    private dialAndStream;
+    private sendP2pCommand;
+    /**
+     * Returns node status via P2P STATUS command.
+     * @param {string} nodeUri - multiaddr of the node
+     */
+    getEndpoints(nodeUri: string): Promise<any>;
+    /**
+     * Get current nonce from the node via P2P.
+     */
+    getNonce(nodeUri: string, consumerAddress: string, signal?: AbortSignal): Promise<number>;
+    /**
+     * Encrypt data via P2P ENCRYPT command.
+     */
+    encrypt(data: any, chainId: number, nodeUri: string, signerOrAuthToken: Signer | string, _policyServer?: any, signal?: AbortSignal): Promise<string>;
+    /**
+     * Get file details for a given DID and service ID via P2P.
+     */
+    checkDidFiles(did: string, serviceId: string, nodeUri: string, withChecksum?: boolean, signal?: AbortSignal): Promise<FileInfo[]>;
+    /**
+     * Get File details via P2P.
+     */
+    getFileInfo(file: StorageObject, nodeUri: string, withChecksum?: boolean, signal?: AbortSignal): Promise<FileInfo[]>;
+    /**
+     * Returns compute environments via P2P.
+     */
+    getComputeEnvironments(nodeUri: string, signal?: AbortSignal): Promise<ComputeEnvironment[]>;
+    /**
+     * Initializes the provider for a service (download) request via P2P.
+     */
+    initialize(did: string, serviceId: string, fileIndex: number, consumerAddress: string, nodeUri: string, signal?: AbortSignal, userCustomParameters?: UserCustomParameters, computeEnv?: string, validUntil?: number): Promise<ProviderInitialize>;
+    /**
+     * Initializes compute request via P2P.
+     */
+    initializeCompute(assets: ComputeAsset[], algorithm: ComputeAlgorithm, computeEnv: string, token: string, validUntil: number, nodeUri: string, signerOrAuthToken: Signer | string, resources: ComputeResourceRequest[], chainId: number, policyServer?: any, signal?: AbortSignal, output?: ComputeOutput, dockerRegistryAuth?: dockerRegistryAuth): Promise<ProviderComputeInitializeResults>;
+    /**
+     * Sends a DOWNLOAD command to the peer via P2P, reads the binary stream
+     * directly from the lpStream, and returns a DownloadResponse.
+     * The node decrypts the service file and streams raw file data back.
+     */
+    getDownloadUrl(did: string, serviceId: string, fileIndex: number, transferTxId: string, nodeUri: string, signerOrAuthToken: Signer | string, policyServer?: any, userCustomParameters?: UserCustomParameters): Promise<DownloadResponse>;
+    /**
+     * Start a paid compute job via P2P.
+     */
+    computeStart(nodeUri: string, signerOrAuthToken: Signer | string, computeEnv: string, datasets: ComputeAsset[], algorithm: ComputeAlgorithm, maxJobDuration: number, token: string, resources: ComputeResourceRequest[], chainId: number, metadata?: ComputeJobMetadata, additionalViewers?: string[], output?: ComputeOutput, policyServer?: any, signal?: AbortSignal, queueMaxWaitTime?: number, dockerRegistryAuth?: dockerRegistryAuth): Promise<ComputeJob | ComputeJob[]>;
+    /**
+     * Start a free compute job via P2P.
+     */
+    freeComputeStart(nodeUri: string, signerOrAuthToken: Signer | string, computeEnv: string, datasets: ComputeAsset[], algorithm: ComputeAlgorithm, resources?: ComputeResourceRequest[], metadata?: ComputeJobMetadata, additionalViewers?: string[], output?: ComputeOutput, policyServer?: any, signal?: AbortSignal, queueMaxWaitTime?: number, dockerRegistryAuth?: dockerRegistryAuth): Promise<ComputeJob | ComputeJob[]>;
+    /**
+     * Get streamable compute logs via P2P. Returns an async generator of Uint8Array chunks.
+     */
+    computeStreamableLogs(nodeUri: string, signerOrAuthToken: Signer | string, jobId: string, signal?: AbortSignal): Promise<any>;
+    /**
+     * Stop a compute job via P2P.
+     */
+    computeStop(jobId: string, nodeUri: string, signerOrAuthToken: Signer | string, agreementId?: string, signal?: AbortSignal): Promise<ComputeJob | ComputeJob[]>;
+    /**
+     * Get compute status via P2P.
+     */
+    computeStatus(nodeUri: string, signerOrAuthToken: Signer | string, jobId?: string, agreementId?: string, signal?: AbortSignal): Promise<ComputeJob | ComputeJob[]>;
+    /**
+     * Get compute result as an async generator of Uint8Array chunks via P2P.
+     * Supports resumable downloads via `offset` (byte position to resume from).
+     */
+    getComputeResult(nodeUri: string, signerOrAuthToken: Signer | string, jobId: string, index: number, offset?: number): Promise<ComputeResultStream>;
+    getComputeResultUrl(nodeUri: string, signerOrAuthToken: Signer | string, jobId: string, index: number): Promise<string>;
+    /**
+     * Generate an auth token via P2P.
+     */
+    generateAuthToken(consumer: Signer, nodeUri: string, signal?: AbortSignal): Promise<string>;
+    /**
+     * Resolve a DDO by DID via P2P GET_DDO command.
+     */
+    resolveDdo(nodeUri: string, did: string, signal?: AbortSignal): Promise<any>;
+    /**
+     * Validate a DDO via P2P VALIDATE_DDO command.
+     */
+    validateDdo(nodeUri: string, ddo: DDO, signer: Signer, signal?: AbortSignal): Promise<ValidateMetadata>;
+    /**
+     * Invalidate an auth token via P2P.
+     */
+    invalidateAuthToken(consumer: Signer, token: string, nodeUri: string, signal?: AbortSignal): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Check if a P2P node is reachable by calling STATUS.
+     */
+    isValidProvider(nodeUri: string, signal?: AbortSignal): Promise<boolean>;
+    /**
+     * PolicyServer passthrough via P2P.
+     */
+    PolicyServerPassthrough(nodeUri: string, request: PolicyServerPassthroughCommand, signal?: AbortSignal): Promise<any>;
+    /**
+     * Initialize Policy Server verification via P2P.
+     */
+    initializePSVerification(nodeUri: string, request: PolicyServerInitializeCommand, signal?: AbortSignal): Promise<any>;
+    /**
+     * Download node logs via P2P.
+     */
+    downloadNodeLogs(nodeUri: string, signer: Signer, startTime: string, endTime: string, maxLogs?: number, moduleName?: string, level?: string, page?: number, signal?: AbortSignal): Promise<any>;
+    /**
+     * Fetch node configuration via P2P. Accepts a pre-signed payload —
+     * the caller is responsible for nonce retrieval and signing.
+     */
+    fetchConfig(nodeUri: string, payload: Record<string, any>): Promise<any>;
+    /**
+     * Push node configuration via P2P. Accepts a pre-signed payload —
+     * the caller is responsible for nonce retrieval and signing.
+     */
+    pushConfig(nodeUri: string, payload: Record<string, any>): Promise<any>;
+}

package/dist/types/utils/FetchHelper.d.ts

@@ -6,9 +6,10 @@ import { DownloadResponse } from '../@types/index.js';
  */
 export declare function downloadFileBrowser(url: string): void;
 /**
- * Triggers  a file download from the specified URL when called from a browser context.
- * @param {string} url - The URL of the file to download
- * @param {number} [index] - The file index
- * @returns {Promise<void>} - A Promise that resolves when the file has been downloaded
+ * Downloads a file from a URL, or passes through an already-collected DownloadResponse
+ * (returned by P2P transport).
+ * @param {string | DownloadResponse} urlOrData - HTTP URL or pre-collected P2P response
+ * @param {number} [index] - The file index, used as fallback filename for URL downloads
+ * @returns {Promise<DownloadResponse>}
  */
-export declare function downloadFile(url: string, index?: number): Promise<DownloadResponse>;
+export declare function downloadFile(urlOrData: string | DownloadResponse, index?: number): Promise<DownloadResponse>;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@oceanprotocol/lib",
   "source": "./src/index.ts",
-  "version": "6.1.2",
+  "version": "7.0.0-next.0",
   "description": "JavaScript client library for Ocean Protocol",
   "main": "./dist/lib.cjs",
   "umd:main": "dist/lib.umd.js",
@@ -56,6 +56,14 @@
     "web3": "^1.8.0"
   },
   "dependencies": {
+    "@chainsafe/libp2p-noise": "^17.0.0",
+    "@chainsafe/libp2p-yamux": "^8.0.1",
+    "@libp2p/bootstrap": "^12.0.14",
+    "@libp2p/identify": "^4.0.13",
+    "@libp2p/kad-dht": "^16.1.6",
+    "@libp2p/tcp": "^11.0.13",
+    "@libp2p/websockets": "^10.1.6",
+    "@multiformats/multiaddr": "^13.0.1",
     "@oasisprotocol/sapphire-paratime": "^1.3.2",
     "@oceanprotocol/contracts": "^2.6.0",
     "@oceanprotocol/ddo-js": "^0.1.4",
@@ -69,7 +77,9 @@
     "eciesjs": "^0.4.5",
     "ethers": "^6.15.0",
     "form-data": "^2.3.3",
-    "jsonwebtoken": "^9.0.2"
+    "jsonwebtoken": "^9.0.2",
+    "libp2p": "^3.1.6",
+    "uint8arrays": "^4.0.10"
   },
   "devDependencies": {
     "@istanbuljs/nyc-config-typescript": "^1.0.2",