@ethersphere/bee-js 3.3.0 → 3.3.1

package/dist/mjs/feed/index.js

@@ -1,15 +1,15 @@
-import { keccak256Hash } from '../utils/hash';
-import { serializeBytes } from '../chunk/serialize';
-import { uploadSingleOwnerChunkData, makeSingleOwnerChunkFromData } from '../chunk/soc';
-import { fetchFeedUpdate } from '../modules/feed';
-import { REFERENCE_HEX_LENGTH, ENCRYPTED_REFERENCE_HEX_LENGTH, } from '../types';
-import { makeBytes, bytesAtOffset } from '../utils/bytes';
-import { BeeResponseError } from '../utils/error';
-import { bytesToHex, hexToBytes, makeHexString } from '../utils/hex';
-import { readUint64BigEndian, writeUint64BigEndian } from '../utils/uint64';
-import * as chunkAPI from '../modules/chunk';
-import { makeHexEthAddress } from '../utils/eth';
-import { assertAddress } from '../utils/type';
+import { keccak256Hash } from "../utils/hash.js";
+import { serializeBytes } from "../chunk/serialize.js";
+import { uploadSingleOwnerChunkData, makeSingleOwnerChunkFromData } from "../chunk/soc.js";
+import { fetchFeedUpdate } from "../modules/feed.js";
+import { REFERENCE_HEX_LENGTH, ENCRYPTED_REFERENCE_HEX_LENGTH } from "../types/index.js";
+import { makeBytes, bytesAtOffset } from "../utils/bytes.js";
+import { BeeResponseError } from "../utils/error.js";
+import { bytesToHex, hexToBytes, makeHexString } from "../utils/hex.js";
+import { readUint64BigEndian, writeUint64BigEndian } from "../utils/uint64.js";
+import * as chunkAPI from "../modules/chunk.js";
+import { makeHexEthAddress } from "../utils/eth.js";
+import { assertAddress } from "../utils/type.js";
 const TIMESTAMP_PAYLOAD_OFFSET = 0;
 const TIMESTAMP_PAYLOAD_SIZE = 8;
 const REFERENCE_PAYLOAD_OFFSET = TIMESTAMP_PAYLOAD_SIZE;
@@ -17,120 +17,129 @@ const REFERENCE_PAYLOAD_MIN_SIZE = 32;
 const REFERENCE_PAYLOAD_MAX_SIZE = 64;
 const INDEX_HEX_LENGTH = 16;
 export function isEpoch(epoch) {
-    return typeof epoch === 'object' && epoch !== null && 'time' in epoch && 'level' in epoch;
+  return typeof epoch === 'object' && epoch !== null && 'time' in epoch && 'level' in epoch;
 }
+
 function hashFeedIdentifier(topic, index) {
-    return keccak256Hash(hexToBytes(topic), index);
+  return keccak256Hash(hexToBytes(topic), index);
 }
+
 export function makeSequentialFeedIdentifier(topic, index) {
-    const indexBytes = writeUint64BigEndian(index);
-    return hashFeedIdentifier(topic, indexBytes);
+  const indexBytes = writeUint64BigEndian(index);
+  return hashFeedIdentifier(topic, indexBytes);
 }
 export function makeFeedIndexBytes(s) {
-    const hex = makeHexString(s, INDEX_HEX_LENGTH);
-    return hexToBytes(hex);
+  const hex = makeHexString(s, INDEX_HEX_LENGTH);
+  return hexToBytes(hex);
 }
 export function makeFeedIdentifier(topic, index) {
-    if (typeof index === 'number') {
-        return makeSequentialFeedIdentifier(topic, index);
-    }
-    else if (typeof index === 'string') {
-        const indexBytes = makeFeedIndexBytes(index);
-        return hashFeedIdentifier(topic, indexBytes);
-    }
-    else if (isEpoch(index)) {
-        throw new TypeError('epoch is not yet implemented');
-    }
-    return hashFeedIdentifier(topic, index);
+  if (typeof index === 'number') {
+    return makeSequentialFeedIdentifier(topic, index);
+  } else if (typeof index === 'string') {
+    const indexBytes = makeFeedIndexBytes(index);
+    return hashFeedIdentifier(topic, indexBytes);
+  } else if (isEpoch(index)) {
+    throw new TypeError('epoch is not yet implemented');
+  }
+
+  return hashFeedIdentifier(topic, index);
 }
 export async function uploadFeedUpdate(ky, signer, topic, index, reference, postageBatchId, options) {
-    const identifier = makeFeedIdentifier(topic, index);
-    const at = options?.at ?? Date.now() / 1000.0;
-    const timestamp = writeUint64BigEndian(at);
-    const payloadBytes = serializeBytes(timestamp, reference);
-    return uploadSingleOwnerChunkData(ky, signer, postageBatchId, identifier, payloadBytes, options);
+  const identifier = makeFeedIdentifier(topic, index);
+  const at = options?.at ?? Date.now() / 1000.0;
+  const timestamp = writeUint64BigEndian(at);
+  const payloadBytes = serializeBytes(timestamp, reference);
+  return uploadSingleOwnerChunkData(ky, signer, postageBatchId, identifier, payloadBytes, options);
 }
 export async function findNextIndex(ky, owner, topic, options) {
-    try {
-        const feedUpdate = await fetchFeedUpdate(ky, owner, topic, options);
-        return makeHexString(feedUpdate.feedIndexNext, INDEX_HEX_LENGTH);
-    }
-    catch (e) {
-        if (e instanceof BeeResponseError && e.status === 404) {
-            return bytesToHex(makeBytes(8));
-        }
-        throw e;
+  try {
+    const feedUpdate = await fetchFeedUpdate(ky, owner, topic, options);
+    return makeHexString(feedUpdate.feedIndexNext, INDEX_HEX_LENGTH);
+  } catch (e) {
+    if (e instanceof BeeResponseError && e.status === 404) {
+      return bytesToHex(makeBytes(8));
     }
+
+    throw e;
+  }
 }
 export async function updateFeed(ky, signer, topic, reference, postageBatchId, options) {
-    const ownerHex = makeHexEthAddress(signer.address);
-    const nextIndex = await findNextIndex(ky, ownerHex, topic, options);
-    return uploadFeedUpdate(ky, signer, topic, nextIndex, reference, postageBatchId, options);
+  const ownerHex = makeHexEthAddress(signer.address);
+  const nextIndex = await findNextIndex(ky, ownerHex, topic, options);
+  return uploadFeedUpdate(ky, signer, topic, nextIndex, reference, postageBatchId, options);
 }
+
 function verifyChunkReferenceAtOffset(offset, data) {
-    try {
-        return bytesAtOffset(data, offset, REFERENCE_PAYLOAD_MAX_SIZE);
-    }
-    catch (e) {
-        return bytesAtOffset(data, offset, REFERENCE_PAYLOAD_MIN_SIZE);
-    }
+  try {
+    return bytesAtOffset(data, offset, REFERENCE_PAYLOAD_MAX_SIZE);
+  } catch (e) {
+    return bytesAtOffset(data, offset, REFERENCE_PAYLOAD_MIN_SIZE);
+  }
 }
+
 export function verifyChunkReference(data) {
-    return verifyChunkReferenceAtOffset(0, data);
+  return verifyChunkReferenceAtOffset(0, data);
 }
 export async function downloadFeedUpdate(ky, owner, topic, index) {
-    const identifier = makeFeedIdentifier(topic, index);
-    const address = keccak256Hash(identifier, owner);
-    const addressHex = bytesToHex(address);
-    const data = await chunkAPI.download(ky, addressHex);
-    const soc = makeSingleOwnerChunkFromData(data, address);
-    const payload = soc.payload();
-    const timestampBytes = bytesAtOffset(payload, TIMESTAMP_PAYLOAD_OFFSET, TIMESTAMP_PAYLOAD_SIZE);
-    const timestamp = readUint64BigEndian(timestampBytes);
-    const reference = verifyChunkReferenceAtOffset(REFERENCE_PAYLOAD_OFFSET, payload);
-    return {
-        timestamp,
-        reference,
-    };
+  const identifier = makeFeedIdentifier(topic, index);
+  const address = keccak256Hash(identifier, owner);
+  const addressHex = bytesToHex(address);
+  const data = await chunkAPI.download(ky, addressHex);
+  const soc = makeSingleOwnerChunkFromData(data, address);
+  const payload = soc.payload();
+  const timestampBytes = bytesAtOffset(payload, TIMESTAMP_PAYLOAD_OFFSET, TIMESTAMP_PAYLOAD_SIZE);
+  const timestamp = readUint64BigEndian(timestampBytes);
+  const reference = verifyChunkReferenceAtOffset(REFERENCE_PAYLOAD_OFFSET, payload);
+  return {
+    timestamp,
+    reference
+  };
 }
 export function makeFeedReader(ky, type, topic, owner) {
-    const download = async (options) => fetchFeedUpdate(ky, owner, topic, { ...options, type });
-    return {
-        type,
-        owner,
-        topic,
-        download,
-    };
+  const download = async options => fetchFeedUpdate(ky, owner, topic, { ...options,
+    type
+  });
+
+  return {
+    type,
+    owner,
+    topic,
+    download
+  };
 }
+
 function makeChunkReference(reference) {
-    if (typeof reference === 'string') {
-        try {
-            // Non-encrypted chunk hex string reference
-            const hexReference = makeHexString(reference, REFERENCE_HEX_LENGTH);
-            return hexToBytes(hexReference);
-        }
-        catch (e) {
-            if (!(e instanceof TypeError)) {
-                throw e;
-            }
-            // Encrypted chunk hex string reference
-            const hexReference = makeHexString(reference, ENCRYPTED_REFERENCE_HEX_LENGTH);
-            return hexToBytes(hexReference);
-        }
-    }
-    else if (reference instanceof Uint8Array) {
-        return verifyChunkReference(reference);
+  if (typeof reference === 'string') {
+    try {
+      // Non-encrypted chunk hex string reference
+      const hexReference = makeHexString(reference, REFERENCE_HEX_LENGTH);
+      return hexToBytes(hexReference);
+    } catch (e) {
+      if (!(e instanceof TypeError)) {
+        throw e;
+      } // Encrypted chunk hex string reference
+
+
+      const hexReference = makeHexString(reference, ENCRYPTED_REFERENCE_HEX_LENGTH);
+      return hexToBytes(hexReference);
     }
-    throw new TypeError('invalid chunk reference');
+  } else if (reference instanceof Uint8Array) {
+    return verifyChunkReference(reference);
+  }
+
+  throw new TypeError('invalid chunk reference');
 }
+
 export function makeFeedWriter(ky, type, topic, signer) {
-    const upload = async (postageBatchId, reference, options) => {
-        assertAddress(postageBatchId);
-        const canonicalReference = makeChunkReference(reference);
-        return updateFeed(ky, signer, topic, canonicalReference, postageBatchId, { ...options, type });
-    };
-    return {
-        ...makeFeedReader(ky, type, topic, makeHexEthAddress(signer.address)),
-        upload,
-    };
-}
+  const upload = async (postageBatchId, reference, options) => {
+    assertAddress(postageBatchId);
+    const canonicalReference = makeChunkReference(reference);
+    return updateFeed(ky, signer, topic, canonicalReference, postageBatchId, { ...options,
+      type
+    });
+  };
+
+  return { ...makeFeedReader(ky, type, topic, makeHexEthAddress(signer.address)),
+    upload
+  };
+}

package/dist/mjs/feed/json.js

@@ -1,23 +1,27 @@
-import { isError } from '../utils/type';
+import { isError } from "../utils/type.js";
+
 function serializeJson(data) {
-    try {
-        const jsonString = JSON.stringify(data);
-        return new TextEncoder().encode(jsonString);
-    }
-    catch (e) {
-        if (isError(e)) {
-            e.message = `JsonFeed: ${e.message}`;
-        }
-        throw e;
+  try {
+    const jsonString = JSON.stringify(data);
+    return new TextEncoder().encode(jsonString);
+  } catch (e) {
+    if (isError(e)) {
+      e.message = `JsonFeed: ${e.message}`;
     }
+
+    throw e;
+  }
 }
+
 export async function getJsonData(bee, reader) {
-    const feedUpdate = await reader.download();
-    const retrievedData = await bee.downloadData(feedUpdate.reference);
-    return retrievedData.json();
+  const feedUpdate = await reader.download();
+  const retrievedData = await bee.downloadData(feedUpdate.reference);
+  return retrievedData.json();
 }
 export async function setJsonData(bee, writer, postageBatchId, data, options) {
-    const serializedData = serializeJson(data);
-    const { reference } = await bee.uploadData(postageBatchId, serializedData, options);
-    return writer.upload(postageBatchId, reference);
-}
+  const serializedData = serializeJson(data);
+  const {
+    reference
+  } = await bee.uploadData(postageBatchId, serializedData, options);
+  return writer.upload(postageBatchId, reference);
+}

package/dist/mjs/feed/topic.js

@@ -1,20 +1,21 @@
-import { keccak256Hash } from '../utils/hash';
-import { assertBytes } from '../utils/bytes';
-import { makeHexString, bytesToHex } from '../utils/hex';
-import { TOPIC_BYTES_LENGTH, TOPIC_HEX_LENGTH } from '../types';
+import { keccak256Hash } from "../utils/hash.js";
+import { assertBytes } from "../utils/bytes.js";
+import { makeHexString, bytesToHex } from "../utils/hex.js";
+import { TOPIC_BYTES_LENGTH, TOPIC_HEX_LENGTH } from "../types/index.js";
 export function makeTopic(topic) {
-    if (typeof topic === 'string') {
-        return makeHexString(topic, TOPIC_HEX_LENGTH);
-    }
-    else if (topic instanceof Uint8Array) {
-        assertBytes(topic, TOPIC_BYTES_LENGTH);
-        return bytesToHex(topic, TOPIC_HEX_LENGTH);
-    }
-    throw new TypeError('invalid topic');
+  if (typeof topic === 'string') {
+    return makeHexString(topic, TOPIC_HEX_LENGTH);
+  } else if (topic instanceof Uint8Array) {
+    assertBytes(topic, TOPIC_BYTES_LENGTH);
+    return bytesToHex(topic, TOPIC_HEX_LENGTH);
+  }
+
+  throw new TypeError('invalid topic');
 }
 export function makeTopicFromString(s) {
-    if (typeof s !== 'string') {
-        throw new TypeError('topic has to be string!');
-    }
-    return bytesToHex(keccak256Hash(s), TOPIC_HEX_LENGTH);
-}
+  if (typeof s !== 'string') {
+    throw new TypeError('topic has to be string!');
+  }
+
+  return bytesToHex(keccak256Hash(s), TOPIC_HEX_LENGTH);
+}

package/dist/mjs/feed/type.js

@@ -1,10 +1,10 @@
 const feedTypes = ['sequence', 'epoch'];
 export const DEFAULT_FEED_TYPE = 'sequence';
 export function isFeedType(type) {
-    return typeof type === 'string' && feedTypes.includes(type);
+  return typeof type === 'string' && feedTypes.includes(type);
 }
 export function assertFeedType(type) {
-    if (!isFeedType(type)) {
-        throw new TypeError('invalid feed type');
-    }
-}
+  if (!isFeedType(type)) {
+    throw new TypeError('invalid feed type');
+  }
+}

package/dist/mjs/index.js

@@ -1,7 +1,7 @@
-import { Bee } from './bee';
-import { BeeDebug } from './bee-debug';
-export * as Utils from './utils/expose';
-export * from './types';
-export * from './utils/error';
-export { SUPPORTED_BEE_VERSION, SUPPORTED_BEE_VERSION_EXACT } from './modules/debug/status';
-export { Bee, BeeDebug };
+import { Bee } from "./bee.js";
+import { BeeDebug } from "./bee-debug.js";
+export * as Utils from "./utils/expose.js";
+export * from "./types/index.js";
+export * from "./utils/error.js";
+export { SUPPORTED_BEE_VERSION, SUPPORTED_BEE_VERSION_EXACT } from "./modules/debug/status.js";
+export { Bee, BeeDebug };

package/dist/mjs/modules/bytes.js

@@ -1,8 +1,8 @@
-import { prepareData } from '../utils/data';
-import { extractUploadHeaders } from '../utils/headers';
-import { http } from '../utils/http';
-import { wrapBytesWithHelpers } from '../utils/bytes';
-import { makeTagUid } from '../utils/type';
+import { prepareData } from "../utils/data.js";
+import { extractUploadHeaders } from "../utils/headers.js";
+import { http } from "../utils/http.js";
+import { wrapBytesWithHelpers } from "../utils/bytes.js";
+import { makeTagUid } from "../utils/type.js";
 const endpoint = 'bytes';
 /**
  * Upload data to a Bee node
@@ -12,21 +12,22 @@ const endpoint = 'bytes';
  * @param postageBatchId  Postage BatchId that will be assigned to uploaded data
  * @param options         Additional options like tag, encryption, pinning
  */
+
 export async function upload(ky, data, postageBatchId, options) {
-    const response = await http(ky, {
-        path: endpoint,
-        method: 'post',
-        responseType: 'json',
-        body: await prepareData(data),
-        headers: {
-            'content-type': 'application/octet-stream',
-            ...extractUploadHeaders(postageBatchId, options),
-        },
-    });
-    return {
-        reference: response.data.reference,
-        tagUid: makeTagUid(response.headers.get('swarm-tag')),
-    };
+  const response = await http(ky, {
+    path: endpoint,
+    method: 'post',
+    responseType: 'json',
+    body: await prepareData(data),
+    headers: {
+      'content-type': 'application/octet-stream',
+      ...extractUploadHeaders(postageBatchId, options)
+    }
+  });
+  return {
+    reference: response.data.reference,
+    tagUid: makeTagUid(response.headers.get('swarm-tag'))
+  };
 }
 /**
  * Download data as a byte array
@@ -34,12 +35,13 @@ export async function upload(ky, data, postageBatchId, options) {
  * @param ky
  * @param hash Bee content reference
  */
+
 export async function download(ky, hash) {
-    const response = await http(ky, {
-        responseType: 'arraybuffer',
-        path: `${endpoint}/${hash}`,
-    });
-    return wrapBytesWithHelpers(new Uint8Array(response.data));
+  const response = await http(ky, {
+    responseType: 'arraybuffer',
+    path: `${endpoint}/${hash}`
+  });
+  return wrapBytesWithHelpers(new Uint8Array(response.data));
 }
 /**
  * Download data as a readable stream
@@ -47,10 +49,11 @@ export async function download(ky, hash) {
  * @param ky
  * @param hash Bee content reference
  */
+
 export async function downloadReadable(ky, hash) {
-    const response = await http(ky, {
-        responseType: 'stream',
-        path: `${endpoint}/${hash}`,
-    });
-    return response.data;
-}
+  const response = await http(ky, {
+    responseType: 'stream',
+    path: `${endpoint}/${hash}`
+  });
+  return response.data;
+}

package/dist/mjs/modules/bzz.js

@@ -1,19 +1,18 @@
-import { extractUploadHeaders, readFileHeaders } from '../utils/headers';
-import { http } from '../utils/http';
-import { prepareData } from '../utils/data';
-import { makeTar } from '../utils/tar';
-import { assertCollection } from '../utils/collection';
-import { wrapBytesWithHelpers } from '../utils/bytes';
-import { isReadable } from '../utils/stream';
-import { makeTagUid } from '../utils/type';
+import { extractUploadHeaders, readFileHeaders } from "../utils/headers.js";
+import { http } from "../utils/http.js";
+import { prepareData } from "../utils/data.js";
+import { makeTar } from "../utils/tar.js";
+import { assertCollection } from "../utils/collection.js";
+import { wrapBytesWithHelpers } from "../utils/bytes.js";
+import { isReadable } from "../utils/stream.js";
+import { makeTagUid } from "../utils/type.js";
 const bzzEndpoint = 'bzz';
+
 function extractFileUploadHeaders(postageBatchId, options) {
-    const headers = extractUploadHeaders(postageBatchId, options);
-    if (options?.size)
-        headers['content-length'] = String(options.size);
-    if (options?.contentType)
-        headers['content-type'] = options.contentType;
-    return headers;
+  const headers = extractUploadHeaders(postageBatchId, options);
+  if (options?.size) headers['content-length'] = String(options.size);
+  if (options?.contentType) headers['content-type'] = options.contentType;
+  return headers;
 }
 /**
  * Upload single file
@@ -24,26 +23,29 @@ function extractFileUploadHeaders(postageBatchId, options) {
  * @param name Name that will be attached to the uploaded file. Wraps the data into manifest with set index document.
  * @param options
  */
+
+
 export async function uploadFile(ky, data, postageBatchId, name, options) {
-    if (isReadable(data) && !options?.contentType) {
-        if (!options)
-            options = {};
-        options.contentType = 'application/octet-stream';
-    }
-    const response = await http(ky, {
-        method: 'post',
-        path: bzzEndpoint,
-        body: await prepareData(data),
-        headers: {
-            ...extractFileUploadHeaders(postageBatchId, options),
-        },
-        searchParams: { name },
-        responseType: 'json',
-    });
-    return {
-        reference: response.data.reference,
-        tagUid: makeTagUid(response.headers.get('swarm-tag')),
-    };
+  if (isReadable(data) && !options?.contentType) {
+    if (!options) options = {};
+    options.contentType = 'application/octet-stream';
+  }
+
+  const response = await http(ky, {
+    method: 'post',
+    path: bzzEndpoint,
+    body: await prepareData(data),
+    headers: { ...extractFileUploadHeaders(postageBatchId, options)
+    },
+    searchParams: {
+      name
+    },
+    responseType: 'json'
+  });
+  return {
+    reference: response.data.reference,
+    tagUid: makeTagUid(response.headers.get('swarm-tag'))
+  };
 }
 /**
  * Download single file as a buffer
@@ -52,17 +54,17 @@ export async function uploadFile(ky, data, postageBatchId, name, options) {
  * @param hash Bee file or collection hash
  * @param path If hash is collection then this defines path to a single file in the collection
  */
+
 export async function downloadFile(ky, hash, path = '') {
-    const response = await http(ky, {
-        method: 'GET',
-        responseType: 'arraybuffer',
-        path: `${bzzEndpoint}/${hash}/${path}`,
-    });
-    const file = {
-        ...readFileHeaders(response.headers),
-        data: wrapBytesWithHelpers(new Uint8Array(response.data)),
-    };
-    return file;
+  const response = await http(ky, {
+    method: 'GET',
+    responseType: 'arraybuffer',
+    path: `${bzzEndpoint}/${hash}/${path}`
+  });
+  const file = { ...readFileHeaders(response.headers),
+    data: wrapBytesWithHelpers(new Uint8Array(response.data))
+  };
+  return file;
 }
 /**
  * Download single file as a readable stream
@@ -71,25 +73,24 @@ export async function downloadFile(ky, hash, path = '') {
  * @param hash Bee file or collection hash
  * @param path If hash is collection then this defines path to a single file in the collection
  */
+
 export async function downloadFileReadable(ky, hash, path = '') {
-    const response = await http(ky, {
-        method: 'GET',
-        responseType: 'stream',
-        path: `${bzzEndpoint}/${hash}/${path}`,
-    });
-    const file = {
-        ...readFileHeaders(response.headers),
-        data: response.data,
-    };
-    return file;
+  const response = await http(ky, {
+    method: 'GET',
+    responseType: 'stream',
+    path: `${bzzEndpoint}/${hash}/${path}`
+  });
+  const file = { ...readFileHeaders(response.headers),
+    data: response.data
+  };
+  return file;
 }
+
 function extractCollectionUploadHeaders(postageBatchId, options) {
-    const headers = extractUploadHeaders(postageBatchId, options);
-    if (options?.indexDocument)
-        headers['swarm-index-document'] = options.indexDocument;
-    if (options?.errorDocument)
-        headers['swarm-error-document'] = options.errorDocument;
-    return headers;
+  const headers = extractUploadHeaders(postageBatchId, options);
+  if (options?.indexDocument) headers['swarm-index-document'] = options.indexDocument;
+  if (options?.errorDocument) headers['swarm-error-document'] = options.errorDocument;
+  return headers;
 }
 /**
  * Upload collection
@@ -98,22 +99,24 @@ function extractCollectionUploadHeaders(postageBatchId, options) {
  * @param postageBatchId  Postage BatchId that will be assigned to uploaded data
  * @param options
  */
+
+
 export async function uploadCollection(ky, collection, postageBatchId, options) {
-    assertCollection(collection);
-    const tarData = makeTar(collection);
-    const response = await http(ky, {
-        method: 'post',
-        path: bzzEndpoint,
-        body: tarData,
-        responseType: 'json',
-        headers: {
-            'content-type': 'application/x-tar',
-            'swarm-collection': 'true',
-            ...extractCollectionUploadHeaders(postageBatchId, options),
-        },
-    });
-    return {
-        reference: response.data.reference,
-        tagUid: makeTagUid(response.headers.get('swarm-tag')),
-    };
-}
+  assertCollection(collection);
+  const tarData = makeTar(collection);
+  const response = await http(ky, {
+    method: 'post',
+    path: bzzEndpoint,
+    body: tarData,
+    responseType: 'json',
+    headers: {
+      'content-type': 'application/x-tar',
+      'swarm-collection': 'true',
+      ...extractCollectionUploadHeaders(postageBatchId, options)
+    }
+  });
+  return {
+    reference: response.data.reference,
+    tagUid: makeTagUid(response.headers.get('swarm-tag'))
+  };
+}