@ethersphere/bee-js 8.3.1 → 9.0.2

package/dist/cjs/stamper/stamper.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Stamper = void 0;
+const cafe_utility_1 = require("cafe-utility");
+const typed_bytes_1 = require("../utils/typed-bytes");
+class Stamper {
+    constructor(signer, batchId, buckets, depth) {
+        this.signer = new typed_bytes_1.PrivateKey(signer);
+        this.batchId = new typed_bytes_1.BatchId(batchId);
+        this.buckets = buckets;
+        this.depth = depth;
+        this.maxSlot = 2 ** (this.depth - 16);
+    }
+    static fromBlank(signer, batchId, depth) {
+        return new Stamper(signer, batchId, new Uint32Array(65536), depth);
+    }
+    static fromState(signer, batchId, buckets, depth) {
+        return new Stamper(signer, batchId, buckets, depth);
+    }
+    stamp(chunk) {
+        const address = chunk.hash();
+        const bucket = cafe_utility_1.Binary.uint16ToNumber(address, 'BE');
+        const height = this.buckets[bucket];
+        if (height >= this.maxSlot) {
+            throw Error('Bucket is full');
+        }
+        this.buckets[bucket]++;
+        const index = cafe_utility_1.Binary.concatBytes(cafe_utility_1.Binary.numberToUint32(bucket, 'BE'), cafe_utility_1.Binary.numberToUint32(height, 'BE'));
+        const timestamp = cafe_utility_1.Binary.numberToUint64(BigInt(Date.now()), 'BE');
+        const signature = this.signer.sign(cafe_utility_1.Binary.concatBytes(address, this.batchId.toUint8Array(), index, timestamp));
+        return {
+            batchId: this.batchId,
+            index,
+            issuer: this.signer.publicKey().address().toUint8Array(),
+            signature: signature.toUint8Array(),
+            timestamp,
+        };
+    }
+    getState() {
+        return this.buckets;
+    }
+}
+exports.Stamper = Stamper;

package/dist/cjs/types/debug.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BeeModes = void 0;
+exports.toBeeMode = exports.BeeModes = void 0;
 var BeeModes;
 (function (BeeModes) {
     BeeModes["FULL"] = "full";
@@ -8,3 +8,18 @@ var BeeModes;
     BeeModes["ULTRA_LIGHT"] = "ultra-light";
     BeeModes["DEV"] = "dev";
 })(BeeModes = exports.BeeModes || (exports.BeeModes = {}));
+function toBeeMode(value) {
+    switch (value) {
+        case 'full':
+            return BeeModes.FULL;
+        case 'light':
+            return BeeModes.LIGHT;
+        case 'ultra-light':
+            return BeeModes.ULTRA_LIGHT;
+        case 'dev':
+            return BeeModes.DEV;
+        default:
+            throw new Error(`Unknown Bee mode: ${value}`);
+    }
+}
+exports.toBeeMode = toBeeMode;

package/dist/cjs/types/index.js

@@ -14,28 +14,16 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SIGNATURE_BYTES_LENGTH = exports.SIGNATURE_HEX_LENGTH = exports.TOPIC_HEX_LENGTH = exports.TOPIC_BYTES_LENGTH = exports.RedundancyStrategy = exports.RedundancyLevel = exports.FEED_INDEX_HEX_LENGTH = exports.TAGS_LIMIT_MAX = exports.TAGS_LIMIT_MIN = exports.STAMPS_DEPTH_MAX = exports.STAMPS_AMOUNT_MIN = exports.STAMPS_DEPTH_MIN = exports.ENCRYPTED_REFERENCE_BYTES_LENGTH = exports.REFERENCE_BYTES_LENGTH = exports.ENCRYPTED_REFERENCE_HEX_LENGTH = exports.REFERENCE_HEX_LENGTH = exports.BATCH_ID_HEX_LENGTH = exports.PUBKEY_HEX_LENGTH = exports.PSS_TARGET_HEX_LENGTH_MAX = exports.ADDRESS_HEX_LENGTH = exports.CHUNK_SIZE = exports.BRANCHES = exports.SECTION_SIZE = exports.SPAN_SIZE = void 0;
+exports.RedundancyStrategy = exports.RedundancyLevel = exports.FEED_INDEX_HEX_LENGTH = exports.TAGS_LIMIT_MAX = exports.TAGS_LIMIT_MIN = exports.STAMPS_DEPTH_MAX = exports.STAMPS_DEPTH_MIN = exports.PSS_TARGET_HEX_LENGTH_MAX = exports.CHUNK_SIZE = exports.BRANCHES = exports.SECTION_SIZE = void 0;
 __exportStar(require("./debug"), exports);
-exports.SPAN_SIZE = 8;
 exports.SECTION_SIZE = 32;
 exports.BRANCHES = 128;
 exports.CHUNK_SIZE = exports.SECTION_SIZE * exports.BRANCHES;
-exports.ADDRESS_HEX_LENGTH = 64;
-exports.PSS_TARGET_HEX_LENGTH_MAX = 6;
-exports.PUBKEY_HEX_LENGTH = 66;
-exports.BATCH_ID_HEX_LENGTH = 64;
-exports.REFERENCE_HEX_LENGTH = 64;
-exports.ENCRYPTED_REFERENCE_HEX_LENGTH = 128;
-exports.REFERENCE_BYTES_LENGTH = 32;
-exports.ENCRYPTED_REFERENCE_BYTES_LENGTH = 64;
+exports.PSS_TARGET_HEX_LENGTH_MAX = 4;
 /**
  * Minimal depth that can be used for creation of postage batch
  */
 exports.STAMPS_DEPTH_MIN = 17;
-/**
- * Minimal amount that can be used for creation of postage batch
- */
-exports.STAMPS_AMOUNT_MIN = 24000 * 24 * 60 * 12;
 /**
  * Maximal depth that can be used for creation of postage batch
  */
@@ -72,13 +60,3 @@ var RedundancyStrategy;
     RedundancyStrategy[RedundancyStrategy["PROX"] = 2] = "PROX";
     RedundancyStrategy[RedundancyStrategy["RACE"] = 3] = "RACE";
 })(RedundancyStrategy = exports.RedundancyStrategy || (exports.RedundancyStrategy = {}));
-/*********************************************************
- * Writers and Readers interfaces
- */
-exports.TOPIC_BYTES_LENGTH = 32;
-exports.TOPIC_HEX_LENGTH = 64;
-/*********************************************************
- * Ethereum compatible signing interfaces and definitions
- */
-exports.SIGNATURE_HEX_LENGTH = 130;
-exports.SIGNATURE_BYTES_LENGTH = 65;

package/dist/cjs/utils/bytes.js

@@ -1,121 +1,73 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.wrapBytesWithHelpers = exports.makeBytes = exports.bytesEqual = exports.flexBytesAtOffset = exports.bytesAtOffset = exports.assertFlexBytes = exports.isFlexBytes = exports.assertBytes = exports.hasBytesAtOffset = exports.isBytes = void 0;
-const hex_1 = require("./hex");
-/**
- * Type guard for `Bytes<T>` type
- *
- * @param b       The byte array
- * @param length  The length of the byte array
- */
-function isBytes(b, length) {
-    return b instanceof Uint8Array && b.length === length;
-}
-exports.isBytes = isBytes;
-/**
- * Function that verifies if passed data are Bytes and if the array has "length" number of bytes under given offset.
- * @param data
- * @param offset
- * @param length
- */
-function hasBytesAtOffset(data, offset, length) {
-    if (!(data instanceof Uint8Array)) {
-        throw new TypeError('Data has to an Uint8Array!');
+exports.Bytes = void 0;
+const cafe_utility_1 = require("cafe-utility");
+const DECODER = new TextDecoder();
+const ENCODER = new TextEncoder();
+class Bytes {
+    constructor(bytes, byteLength) {
+        if (bytes instanceof Bytes) {
+            this.bytes = bytes.bytes;
+        }
+        else if (typeof bytes === 'string') {
+            this.bytes = cafe_utility_1.Binary.hexToUint8Array(cafe_utility_1.Types.asHexString(bytes, { name: 'Bytes#constructor(bytes)' }));
+        }
+        else if (bytes instanceof ArrayBuffer) {
+            this.bytes = new Uint8Array(bytes);
+        }
+        else {
+            this.bytes = bytes;
+        }
+        this.length = this.bytes.length;
+        if (byteLength) {
+            if (Array.isArray(byteLength)) {
+                if (!byteLength.includes(this.length)) {
+                    throw new Error(`Bytes#checkByteLength: bytes length is ${this.length} but expected ${byteLength.join(' or ')}`);
+                }
+            }
+            else if (this.length !== byteLength) {
+                throw new Error(`Bytes#checkByteLength: bytes length is ${this.length} but expected ${byteLength}`);
+            }
+        }
     }
-    const offsetBytes = data.slice(offset, offset + length);
-    return isBytes(offsetBytes, length);
-}
-exports.hasBytesAtOffset = hasBytesAtOffset;
-/**
- * Verifies if a byte array has a certain length
- *
- * @param b       The byte array
- * @param length  The specified length
- */
-function assertBytes(b, length) {
-    if (!isBytes(b, length)) {
-        throw new TypeError(`Parameter is not valid Bytes of length: ${length} !== ${b.length}`);
+    static keccak256(bytes) {
+        return new Bytes(cafe_utility_1.Binary.keccak256(new Bytes(bytes).toUint8Array()));
     }
-}
-exports.assertBytes = assertBytes;
-/**
- * Type guard for FlexBytes<Min,Max> type
- *
- * @param b       The byte array
- * @param min     Minimum size of the array
- * @param max     Maximum size of the array
- */
-function isFlexBytes(b, min, max) {
-    return b instanceof Uint8Array && b.length >= min && b.length <= max;
-}
-exports.isFlexBytes = isFlexBytes;
-/**
- * Verifies if a byte array has a certain length between min and max
- *
- * @param b       The byte array
- * @param min     Minimum size of the array
- * @param max     Maximum size of the array
- */
-function assertFlexBytes(b, min, max) {
-    if (!isFlexBytes(b, min, max)) {
-        throw new TypeError(`Parameter is not valid FlexBytes of  min: ${min}, max: ${max}, length: ${b.length}`);
+    static fromUtf8(utf8) {
+        return new Bytes(ENCODER.encode(utf8));
+    }
+    static fromSlice(bytes, start, length) {
+        if (length === undefined) {
+            return new Bytes(bytes.slice(start));
+        }
+        return new Bytes(bytes.slice(start, start + length));
+    }
+    offset(index) {
+        return new Uint8Array(this.bytes.slice(index));
+    }
+    toUint8Array() {
+        return new Uint8Array(this.bytes);
+    }
+    toHex() {
+        return cafe_utility_1.Binary.uint8ArrayToHex(this.bytes);
+    }
+    toBase64() {
+        return cafe_utility_1.Binary.uint8ArrayToBase64(this.bytes);
+    }
+    toBase32() {
+        return cafe_utility_1.Binary.uint8ArrayToBase32(this.bytes);
+    }
+    toString() {
+        return this.toHex();
+    }
+    toUtf8() {
+        return DECODER.decode(this.bytes);
+    }
+    toJSON() {
+        return JSON.parse(this.toUtf8());
+    }
+    equals(other) {
+        return this.toHex() === new Bytes(other).toHex();
     }
 }
-exports.assertFlexBytes = assertFlexBytes;
-/**
- * Return `length` bytes starting from `offset`
- *
- * @param data   The original data
- * @param offset The offset to start from
- * @param length The length of data to be returned
- */
-function bytesAtOffset(data, offset, length) {
-    const offsetBytes = data.slice(offset, offset + length);
-    // We are returning strongly typed Bytes so we have to verify that length is really what we claim
-    assertBytes(offsetBytes, length);
-    return offsetBytes;
-}
-exports.bytesAtOffset = bytesAtOffset;
-/**
- * Return flex bytes starting from `offset`
- *
- * @param data   The original data
- * @param offset The offset to start from
- * @param _min   The minimum size of the data
- * @param _max   The maximum size of the data
- */
-function flexBytesAtOffset(data, offset, 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-_min, 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-_max) {
-    return data.slice(offset);
-}
-exports.flexBytesAtOffset = flexBytesAtOffset;
-/**
- * Returns true if two byte arrays are equal
- *
- * @param a Byte array to compare
- * @param b Byte array to compare
- */
-function bytesEqual(a, b) {
-    return a.length === b.length && a.every((value, index) => value === b[index]);
-}
-exports.bytesEqual = bytesEqual;
-/**
- * Returns a new byte array filled with zeroes with the specified length
- *
- * @param length The length of data to be returned
- */
-function makeBytes(length) {
-    return new Uint8Array(length);
-}
-exports.makeBytes = makeBytes;
-function wrapBytesWithHelpers(data) {
-    return Object.assign(data, {
-        text: () => new TextDecoder('utf-8').decode(data),
-        json: () => JSON.parse(new TextDecoder('utf-8').decode(data)),
-        hex: () => (0, hex_1.bytesToHex)(data),
-    });
-}
-exports.wrapBytesWithHelpers = wrapBytesWithHelpers;
+exports.Bytes = Bytes;

package/dist/cjs/utils/chunk-size.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.totalChunks = void 0;
+function totalChunks(fileSize) {
+    const chunkSize = 4096;
+    const hashesPerChunk = 128;
+    function chunksAtLevel(chunkCount) {
+        if (chunkCount <= 1) {
+            return chunkCount;
+        }
+        const upperLevelChunks = Math.ceil(chunkCount / hashesPerChunk);
+        return chunkCount + chunksAtLevel(upperLevelChunks);
+    }
+    const baseLevelChunks = Math.ceil(fileSize / chunkSize);
+    return chunksAtLevel(baseLevelChunks);
+}
+exports.totalChunks = totalChunks;

package/dist/cjs/utils/chunk-stream.browser.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.streamFiles = exports.streamDirectory = exports.hashDirectory = void 0;
+const cafe_utility_1 = require("cafe-utility");
+const __1 = require("..");
+const manifest_1 = require("../manifest/manifest");
+const chunk_size_1 = require("./chunk-size");
+const collection_1 = require("./collection");
+const mime_1 = require("./mime");
+const typed_bytes_1 = require("./typed-bytes");
+async function hashDirectory(_dir) {
+    throw new Error('Hashing directories is not supported in browsers!');
+}
+exports.hashDirectory = hashDirectory;
+async function streamDirectory(_bee, _dir, _postageBatchId, _onUploadProgress, _options, _requestOptions) {
+    throw new Error('Streaming directories is not supported in browsers!');
+}
+exports.streamDirectory = streamDirectory;
+async function streamFiles(bee, files, postageBatchId, onUploadProgress, options, requestOptions) {
+    const queue = new cafe_utility_1.AsyncQueue(64, 64);
+    let total = 0;
+    let processed = 0;
+    for (const file of files) {
+        total += (0, chunk_size_1.totalChunks)(file.size);
+    }
+    postageBatchId = new typed_bytes_1.BatchId(postageBatchId);
+    async function onChunk(chunk) {
+        await queue.enqueue(async () => {
+            await bee.uploadChunk(postageBatchId, chunk.build(), options, requestOptions);
+            onUploadProgress?.({ total, processed: ++processed });
+        });
+    }
+    const mantaray = new manifest_1.MantarayNode();
+    for (const file of files) {
+        const rootChunk = await new Promise((resolve, reject) => {
+            const tree = new cafe_utility_1.MerkleTree(onChunk);
+            let offset = 0;
+            const reader = new FileReader();
+            reader.onerror = () => {
+                reject(reader.error);
+            };
+            const readNextChunk = async () => {
+                if (offset >= file.size) {
+                    const rootChunk = await tree.finalize();
+                    resolve(rootChunk);
+                    return;
+                }
+                const slice = file.slice(offset, offset + 4096);
+                reader.readAsArrayBuffer(slice);
+            };
+            reader.onload = async (event) => {
+                if (!event.target) {
+                    reject('No event target');
+                    return;
+                }
+                const data = event.target.result;
+                if (data) {
+                    await tree.append(new Uint8Array(data));
+                    offset += 4096;
+                }
+                readNextChunk();
+            };
+            readNextChunk();
+        });
+        await queue.drain();
+        const { filename, extension } = cafe_utility_1.Strings.parseFilename(file.name);
+        mantaray.addFork((0, collection_1.makeFilePath)(file), rootChunk.hash(), {
+            'Content-Type': maybeEnrichMime(mime_1.mimes[extension.toLowerCase()] || 'application/octet-stream'),
+            Filename: filename,
+        });
+        if (file.name === 'index.html') {
+            mantaray.addFork('/', __1.NULL_ADDRESS, {
+                'website-index-document': 'index.html',
+            });
+        }
+    }
+    return mantaray.saveRecursively(bee, postageBatchId, options, requestOptions);
+}
+exports.streamFiles = streamFiles;
+function maybeEnrichMime(mime) {
+    if (['text/html', 'text/css'].includes(mime)) {
+        return `${mime}; charset=utf-8`;
+    }
+    return mime;
+}

package/dist/cjs/utils/chunk-stream.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.streamFiles = exports.streamDirectory = exports.hashDirectory = void 0;
+const cafe_utility_1 = require("cafe-utility");
+const fs_1 = require("fs");
+const __1 = require("..");
+const manifest_1 = require("../manifest/manifest");
+const chunk_size_1 = require("./chunk-size");
+const collection_node_1 = require("./collection.node");
+const mime_1 = require("./mime");
+const typed_bytes_1 = require("./typed-bytes");
+async function hashDirectory(dir) {
+    const files = await (0, collection_node_1.makeCollectionFromFS)(dir);
+    const mantaray = new manifest_1.MantarayNode();
+    for (const file of files) {
+        const tree = new cafe_utility_1.MerkleTree(cafe_utility_1.MerkleTree.NOOP);
+        if (!file.fsPath) {
+            throw Error('File does not have fsPath, which should never happen in node. Please report this issue.');
+        }
+        const readStream = (0, fs_1.createReadStream)(file.fsPath);
+        for await (const data of readStream) {
+            await tree.append(data);
+        }
+        const rootChunk = await tree.finalize();
+        const { filename, extension } = cafe_utility_1.Strings.parseFilename(file.path);
+        mantaray.addFork(file.path, rootChunk.hash(), {
+            'Content-Type': maybeEnrichMime(mime_1.mimes[extension.toLowerCase()] || 'application/octet-stream'),
+            Filename: filename,
+        });
+    }
+    return mantaray.calculateSelfAddress();
+}
+exports.hashDirectory = hashDirectory;
+async function streamDirectory(bee, dir, postageBatchId, onUploadProgress, options, requestOptions) {
+    const queue = new cafe_utility_1.AsyncQueue(64, 64);
+    let total = 0;
+    let processed = 0;
+    postageBatchId = new typed_bytes_1.BatchId(postageBatchId);
+    const files = await (0, collection_node_1.makeCollectionFromFS)(dir);
+    for (const file of files) {
+        total += (0, chunk_size_1.totalChunks)(file.size);
+    }
+    async function onChunk(chunk) {
+        await queue.enqueue(async () => {
+            await bee.uploadChunk(postageBatchId, chunk.build(), options, requestOptions);
+            onUploadProgress?.({ total, processed: ++processed });
+        });
+    }
+    const mantaray = new manifest_1.MantarayNode();
+    for (const file of files) {
+        if (!file.fsPath) {
+            throw Error('File does not have fsPath, which should never happen in node. Please report this issue.');
+        }
+        const readStream = (0, fs_1.createReadStream)(file.fsPath);
+        const tree = new cafe_utility_1.MerkleTree(onChunk);
+        for await (const data of readStream) {
+            await tree.append(data);
+        }
+        const rootChunk = await tree.finalize();
+        await queue.drain();
+        const { filename, extension } = cafe_utility_1.Strings.parseFilename(file.path);
+        mantaray.addFork(file.path, rootChunk.hash(), {
+            'Content-Type': maybeEnrichMime(mime_1.mimes[extension.toLowerCase()] || 'application/octet-stream'),
+            Filename: filename,
+        });
+        if (file.path === 'index.html') {
+            mantaray.addFork('/', __1.NULL_ADDRESS, {
+                'website-index-document': 'index.html',
+            });
+        }
+    }
+    return mantaray.saveRecursively(bee, postageBatchId, options, requestOptions);
+}
+exports.streamDirectory = streamDirectory;
+function maybeEnrichMime(mime) {
+    if (['text/html', 'text/css'].includes(mime)) {
+        return `${mime}; charset=utf-8`;
+    }
+    return mime;
+}
+async function streamFiles(_bee, _files, _postageBatchId, _onUploadProgress, _options, _requestOptions) {
+    throw new Error('Streaming files is not supported in Node.js');
+}
+exports.streamFiles = streamFiles;

package/dist/cjs/utils/cid.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertCidToReference = exports.convertReferenceToCid = exports.SWARM_FEED_CODEC = exports.SWARM_MANIFEST_CODEC = void 0;
 const cafe_utility_1 = require("cafe-utility");
+const typed_bytes_1 = require("./typed-bytes");
 exports.SWARM_MANIFEST_CODEC = 0xfa;
 exports.SWARM_FEED_CODEC = 0xfb;
 const CODEC_TABLE = {
@@ -9,9 +10,7 @@ const CODEC_TABLE = {
     [exports.SWARM_FEED_CODEC]: 'feed',
 };
 function convertReferenceToCid(reference, type) {
-    if (reference.length !== 64) {
-        throw TypeError('Only 32-byte, non-encrypted references are supported');
-    }
+    reference = new typed_bytes_1.Reference(reference);
     const base32 = 'b';
     const version = new Uint8Array([1]);
     const codec = new Uint8Array([type === 'feed' ? exports.SWARM_FEED_CODEC : exports.SWARM_MANIFEST_CODEC]);
@@ -19,7 +18,7 @@ function convertReferenceToCid(reference, type) {
     const sha256 = new Uint8Array([27]);
     const size = new Uint8Array([32]);
     const header = cafe_utility_1.Binary.uint8ArrayToBase32(cafe_utility_1.Binary.concatBytes(version, codec, unknown, sha256, size)).replace(/\=+$/, '');
-    const hash = cafe_utility_1.Binary.uint8ArrayToBase32(cafe_utility_1.Binary.hexToUint8Array(reference)).replace(/\=+$/, '');
+    const hash = reference.toBase32().replace(/\=+$/, '');
     return `${base32}${header}${hash}`.toLowerCase();
 }
 exports.convertReferenceToCid = convertReferenceToCid;
@@ -29,10 +28,10 @@ function convertCidToReference(cid) {
     if (!CODEC_TABLE[codec]) {
         throw new Error('Unknown codec');
     }
-    const reference = bytes.slice(-32);
+    const reference = new typed_bytes_1.Reference(bytes.slice(-32));
     return {
         type: CODEC_TABLE[codec],
-        reference: cafe_utility_1.Binary.uint8ArrayToHex(reference),
+        reference,
     };
 }
 exports.convertCidToReference = convertCidToReference;

package/dist/cjs/utils/collection.browser.js

@@ -7,7 +7,7 @@ exports.getFolderSize = exports.makeCollectionFromFS = void 0;
  *
  * @param dir path to the directory
  */
-async function makeCollectionFromFS(dir) {
+async function makeCollectionFromFS(_dir) {
     throw new Error('Creating Collection from File System is not supported in browsers!');
 }
 exports.makeCollectionFromFS = makeCollectionFromFS;
@@ -17,7 +17,7 @@ exports.makeCollectionFromFS = makeCollectionFromFS;
  * @param dir the path to the folder to check
  * @returns size in bytes
  */
-async function getFolderSize(dir) {
+async function getFolderSize(_dir) {
     throw new Error('Creating Collection from File System is not supported in browsers!');
 }
 exports.getFolderSize = getFolderSize;

package/dist/cjs/utils/collection.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getCollectionSize = exports.makeCollectionFromFileList = exports.assertCollection = exports.isCollection = void 0;
+exports.getCollectionSize = exports.makeCollectionFromFileList = exports.makeFilePath = exports.assertCollection = exports.isCollection = void 0;
 const error_1 = require("./error");
 function isCollection(data) {
     if (!Array.isArray(data)) {
@@ -24,7 +24,8 @@ function makeFilePath(file) {
     }
     throw new TypeError('file is not valid File object');
 }
-async function makeCollectionFromFileList(fileList) {
+exports.makeFilePath = makeFilePath;
+function makeCollectionFromFileList(fileList) {
     return Array.from(fileList).map(file => ({
         path: makeFilePath(file),
         size: file.size,

package/dist/cjs/utils/collection.node.js

@@ -8,7 +8,6 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 /**
  * 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
  */
@@ -23,7 +22,6 @@ async function makeCollectionFromFS(dir) {
 }
 exports.makeCollectionFromFS = makeCollectionFromFS;
 async function buildCollectionRelative(dir, relativePath) {
-    // Handles case when the dir is not existing or it is a file ==> throws an error
     const dirname = path_1.default.join(dir, relativePath);
     const entries = await fs_1.default.promises.opendir(dirname);
     let collection = [];

package/dist/cjs/utils/constants.js

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NULL_TOPIC = exports.NULL_STAMP = exports.SWARM_GATEWAY_URL = void 0;
+exports.NULL_OWNER = exports.NULL_IDENTIFIER = exports.NULL_ADDRESS = exports.NULL_TOPIC = exports.NULL_STAMP = exports.SWARM_GATEWAY_URL = void 0;
+const typed_bytes_1 = require("./typed-bytes");
 exports.SWARM_GATEWAY_URL = 'https://api.gateway.ethswarm.org';
-exports.NULL_STAMP = '0000000000000000000000000000000000000000000000000000000000000000';
-exports.NULL_TOPIC = '0000000000000000000000000000000000000000000000000000000000000000';
+exports.NULL_STAMP = new typed_bytes_1.BatchId('0000000000000000000000000000000000000000000000000000000000000000');
+exports.NULL_TOPIC = new typed_bytes_1.Topic('0000000000000000000000000000000000000000000000000000000000000000');
+exports.NULL_ADDRESS = new Uint8Array(32);
+exports.NULL_IDENTIFIER = new Uint8Array(32);
+exports.NULL_OWNER = new Uint8Array(20);

package/dist/cjs/utils/data.browser.js

@@ -2,12 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.prepareWebsocketData = void 0;
 async function prepareWebsocketData(data) {
-    if (typeof data === 'string')
+    if (typeof data === 'string') {
         return new TextEncoder().encode(data);
-    if (data instanceof ArrayBuffer)
+    }
+    if (data instanceof ArrayBuffer) {
         return new Uint8Array(data);
-    if (data instanceof Blob)
+    }
+    if (data instanceof Blob) {
         return new Uint8Array(await new Response(data).arrayBuffer());
+    }
     throw new TypeError('unknown websocket data type');
 }
 exports.prepareWebsocketData = prepareWebsocketData;

package/dist/cjs/utils/data.js

@@ -5,14 +5,18 @@ function isBufferArray(buffer) {
     return Array.isArray(buffer) && buffer.length > 0 && buffer.every(data => data instanceof Buffer);
 }
 async function prepareWebsocketData(data) {
-    if (typeof data === 'string')
+    if (typeof data === 'string') {
         return new TextEncoder().encode(data);
-    if (data instanceof Buffer)
+    }
+    if (data instanceof Buffer) {
         return new Uint8Array(data);
-    if (data instanceof ArrayBuffer)
+    }
+    if (data instanceof ArrayBuffer) {
         return new Uint8Array(data);
-    if (isBufferArray(data))
+    }
+    if (isBufferArray(data)) {
         return new Uint8Array(Buffer.concat(data));
+    }
     throw new TypeError('unknown websocket data type');
 }
 exports.prepareWebsocketData = prepareWebsocketData;