@ethersphere/bee-js 3.3.3 → 4.0.0

package/dist/mjs/bee.js

@@ -50,13 +50,14 @@ import { createFeedManifest } from "./modules/feed.js";
 import { assertBeeUrl, stripLastSlash } from "./utils/url.js";
 import { makeEthAddress, makeHexEthAddress } from "./utils/eth.js";
 import { wrapBytesWithHelpers } from "./utils/bytes.js";
-import { assertAddressPrefix, assertAllTagsOptions, assertBatchId, assertCollectionUploadOptions, assertData, assertFileData, assertFileUploadOptions, assertPssMessageHandler, assertPublicKey, assertReference, assertRequestOptions, assertUploadOptions, makeTagUid } from "./utils/type.js";
+import { assertAddressPrefix, assertAllTagsOptions, assertBatchId, assertCollectionUploadOptions, assertData, assertFileData, assertFileUploadOptions, assertPssMessageHandler, assertPublicKey, assertReference, assertReferenceOrEns, assertRequestOptions, assertUploadOptions, makeTagUid } from "./utils/type.js";
 import { setJsonData, getJsonData } from "./feed/json.js";
 import { makeCollectionFromFileList, assertCollection } from "./utils/collection.js";
 import { makeCollectionFromFS } from "./utils/collection.node.js";
 import { CHUNK_SIZE, SPAN_SIZE } from "./types/index.js";
 import { makeDefaultKy, wrapRequestClosure, wrapResponseClosure } from "./utils/http.js";
 import { isReadable } from "./utils/stream.js";
+import { areAllSequentialFeedsUpdateRetrievable } from "./feed/retrievable.js";
 /**
  * The main component that abstracts operations available on the main Bee API.
  *
@@ -131,8 +132,10 @@ export class Bee {
   /**
    * Download data as a byte array
    *
-   * @param reference Bee data reference
+   * @param reference Bee data reference in hex string (either 64 or 128 chars long) or ENS domain.
    * @param options Options that affects the request behavior
+   * @throws TypeError if some of the input parameters is not expected type
+   * @throws BeeArgumentError if there is passed ENS domain with invalid unicode characters
    * @see [Bee docs - Upload and download](https://docs.ethswarm.org/docs/access-the-swarm/upload-and-download)
    * @see [Bee API reference - `GET /bytes`](https://docs.ethswarm.org/api/#tag/Bytes/paths/~1bytes~1{reference}/get)
    */
@@ -141,15 +144,17 @@ export class Bee {
   downloadData(reference, options) {
     return __awaiter(this, void 0, void 0, function* () {
       assertRequestOptions(options);
-      assertReference(reference);
+      assertReferenceOrEns(reference);
       return bytes.download(this.getKy(options), reference);
     });
   }
   /**
    * Download data as a Readable stream
    *
-   * @param reference Bee data reference
+   * @param reference Bee data reference in hex string (either 64 or 128 chars long) or ENS domain.
    * @param options Options that affects the request behavior
+   * @throws TypeError if some of the input parameters is not expected type
+   * @throws BeeArgumentError if there is passed ENS domain with invalid unicode characters
    * @see [Bee docs - Upload and download](https://docs.ethswarm.org/docs/access-the-swarm/upload-and-download)
    * @see [Bee API reference - `GET /bytes`](https://docs.ethswarm.org/api/#tag/Bytes/paths/~1bytes~1{reference}/get)
    */
@@ -158,7 +163,7 @@ export class Bee {
   downloadReadableData(reference, options) {
     return __awaiter(this, void 0, void 0, function* () {
       assertRequestOptions(options);
-      assertReference(reference);
+      assertReferenceOrEns(reference);
       return bytes.downloadReadable(this.getKy(options), reference);
     });
   }
@@ -198,8 +203,10 @@ export class Bee {
   /**
    * Download chunk as a byte array
    *
-   * @param reference Bee chunk reference
+   * @param reference Bee chunk reference in hex string (either 64 or 128 chars long) or ENS domain.
    * @param options Options that affects the request behavior
+   * @throws TypeError if some of the input parameters is not expected type
+   * @throws BeeArgumentError if there is passed ENS domain with invalid unicode characters
    * @see [Bee docs - Upload and download](https://docs.ethswarm.org/docs/access-the-swarm/upload-and-download)
    * @see [Bee API reference - `GET /chunks`](https://docs.ethswarm.org/api/#tag/Chunk/paths/~1chunks~1{reference}/get)
    */
@@ -208,7 +215,7 @@ export class Bee {
   downloadChunk(reference, options) {
     return __awaiter(this, void 0, void 0, function* () {
       assertRequestOptions(options);
-      assertReference(reference);
+      assertReferenceOrEns(reference);
       return chunk.download(this.getKy(options), reference);
     });
   }
@@ -261,10 +268,11 @@ export class Bee {
   /**
    * Download single file.
    *
-   * @param reference Bee file reference
+   * @param reference Bee file reference in hex string (either 64 or 128 chars long) or ENS domain.
    * @param path If reference points to manifest, then this parameter defines path to the file
    * @param options Options that affects the request behavior
-   *
+   * @throws TypeError if some of the input parameters is not expected type
+   * @throws BeeArgumentError if there is passed ENS domain with invalid unicode characters
    * @see Data
    * @see [Bee docs - Upload and download](https://docs.ethswarm.org/docs/access-the-swarm/upload-and-download)
    * @see [Bee API reference - `GET /bzz`](https://docs.ethswarm.org/api/#tag/Collection/paths/~1bzz~1{reference}~1{path}/get)
@@ -274,16 +282,18 @@ export class Bee {
   downloadFile(reference, path = '', options) {
     return __awaiter(this, void 0, void 0, function* () {
       assertRequestOptions(options);
-      assertReference(reference);
+      assertReferenceOrEns(reference);
       return bzz.downloadFile(this.getKy(options), reference, path);
     });
   }
   /**
    * Download single file as a readable stream
    *
-   * @param reference Hash reference to file
+   * @param reference Bee file reference in hex string (either 64 or 128 chars long) or ENS domain.
    * @param path If reference points to manifest / collections, then this parameter defines path to the file
    * @param options Options that affects the request behavior
+   * @throws TypeError if some of the input parameters is not expected type
+   * @throws BeeArgumentError if there is passed ENS domain with invalid unicode characters
    *
    * @see [Bee docs - Upload and download](https://docs.ethswarm.org/docs/access-the-swarm/upload-and-download)
    * @see [Bee API reference - `GET /bzz`](https://docs.ethswarm.org/api/#tag/Collection/paths/~1bzz~1{reference}~1{path}/get)
@@ -293,7 +303,7 @@ export class Bee {
   downloadReadableFile(reference, path = '', options) {
     return __awaiter(this, void 0, void 0, function* () {
       assertRequestOptions(options);
-      assertReference(reference);
+      assertReferenceOrEns(reference);
       return bzz.downloadFileReadable(this.getKy(options), reference, path);
     });
   }
@@ -541,9 +551,10 @@ export class Bee {
    *
    * **Warning! Not allowed when node is in Gateway mode!**
    *
-   * @param reference Bee data reference
+   * @param reference Bee data reference in hex string (either 64 or 128 chars long) or ENS domain.
    * @param options Options that affects the request behavior
-   * @throws TypeError if reference is in not correct format
+   * @throws TypeError if some of the input parameters is not expected type
+   * @throws BeeArgumentError if there is passed ENS domain with invalid unicode characters
    *
    * @see [Bee docs - Pinning](https://docs.ethswarm.org/docs/access-the-swarm/pinning)
    */
@@ -559,10 +570,11 @@ export class Bee {
   /**
    * Instructs the Bee node to reupload a locally pinned data into the network.
    *
-   * @param reference
+   * @param reference Bee data reference to be re-uploaded in hex string (either 64 or 128 chars long) or ENS domain.
    * @param options Options that affects the request behavior
    * @throws BeeArgumentError if the reference is not locally pinned
-   * @throws TypeError if reference is in not correct format
+   * @throws TypeError if some of the input parameters is not expected type
+   * @throws BeeArgumentError if there is passed ENS domain with invalid unicode characters
    *
    * @see [Bee API reference - `PUT /stewardship`](https://docs.ethswarm.org/api/#tag/Stewardship/paths/~1stewardship~1{reference}/put)
    */
@@ -571,15 +583,17 @@ export class Bee {
   reuploadPinnedData(reference, options) {
     return __awaiter(this, void 0, void 0, function* () {
       assertRequestOptions(options);
-      assertReference(reference);
+      assertReferenceOrEns(reference);
       yield stewardship.reupload(this.getKy(options), reference);
     });
   }
   /**
    * Checks if content specified by reference is retrievable from the network.
    *
-   * @param reference The checked content
+   * @param reference Bee data reference to be checked in hex string (either 64 or 128 chars long) or ENS domain.
    * @param options Options that affects the request behavior
+   * @throws TypeError if some of the input parameters is not expected type
+   * @throws BeeArgumentError if there is passed ENS domain with invalid unicode characters
    *
    * @see [Bee API reference - `GET /stewardship`](https://docs.ethswarm.org/api/#tag/Stewardship/paths/~1stewardship~1{reference}/get)
    */
@@ -588,10 +602,54 @@ export class Bee {
   isReferenceRetrievable(reference, options) {
     return __awaiter(this, void 0, void 0, function* () {
       assertRequestOptions(options);
-      assertReference(reference);
+      assertReferenceOrEns(reference);
       return stewardship.isRetrievable(this.getKy(options), reference);
     });
   }
+  /**
+   * Functions that validates if feed is retrievable in the network.
+   *
+   * If no index is passed then it check for "latest" update, which is a weaker guarantee as nobody can be really
+   * sure what is the "latest" update.
+   *
+   * If index is passed then it validates all previous sequence index chunks if they are available as they are required
+   * to correctly resolve the feed upto the given index update.
+   *
+   * @param type
+   * @param owner
+   * @param topic
+   * @param index
+   * @param options
+   */
+
+
+  isFeedRetrievable(type, owner, topic, index, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const canonicalOwner = makeEthAddress(owner);
+      const canonicalTopic = makeTopic(topic);
+
+      if (!index) {
+        try {
+          yield this.makeFeedReader(type, canonicalTopic, canonicalOwner).download();
+          return true;
+        } catch (e) {
+          const err = e; // Only if the error is "not-found" then we return false otherwise we re-throw the error
+
+          if ((err === null || err === void 0 ? void 0 : err.status) === 404) {
+            return false;
+          }
+
+          throw e;
+        }
+      }
+
+      if (type !== 'sequence') {
+        throw new BeeError('Only Sequence type of Feeds is supported at the moment');
+      }
+
+      return areAllSequentialFeedsUpdateRetrievable(this, canonicalOwner, canonicalTopic, index, options);
+    });
+  }
   /**
    * Send data to recipient or target with Postal Service for Swarm.
    *

package/dist/mjs/chunk/cac.js

@@ -1,6 +1,6 @@
 import { BeeError } from "../utils/error.js";
 import { bmtHash } from "./bmt.js";
-import { bytesEqual, flexBytesAtOffset, assertFlexBytes } from "../utils/bytes.js";
+import { assertFlexBytes, bytesEqual, flexBytesAtOffset } from "../utils/bytes.js";
 import { serializeBytes } from "./serialize.js";
 import { makeSpan, SPAN_SIZE } from "./span.js";
 export const MIN_PAYLOAD_SIZE = 1;

package/dist/mjs/feed/identifier.js

@@ -0,0 +1,35 @@
+import { FEED_INDEX_HEX_LENGTH } from "../types/index.js";
+import { keccak256Hash } from "../utils/hash.js";
+import { hexToBytes, makeHexString } from "../utils/hex.js";
+import { writeUint64BigEndian } from "../utils/uint64.js";
+
+function isEpoch(epoch) {
+  return typeof epoch === 'object' && epoch !== null && 'time' in epoch && 'level' in epoch;
+}
+
+function hashFeedIdentifier(topic, index) {
+  return keccak256Hash(hexToBytes(topic), index);
+}
+
+function makeSequentialFeedIdentifier(topic, index) {
+  const indexBytes = writeUint64BigEndian(index);
+  return hashFeedIdentifier(topic, indexBytes);
+}
+
+function makeFeedIndexBytes(s) {
+  const hex = makeHexString(s, FEED_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);
+}

package/dist/mjs/feed/index.js

@@ -32,66 +32,26 @@ var __awaiter = this && this.__awaiter || function (thisArg, _arguments, P, gene
 
 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 { fetchLatestFeedUpdate } from "../modules/feed.js";
+import { makeSingleOwnerChunkFromData, uploadSingleOwnerChunkData } from "../chunk/soc.js";
+import { FEED_INDEX_HEX_LENGTH } from "../types/index.js";
+import { bytesAtOffset, makeBytes } 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";
+import { makeFeedIdentifier } from "./identifier.js";
+import { makeBytesReference } from "../utils/reference.js";
 const TIMESTAMP_PAYLOAD_OFFSET = 0;
 const TIMESTAMP_PAYLOAD_SIZE = 8;
 const REFERENCE_PAYLOAD_OFFSET = TIMESTAMP_PAYLOAD_SIZE;
-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;
-}
-
-function hashFeedIdentifier(topic, index) {
-  return keccak256Hash(hexToBytes(topic), index);
-}
-
-export function makeSequentialFeedIdentifier(topic, index) {
-  const indexBytes = writeUint64BigEndian(index);
-  return hashFeedIdentifier(topic, indexBytes);
-}
-export function makeFeedIndexBytes(s) {
-  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);
-}
-export function uploadFeedUpdate(ky, signer, topic, index, reference, postageBatchId, options) {
-  var _a;
-
-  return __awaiter(this, void 0, void 0, function* () {
-    const identifier = makeFeedIdentifier(topic, index);
-    const at = (_a = options === null || options === void 0 ? void 0 : options.at) !== null && _a !== void 0 ? _a : Date.now() / 1000.0;
-    const timestamp = writeUint64BigEndian(at);
-    const payloadBytes = serializeBytes(timestamp, reference);
-    return uploadSingleOwnerChunkData(ky, signer, postageBatchId, identifier, payloadBytes, options);
-  });
-}
 export function findNextIndex(ky, owner, topic, options) {
   return __awaiter(this, void 0, void 0, function* () {
     try {
-      const feedUpdate = yield fetchFeedUpdate(ky, owner, topic, options);
-      return makeHexString(feedUpdate.feedIndexNext, INDEX_HEX_LENGTH);
+      const feedUpdate = yield fetchLatestFeedUpdate(ky, owner, topic, options);
+      return makeHexString(feedUpdate.feedIndexNext, FEED_INDEX_HEX_LENGTH);
     } catch (e) {
       if (e instanceof BeeResponseError && e.status === 404) {
         return bytesToHex(makeBytes(8));
@@ -101,36 +61,33 @@ export function findNextIndex(ky, owner, topic, options) {
     }
   });
 }
-export function updateFeed(ky, signer, topic, reference, postageBatchId, options) {
+export function updateFeed(ky, signer, topic, reference, postageBatchId, options, index = 'latest') {
+  var _a;
+
   return __awaiter(this, void 0, void 0, function* () {
     const ownerHex = makeHexEthAddress(signer.address);
-    const nextIndex = yield findNextIndex(ky, ownerHex, topic, options);
-    return uploadFeedUpdate(ky, signer, topic, nextIndex, reference, postageBatchId, options);
+    const nextIndex = index === 'latest' ? yield findNextIndex(ky, ownerHex, topic, options) : index;
+    const identifier = makeFeedIdentifier(topic, nextIndex);
+    const at = (_a = options === null || options === void 0 ? void 0 : options.at) !== null && _a !== void 0 ? _a : Date.now() / 1000.0;
+    const timestamp = writeUint64BigEndian(at);
+    const payloadBytes = serializeBytes(timestamp, reference);
+    return uploadSingleOwnerChunkData(ky, signer, postageBatchId, identifier, payloadBytes, options);
   });
 }
-
-function verifyChunkReferenceAtOffset(offset, data) {
-  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);
+export function getFeedUpdateChunkReference(owner, topic, index) {
+  const identifier = makeFeedIdentifier(topic, index);
+  return keccak256Hash(identifier, owner);
 }
 export function downloadFeedUpdate(ky, owner, topic, index) {
   return __awaiter(this, void 0, void 0, function* () {
-    const identifier = makeFeedIdentifier(topic, index);
-    const address = keccak256Hash(identifier, owner);
+    const address = getFeedUpdateChunkReference(owner, topic, index);
     const addressHex = bytesToHex(address);
     const data = yield 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);
+    const reference = makeBytesReference(payload, REFERENCE_PAYLOAD_OFFSET);
     return {
       timestamp,
       reference
@@ -138,46 +95,34 @@ export function downloadFeedUpdate(ky, owner, topic, index) {
   });
 }
 export function makeFeedReader(ky, type, topic, owner) {
-  const download = options => __awaiter(this, void 0, void 0, function* () {
-    return fetchFeedUpdate(ky, owner, topic, Object.assign(Object.assign({}, 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);
+    download(options) {
+      return __awaiter(this, void 0, void 0, function* () {
+        if (!(options === null || options === void 0 ? void 0 : options.index)) {
+          return fetchLatestFeedUpdate(ky, owner, topic, Object.assign(Object.assign({}, options), {
+            type
+          }));
+        }
+
+        const update = yield downloadFeedUpdate(ky, hexToBytes(owner), topic, options.index);
+        return {
+          reference: bytesToHex(update.reference),
+          feedIndex: options.index,
+          feedIndexNext: ''
+        };
+      });
     }
-  } else if (reference instanceof Uint8Array) {
-    return verifyChunkReference(reference);
-  }
 
-  throw new TypeError('invalid chunk reference');
+  };
 }
-
 export function makeFeedWriter(ky, type, topic, signer) {
   const upload = (postageBatchId, reference, options) => __awaiter(this, void 0, void 0, function* () {
     assertAddress(postageBatchId);
-    const canonicalReference = makeChunkReference(reference);
+    const canonicalReference = makeBytesReference(reference);
     return updateFeed(ky, signer, topic, canonicalReference, postageBatchId, Object.assign(Object.assign({}, options), {
       type
     }));

package/dist/mjs/feed/retrievable.js

@@ -0,0 +1,105 @@
+var __awaiter = this && this.__awaiter || function (thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function (resolve) {
+      resolve(value);
+    });
+  }
+
+  return new (P || (P = Promise))(function (resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+
+import { getFeedUpdateChunkReference } from "./index.js";
+import { readUint64BigEndian } from "../utils/uint64.js";
+import { bytesToHex } from "../utils/hex.js";
+
+function makeNumericIndex(index) {
+  if (index instanceof Uint8Array) {
+    return readUint64BigEndian(index);
+  }
+
+  if (typeof index === 'string') {
+    return parseInt(index);
+  }
+
+  if (typeof index === 'number') {
+    return index;
+  }
+
+  throw new TypeError('Unknown type of index!');
+}
+/**
+ * Function that checks if a chunk is retrievable by actually downloading it.
+ * The /stewardship/{reference} endpoint does not support verification of chunks, but only manifest's references.
+ *
+ * @param bee
+ * @param ref
+ * @param options
+ */
+
+
+function isChunkRetrievable(bee, ref, options) {
+  return __awaiter(this, void 0, void 0, function* () {
+    try {
+      yield bee.downloadChunk(ref, options);
+      return true;
+    } catch (e) {
+      const err = e;
+
+      if (err.status === 404) {
+        return false;
+      }
+
+      throw e;
+    }
+  });
+}
+/**
+ * Creates array of references for all sequence updates chunk up to the given index.
+ *
+ * @param owner
+ * @param topic
+ * @param index
+ */
+
+
+function getAllSequenceUpdateReferences(owner, topic, index) {
+  const numIndex = makeNumericIndex(index);
+  const updateReferences = new Array(numIndex + 1);
+
+  for (let i = 0; i <= numIndex; i++) {
+    updateReferences[i] = bytesToHex(getFeedUpdateChunkReference(owner, topic, i));
+  }
+
+  return updateReferences;
+}
+
+export function areAllSequentialFeedsUpdateRetrievable(bee, owner, topic, index, options) {
+  return __awaiter(this, void 0, void 0, function* () {
+    const chunkRetrievablePromises = getAllSequenceUpdateReferences(owner, topic, index).map(ref => __awaiter(this, void 0, void 0, function* () {
+      return isChunkRetrievable(bee, ref, options);
+    }));
+    return (yield Promise.all(chunkRetrievablePromises)).every(result => result);
+  });
+}

package/dist/mjs/modules/debug/status.js

@@ -34,9 +34,9 @@ import { http } from "../../utils/http.js";
 import getMajorSemver from 'semver/functions/major.js'; // Following lines bellow are automatically updated with GitHub Action when Bee version is updated
 // so if you are changing anything about them change the `update_bee` action accordingly!
 
-export const SUPPORTED_BEE_VERSION_EXACT = '1.5.0-dda5606e';
-export const SUPPORTED_API_VERSION = '3.0.0';
-export const SUPPORTED_DEBUG_API_VERSION = '2.0.0';
+export const SUPPORTED_BEE_VERSION_EXACT = '1.6.0-6ceadd35';
+export const SUPPORTED_API_VERSION = '3.0.1';
+export const SUPPORTED_DEBUG_API_VERSION = '2.0.1';
 export const SUPPORTED_BEE_VERSION = SUPPORTED_BEE_VERSION_EXACT.substring(0, SUPPORTED_BEE_VERSION_EXACT.indexOf('-'));
 const NODE_INFO_URL = 'node';
 const HEALTH_URL = 'health';

package/dist/mjs/modules/feed.js

@@ -89,7 +89,7 @@ function readFeedUpdateHeaders(headers) {
  */
 
 
-export function fetchFeedUpdate(ky, owner, topic, options) {
+export function fetchLatestFeedUpdate(ky, owner, topic, options) {
   return __awaiter(this, void 0, void 0, function* () {
     const response = yield http(ky, {
       responseType: 'json',

package/dist/mjs/types/index.js

@@ -23,6 +23,7 @@ export const STAMPS_DEPTH_MIN = 17;
 export const STAMPS_DEPTH_MAX = 255;
 export const TAGS_LIMIT_MIN = 1;
 export const TAGS_LIMIT_MAX = 1000;
+export const FEED_INDEX_HEX_LENGTH = 16;
 /*********************************************************
  * Writers and Readers interfaces
  */

package/dist/mjs/utils/bytes.js

@@ -9,6 +9,21 @@ import { bytesToHex } from "./hex.js";
 export function isBytes(b, length) {
   return b instanceof Uint8Array && b.length === length;
 }
+/**
+ * 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
+ */
+
+export function hasBytesAtOffset(data, offset, length) {
+  if (!(data instanceof Uint8Array)) {
+    throw new TypeError('Data has to an Uint8Array!');
+  }
+
+  const offsetBytes = data.slice(offset, offset + length);
+  return isBytes(offsetBytes, length);
+}
 /**
  * Verifies if a byte array has a certain length
  *

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

@@ -31,7 +31,6 @@ var __awaiter = this && this.__awaiter || function (thisArg, _arguments, P, gene
 };
 
 import { isNodeReadable, isReadableStream } from "./stream.js";
-import Blob from 'cross-blob';
 /**
  * Validates input and converts to Uint8Array
  *

package/dist/mjs/utils/data.js

@@ -30,7 +30,7 @@ var __awaiter = this && this.__awaiter || function (thisArg, _arguments, P, gene
   });
 };
 
-import Blob from 'cross-blob';
+import BlobPolyfill from 'fetch-blob';
 import { isNodeReadable, isReadableStream, readableWebToNode } from "./stream.js";
 /**
  * Prepare data for valid input for node-fetch.
@@ -43,17 +43,17 @@ import { isNodeReadable, isReadableStream, readableWebToNode } from "./stream.js
 
 export function prepareData(data) {
   return __awaiter(this, void 0, void 0, function* () {
-    if (typeof data === 'string') return new Blob([data], {
+    if (typeof data === 'string') return new BlobPolyfill([data], {
       type: 'text/plain'
     });
 
     if (data instanceof Uint8Array || data instanceof ArrayBuffer) {
-      return new Blob([data], {
+      return new BlobPolyfill([data], {
         type: 'application/octet-stream'
       });
     }
 
-    if (data instanceof Blob || isNodeReadable(data)) return data;
+    if (data instanceof BlobPolyfill || isNodeReadable(data)) return data;
 
     if (isReadableStream(data)) {
       return readableWebToNode(data);
@@ -72,7 +72,6 @@ export function prepareWebsocketData(data) {
     if (typeof data === 'string') return new TextEncoder().encode(data);
     if (data instanceof Buffer) return new Uint8Array(data);
     if (data instanceof ArrayBuffer) return new Uint8Array(data);
-    if (data instanceof Blob) return new Uint8Array(yield new Response(data).arrayBuffer());
     if (isBufferArray(data)) return new Uint8Array(Buffer.concat(data));
     throw new TypeError('unknown websocket data type');
   });