@ethersphere/bee-js 8.3.1 → 9.0.2

package/dist/types/utils/collection.node.d.ts

@@ -1,7 +1,6 @@
 import { Collection } from '../types';
 /**
  * Creates array in the format of Collection with data loaded from directory on filesystem.
- * The function loads all the data into memory!
  *
  * @param dir path to the directory
  */

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

@@ -1,4 +1,7 @@
-import { BatchId, Topic } from '..';
+import { BatchId, Topic } from './typed-bytes';
 export declare const SWARM_GATEWAY_URL = "https://api.gateway.ethswarm.org";
 export declare const NULL_STAMP: BatchId;
 export declare const NULL_TOPIC: Topic;
+export declare const NULL_ADDRESS: Uint8Array;
+export declare const NULL_IDENTIFIER: Uint8Array;
+export declare const NULL_OWNER: Uint8Array;

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

@@ -0,0 +1,17 @@
+export declare class Duration {
+    private seconds;
+    private constructor();
+    static fromMilliseconds(milliseconds: number): Duration;
+    static fromSeconds(seconds: number): Duration;
+    static fromHours(hours: number): Duration;
+    static fromDays(days: number): Duration;
+    static fromWeeks(weeks: number): Duration;
+    static fromYears(years: number): Duration;
+    static fromEndDate(endDate: Date, startDate?: Date): Duration;
+    toSeconds(): number;
+    toHours(): number;
+    toDays(): number;
+    toWeeks(): number;
+    toYears(): number;
+    toEndDate(startDate?: Date): Date;
+}

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

@@ -8,8 +8,8 @@ export declare class BeeArgumentError extends BeeError {
 export declare class BeeResponseError extends BeeError {
     method: string;
     url: string;
-    responseBody?: any;
+    responseBody?: unknown;
     status?: number | undefined;
     statusText?: string | undefined;
-    constructor(method: string, url: string, message: string, responseBody?: any, status?: number | undefined, statusText?: string | undefined);
+    constructor(method: string, url: string, message: string, responseBody?: unknown, status?: number | undefined, statusText?: string | undefined);
 }

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

@@ -1,10 +1,5 @@
-export { getCollectionSize } from './collection';
+export { getCollectionSize, makeCollectionFromFileList } from './collection';
 export { getFolderSize } from './collection.node';
-export { Bytes, FlexBytes, assertBytes, assertFlexBytes, bytesAtOffset, bytesEqual, flexBytesAtOffset, isBytes, isFlexBytes, } from './bytes';
-export { HexString, PrefixedHexString, assertHexString, assertPrefixedHexString, bytesToHex, hexToBytes, intToHex, isHexString, makeHexString, } from './hex';
-export { EthAddress, capitalizeAddressERC55, ethToSwarmAddress, fromLittleEndian, isHexEthAddress, makeEthAddress, makeEthereumWalletSigner, makeHexEthAddress, toLittleEndian, } from './eth';
-export { keccak256Hash } from './hash';
 export { makeMaxTarget } from './pss';
-export { getAmountForTtl, getDepthForCapacity, getStampCostInBzz, getStampCostInPlur, getStampEffectiveBytes, getStampMaximumCapacityBytes, getStampTtlSeconds, getStampUsage, } from './stamps';
 export { approximateOverheadForRedundancyLevel, getRedundancyStat, getRedundancyStats } from './redundancy';
-export { convertCidToReference, convertReferenceToCid } from './cid';
+export { getAmountForDuration, getDepthForSize, getStampCost, getStampDuration, getStampEffectiveBytes, getStampEffectiveBytesBreakpoints, getStampTheoreticalBytes, getStampUsage, } from './stamps';

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

@@ -1,5 +1,4 @@
-import { BatchId, DownloadRedundancyOptions, FileHeaders, UploadOptions, UploadRedundancyOptions } from '../types';
+import { EnvelopeWithBatchId, FileHeaders } from '../types';
+import { BatchId } from './typed-bytes';
 export declare function readFileHeaders(headers: Record<string, string>): FileHeaders;
-export declare function extractUploadHeaders(stamp: BatchId | Uint8Array | string, options?: UploadOptions): Record<string, string>;
-export declare function extractRedundantUploadHeaders(postageBatchId: BatchId, options?: UploadOptions & UploadRedundancyOptions): Record<string, string>;
-export declare function extractDownloadHeaders(options?: DownloadRedundancyOptions): Record<string, string>;
+export declare function prepareRequestHeaders(stamp: BatchId | Uint8Array | string | EnvelopeWithBatchId | null, nullableOptions?: unknown): Record<string, string>;

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

@@ -0,0 +1 @@
+export declare const mimes: Record<string, string>;

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

@@ -1,4 +1,4 @@
-import { AddressPrefix } from '../types';
+import { PeerAddress } from './typed-bytes';
 /**
  * Utility function that for given strings/reference takes the most specific
  * target that Bee node will except.
@@ -6,4 +6,4 @@ import { AddressPrefix } from '../types';
  * @param target is a non-prefixed hex string Bee address
  * @see [Bee docs - PSS](https://docs.ethswarm.org/docs/develop/tools-and-features/pss)
  */
-export declare function makeMaxTarget(target: string): AddressPrefix;
+export declare function makeMaxTarget(target: PeerAddress | Uint8Array | string): string;

package/dist/types/utils/resource-locator.d.ts

@@ -0,0 +1,6 @@
+import { Reference } from './typed-bytes';
+export declare class ResourceLocator {
+    private raw;
+    constructor(raw: Reference | Uint8Array | string);
+    toString(): string;
+}

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

@@ -0,0 +1,16 @@
+/**
+ * Represents a size in bytes.
+ *
+ * Uses 1000 instead of 1024 for converting between units.
+ * This is to stay consistent with the Swarm papers
+ * on theoretical and effective storage capacity.
+ */
+export declare class Size {
+    private bytes;
+    private constructor();
+    static fromBytes(bytes: number): Size;
+    static fromGigabytes(gigabytes: number): Size;
+    toBytes(): number;
+    toGigabytes(): number;
+    toFormattedString(): string;
+}

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

@@ -1,4 +1,8 @@
-import { BatchId, Envelope, NumberString } from '../types';
+import { EnvelopeWithBatchId, NumberString } from '../types';
+import { Bytes } from './bytes';
+import { Duration } from './duration';
+import { Size } from './size';
+import { BZZ } from './tokens';
 /**
  * Utility function that calculates usage of postage batch based on its utilization, depth and bucket depth.
  *
@@ -8,59 +12,49 @@ import { BatchId, Envelope, NumberString } from '../types';
  */
 export declare function getStampUsage(utilization: number, depth: number, bucketDepth: number): number;
 /**
- * Utility function that calculates the theoritical maximum capacity of a postage batch based on its depth.
+ * Utility function that calculates the theoritical maximum size of a postage batch based on its depth.
  *
- * For smaller depths (up to 20), this may provide less accurate results.
+ * For smaller depths (up to 22), this may provide less accurate results.
  *
- * @returns {number} The maximum capacity of the postage batch in bytes.
+ * @returns {number} The maximum theoretical size of the postage batch in bytes.
  */
-export declare function getStampMaximumCapacityBytes(depth: number): number;
+export declare function getStampTheoreticalBytes(depth: number): number;
 /**
- * Utility function that calculates the effective volume of a postage batch based on its depth.
+ * Utility function that calculates the effective size of a postage batch based on its depth.
  *
- * Below 22 depth the effective volume is 0
+ * Below 22 depth the effective size is 0
  * Above 34 it's always > 99%
  *
- * @returns {number} The effective volume of the postage batch in bytes.
+ * @returns {number} The effective size of the postage batch in bytes.
  */
 export declare function getStampEffectiveBytes(depth: number): number;
+export declare function getStampEffectiveBytesBreakpoints(): Map<number, number>;
 /**
  * Utility function that calculates the cost of a postage batch based on its depth and amount.
- *
- * @returns {number} The cost of the postage batch in PLUR (10000000000000000 [1e16] PLUR = 1 BZZ)
- */
-export declare function getStampCostInPlur(depth: number, amount: number): number;
-/**
- * Utility function that calculates the cost of a postage batch based on its depth and amount.
- *
- * @returns {number} The cost of the postage batch in BZZ (1 BZZ = 10000000000000000 [1e16] PLUR)
  */
-export declare function getStampCostInBzz(depth: number, amount: number): number;
+export declare function getStampCost(depth: number, amount: NumberString | string | bigint): BZZ;
 /**
  * Utility function that calculates the TTL of a postage batch based on its amount, price per block and block time.
  *
  * For more accurate results, get the price per block and block time from the Bee node or the blockchain.
  *
- * @returns {number} The TTL of the postage batch in seconds.
+ * @returns {number} The TTL of the postage batch.
  */
-export declare function getStampTtlSeconds(amount: number, pricePerBlock?: number, blockTime?: number): number;
+export declare function getStampDuration(amount: NumberString | string | bigint, pricePerBlock: number, blockTime?: number): Duration;
 /**
- * Utility function that calculates the amount of tokens required to maintain a given Time To Live (TTL) for a postage batch.
+ * Get the postage batch `amount` required for a given `duration`.
  *
- * This function estimates the required amount based on the provided TTL in days.
- *
- * @param {number} days - The Time To Live (TTL) in days.
- * @returns {NumberString} The estimated amount of tokens needed for the specified TTL.
+ * @param duration A duration object representing the duration of the storage.
+ * @param pricePerBlock The price per block in PLUR.
+ * @param blockTime The block time in seconds.
  */
-export declare function getAmountForTtl(days: number): NumberString;
+export declare function getAmountForDuration(duration: Duration, pricePerBlock: number, blockTime?: number): bigint;
 /**
- * Utility function that calculates the depth required for a postage batch to achieve the specified capacity in gigabytes.
- *
- * The depth is determined based on the given gigabytes, and the result is adjusted to a minimum depth of 18.
+ * Utility function that calculates the depth required for a postage batch to achieve the specified effective size
  *
- * @param {number} gigabytes - The desired capacity of the postage batch in gigabytes.
- * @returns {number} The calculated depth necessary to achieve the specified capacity.
+ * @param size The effective size of the postage batch
+ * @returns
  */
-export declare function getDepthForCapacity(gigabytes: number): number;
-export declare function convertEnvelopeToMarshaledStamp(batchID: BatchId, envelope: Envelope): Uint8Array;
-export declare function marshalStamp(signature: Uint8Array, batchID: Uint8Array, timestamp: Uint8Array, index: Uint8Array): Uint8Array;
+export declare function getDepthForSize(size: Size): number;
+export declare function convertEnvelopeToMarshaledStamp(envelope: EnvelopeWithBatchId): Bytes;
+export declare function marshalStamp(signature: Uint8Array, batchId: Uint8Array, timestamp: Uint8Array, index: Uint8Array): Bytes;

package/dist/types/utils/tar-uploader.browser.d.ts

@@ -1,4 +1,3 @@
-import { BatchId, BeeRequestOptions, Collection, CollectionUploadOptions, Reference, UploadRedundancyOptions } from '..';
-export declare function uploadTar(requestOptions: BeeRequestOptions, collection: Collection, postageBatchId: BatchId, options?: CollectionUploadOptions & UploadRedundancyOptions): Promise<import("axios").AxiosResponse<{
-    reference: Reference;
-}, any>>;
+import { BeeRequestOptions, Collection, CollectionUploadOptions } from '..';
+import { BatchId } from './typed-bytes';
+export declare function uploadTar(requestOptions: BeeRequestOptions, collection: Collection, postageBatchId: BatchId, options?: CollectionUploadOptions): Promise<import("axios").AxiosResponse<unknown, any>>;

package/dist/types/utils/tar-uploader.d.ts

@@ -1,4 +1,3 @@
-import { BatchId, BeeRequestOptions, Collection, CollectionUploadOptions, Reference, UploadRedundancyOptions } from '..';
-export declare function uploadTar(requestOptions: BeeRequestOptions, collection: Collection, postageBatchId: BatchId, options?: CollectionUploadOptions & UploadRedundancyOptions): Promise<import("axios").AxiosResponse<{
-    reference: Reference;
-}, any>>;
+import { BeeRequestOptions, Collection, CollectionUploadOptions } from '..';
+import { BatchId } from './typed-bytes';
+export declare function uploadTar(requestOptions: BeeRequestOptions, collection: Collection, postageBatchId: BatchId, options?: CollectionUploadOptions): Promise<import("axios").AxiosResponse<unknown, any>>;

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

@@ -0,0 +1,77 @@
+import { NumberString } from '..';
+export declare class BZZ {
+    static readonly DIGITS = 16;
+    private state;
+    private constructor();
+    static fromDecimalString(string: string): BZZ;
+    static fromPLUR(plur: NumberString | string | bigint): BZZ;
+    toPLURString(): string;
+    toPLURBigInt(): bigint;
+    toDecimalString(): string;
+    toSignificantDigits(digits: number): string;
+    /**
+     * Does not mutate the current BZZ instance.
+     *
+     * @param other BZZ instance, or amount in PLUR
+     * @returns New BZZ instance
+     */
+    plus(other: BZZ | NumberString | string | bigint): BZZ;
+    /**
+     * Does not mutate the current BZZ instance.
+     *
+     * @param other BZZ instance, or amount in PLUR
+     * @returns New BZZ instance
+     */
+    minus(other: BZZ | NumberString | string | bigint): BZZ;
+    /**
+     * Does not mutate the current BZZ instance.
+     *
+     * @param other Divisor
+     * @returns New BZZ instance
+     */
+    divide(other: bigint): BZZ;
+    gt(other: BZZ): boolean;
+    gte(other: BZZ): boolean;
+    lt(other: BZZ): boolean;
+    lte(other: BZZ): boolean;
+    eq(other: BZZ): boolean;
+    exchangeToDAI(daiPerBzz: DAI): DAI;
+}
+export declare class DAI {
+    static readonly DIGITS = 18;
+    private state;
+    private constructor();
+    static fromDecimalString(string: string): DAI;
+    static fromWei(wei: NumberString | string | bigint): DAI;
+    toWeiString(): string;
+    toWeiBigInt(): bigint;
+    toDecimalString(): string;
+    toSignificantDigits(digits: number): string;
+    /**
+     * Does not mutate the current DAI instance.
+     *
+     * @param other DAI instance, or amount in PLUR
+     * @returns New DAI instance
+     */
+    plus(other: DAI | NumberString | string | bigint): DAI;
+    /**
+     * Does not mutate the current DAI instance.
+     *
+     * @param other DAI instance, or amount in PLUR
+     * @returns New DAI instance
+     */
+    minus(other: DAI | NumberString | string | bigint): DAI;
+    /**
+     * Does not mutate the current DAI instance.
+     *
+     * @param other Divisor
+     * @returns New DAI instance
+     */
+    divide(other: bigint): DAI;
+    gt(other: DAI): boolean;
+    gte(other: DAI): boolean;
+    lt(other: DAI): boolean;
+    lte(other: DAI): boolean;
+    eq(other: DAI): boolean;
+    exchangeToBZZ(daiPerBzz: DAI): BZZ;
+}

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

@@ -1,54 +1,23 @@
 /// <reference types="node" />
-import { Readable } from 'stream';
-import { Address, AddressPrefix, AllTagsOptions, BatchId, BeeRequestOptions, CashoutOptions, CollectionUploadOptions, FileUploadOptions, NumberString, PostageBatchOptions, PssMessageHandler, PublicKey, Reference, ReferenceOrEns, Tag, TransactionHash, TransactionOptions, UploadOptions } from '../types';
-export declare function isReadable(obj: unknown): obj is Readable;
-export declare function isInteger(value: unknown): value is number | NumberString;
-export declare function isObject(value: unknown): value is Record<string, unknown>;
-export declare function isStrictlyObject(value: unknown): value is Record<string, unknown>;
-/**
- * Asserts if object is Error
- *
- * @param e
- */
-export declare function isError(e: unknown): e is Error;
-export declare function assertStrictlyObject(value: unknown, name?: string): asserts value is object;
-export declare function assertBoolean(value: unknown, name?: string): asserts value is boolean;
-export declare function assertInteger(value: unknown, name?: string): asserts value is number | NumberString;
-export declare function assertNonNegativeInteger(value: unknown, name?: string): asserts value is number | NumberString;
-export declare function assertPositiveInteger(value: unknown, name?: string): asserts value is number | NumberString;
-export declare function assertReference(value: unknown): asserts value is Reference;
-export declare function assertReferenceOrEns(value: unknown): asserts value is ReferenceOrEns;
-/**
- * Function that mainly converts Swarm CID into hex encoded Swarm Reference
- *
- * @param value
- * @param expectedCidType
- */
-export declare function makeReferenceOrEns(value: unknown, expectedCidType: 'feed' | 'manifest'): ReferenceOrEns;
-/**
- * Function that adds getter which converts the reference into CID base32 encoded string.
- * @param result
- * @param cidType feed or manifest
- */
-export declare function addCidConversionFunction<T extends {
-    reference: string;
-}>(result: T, cidType: 'feed' | 'manifest'): T & {
-    cid: () => string;
-};
-export declare function assertAddress(value: unknown): asserts value is Address;
-export declare function assertBatchId(value: unknown): asserts value is BatchId;
-export declare function assertRequestOptions(value: unknown, name?: string): asserts value is BeeRequestOptions;
-export declare function assertUploadOptions(value: unknown, name?: string): asserts value is UploadOptions;
-export declare function assertFileUploadOptions(value: unknown): asserts value is FileUploadOptions;
-export declare function assertCollectionUploadOptions(value: unknown): asserts value is CollectionUploadOptions;
+import * as stream from 'stream';
+import { AllTagsOptions, BeeRequestOptions, CollectionUploadOptions, DownloadOptions, FileUploadOptions, GsocMessageHandler, NumberString, PostageBatchOptions, PssMessageHandler, RedundantUploadOptions, Tag, TransactionOptions, UploadOptions } from '../types';
+export declare function isReadable(value: unknown): value is stream.Readable;
+export declare function asNumberString(value: unknown, options?: {
+    name?: string;
+    min?: bigint;
+    max?: bigint;
+}): NumberString;
+export declare function prepareBeeRequestOptions(value: unknown): BeeRequestOptions;
+export declare function prepareDownloadOptions(value: unknown): DownloadOptions;
+export declare function prepareUploadOptions(value: unknown, name?: string): UploadOptions;
+export declare function prepareRedundantUploadOptions(value: unknown, name?: string): RedundantUploadOptions;
+export declare function prepareFileUploadOptions(value: unknown): FileUploadOptions;
+export declare function prepareCollectionUploadOptions(value: unknown): CollectionUploadOptions;
 export declare function isTag(value: unknown): value is Tag;
-export declare function assertTag(value: unknown): asserts value is Tag;
-export declare function assertAddressPrefix(value: unknown): asserts value is AddressPrefix;
-export declare function assertPssMessageHandler(value: unknown): asserts value is PssMessageHandler;
-export declare function assertPublicKey(value: unknown): asserts value is PublicKey;
-export declare function assertPostageBatchOptions(value: unknown): asserts value is PostageBatchOptions;
-export declare function assertTransactionOptions(value: unknown, name?: string): asserts value is TransactionOptions;
-export declare function assertCashoutOptions(value: unknown): asserts value is CashoutOptions;
+export declare function preparePssMessageHandler(value: unknown): PssMessageHandler;
+export declare function prepareGsocMessageHandler(value: unknown): GsocMessageHandler;
+export declare function preparePostageBatchOptions(value: unknown): PostageBatchOptions;
+export declare function prepareTransactionOptions(value: unknown, name?: string): TransactionOptions;
 /**
  * Check whether the given parameter is valid data to upload
  * @param value
@@ -60,15 +29,14 @@ export declare function assertData(value: unknown): asserts value is string | Ui
  * @param value
  * @throws TypeError if not valid
  */
-export declare function assertFileData(value: unknown): asserts value is string | Uint8Array | Readable | File;
+export declare function assertFileData(value: unknown): asserts value is string | Uint8Array | stream.Readable | File;
 /**
  * Checks whether optional options for AllTags query are valid
  * @param options
  */
-export declare function assertAllTagsOptions(entry: unknown): asserts entry is AllTagsOptions;
+export declare function prepareAllTagsOptions(value: unknown): AllTagsOptions;
 /**
  * Utility functions that return Tag UID
  * @param tagUid
  */
 export declare function makeTagUid(tagUid: number | Tag | string | null | undefined): number;
-export declare function assertTransactionHash(transactionHash: unknown): asserts transactionHash is TransactionHash;

package/dist/types/utils/typed-bytes.d.ts

@@ -0,0 +1,68 @@
+import { Bytes } from './bytes';
+export declare class PrivateKey extends Bytes {
+    static readonly LENGTH = 32;
+    constructor(bytes: Uint8Array | string | Bytes);
+    publicKey(): PublicKey;
+    sign(data: Uint8Array | string): Signature;
+}
+export declare class PublicKey extends Bytes {
+    static readonly LENGTH = 64;
+    constructor(bytes: Uint8Array | string | Bytes);
+    address(): EthAddress;
+    toCompressedUint8Array(): Uint8Array;
+    toCompressedHex(): string;
+}
+export declare class EthAddress extends Bytes {
+    static readonly LENGTH = 20;
+    constructor(bytes: Uint8Array | string | Bytes);
+    toChecksum(): string;
+}
+export declare class Identifier extends Bytes {
+    static readonly LENGTH = 32;
+    constructor(bytes: Uint8Array | string | Bytes);
+    static fromString(value: string): Identifier;
+}
+export declare class Reference extends Bytes {
+    static readonly LENGTH = 32;
+    constructor(bytes: Uint8Array | string | Bytes);
+    toCid(type: 'feed' | 'manifest'): string;
+    static isValid(value: string): boolean;
+}
+export declare class TransactionId extends Bytes {
+    static readonly LENGTH = 32;
+    constructor(bytes: Uint8Array | string | Bytes);
+}
+export declare class Span extends Bytes {
+    static readonly LENGTH = 8;
+    constructor(bytes: Uint8Array | string | Bytes);
+    static fromBigInt(number: bigint): FeedIndex;
+    toBigInt(): bigint;
+    static fromSlice(bytes: Uint8Array, start: number): Span;
+}
+export declare class PeerAddress extends Bytes {
+    static readonly LENGTH = 32;
+    constructor(bytes: Uint8Array | string | Bytes);
+}
+export declare class BatchId extends Bytes {
+    static readonly LENGTH = 32;
+    constructor(bytes: Uint8Array | string | Bytes);
+}
+export declare class Signature extends Bytes {
+    static readonly LENGTH = 65;
+    constructor(bytes: Uint8Array | string | Bytes);
+    static fromSlice(bytes: Uint8Array, start: number): Signature;
+    recoverPublicKey(digest: Uint8Array | string): PublicKey;
+    isValid(digest: Uint8Array | string, expectedAddress: EthAddress | Uint8Array | string): boolean;
+}
+export declare class Topic extends Bytes {
+    static readonly LENGTH = 32;
+    constructor(bytes: Uint8Array | string | Bytes);
+    static fromString(value: string): Topic;
+}
+export declare class FeedIndex extends Bytes {
+    static readonly LENGTH = 8;
+    static readonly MINUS_ONE: FeedIndex;
+    constructor(bytes: Uint8Array | string | Bytes);
+    static fromBigInt(number: bigint): FeedIndex;
+    toBigInt(): bigint;
+}

package/dist/types/utils/upload-progress.d.ts

@@ -0,0 +1,4 @@
+export interface UploadProgress {
+    total: number;
+    processed: number;
+}

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

@@ -0,0 +1,2 @@
+export declare function normalizeBatchTTL(batchTTL: number): number;
+export declare function normalizeCurrentPrice(currentPrice: number): number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ethersphere/bee-js",
-  "version": "8.3.1",
+  "version": "9.0.2",
   "description": "Javascript client for Bee",
   "keywords": [
     "bee",
@@ -31,16 +31,20 @@
       "types": "./dist/types/index.d.ts"
     }
   },
+  "engines": {
+    "bee": "2.4.0-390a402e",
+    "beeApiVersion": "7.2.0"
+  },
   "types": "dist/types/index.d.ts",
   "browser": {
     "stream": false,
     "fs": false,
-    "./src/utils/data.ts": "./src/utils/data.browser.ts",
     "./dist/cjs/utils/data.js": "./dist/cjs/utils/data.browser.js",
     "./dist/mjs/utils/data.js": "./dist/mjs/utils/data.browser.js",
+    "./dist/cjs/utils/chunk-stream.js": "./dist/cjs/utils/chunk-stream.browser.js",
+    "./dist/mjs/utils/chunk-stream.js": "./dist/mjs/utils/chunk-stream.browser.js",
     "./dist/cjs/utils/collection.node.js": "./dist/cjs/utils/collection.browser.js",
-    "./dist/mjs/utils/collection.node.js": "./dist/mjs/utils/collection.browser.js",
-    "./src/utils/collection.node.ts": "./src/utils/collection.browser.ts"
+    "./dist/mjs/utils/collection.node.js": "./dist/mjs/utils/collection.browser.js"
   },
   "files": [
     "dist"
@@ -51,21 +55,16 @@
     "build:node": "tsc -p tsconfig.json && tsc -p tsconfig-mjs.json && ./build-fixup && babel --plugins \"babel-plugin-add-import-extension\" --out-dir dist/mjs/ dist/mjs/",
     "build:types": "tsc --emitDeclarationOnly --declaration --outDir dist/types",
     "build:browser": "webpack --progress",
-    "mock-ci": "npm run lint:check && npm run check:types && npm run test",
     "test": "jest --config=jest.config.ts --runInBand --verbose",
-    "test:coverage": "jest --config=jest.config.ts --coverage",
     "check:types": "tsc --project tsconfig.test.json",
     "lint": "eslint --fix \"src/**/*.ts\" \"test/**/*.ts\" && prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
     "lint:check": "eslint \"src/**/*.ts\" \"test/**/*.ts\" && prettier --check \"src/**/*.ts\" \"test/**/*.ts\"",
-    "depcheck": "depcheck .",
-    "bee": "npx @fairdatasociety/fdp-play@3.2.0 start --detach --fresh"
+    "depcheck": "depcheck ."
   },
   "dependencies": {
     "axios": "^0.28.1",
-    "cafe-utility": "^23.10.0",
-    "elliptic": "^6.5.4",
+    "cafe-utility": "^27.14.2",
     "isomorphic-ws": "^4.0.1",
-    "js-sha3": "^0.8.0",
     "semver": "^7.3.5",
     "ws": "^8.7.0"
   },
@@ -80,7 +79,6 @@
     "@commitlint/config-conventional": "^17.4.2",
     "@jest/types": "^29.6.3",
     "@naholyr/cross-env": "^1.0.0",
-    "@types/elliptic": "^6.4.14",
     "@types/jest": "^29.5.13",
     "@types/node": "^18.11.11",
     "@types/semver": "^7.3.9",
@@ -97,7 +95,7 @@
     "eslint-plugin-unused-imports": "^2.0.0",
     "husky": "^8.0.1",
     "jest": "^29.7.0",
-    "nock": "^13.3.0",
+    "jest-puppeteer": "^11.0.0",
     "prettier": "^2.6.2",
     "rimraf": "^3.0.2",
     "terser-webpack-plugin": "^5.3.1",
@@ -106,9 +104,5 @@
     "typescript": "^4.9.5",
     "webpack": "^5.75.0",
     "webpack-cli": "^5.0.1"
-  },
-  "engines": {
-    "bee": "2.2.0-06a0aca7",
-    "beeApiVersion": "7.1.0"
   }
 }