@oceanprotocol/lib 8.0.6 → 8.2.0

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

@@ -1,9 +1,9 @@
 import { type Libp2p, type Libp2pOptions } from 'libp2p';
-import { type Multiaddr } from '@multiformats/multiaddr';
 import { Signer } from 'ethers';
-import { StorageObject, FileInfo, ComputeJob, ComputeOutput, ComputeAlgorithm, ComputeAsset, ComputeEnvironment, ProviderInitialize, ProviderComputeInitializeResults, UserCustomParameters, ComputeResourceRequest, ComputeJobMetadata, PolicyServerInitializeCommand, PolicyServerPassthroughCommand, dockerRegistryAuth, DownloadResponse, ComputeResultStream, NodeStatus, NodeComputeJob, PersistentStorageAccessList, PersistentStorageBucket, PersistentStorageCreateBucketRequest, PersistentStorageDeleteFileResponse, PersistentStorageFileEntry, PersistentStorageObject } from '../../@types/index.js';
-import { NodeLogsParams, NodeLogEntry } from '../../@types/Provider.js';
+import { StorageObject, FileInfo, ComputeJob, ComputeOutput, ComputeAlgorithm, ComputeAsset, ComputeEnvironment, ProviderInitialize, ProviderComputeInitializeResults, UserCustomParameters, ComputeResourceRequest, ComputeJobMetadata, PolicyServerInitializeCommand, PolicyServerPassthroughCommand, dockerRegistryAuth, DownloadResponse, ComputeResultStream, NodeStatus, NodeComputeJob, PersistentStorageAccessList, PersistentStorageBucket, PersistentStorageCreateBucketRequest, PersistentStorageDeleteFileResponse, PersistentStorageFileEntry, PersistentStorageObject, OceanNode, SignerOrAuthTokenOrSignature } from '../../@types/index.js';
+import { NodeLogEntry } from '../../@types/Provider.js';
 import { type DDO, type ValidateMetadata } from '@oceanprotocol/ddo-js';
+import { CID } from 'multiformats/cid';
 export declare const OCEAN_P2P_PROTOCOL = "/ocean/nodes/1.0.0";
 /**
  * Optional request payload sent as LP frames after the command JSON; ends with an empty LP frame.
@@ -68,146 +68,149 @@ export declare class P2pProvider {
     private handleProtocolCommands;
     private getOrCreateLibp2pNode;
     private toUint8Array;
+    cidFromRawString(data: string): Promise<CID<unknown, 85, 18, 1>>;
+    getProvidersForString(input: string, signal?: AbortSignal): Promise<Array<{
+        id: string;
+        multiaddrs: any[];
+    }>>;
     private isDialable;
+    /**
+     * True when the multiaddr does not include the relay `p2p-circuit` protocol segment.
+     * (Direct / transport paths omit it; relay paths contain `/p2p-circuit/...`.)
+     */
+    private isNotP2PCircuit;
     private peerIdFromMultiaddr;
     private getConnection;
-    private dialByPeerId;
-    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;
+    protected getAuthorization(s: SignerOrAuthTokenOrSignature): string;
+    private getSignedCommandParams;
     private dialAndStream;
     private sendP2pCommand;
     /**
      * Returns node status via P2P STATUS command.
      * @param {string} nodeUri - multiaddr of the node
      */
-    getEndpoints(nodeUri: string | Multiaddr[]): Promise<any>;
-    getNodeStatus(nodeUri: string | Multiaddr[], signal?: AbortSignal): Promise<NodeStatus>;
-    getNodeJobs(nodeUri: string | Multiaddr[], fromTimestamp?: number, signal?: AbortSignal): Promise<NodeComputeJob[]>;
+    getEndpoints(nodeUri: OceanNode): Promise<any>;
+    getNodeStatus(nodeUri: OceanNode, signal?: AbortSignal): Promise<NodeStatus>;
+    getNodeJobs(nodeUri: OceanNode, fromTimestamp?: number, signal?: AbortSignal): Promise<NodeComputeJob[]>;
     /**
      * Get current nonce from the node via P2P.
      */
-    getNonce(nodeUri: string | Multiaddr[], consumerAddress: string, signal?: AbortSignal): Promise<number>;
+    getNonce(nodeUri: OceanNode, consumerAddress: string, signal?: AbortSignal): Promise<number>;
     /**
      * Encrypt data via P2P ENCRYPT command.
      */
-    encrypt(data: any, chainId: number, nodeUri: string | Multiaddr[], signerOrAuthToken: Signer | string, _policyServer?: any, signal?: AbortSignal): Promise<string>;
+    encrypt(data: any, chainId: number, nodeUri: OceanNode, signerOrAuthToken: SignerOrAuthTokenOrSignature, _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 | Multiaddr[], withChecksum?: boolean, signal?: AbortSignal): Promise<FileInfo[]>;
+    checkDidFiles(did: string, serviceId: string, nodeUri: OceanNode, withChecksum?: boolean, signal?: AbortSignal): Promise<FileInfo[]>;
     /**
      * Get File details via P2P.
      */
-    getFileInfo(file: StorageObject, nodeUri: string | Multiaddr[], withChecksum?: boolean, signal?: AbortSignal): Promise<FileInfo[]>;
+    getFileInfo(file: StorageObject, nodeUri: OceanNode, withChecksum?: boolean, signal?: AbortSignal): Promise<FileInfo[]>;
     /**
      * Returns compute environments via P2P.
      */
-    getComputeEnvironments(nodeUri: string | Multiaddr[], signal?: AbortSignal): Promise<ComputeEnvironment[]>;
+    getComputeEnvironments(nodeUri: OceanNode, 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 | Multiaddr[], signal?: AbortSignal, userCustomParameters?: UserCustomParameters, computeEnv?: string, validUntil?: number): Promise<ProviderInitialize>;
+    initialize(did: string, serviceId: string, fileIndex: number, consumerAddress: string, nodeUri: OceanNode, signal?: AbortSignal, userCustomParameters?: UserCustomParameters, computeEnv?: string, validUntil?: number): Promise<ProviderInitialize>;
     /**
      * Initializes compute request via P2P. No auth required -- the node only
      * validates parameters and applies rate limits.
      */
-    initializeCompute(assets: ComputeAsset[], algorithm: ComputeAlgorithm, computeEnv: string, token: string, validUntil: number, nodeUri: string | Multiaddr[], consumerAddress: string, resources: ComputeResourceRequest[], chainId: number, policyServer?: any, signal?: AbortSignal, queueMaxWaitTime?: number, dockerRegistryAuthData?: dockerRegistryAuth, output?: ComputeOutput): Promise<ProviderComputeInitializeResults>;
+    initializeCompute(assets: ComputeAsset[], algorithm: ComputeAlgorithm, computeEnv: string, token: string, validUntil: number, nodeUri: OceanNode, consumerAddress: string, resources: ComputeResourceRequest[], chainId: number, policyServer?: any, signal?: AbortSignal, queueMaxWaitTime?: number, dockerRegistryAuthData?: dockerRegistryAuth, output?: ComputeOutput): 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 | Multiaddr[], signerOrAuthToken: Signer | string, policyServer?: any, userCustomParameters?: UserCustomParameters): Promise<DownloadResponse>;
+    getDownloadUrl(did: string, serviceId: string, fileIndex: number, transferTxId: string, nodeUri: OceanNode, signerOrAuthToken: SignerOrAuthTokenOrSignature, policyServer?: any, userCustomParameters?: UserCustomParameters): Promise<DownloadResponse>;
     /**
      * Start a paid compute job via P2P.
      */
-    computeStart(nodeUri: string | Multiaddr[], 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[]>;
+    computeStart(nodeUri: OceanNode, signerOrAuthToken: SignerOrAuthTokenOrSignature, 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 | Multiaddr[], 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[]>;
+    freeComputeStart(nodeUri: OceanNode, signerOrAuthToken: SignerOrAuthTokenOrSignature, 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 | Multiaddr[], signerOrAuthToken: Signer | string, jobId: string, signal?: AbortSignal): Promise<any>;
+    computeStreamableLogs(nodeUri: OceanNode, signerOrAuthToken: SignerOrAuthTokenOrSignature, jobId: string, signal?: AbortSignal): Promise<any>;
     /**
      * Stop a compute job via P2P.
      */
-    computeStop(jobId: string, nodeUri: string | Multiaddr[], signerOrAuthToken: Signer | string, agreementId?: string, signal?: AbortSignal): Promise<ComputeJob | ComputeJob[]>;
+    computeStop(jobId: string, nodeUri: OceanNode, signerOrAuthToken: SignerOrAuthTokenOrSignature, agreementId?: string, signal?: AbortSignal): Promise<ComputeJob | ComputeJob[]>;
     /**
      * Get compute status via P2P.
      */
-    computeStatus(nodeUri: string | Multiaddr[], signerOrAuthToken: Signer | string, jobId?: string, agreementId?: string, signal?: AbortSignal): Promise<ComputeJob | ComputeJob[]>;
+    computeStatus(nodeUri: OceanNode, signerOrAuthToken: SignerOrAuthTokenOrSignature, 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 | Multiaddr[], signerOrAuthToken: Signer | string, jobId: string, index: number, offset?: number): Promise<ComputeResultStream>;
-    getComputeResultUrl(nodeUri: string | Multiaddr[], signerOrAuthToken: Signer | string, jobId: string, index: number): Promise<string>;
+    getComputeResult(nodeUri: OceanNode, signerOrAuthToken: SignerOrAuthTokenOrSignature, jobId: string, index: number, offset?: number): Promise<ComputeResultStream>;
+    getComputeResultUrl(nodeUri: OceanNode, signerOrAuthToken: SignerOrAuthTokenOrSignature, jobId: string, index: number): Promise<string>;
     /**
      * Generate an auth token via P2P (auto-signs with Signer).
      */
-    generateAuthToken(consumer: Signer, nodeUri: string | Multiaddr[], signal?: AbortSignal): Promise<string>;
+    generateAuthToken(consumer: Signer, nodeUri: OceanNode, signal?: AbortSignal): Promise<string>;
     /**
      * Generate an auth token from a pre-signed request (no Signer needed).
      */
-    generateSignedAuthToken(address: string, signature: string, nonce: string, nodeUri: string | Multiaddr[], signal?: AbortSignal): Promise<string>;
+    generateSignedAuthToken(address: string, signature: string, nonce: string, nodeUri: OceanNode, signal?: AbortSignal): Promise<string>;
     /**
      * Resolve a DDO by DID via P2P GET_DDO command.
      */
-    resolveDdo(nodeUri: string | Multiaddr[], did: string, signal?: AbortSignal): Promise<any>;
+    resolveDdo(nodeUri: OceanNode, did: string, signal?: AbortSignal): Promise<any>;
     /**
      * Validate a DDO via P2P VALIDATE_DDO command.
      */
-    validateDdo(nodeUri: string | Multiaddr[], ddo: DDO, signer: Signer, signal?: AbortSignal): Promise<ValidateMetadata>;
+    validateDdo(nodeUri: OceanNode, ddo: DDO, signerOrAuthToken: SignerOrAuthTokenOrSignature, signal?: AbortSignal): Promise<ValidateMetadata>;
     /**
      * Invalidate an auth token via P2P.
      */
-    invalidateAuthToken(consumer: Signer, token: string, nodeUri: string | Multiaddr[], signal?: AbortSignal): Promise<{
+    invalidateAuthToken(consumer: Signer, token: string, nodeUri: OceanNode, signal?: AbortSignal): Promise<{
         success: boolean;
     }>;
     /**
      * Check if a P2P node is reachable by calling STATUS.
      */
-    isValidProvider(nodeUri: string | Multiaddr[], signal?: AbortSignal): Promise<boolean>;
+    isValidProvider(nodeUri: OceanNode, signal?: AbortSignal): Promise<boolean>;
     /**
      * PolicyServer passthrough via P2P.
      */
-    PolicyServerPassthrough(nodeUri: string | Multiaddr[], request: PolicyServerPassthroughCommand, signal?: AbortSignal): Promise<any>;
+    PolicyServerPassthrough(nodeUri: OceanNode, request: PolicyServerPassthroughCommand, signal?: AbortSignal): Promise<any>;
     /**
      * Initialize Policy Server verification via P2P.
      */
-    initializePSVerification(nodeUri: string | Multiaddr[], request: PolicyServerInitializeCommand, signal?: AbortSignal): Promise<any>;
+    initializePSVerification(nodeUri: OceanNode, request: PolicyServerInitializeCommand, signal?: AbortSignal): Promise<any>;
     /**
      * Download node logs via P2P.
      */
-    downloadNodeLogs(nodeUri: string | Multiaddr[], signer: Signer, startTime: string, endTime: string, maxLogs?: number, moduleName?: string, level?: string, page?: number, signal?: AbortSignal): Promise<NodeLogEntry[]>;
-    /**
-     * Fetch node logs via P2P with a pre-signed payload.
-     * P2P only — use downloadNodeLogs() for the auto-signed variant.
-     */
-    fetchNodeLogs(nodeUri: string | Multiaddr[], address: string, signature: string, nonce: string, logParams?: NodeLogsParams): Promise<NodeLogEntry[]>;
+    downloadNodeLogs(nodeUri: OceanNode, signerOrAuthToken: SignerOrAuthTokenOrSignature, startTime: string, endTime: string, maxLogs?: number, moduleName?: string, level?: string, page?: number, signal?: AbortSignal): Promise<NodeLogEntry[]>;
     /**
      * Fetch node configuration via P2P. Accepts a pre-signed payload —
      * the caller is responsible for nonce retrieval and signing.
      */
-    fetchConfig(nodeUri: string | Multiaddr[], payload: Record<string, any>): Promise<any>;
+    fetchConfig(nodeUri: OceanNode, 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 | Multiaddr[], payload: Record<string, any>): Promise<any>;
+    pushConfig(nodeUri: OceanNode, payload: Record<string, any>): Promise<any>;
     private getPersistentStorageSignaturePayload;
-    createPersistentStorageBucket(nodeUri: string | Multiaddr[], signerOrAuthToken: Signer | string, payload: PersistentStorageCreateBucketRequest, signal?: AbortSignal): Promise<{
+    createPersistentStorageBucket(nodeUri: OceanNode, signerOrAuthToken: SignerOrAuthTokenOrSignature, payload: PersistentStorageCreateBucketRequest, signal?: AbortSignal): Promise<{
         bucketId: string;
         owner: string;
         accessList: PersistentStorageAccessList[];
     }>;
-    getPersistentStorageBuckets(nodeUri: string | Multiaddr[], signerOrAuthToken: Signer | string, owner: string, signal?: AbortSignal): Promise<PersistentStorageBucket[]>;
-    listPersistentStorageFiles(nodeUri: string | Multiaddr[], signerOrAuthToken: Signer | string, bucketId: string, signal?: AbortSignal): Promise<PersistentStorageFileEntry[]>;
-    getPersistentStorageFileObject(nodeUri: string | Multiaddr[], signerOrAuthToken: Signer | string, bucketId: string, fileName: string, signal?: AbortSignal): Promise<PersistentStorageObject>;
-    uploadPersistentStorageFile(nodeUri: string | Multiaddr[], signerOrAuthToken: Signer | string, bucketId: string, fileName: string, content: P2PRequestBodyStream, signal?: AbortSignal): Promise<PersistentStorageFileEntry>;
-    deletePersistentStorageFile(nodeUri: string | Multiaddr[], signerOrAuthToken: Signer | string, bucketId: string, fileName: string, signal?: AbortSignal): Promise<PersistentStorageDeleteFileResponse>;
+    getPersistentStorageBuckets(nodeUri: OceanNode, signerOrAuthToken: SignerOrAuthTokenOrSignature, owner: string, signal?: AbortSignal): Promise<PersistentStorageBucket[]>;
+    listPersistentStorageFiles(nodeUri: OceanNode, signerOrAuthToken: SignerOrAuthTokenOrSignature, bucketId: string, signal?: AbortSignal): Promise<PersistentStorageFileEntry[]>;
+    getPersistentStorageFileObject(nodeUri: OceanNode, signerOrAuthToken: SignerOrAuthTokenOrSignature, bucketId: string, fileName: string, signal?: AbortSignal): Promise<PersistentStorageObject>;
+    uploadPersistentStorageFile(nodeUri: OceanNode, signerOrAuthToken: SignerOrAuthTokenOrSignature, bucketId: string, fileName: string, content: P2PRequestBodyStream, signal?: AbortSignal): Promise<PersistentStorageFileEntry>;
+    deletePersistentStorageFile(nodeUri: OceanNode, signerOrAuthToken: SignerOrAuthTokenOrSignature, bucketId: string, fileName: string, signal?: AbortSignal): Promise<PersistentStorageDeleteFileResponse>;
 }

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

@@ -1,6 +1,6 @@
 import { Signer } from 'ethers';
 import { Aquarius } from '../services/Aquarius.js';
-import { DDO } from '@oceanprotocol/ddo-js';
+import { type DDO } from '@oceanprotocol/ddo-js';
 import { StorageObject } from '../@types/File.js';
 export declare const DEVELOPMENT_CHAIN_ID = 8996;
 export declare function useOasisSDK(network: string | number): boolean;

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

@@ -1,4 +1,4 @@
-import { Signer, Contract, TransactionResponse, BaseContractMethod, EventLog, TransactionReceipt } from 'ethers';
+import { Signer, Contract, TransactionResponse, TransactionRequest, BaseContractMethod, TransactionReceipt } from 'ethers';
 import { Config } from '../config/index.js';
 export declare function setContractDefaults(contract: Contract, config: Config): Contract;
 /**
@@ -33,7 +33,7 @@ export declare function unitsToAmount(signer: Signer, token: string, amount: str
  * @returns {Promise<string>} - The converted amount in units
  */
 export declare function amountToUnits(signer: Signer, token: string, amount: string, tokenDecimals?: number): Promise<string>;
-export declare function getEventFromTx(txReceipt: TransactionReceipt, eventName: string): EventLog | undefined;
+export declare function getEventFromTx(txReceipt: TransactionReceipt, eventName: string): any;
 /**
  * Send the transation on chain
  * @param {BigNumber} estGas estimated gas for the transaction
@@ -41,6 +41,10 @@ export declare function getEventFromTx(txReceipt: TransactionReceipt, eventName:
  * @param {number} gasFeeMultiplier number represinting the multiplier we apply to gas fees
  * @param {Function} functionToSend function that we need to send
  * @param {...any[]} args arguments of the function
- * @return {Promise<any>} transaction receipt
+ * @return {Promise<any>}  transaction receipt
  */
 export declare function sendTx(estGas: bigint, signer: Signer, gasFeeMultiplier: number, functionToSend: BaseContractMethod, ...args: any[]): Promise<TransactionResponse>;
+export declare function buildTxOverrides(estGas: bigint, signer: Signer, gasFeeMultiplier: number): Promise<Record<string, any>>;
+export declare function buildUnsignedTx(functionToSend: BaseContractMethod, args: any[], overrides: Record<string, any>): Promise<TransactionRequest>;
+export declare function sendPreparedTx(functionToSend: BaseContractMethod, args: any[], overrides: Record<string, any>): Promise<TransactionResponse>;
+export declare function sendPreparedTransaction(signer: Signer, tx: TransactionRequest): Promise<TransactionResponse>;

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

@@ -3,7 +3,7 @@ import { Config } from '../config/Config.js';
 import { Datatoken } from '../contracts/Datatoken.js';
 import { ConsumeMarketFee } from '../@types/Datatoken.js';
 import { ProviderFees } from '../@types/Provider.js';
-import { Asset } from '@oceanprotocol/ddo-js';
+import { type Asset } from '@oceanprotocol/ddo-js';
 /**
  * Orders an asset based on the specified pricing schema and configuration.
  * @param {Asset} asset - The asset to be ordered.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@oceanprotocol/lib",
   "source": "./src/index.ts",
-  "version": "8.0.6",
+  "version": "8.2.0",
   "description": "JavaScript client library for Ocean Protocol",
   "main": "./dist/lib.cjs",
   "umd:main": "dist/lib.umd.js",
@@ -68,8 +68,8 @@
     "web3": "^1.8.0"
   },
   "dependencies": {
-    "@oceanprotocol/ddo-js": "^0.3.0",
     "@oasisprotocol/sapphire-paratime": "^1.3.2",
+    "@oceanprotocol/ddo-js": "^0.3.0",
     "bignumber.js": "^9.3.1",
     "cross-fetch": "^4.0.0",
     "crypto-js": "^4.1.1",
@@ -90,8 +90,7 @@
     "@libp2p/tcp": "^11.0.13",
     "@libp2p/websockets": "^10.1.6",
     "@multiformats/multiaddr": "^13.0.1",
-    "@oceanprotocol/contracts": "^2.6.0",
-    "libp2p": "^3.1.6",
+    "@oceanprotocol/contracts": "^2.7.0",
     "@truffle/hdwallet-provider": "^2.0.14",
     "@types/chai": "^5.2.2",
     "@types/chai-spies": "^1.0.3",
@@ -112,11 +111,12 @@
     "eslint-config-prettier": "^10.1.5",
     "eslint-plugin-prettier": "^4.2.1",
     "fs": "0.0.1-security",
+    "libp2p": "^3.1.6",
     "microbundle": "^0.15.1",
     "mocha": "^11.7.1",
     "mock-local-storage": "^1.1.24",
-    "nyc": "^17.1.0",
-    "ora": "5.4.1",
+    "nyc": "^18.0.0",
+    "ora": "9.4.0",
     "prettier": "^2.7.1",
     "release-it": "^19.2.4",
     "source-map-support": "^0.5.21",