@ethersphere/bee-js 3.3.3 → 4.0.0

package/dist/mjs/utils/reference.js

@@ -0,0 +1,32 @@
+import { ENCRYPTED_REFERENCE_BYTES_LENGTH, ENCRYPTED_REFERENCE_HEX_LENGTH, REFERENCE_BYTES_LENGTH, REFERENCE_HEX_LENGTH } from "../types/index.js";
+import { bytesAtOffset, hasBytesAtOffset } from "./bytes.js";
+import { hexToBytes, makeHexString } from "./hex.js";
+export function makeBytesReference(reference, offset = 0) {
+  if (typeof reference === 'string') {
+    if (offset) {
+      throw new Error('Offset property can be set only for UintArray reference!');
+    }
+
+    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) {
+    if (hasBytesAtOffset(reference, offset, ENCRYPTED_REFERENCE_BYTES_LENGTH)) {
+      return bytesAtOffset(reference, offset, ENCRYPTED_REFERENCE_BYTES_LENGTH);
+    } else if (hasBytesAtOffset(reference, offset, REFERENCE_BYTES_LENGTH)) {
+      return bytesAtOffset(reference, offset, REFERENCE_BYTES_LENGTH);
+    }
+  }
+
+  throw new TypeError('invalid chunk reference');
+}

package/dist/mjs/utils/type.js

@@ -1,7 +1,7 @@
 import { ADDRESS_HEX_LENGTH, BATCH_ID_HEX_LENGTH, ENCRYPTED_REFERENCE_HEX_LENGTH, PUBKEY_HEX_LENGTH, REFERENCE_HEX_LENGTH, TAGS_LIMIT_MAX, TAGS_LIMIT_MIN, PSS_TARGET_HEX_LENGTH_MAX } from "../types/index.js";
 import { BeeArgumentError } from "./error.js";
 import { isFile } from "./file.js";
-import { assertHexString, assertPrefixedHexString } from "./hex.js";
+import { assertHexString, assertPrefixedHexString, isHexString } from "./hex.js";
 import { isReadable } from "./stream.js";
 export function isUint8Array(obj) {
   return obj instanceof Uint8Array;
@@ -58,6 +58,43 @@ export function assertReference(value) {
     assertHexString(value, ENCRYPTED_REFERENCE_HEX_LENGTH);
   }
 }
+export function assertReferenceOrEns(value) {
+  if (typeof value !== 'string') {
+    throw new TypeError('ReferenceOrEns has to be a string!');
+  }
+
+  if (isHexString(value)) {
+    assertReference(value);
+    return;
+  }
+  /**
+   * a.asdf - VALID
+   * test.eth - VALID
+   * ADAM.ETH - VALID
+   * ADAM UHLIR.ETH - INVALID
+   * test.whatever.eth - VALID
+   * -adg.ets - INVALID
+   * adg-.ets - INVALID
+   * as-a.com - VALID
+   * ethswarm.org - VALID
+   * http://asdf.asf - INVALID
+   * řš+ýí.šě+ř.čě - VALID
+   * tsg.asg?asg - INVALID
+   * tsg.asg:1599 - INVALID
+   * ethswarm.something- - INVALID
+   * ethswarm.-something - INVALID
+   * ethswarm.some-thing - VALID
+   */
+
+
+  const DOMAIN_REGEX = /^(?:(?!-)[^.\/?:\s]{1,63}(?<!-)\.)+(?!-)[^.\/?:\s]{2,63}(?<!-)$/; // We are doing best-effort validation of domain here. The proper way would be to do validation using IDNA UTS64 standard
+  // but that would give us high penalty to our dependencies as the library (idna-uts46-hx) that does this validation and translation
+  // adds 160kB minified size which is significant. We expects that full validation will be done on Bee side.
+
+  if (!DOMAIN_REGEX.test(value)) {
+    throw new TypeError('ReferenceOrEns is not valid Reference, but also not valid ENS domain.');
+  }
+}
 export function assertAddress(value) {
   assertHexString(value, ADDRESS_HEX_LENGTH, 'Address');
 }

package/dist/types/bee.d.ts

@@ -1,6 +1,7 @@
+import { Index, IndexBytes } from './feed';
 import { FeedType } from './feed/type';
 import { EthAddress } from './utils/eth';
-import { AllTagsOptions, Collection, Readable, RequestOptions, UploadResult } from './types';
+import { AllTagsOptions, Collection, Readable, ReferenceOrEns, RequestOptions, UploadResult } from './types';
 import type { Tag, FileData, Reference, UploadOptions, PublicKey, AddressPrefix, PssMessageHandler, PssSubscription, CollectionUploadOptions, FileUploadOptions, Data, Signer, FeedReader, FeedWriter, SOCWriter, SOCReader, Topic, BeeOptions, JsonFeedOptions, AnyJson, Pin, BatchId } from './types';
 /**
  * The main component that abstracts operations available on the main Bee API.
@@ -42,21 +43,25 @@ export declare 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)
      */
-    downloadData(reference: Reference | string, options?: RequestOptions): Promise<Data>;
+    downloadData(reference: ReferenceOrEns | string, options?: RequestOptions): Promise<Data>;
     /**
      * 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)
      */
-    downloadReadableData(reference: Reference | string, options?: RequestOptions): Promise<ReadableStream<Uint8Array>>;
+    downloadReadableData(reference: ReferenceOrEns | string, options?: RequestOptions): Promise<ReadableStream<Uint8Array>>;
     /**
      * Upload chunk to a Bee node
      *
@@ -72,12 +77,14 @@ export declare 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)
      */
-    downloadChunk(reference: Reference | string, options?: RequestOptions): Promise<Data>;
+    downloadChunk(reference: ReferenceOrEns | string, options?: RequestOptions): Promise<Data>;
     /**
      * Upload single file to a Bee node.
      *
@@ -98,26 +105,29 @@ export declare 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)
      */
-    downloadFile(reference: Reference | string, path?: string, options?: RequestOptions): Promise<FileData<Data>>;
+    downloadFile(reference: ReferenceOrEns | string, path?: string, options?: RequestOptions): Promise<FileData<Data>>;
     /**
      * 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)
      */
-    downloadReadableFile(reference: Reference | string, path?: string, options?: RequestOptions): Promise<FileData<ReadableStream<Uint8Array>>>;
+    downloadReadableFile(reference: ReferenceOrEns | string, path?: string, options?: RequestOptions): Promise<FileData<ReadableStream<Uint8Array>>>;
     /**
      * Upload collection of files to a Bee node
      *
@@ -272,9 +282,10 @@ export declare 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)
      */
@@ -282,23 +293,42 @@ export declare 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)
      */
-    reuploadPinnedData(reference: Reference | string, options?: RequestOptions): Promise<void>;
+    reuploadPinnedData(reference: ReferenceOrEns | string, options?: RequestOptions): Promise<void>;
     /**
      * 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)
      */
-    isReferenceRetrievable(reference: Reference | string, options?: RequestOptions): Promise<boolean>;
+    isReferenceRetrievable(reference: ReferenceOrEns | string, options?: RequestOptions): Promise<boolean>;
+    /**
+     * 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: FeedType, owner: EthAddress | Uint8Array | string, topic: Topic | Uint8Array | string, index?: Index | number | IndexBytes | string, options?: RequestOptions): Promise<boolean>;
     /**
      * Send data to recipient or target with Postal Service for Swarm.
      *

package/dist/types/chunk/cac.d.ts

@@ -1,8 +1,7 @@
-import { BrandedType } from '../types';
+import { BrandedType, PlainBytesReference } from '../types';
 import { Bytes, FlexBytes } from '../utils/bytes';
 export declare const MIN_PAYLOAD_SIZE = 1;
 export declare const MAX_PAYLOAD_SIZE = 4096;
-export declare type ChunkAddress = Bytes<32>;
 /**
  * General chunk interface for Swarm
  *
@@ -16,7 +15,7 @@ export interface Chunk {
     readonly data: Uint8Array;
     span(): Bytes<8>;
     payload(): FlexBytes<1, 4096>;
-    address(): ChunkAddress;
+    address(): PlainBytesReference;
 }
 declare type ValidChunkData = BrandedType<Uint8Array, 'ValidChunkData'>;
 /**
@@ -31,7 +30,7 @@ export declare function makeContentAddressedChunk(payloadBytes: Uint8Array): Chu
  * @param data          The chunk data
  * @param chunkAddress  The address of the chunk
  */
-export declare function isValidChunkData(data: unknown, chunkAddress: ChunkAddress): data is ValidChunkData;
+export declare function isValidChunkData(data: unknown, chunkAddress: PlainBytesReference): data is ValidChunkData;
 /**
  * Asserts if data are representing given address of its chunk.
  *
@@ -40,5 +39,5 @@ export declare function isValidChunkData(data: unknown, chunkAddress: ChunkAddre
  *
  * @returns a valid content addressed chunk or throws error
  */
-export declare function assertValidChunkData(data: unknown, chunkAddress: ChunkAddress): asserts data is ValidChunkData;
+export declare function assertValidChunkData(data: unknown, chunkAddress: PlainBytesReference): asserts data is ValidChunkData;
 export {};

package/dist/types/chunk/soc.d.ts

@@ -1,6 +1,6 @@
 import { Bytes } from '../utils/bytes';
-import { Chunk, ChunkAddress } from './cac';
-import { UploadOptions, Signature, Signer, BatchId, Reference, Ky } from '../types';
+import { Chunk } from './cac';
+import { UploadOptions, Signature, Signer, BatchId, Reference, Ky, PlainBytesReference } from '../types';
 import { EthAddress } from '../utils/eth';
 export declare type Identifier = Bytes<32>;
 /**
@@ -24,8 +24,8 @@ export interface SingleOwnerChunk extends Chunk {
  *
  * @returns a single owner chunk or throws error
  */
-export declare function makeSingleOwnerChunkFromData(data: Uint8Array, address: ChunkAddress): SingleOwnerChunk;
-export declare function makeSOCAddress(identifier: Identifier, address: EthAddress): ChunkAddress;
+export declare function makeSingleOwnerChunkFromData(data: Uint8Array, address: PlainBytesReference): SingleOwnerChunk;
+export declare function makeSOCAddress(identifier: Identifier, address: EthAddress): PlainBytesReference;
 /**
  * Creates a single owner chunk object
  *

package/dist/types/feed/identifier.d.ts

@@ -0,0 +1,4 @@
+import { Topic } from '../types';
+import { Identifier } from '../chunk/soc';
+import { Index } from './index';
+export declare function makeFeedIdentifier(topic: Topic, index: Index): Identifier;

package/dist/types/feed/index.d.ts

@@ -1,35 +1,28 @@
-import { Identifier } from '../chunk/soc';
 import { FeedUpdateOptions } from '../modules/feed';
-import { Reference, UploadOptions, Signer, FeedReader, FeedWriter, Topic, BatchId, Ky } from '../types';
+import { BatchId, BytesReference, FEED_INDEX_HEX_LENGTH, FeedReader, FeedWriter, Ky, PlainBytesReference, Reference, Signer, Topic, UploadOptions } from '../types';
 import { Bytes } from '../utils/bytes';
 import { HexString } from '../utils/hex';
 import { EthAddress, HexEthAddress } from '../utils/eth';
 import type { FeedType } from './type';
-declare const INDEX_HEX_LENGTH = 16;
 export interface Epoch {
     time: number;
     level: number;
 }
+/**
+ * Bytes of Feed's Index.
+ * For Sequential Feeds this is numeric value in big-endian.
+ */
 export declare type IndexBytes = Bytes<8>;
 export declare type Index = number | Epoch | IndexBytes | string;
 export interface FeedUploadOptions extends UploadOptions, FeedUpdateOptions {
 }
-declare type PlainChunkReference = Bytes<32>;
-declare type EncryptedChunkReference = Bytes<64>;
-export declare type ChunkReference = PlainChunkReference | EncryptedChunkReference;
 export interface FeedUpdate {
     timestamp: number;
-    reference: ChunkReference;
+    reference: BytesReference;
 }
-export declare function isEpoch(epoch: unknown): epoch is Epoch;
-export declare function makeSequentialFeedIdentifier(topic: Topic, index: number): Identifier;
-export declare function makeFeedIndexBytes(s: string): IndexBytes;
-export declare function makeFeedIdentifier(topic: Topic, index: Index): Identifier;
-export declare function uploadFeedUpdate(ky: Ky, signer: Signer, topic: Topic, index: Index, reference: ChunkReference, postageBatchId: BatchId, options?: FeedUploadOptions): Promise<Reference>;
-export declare function findNextIndex(ky: Ky, owner: HexEthAddress, topic: Topic, options?: FeedUpdateOptions): Promise<HexString<typeof INDEX_HEX_LENGTH>>;
-export declare function updateFeed(ky: Ky, signer: Signer, topic: Topic, reference: ChunkReference, postageBatchId: BatchId, options?: FeedUploadOptions): Promise<Reference>;
-export declare function verifyChunkReference(data: Uint8Array): ChunkReference;
+export declare function findNextIndex(ky: Ky, owner: HexEthAddress, topic: Topic, options?: FeedUpdateOptions): Promise<HexString<typeof FEED_INDEX_HEX_LENGTH>>;
+export declare function updateFeed(ky: Ky, signer: Signer, topic: Topic, reference: BytesReference, postageBatchId: BatchId, options?: FeedUploadOptions, index?: Index): Promise<Reference>;
+export declare function getFeedUpdateChunkReference(owner: EthAddress, topic: Topic, index: Index): PlainBytesReference;
 export declare function downloadFeedUpdate(ky: Ky, owner: EthAddress, topic: Topic, index: Index): Promise<FeedUpdate>;
 export declare function makeFeedReader(ky: Ky, type: FeedType, topic: Topic, owner: HexEthAddress): FeedReader;
 export declare function makeFeedWriter(ky: Ky, type: FeedType, topic: Topic, signer: Signer): FeedWriter;
-export {};

package/dist/types/feed/retrievable.d.ts

@@ -0,0 +1,5 @@
+import { Bee } from '../bee';
+import { EthAddress } from '../utils/eth';
+import { RequestOptions, Topic } from '../types';
+import { Index } from './index';
+export declare function areAllSequentialFeedsUpdateRetrievable(bee: Bee, owner: EthAddress, topic: Topic, index: Index, options?: RequestOptions): Promise<boolean>;

package/dist/types/modules/bytes.d.ts

@@ -1,4 +1,4 @@
-import type { BatchId, Data, Ky, Reference, UploadOptions } from '../types';
+import type { BatchId, Data, Ky, ReferenceOrEns, UploadOptions } from '../types';
 import { UploadResult } from '../types';
 /**
  * Upload data to a Bee node
@@ -15,11 +15,11 @@ export declare function upload(ky: Ky, data: string | Uint8Array, postageBatchId
  * @param ky
  * @param hash Bee content reference
  */
-export declare function download(ky: Ky, hash: Reference): Promise<Data>;
+export declare function download(ky: Ky, hash: ReferenceOrEns): Promise<Data>;
 /**
  * Download data as a readable stream
  *
  * @param ky
  * @param hash Bee content reference
  */
-export declare function downloadReadable(ky: Ky, hash: Reference): Promise<ReadableStream<Uint8Array>>;
+export declare function downloadReadable(ky: Ky, hash: ReferenceOrEns): Promise<ReadableStream<Uint8Array>>;

package/dist/types/modules/bzz.d.ts

@@ -1,4 +1,4 @@
-import { BatchId, Collection, CollectionUploadOptions, Data, FileData, FileUploadOptions, Ky, Readable, UploadResult } from '../types';
+import { BatchId, Collection, CollectionUploadOptions, Data, FileData, FileUploadOptions, Ky, Readable, ReferenceOrEns, UploadResult } from '../types';
 /**
  * Upload single file
  *
@@ -16,7 +16,7 @@ export declare function uploadFile(ky: Ky, data: string | Uint8Array | Readable
  * @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 declare function downloadFile(ky: Ky, hash: string, path?: string): Promise<FileData<Data>>;
+export declare function downloadFile(ky: Ky, hash: ReferenceOrEns, path?: string): Promise<FileData<Data>>;
 /**
  * Download single file as a readable stream
  *
@@ -24,7 +24,7 @@ export declare function downloadFile(ky: Ky, hash: string, path?: string): Promi
  * @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 declare function downloadFileReadable(ky: Ky, hash: string, path?: string): Promise<FileData<ReadableStream<Uint8Array>>>;
+export declare function downloadFileReadable(ky: Ky, hash: ReferenceOrEns, path?: string): Promise<FileData<ReadableStream<Uint8Array>>>;
 /**
  * Upload collection
  * @param ky Ky instance for given Bee class instance

package/dist/types/modules/chunk.d.ts

@@ -1,4 +1,4 @@
-import type { BatchId, Data, Ky, Reference, UploadOptions } from '../types';
+import type { BatchId, Data, Ky, Reference, ReferenceOrEns, UploadOptions } from '../types';
 /**
  * Upload chunk to a Bee node
  *
@@ -19,4 +19,4 @@ export declare function upload(ky: Ky, data: Uint8Array, postageBatchId: BatchId
  * @param hash Bee content reference
  *
  */
-export declare function download(ky: Ky, hash: string): Promise<Data>;
+export declare function download(ky: Ky, hash: ReferenceOrEns): Promise<Data>;

package/dist/types/modules/debug/status.d.ts

@@ -1,9 +1,9 @@
 import type { Health, NodeInfo } from '../../types/debug';
 import { Ky } from '../../types';
 import { BeeVersions } from '../../types/debug';
-export declare const SUPPORTED_BEE_VERSION_EXACT = "1.5.0-dda5606e";
-export declare const SUPPORTED_API_VERSION = "3.0.0";
-export declare const SUPPORTED_DEBUG_API_VERSION = "2.0.0";
+export declare const SUPPORTED_BEE_VERSION_EXACT = "1.6.0-6ceadd35";
+export declare const SUPPORTED_API_VERSION = "3.0.1";
+export declare const SUPPORTED_DEBUG_API_VERSION = "2.0.1";
 export declare const SUPPORTED_BEE_VERSION: string;
 /**
  * Get health of node

package/dist/types/modules/feed.d.ts

@@ -13,9 +13,20 @@ export interface FeedUpdateOptions {
      * Can be 'epoch' or 'sequence' (default: 'sequence')
      */
     type?: FeedType;
+    /**
+     * Fetch specific previous Feed's update (default fetches latest update)
+     */
+    index?: string;
 }
 interface FeedUpdateHeaders {
+    /**
+     * The current feed's index
+     */
     feedIndex: string;
+    /**
+     * The feed's index for next update.
+     * Only set for the latest update. If update is fetched using previous index, then this is an empty string.
+     */
     feedIndexNext: string;
 }
 export interface FetchFeedUpdateResponse extends ReferenceResponse, FeedUpdateHeaders {
@@ -43,5 +54,5 @@ export declare function createFeedManifest(ky: Ky, owner: HexEthAddress, topic:
  * @param topic       Topic in hex
  * @param options     Additional options, like index, at, type
  */
-export declare function fetchFeedUpdate(ky: Ky, owner: HexEthAddress, topic: Topic, options?: FeedUpdateOptions): Promise<FetchFeedUpdateResponse>;
+export declare function fetchLatestFeedUpdate(ky: Ky, owner: HexEthAddress, topic: Topic, options?: FeedUpdateOptions): Promise<FetchFeedUpdateResponse>;
 export {};

package/dist/types/modules/stewardship.d.ts

@@ -1,4 +1,4 @@
-import type { Ky, Reference } from '../types';
+import type { Ky, ReferenceOrEns } from '../types';
 /**
  * Reupload locally pinned data
  * @param ky Ky instance
@@ -6,5 +6,5 @@ import type { Ky, Reference } from '../types';
  * @param options
  * @throws BeeResponseError if not locally pinned or invalid data
  */
-export declare function reupload(ky: Ky, reference: Reference): Promise<void>;
-export declare function isRetrievable(ky: Ky, reference: Reference): Promise<boolean>;
+export declare function reupload(ky: Ky, reference: ReferenceOrEns): Promise<void>;
+export declare function isRetrievable(ky: Ky, reference: ReferenceOrEns): Promise<boolean>;

package/dist/types/types/debug.d.ts

@@ -139,8 +139,27 @@ export declare enum BeeModes {
  * Information about Bee node and its configuration
  */
 export interface NodeInfo {
+    /**
+     * Indicates whether the node is in a Gateway mode.
+     * Gateway mode is a restricted mode where some features are not available.
+     */
     gatewayMode: boolean;
+    /**
+     * Indicates in what mode Bee is running.
+     */
     beeMode: BeeModes;
+    /**
+     * Indicates whether the Bee node has its own deployed chequebook.
+     *
+     * @see [Bee docs - Chequebook](https://docs.ethswarm.org/docs/introduction/terminology#cheques--chequebook)
+     */
+    chequebookEnabled: boolean;
+    /**
+     * Indicates whether SWAP is enabled for the Bee node.
+     *
+     * @see [Bee docs - SWAP](https://docs.ethswarm.org/docs/introduction/terminology#swap)
+     */
+    swapEnabled: boolean;
 }
 /**
  * Information about Bee node and its configuration
@@ -188,10 +207,8 @@ export interface PingResponse {
 }
 export interface ReserveState {
     radius: number;
+    commitment: number;
     storageRadius: number;
-    available: number;
-    outer: NumberString;
-    inner: NumberString;
 }
 export interface ChainState {
     block: number;

package/dist/types/types/index.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import type { Identifier, SingleOwnerChunk } from '../chunk/soc';
-import type { ChunkReference, FeedUploadOptions } from '../feed';
+import type { FeedUploadOptions } from '../feed';
 import type { FeedType } from '../feed/type';
 import type { FeedUpdateOptions, FetchFeedUpdateResponse } from '../modules/feed';
 import type { Bytes } from '../utils/bytes';
@@ -39,6 +39,7 @@ export declare const STAMPS_DEPTH_MIN = 17;
 export declare const STAMPS_DEPTH_MAX = 255;
 export declare const TAGS_LIMIT_MIN = 1;
 export declare const TAGS_LIMIT_MAX = 1000;
+export declare const FEED_INDEX_HEX_LENGTH = 16;
 /**
  * Generic reference that can be either non-encrypted reference which is a hex string of length 64 or encrypted
  * reference which is a hex string of length 128.
@@ -48,6 +49,14 @@ export declare const TAGS_LIMIT_MAX = 1000;
  * @see [Bee docs - Store with Encryption](https://docs.ethswarm.org/docs/access-the-swarm/store-with-encryption)
  */
 export declare type Reference = HexString<typeof REFERENCE_HEX_LENGTH> | HexString<typeof ENCRYPTED_REFERENCE_HEX_LENGTH>;
+/**
+ * Type that represents either Swarm's reference in hex string or ESN domain (something.eth).
+ * This is the type used on all the download functions.
+ */
+export declare type ReferenceOrEns = Reference | string;
+export declare type PlainBytesReference = Bytes<typeof REFERENCE_BYTES_LENGTH>;
+export declare type EncryptedBytesReference = Bytes<typeof ENCRYPTED_REFERENCE_BYTES_LENGTH>;
+export declare type BytesReference = PlainBytesReference | EncryptedBytesReference;
 export declare type PublicKey = HexString<typeof PUBKEY_HEX_LENGTH>;
 export declare type Address = HexString<typeof ADDRESS_HEX_LENGTH>;
 /**
@@ -356,7 +365,7 @@ export interface FeedWriter extends FeedReader {
      *
      * @returns Reference that points at Single Owner Chunk that contains the new update and pointer to the updated chunk reference.
      */
-    upload(postageBatchId: string | BatchId, reference: ChunkReference | Reference, options?: FeedUploadOptions): Promise<Reference>;
+    upload(postageBatchId: string | BatchId, reference: BytesReference | Reference, options?: FeedUploadOptions): Promise<Reference>;
 }
 /**
  * Interface for downloading single owner chunks

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

@@ -28,6 +28,13 @@ export interface FlexBytes<Min extends number, Max extends number> extends Uint8
  * @param length  The length of the byte array
  */
 export declare function isBytes<Length extends number>(b: unknown, length: Length): b is Bytes<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 declare function hasBytesAtOffset(data: unknown, offset: number, length: number): boolean;
 /**
  * Verifies if a byte array has a certain length
  *

package/dist/types/utils/data.browser.d.ts

@@ -1,5 +1,4 @@
 import { Readable } from '../types';
-import Blob from 'cross-blob';
 /**
  * Validates input and converts to Uint8Array
  *

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

@@ -1,5 +1,5 @@
 import type { Data } from 'ws';
-import Blob from 'cross-blob';
+import BlobPolyfill from 'fetch-blob';
 import { Readable } from '../types';
 /**
  * Prepare data for valid input for node-fetch.
@@ -10,4 +10,4 @@ import { Readable } from '../types';
  * @param data any string, ArrayBuffer, Uint8Array or Readable
  */
 export declare function prepareData(data: string | ArrayBuffer | Uint8Array | Readable): Promise<Blob | ReadableStream<Uint8Array> | never>;
-export declare function prepareWebsocketData(data: Data | Blob): Promise<Uint8Array> | never;
+export declare function prepareWebsocketData(data: Data | BlobPolyfill): Promise<Uint8Array> | never;

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

@@ -0,0 +1,2 @@
+import { BytesReference, Reference } from '../types';
+export declare function makeBytesReference(reference: Uint8Array | BytesReference | Reference, offset?: number): BytesReference;

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

@@ -1,4 +1,4 @@
-import { Address, AddressPrefix, AllTagsOptions, BatchId, CollectionUploadOptions, FileUploadOptions, NumberString, PssMessageHandler, PublicKey, Readable, Reference, Tag, UploadOptions, TransactionHash, RequestOptions, PostageBatchOptions, CashoutOptions } from '../types';
+import { Address, AddressPrefix, AllTagsOptions, BatchId, CollectionUploadOptions, FileUploadOptions, NumberString, PssMessageHandler, PublicKey, Readable, Reference, Tag, UploadOptions, TransactionHash, RequestOptions, PostageBatchOptions, CashoutOptions, ReferenceOrEns } from '../types';
 export declare function isUint8Array(obj: unknown): obj is Uint8Array;
 export declare function isInteger(value: unknown): value is number | NumberString;
 export declare function isObject(value: unknown): value is Record<string, unknown>;
@@ -23,6 +23,7 @@ export declare function assertBoolean(value: unknown, name?: string): asserts va
 export declare function assertInteger(value: unknown, name?: string): asserts value is number | NumberString;
 export declare function assertNonNegativeInteger(value: unknown, name?: string): asserts value is number | NumberString;
 export declare function assertReference(value: unknown): asserts value is Reference;
+export declare function assertReferenceOrEns(value: unknown): asserts value is ReferenceOrEns;
 export declare function assertAddress(value: unknown): asserts value is Address;
 export declare function assertBatchId(value: unknown): asserts value is BatchId;
 export declare function assertRequestOptions(value: unknown, name?: string): asserts value is RequestOptions;