@ethersphere/bee-js 8.3.1 → 9.0.2

package/dist/cjs/index.js

@@ -26,13 +26,29 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Bee = exports.Utils = exports.SUPPORTED_BEE_VERSION_EXACT = exports.SUPPORTED_BEE_VERSION = void 0;
+exports.Stamper = exports.BeeDev = exports.Bee = exports.Size = exports.Utils = exports.Duration = exports.Bytes = exports.SUPPORTED_BEE_VERSION_EXACT = exports.SUPPORTED_BEE_VERSION = exports.MantarayNode = exports.MerkleTree = void 0;
 const bee_1 = require("./bee");
 Object.defineProperty(exports, "Bee", { enumerable: true, get: function () { return bee_1.Bee; } });
+const bee_dev_1 = require("./bee-dev");
+Object.defineProperty(exports, "BeeDev", { enumerable: true, get: function () { return bee_dev_1.BeeDev; } });
+const stamper_1 = require("./stamper/stamper");
+Object.defineProperty(exports, "Stamper", { enumerable: true, get: function () { return stamper_1.Stamper; } });
+var cafe_utility_1 = require("cafe-utility");
+Object.defineProperty(exports, "MerkleTree", { enumerable: true, get: function () { return cafe_utility_1.MerkleTree; } });
+var manifest_1 = require("./manifest/manifest");
+Object.defineProperty(exports, "MantarayNode", { enumerable: true, get: function () { return manifest_1.MantarayNode; } });
 var status_1 = require("./modules/debug/status");
 Object.defineProperty(exports, "SUPPORTED_BEE_VERSION", { enumerable: true, get: function () { return status_1.SUPPORTED_BEE_VERSION; } });
 Object.defineProperty(exports, "SUPPORTED_BEE_VERSION_EXACT", { enumerable: true, get: function () { return status_1.SUPPORTED_BEE_VERSION_EXACT; } });
 __exportStar(require("./types"), exports);
+var bytes_1 = require("./utils/bytes");
+Object.defineProperty(exports, "Bytes", { enumerable: true, get: function () { return bytes_1.Bytes; } });
 __exportStar(require("./utils/constants"), exports);
+var duration_1 = require("./utils/duration");
+Object.defineProperty(exports, "Duration", { enumerable: true, get: function () { return duration_1.Duration; } });
 __exportStar(require("./utils/error"), exports);
 exports.Utils = __importStar(require("./utils/expose"));
+var size_1 = require("./utils/size");
+Object.defineProperty(exports, "Size", { enumerable: true, get: function () { return size_1.Size; } });
+__exportStar(require("./utils/tokens"), exports);
+__exportStar(require("./utils/typed-bytes"), exports);

package/dist/cjs/manifest/manifest.js

@@ -0,0 +1,369 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MantarayNode = exports.Fork = void 0;
+const cafe_utility_1 = require("cafe-utility");
+const __1 = require("..");
+const typed_bytes_1 = require("../utils/typed-bytes");
+const ENCODER = new TextEncoder();
+const DECODER = new TextDecoder();
+const TYPE_VALUE = 2;
+const TYPE_EDGE = 4;
+const TYPE_WITH_PATH_SEPARATOR = 8;
+const TYPE_WITH_METADATA = 16;
+const PATH_SEPARATOR = new Uint8Array([47]);
+const VERSION_02_HASH_HEX = '5768b3b6a7db56d21d1abff40d41cebfc83448fed8d7e9b06ec0d3b073f28f7b';
+const VERSION_02_HASH = cafe_utility_1.Binary.hexToUint8Array(VERSION_02_HASH_HEX);
+class Fork {
+    constructor(prefix, node) {
+        this.prefix = prefix;
+        this.node = node;
+    }
+    static split(a, b) {
+        const commonPart = cafe_utility_1.Binary.commonPrefix(a.prefix, b.prefix);
+        const node = new MantarayNode({ path: commonPart });
+        const newAFork = new Fork(a.prefix.slice(commonPart.length), a.node);
+        const newBFork = new Fork(b.prefix.slice(commonPart.length), b.node);
+        a.node.path = a.prefix.slice(commonPart.length);
+        b.node.path = b.prefix.slice(commonPart.length);
+        a.prefix = a.prefix.slice(commonPart.length);
+        b.prefix = b.prefix.slice(commonPart.length);
+        node.forks.set(newAFork.prefix[0], newAFork);
+        node.forks.set(newBFork.prefix[0], newBFork);
+        newAFork.node.parent = node;
+        newBFork.node.parent = node;
+        return new Fork(commonPart, node);
+    }
+    marshal() {
+        if (!this.node.selfAddress) {
+            throw Error('Fork#marshal node.selfAddress is not set');
+        }
+        const data = [];
+        data.push(new Uint8Array([this.node.determineType()]));
+        data.push(cafe_utility_1.Binary.numberToUint8(this.prefix.length));
+        data.push(this.prefix);
+        if (this.prefix.length < 30) {
+            data.push(new Uint8Array(30 - this.prefix.length));
+        }
+        data.push(this.node.selfAddress);
+        if (this.node.metadata) {
+            const metadataBytes = cafe_utility_1.Binary.padEndToMultiple(new Uint8Array([0x00, 0x00, ...ENCODER.encode(JSON.stringify(this.node.metadata))]), 32, 0x0a);
+            const metadataLengthBytes = cafe_utility_1.Binary.numberToUint16(metadataBytes.length - 2, 'BE');
+            metadataBytes.set(metadataLengthBytes, 0);
+            data.push(metadataBytes);
+        }
+        return cafe_utility_1.Binary.concatBytes(...data);
+    }
+    static unmarshal(reader) {
+        const type = cafe_utility_1.Binary.uint8ToNumber(reader.read(1));
+        const prefixLength = cafe_utility_1.Binary.uint8ToNumber(reader.read(1));
+        const prefix = reader.read(prefixLength);
+        reader.read(30 - prefixLength);
+        const targetAddress = reader.read(32);
+        let metadata = undefined;
+        if (isType(type, TYPE_WITH_METADATA)) {
+            const metadataLength = cafe_utility_1.Binary.uint16ToNumber(reader.read(2), 'BE');
+            metadata = JSON.parse(DECODER.decode(reader.read(metadataLength)));
+        }
+        return new Fork(prefix, new MantarayNode({ targetAddress, metadata, path: prefix }));
+    }
+}
+exports.Fork = Fork;
+class MantarayNode {
+    constructor(options) {
+        this.obfuscationKey = new Uint8Array(32);
+        this.selfAddress = null;
+        this.targetAddress = new Uint8Array(32);
+        this.metadata = null;
+        this.path = new Uint8Array(0);
+        this.forks = new Map();
+        this.parent = null;
+        if (options?.targetAddress) {
+            this.targetAddress = options.targetAddress;
+        }
+        if (options?.selfAddress) {
+            this.selfAddress = options.selfAddress;
+        }
+        if (options?.metadata) {
+            this.metadata = options.metadata;
+        }
+        if (options?.obfuscationKey) {
+            this.obfuscationKey = options.obfuscationKey;
+        }
+        if (options?.path) {
+            this.path = options.path;
+        }
+        if (options?.parent) {
+            this.parent = options.parent;
+        }
+    }
+    get fullPath() {
+        return cafe_utility_1.Binary.concatBytes(this.parent?.fullPath ?? new Uint8Array(0), this.path);
+    }
+    get fullPathString() {
+        return DECODER.decode(this.fullPath);
+    }
+    /**
+     * Returns the metadata at the `/` path to access idiomatic properties.
+     */
+    getRootMetadata() {
+        const node = this.find('/');
+        if (node && node.metadata) {
+            return cafe_utility_1.Optional.of(node.metadata);
+        }
+        return cafe_utility_1.Optional.empty();
+    }
+    /**
+     * Returns the `swarm-index-document` and `swarm-error-document` metadata values.
+     */
+    getDocsMetadata() {
+        const node = this.find('/');
+        if (!node || !node.metadata) {
+            return { indexDocument: null, errorDocument: null };
+        }
+        return {
+            indexDocument: node.metadata['website-index-document'] ?? null,
+            errorDocument: node.metadata['website-error-document'] ?? null,
+        };
+    }
+    /**
+     * Attempts to resolve the manifest as a feed, returning the latest update.
+     */
+    async resolveFeed(bee, requestOptions) {
+        const node = this.find('/');
+        if (!node || !node.metadata) {
+            return cafe_utility_1.Optional.empty();
+        }
+        const owner = node.metadata['swarm-feed-owner'];
+        const topic = node.metadata['swarm-feed-topic'];
+        if (!owner || !topic) {
+            return cafe_utility_1.Optional.empty();
+        }
+        return cafe_utility_1.Optional.of(await bee.fetchLatestFeedUpdate(topic, owner, requestOptions));
+    }
+    /**
+     * Gets the binary representation of the node.
+     */
+    async marshal() {
+        for (const fork of this.forks.values()) {
+            if (!fork.node.selfAddress) {
+                fork.node.selfAddress = (await fork.node.calculateSelfAddress()).toUint8Array();
+            }
+        }
+        const header = new Uint8Array(32);
+        header.set(VERSION_02_HASH, 0);
+        header.set(cafe_utility_1.Binary.equals(this.targetAddress, __1.NULL_ADDRESS) && cafe_utility_1.Binary.equals(this.path, new Uint8Array([47]))
+            ? cafe_utility_1.Binary.numberToUint8(0)
+            : cafe_utility_1.Binary.numberToUint8(this.targetAddress.length), 31);
+        const forkBitmap = new Uint8Array(32);
+        for (const fork of this.forks.keys()) {
+            cafe_utility_1.Binary.setBit(forkBitmap, fork, 1, 'LE');
+        }
+        const forks = [];
+        for (let i = 0; i < 256; i++) {
+            if (cafe_utility_1.Binary.getBit(forkBitmap, i, 'LE')) {
+                forks.push(this.forks.get(i).marshal());
+            }
+        }
+        const data = cafe_utility_1.Binary.xorCypher(cafe_utility_1.Binary.concatBytes(header, cafe_utility_1.Binary.equals(this.targetAddress, __1.NULL_ADDRESS) && cafe_utility_1.Binary.equals(this.path, new Uint8Array([47]))
+            ? new Uint8Array(0)
+            : this.targetAddress, forkBitmap, ...forks), this.obfuscationKey);
+        return cafe_utility_1.Binary.concatBytes(this.obfuscationKey, data);
+    }
+    /**
+     * Downloads and unmarshals a MantarayNode from the given reference.
+     *
+     * Do not forget calling `loadRecursively` on the returned node to load the entire tree.
+     */
+    static async unmarshal(bee, reference, options, requestOptions) {
+        const data = (await bee.downloadData(reference, options, requestOptions)).toUint8Array();
+        return this.unmarshalFromData(data);
+    }
+    /**
+     * Unmarshals a MantarayNode from the given data.
+     *
+     * Do not forget calling `loadRecursively` on the returned node to load the entire tree.
+     */
+    static unmarshalFromData(data) {
+        const obfuscationKey = data.subarray(0, 32);
+        const decrypted = cafe_utility_1.Binary.xorCypher(data.subarray(32), obfuscationKey);
+        const reader = new cafe_utility_1.Uint8ArrayReader(decrypted);
+        const versionHash = reader.read(31);
+        if (!cafe_utility_1.Binary.equals(versionHash, VERSION_02_HASH.slice(0, 31))) {
+            throw new Error('MantarayNode#unmarshal invalid version hash');
+        }
+        const targetAddressLength = cafe_utility_1.Binary.uint8ToNumber(reader.read(1));
+        const targetAddress = targetAddressLength === 0 ? __1.NULL_ADDRESS : reader.read(targetAddressLength);
+        const node = new MantarayNode({ targetAddress, obfuscationKey });
+        const forkBitmap = reader.read(32);
+        for (let i = 0; i < 256; i++) {
+            if (cafe_utility_1.Binary.getBit(forkBitmap, i, 'LE')) {
+                const newFork = Fork.unmarshal(reader);
+                node.forks.set(i, newFork);
+                newFork.node.parent = node;
+            }
+        }
+        return node;
+    }
+    /**
+     * Adds a fork to the node.
+     */
+    addFork(path, reference, metadata) {
+        this.selfAddress = null;
+        path = path instanceof Uint8Array ? path : ENCODER.encode(path);
+        // TODO: this should not be ignored
+        // eslint-disable-next-line @typescript-eslint/no-this-alias
+        let tip = this;
+        while (path.length) {
+            const prefix = path.slice(0, 30);
+            path = path.slice(30);
+            const isLast = path.length === 0;
+            const [bestMatch, matchedPath] = tip.findClosest(prefix);
+            const remainingPath = prefix.slice(matchedPath.length);
+            if (matchedPath.length) {
+                tip = bestMatch;
+            }
+            if (!remainingPath.length) {
+                continue;
+            }
+            const newFork = new Fork(remainingPath, new MantarayNode({
+                targetAddress: isLast ? new typed_bytes_1.Reference(reference).toUint8Array() : undefined,
+                metadata: isLast ? metadata : undefined,
+                path: remainingPath,
+            }));
+            const existing = bestMatch.forks.get(remainingPath[0]);
+            if (existing) {
+                const fork = Fork.split(newFork, existing);
+                tip.forks.set(remainingPath[0], fork);
+                fork.node.parent = tip;
+                tip.selfAddress = null;
+                tip = newFork.node;
+            }
+            else {
+                tip.forks.set(remainingPath[0], newFork);
+                newFork.node.parent = tip;
+                tip.selfAddress = null;
+                tip = newFork.node;
+            }
+        }
+    }
+    /**
+     * Removes a fork from the node.
+     */
+    removeFork(path) {
+        this.selfAddress = null;
+        path = path instanceof Uint8Array ? path : ENCODER.encode(path);
+        if (path.length === 0) {
+            throw Error('MantarayNode#removeFork [path] parameter cannot be empty');
+        }
+        const match = this.find(path);
+        if (!match) {
+            throw Error('MantarayNode#removeFork fork not found');
+        }
+        const [parent, matchedPath] = this.findClosest(path.slice(0, path.length - 1));
+        parent.forks.delete(path.slice(matchedPath.length)[0]);
+        for (const fork of match.forks.values()) {
+            parent.addFork(cafe_utility_1.Binary.concatBytes(match.path, fork.prefix), fork.node.targetAddress, fork.node.metadata);
+        }
+    }
+    /**
+     * Calculates the self address of the node.
+     */
+    async calculateSelfAddress() {
+        if (this.selfAddress) {
+            return new typed_bytes_1.Reference(this.selfAddress);
+        }
+        return new typed_bytes_1.Reference((await cafe_utility_1.MerkleTree.root(await this.marshal())).hash());
+    }
+    /**
+     * Saves the node and its children recursively.
+     */
+    async saveRecursively(bee, postageBatchId, options, requestOptions) {
+        for (const fork of this.forks.values()) {
+            await fork.node.saveRecursively(bee, postageBatchId, options, requestOptions);
+        }
+        const result = await bee.uploadData(postageBatchId, await this.marshal(), options, requestOptions);
+        this.selfAddress = result.reference.toUint8Array();
+        return result;
+    }
+    /**
+     * Loads the node and its children recursively.
+     */
+    async loadRecursively(bee, options, requestOptions) {
+        for (const fork of this.forks.values()) {
+            const node = await MantarayNode.unmarshal(bee, fork.node.targetAddress, options, requestOptions);
+            fork.node.targetAddress = node.targetAddress;
+            fork.node.forks = node.forks;
+            fork.node.path = fork.prefix;
+            fork.node.parent = this;
+            await fork.node.loadRecursively(bee, options, requestOptions);
+        }
+    }
+    /**
+     * Finds a node in the tree by its path.
+     */
+    find(path) {
+        const [closest, match] = this.findClosest(path);
+        return match.length === path.length ? closest : null;
+    }
+    /**
+     * Finds the closest node in the tree to the given path.
+     */
+    findClosest(path, current = new Uint8Array()) {
+        path = path instanceof Uint8Array ? path : ENCODER.encode(path);
+        if (path.length === 0) {
+            return [this, current];
+        }
+        const fork = this.forks.get(path[0]);
+        if (fork && cafe_utility_1.Binary.commonPrefix(fork.prefix, path).length === fork.prefix.length) {
+            return fork.node.findClosest(path.slice(fork.prefix.length), cafe_utility_1.Binary.concatBytes(current, fork.prefix));
+        }
+        return [this, current];
+    }
+    /**
+     * Returns an array of all nodes in the tree which have a target address set.
+     *
+     * Must be called after `loadRecursively`.
+     */
+    collect(nodes = []) {
+        for (const fork of this.forks.values()) {
+            if (!cafe_utility_1.Binary.equals(fork.node.targetAddress, __1.NULL_ADDRESS)) {
+                nodes.push(fork.node);
+            }
+            fork.node.collect(nodes);
+        }
+        return nodes;
+    }
+    /**
+     * Returns a path:reference map of all nodes in the tree which have a target address set.
+     *
+     * Must be called after `loadRecursively`.
+     */
+    collectAndMap() {
+        const nodes = this.collect();
+        const result = {};
+        for (const node of nodes) {
+            result[node.fullPathString] = new typed_bytes_1.Reference(node.targetAddress).toHex();
+        }
+        return result;
+    }
+    determineType() {
+        let type = 0;
+        if (!cafe_utility_1.Binary.equals(this.targetAddress, __1.NULL_ADDRESS) || cafe_utility_1.Binary.equals(this.path, PATH_SEPARATOR)) {
+            type |= TYPE_VALUE;
+        }
+        if (this.forks.size > 0) {
+            type |= TYPE_EDGE;
+        }
+        if (cafe_utility_1.Binary.indexOf(this.path, PATH_SEPARATOR) !== -1 && !cafe_utility_1.Binary.equals(this.path, PATH_SEPARATOR)) {
+            type |= TYPE_WITH_PATH_SEPARATOR;
+        }
+        if (this.metadata) {
+            type |= TYPE_WITH_METADATA;
+        }
+        return type;
+    }
+}
+exports.MantarayNode = MantarayNode;
+function isType(value, type) {
+    return (value & type) === type;
+}

package/dist/cjs/modules/bytes.js

@@ -1,10 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.downloadReadable = exports.download = exports.head = exports.upload = void 0;
+const cafe_utility_1 = require("cafe-utility");
 const bytes_1 = require("../utils/bytes");
 const headers_1 = require("../utils/headers");
 const http_1 = require("../utils/http");
 const type_1 = require("../utils/type");
+const typed_bytes_1 = require("../utils/typed-bytes");
 const endpoint = 'bytes';
 /**
  * Upload data to a Bee node
@@ -22,13 +24,16 @@ async function upload(requestOptions, data, postageBatchId, options) {
         data,
         headers: {
             'content-type': 'application/octet-stream',
-            ...(0, headers_1.extractRedundantUploadHeaders)(postageBatchId, options),
+            ...(0, headers_1.prepareRequestHeaders)(postageBatchId, options),
         },
     });
+    const body = cafe_utility_1.Types.asObject(response.data, { name: 'response.data' });
     return {
-        reference: response.data.reference,
+        reference: new typed_bytes_1.Reference(cafe_utility_1.Types.asHexString(body.reference)),
         tagUid: response.headers['swarm-tag'] ? (0, type_1.makeTagUid)(response.headers['swarm-tag']) : undefined,
-        historyAddress: response.headers['swarm-act-history-address'] || '',
+        historyAddress: response.headers['swarm-act-history-address']
+            ? cafe_utility_1.Optional.of(new typed_bytes_1.Reference(response.headers['swarm-act-history-address']))
+            : cafe_utility_1.Optional.empty(),
     };
 }
 exports.upload = upload;
@@ -38,9 +43,10 @@ exports.upload = upload;
  * @param requestOptions Options for making requests
  * @param hash Bee content reference
  */
-async function head(requestOptions, hash) {
+async function head(requestOptions, reference) {
+    reference = new typed_bytes_1.Reference(reference);
     const response = await (0, http_1.http)(requestOptions, {
-        url: `${endpoint}/${hash}`,
+        url: `${endpoint}/${reference}`,
         method: 'head',
         responseType: 'json',
     });
@@ -55,13 +61,16 @@ exports.head = head;
  * @param requestOptions Options for making requests
  * @param hash Bee content reference
  */
-async function download(requestOptions, hash, options) {
+async function download(requestOptions, resource, options) {
+    if (options) {
+        options = (0, type_1.prepareDownloadOptions)(options);
+    }
     const response = await (0, http_1.http)(requestOptions, {
         responseType: 'arraybuffer',
-        url: `${endpoint}/${hash}`,
-        headers: (0, headers_1.extractDownloadHeaders)(options),
+        url: `${endpoint}/${resource}`,
+        headers: (0, headers_1.prepareRequestHeaders)(null, options),
     });
-    return (0, bytes_1.wrapBytesWithHelpers)(new Uint8Array(response.data));
+    return new bytes_1.Bytes(response.data);
 }
 exports.download = download;
 /**
@@ -70,11 +79,14 @@ exports.download = download;
  * @param requestOptions Options for making requests
  * @param hash Bee content reference
  */
-async function downloadReadable(requestOptions, hash, options) {
+async function downloadReadable(requestOptions, resource, options) {
+    if (options) {
+        options = (0, type_1.prepareDownloadOptions)(options);
+    }
     const response = await (0, http_1.http)(requestOptions, {
         responseType: 'stream',
-        url: `${endpoint}/${hash}`,
-        headers: (0, headers_1.extractDownloadHeaders)(options),
+        url: `${endpoint}/${resource}`,
+        headers: (0, headers_1.prepareRequestHeaders)(null, options),
     });
     return response.data;
 }

package/dist/cjs/modules/bzz.js

@@ -1,21 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.uploadCollection = exports.extractCollectionUploadHeaders = exports.downloadFileReadable = exports.downloadFile = exports.uploadFile = void 0;
+exports.uploadCollection = exports.downloadFileReadable = exports.downloadFile = exports.uploadFile = void 0;
+const cafe_utility_1 = require("cafe-utility");
 const bytes_1 = require("../utils/bytes");
 const collection_1 = require("../utils/collection");
 const headers_1 = require("../utils/headers");
 const http_1 = require("../utils/http");
 const tar_uploader_1 = require("../utils/tar-uploader");
 const type_1 = require("../utils/type");
+const typed_bytes_1 = require("../utils/typed-bytes");
 const bzzEndpoint = 'bzz';
-function extractFileUploadHeaders(postageBatchId, options) {
-    const headers = (0, headers_1.extractRedundantUploadHeaders)(postageBatchId, options);
-    if (options?.size)
-        headers['content-length'] = String(options.size);
-    if (options?.contentType)
-        headers['content-type'] = options.contentType;
-    return headers;
-}
 /**
  * Upload single file
  *
@@ -36,16 +30,17 @@ async function uploadFile(requestOptions, data, postageBatchId, name, options) {
         method: 'post',
         url: bzzEndpoint,
         data,
-        headers: {
-            ...extractFileUploadHeaders(postageBatchId, options),
-        },
+        headers: (0, headers_1.prepareRequestHeaders)(postageBatchId, options),
         params: { name },
         responseType: 'json',
     });
+    const body = cafe_utility_1.Types.asObject(response.data, { name: 'response.data' });
     return {
-        reference: response.data.reference,
+        reference: new typed_bytes_1.Reference(cafe_utility_1.Types.asHexString(body.reference)),
         tagUid: response.headers['swarm-tag'] ? (0, type_1.makeTagUid)(response.headers['swarm-tag']) : undefined,
-        historyAddress: response.headers['swarm-act-history-address'] || '',
+        historyAddress: response.headers['swarm-act-history-address']
+            ? cafe_utility_1.Optional.of(new typed_bytes_1.Reference(response.headers['swarm-act-history-address']))
+            : cafe_utility_1.Optional.empty(),
     };
 }
 exports.uploadFile = uploadFile;
@@ -56,16 +51,16 @@ exports.uploadFile = uploadFile;
  * @param hash Bee file or collection hash
  * @param path If hash is collection then this defines path to a single file in the collection
  */
-async function downloadFile(requestOptions, hash, path = '', options) {
+async function downloadFile(requestOptions, resource, path = '', options) {
     const response = await (0, http_1.http)(requestOptions, {
         method: 'GET',
         responseType: 'arraybuffer',
-        url: `${bzzEndpoint}/${hash}/${path}`,
-        headers: (0, headers_1.extractDownloadHeaders)(options),
+        url: `${bzzEndpoint}/${resource}/${path}`,
+        headers: (0, headers_1.prepareRequestHeaders)(null, options),
     });
     const file = {
         ...(0, headers_1.readFileHeaders)(response.headers),
-        data: (0, bytes_1.wrapBytesWithHelpers)(new Uint8Array(response.data)),
+        data: new bytes_1.Bytes(response.data),
     };
     return file;
 }
@@ -77,12 +72,13 @@ exports.downloadFile = downloadFile;
  * @param hash Bee file or collection hash
  * @param path If hash is collection then this defines path to a single file in the collection
  */
-async function downloadFileReadable(requestOptions, hash, path = '', options) {
+async function downloadFileReadable(requestOptions, reference, path = '', options) {
+    reference = new typed_bytes_1.Reference(reference);
     const response = await (0, http_1.http)(requestOptions, {
         method: 'GET',
         responseType: 'stream',
-        url: `${bzzEndpoint}/${hash}/${path}`,
-        headers: (0, headers_1.extractDownloadHeaders)(options),
+        url: `${bzzEndpoint}/${reference}/${path}`,
+        headers: (0, headers_1.prepareRequestHeaders)(null, options),
     });
     const file = {
         ...(0, headers_1.readFileHeaders)(response.headers),
@@ -91,17 +87,8 @@ async function downloadFileReadable(requestOptions, hash, path = '', options) {
     return file;
 }
 exports.downloadFileReadable = downloadFileReadable;
-function extractCollectionUploadHeaders(postageBatchId, options) {
-    const headers = (0, headers_1.extractRedundantUploadHeaders)(postageBatchId, options);
-    if (options?.indexDocument) {
-        headers['swarm-index-document'] = options.indexDocument;
-    }
-    if (options?.errorDocument) {
-        headers['swarm-error-document'] = options.errorDocument;
-    }
-    return headers;
-}
-exports.extractCollectionUploadHeaders = extractCollectionUploadHeaders;
+/*******************************************************************************************************************/
+// Collections
 /**
  * Upload collection
  * @param requestOptions Options for making requests
@@ -112,10 +99,13 @@ exports.extractCollectionUploadHeaders = extractCollectionUploadHeaders;
 async function uploadCollection(requestOptions, collection, postageBatchId, options) {
     (0, collection_1.assertCollection)(collection);
     const response = await (0, tar_uploader_1.uploadTar)(requestOptions, collection, postageBatchId, options);
+    const body = cafe_utility_1.Types.asObject(response.data, { name: 'response.data' });
     return {
-        reference: response.data.reference,
+        reference: new typed_bytes_1.Reference(cafe_utility_1.Types.asHexString(body.reference)),
         tagUid: response.headers['swarm-tag'] ? (0, type_1.makeTagUid)(response.headers['swarm-tag']) : undefined,
-        historyAddress: response.headers['swarm-act-history-address'] || '',
+        historyAddress: response.headers['swarm-act-history-address']
+            ? cafe_utility_1.Optional.of(new typed_bytes_1.Reference(response.headers['swarm-act-history-address']))
+            : cafe_utility_1.Optional.empty(),
     };
 }
 exports.uploadCollection = uploadCollection;

package/dist/cjs/modules/chunk.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.download = exports.upload = void 0;
-const bytes_1 = require("../utils/bytes");
+const cafe_utility_1 = require("cafe-utility");
 const headers_1 = require("../utils/headers");
 const http_1 = require("../utils/http");
 const type_1 = require("../utils/type");
+const typed_bytes_1 = require("../utils/typed-bytes");
 const endpoint = 'chunks';
 /**
  * Upload chunk to a Bee node
@@ -25,14 +26,17 @@ async function upload(requestOptions, data, stamp, options) {
         data,
         headers: {
             'content-type': 'application/octet-stream',
-            ...(0, headers_1.extractUploadHeaders)(stamp, options),
+            ...(0, headers_1.prepareRequestHeaders)(stamp, options),
         },
         responseType: 'json',
     });
+    const body = cafe_utility_1.Types.asObject(response.data, { name: 'response.data' });
     return {
-        reference: response.data.reference,
+        reference: new typed_bytes_1.Reference(cafe_utility_1.Types.asString(body.reference, { name: 'reference' })),
         tagUid: response.headers['swarm-tag'] ? (0, type_1.makeTagUid)(response.headers['swarm-tag']) : undefined,
-        historyAddress: response.headers['swarm-act-history-address'] || '',
+        historyAddress: response.headers['swarm-act-history-address']
+            ? cafe_utility_1.Optional.of(new typed_bytes_1.Reference(response.headers['swarm-act-history-address']))
+            : cafe_utility_1.Optional.empty(),
     };
 }
 exports.upload = upload;
@@ -43,11 +47,13 @@ exports.upload = upload;
  * @param hash Bee content reference
  *
  */
-async function download(requestOptions, hash) {
+async function download(requestOptions, reference, options) {
+    reference = new typed_bytes_1.Reference(reference);
     const response = await (0, http_1.http)(requestOptions, {
         responseType: 'arraybuffer',
-        url: `${endpoint}/${hash}`,
+        url: `${endpoint}/${reference}`,
+        headers: (0, headers_1.prepareRequestHeaders)(null, options),
     });
-    return (0, bytes_1.wrapBytesWithHelpers)(new Uint8Array(response.data));
+    return new Uint8Array(response.data);
 }
 exports.download = download;