@ethersphere/bee-js 3.3.4 → 4.1.0

package/dist/mjs/test/utils.js

@@ -0,0 +1,458 @@
+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 { Readable } from 'stream';
+import { ReadableStream as ReadableStreamPolyfill } from 'web-streams-polyfill';
+import ky from 'ky-universal';
+import { bytesToHex } from "../src/utils/hex.js";
+import { deleteChunkFromLocalStorage } from "../src/modules/debug/chunk.js";
+import { BeeResponseError } from "../src/index.js";
+import { assertBytes } from "../src/utils/bytes.js";
+import * as stamps from "../src/modules/debug/stamps.js";
+/**
+ * Load common own Jest Matchers which can be used to check particular return values.
+ */
+
+export function commonMatchers() {
+  expect.extend({
+    toBeHashReference(received) {
+      const result = {
+        pass: false,
+        message: () => 'Given input is not a Swarm hash reference'
+      };
+
+      if (typeof received === 'string' && /^[0-9a-fA-F]{64}$/.test(received)) {
+        result.pass = true;
+
+        result.message = () => 'Given string is semantically valid Swarm hash reference';
+      }
+
+      return result;
+    },
+
+    toBeBeeResponse(received, expectedStatusCode) {
+      const result = {
+        pass: false,
+        message: () => `Bee response does not have status code ${expectedStatusCode}. Got: ${received.code}\nResponse message: ${received.message}`
+      };
+
+      if (received.code === expectedStatusCode) {
+        result.pass = true;
+
+        result.message = () => 'Bee response meets with its requirements';
+      }
+
+      return result;
+    },
+
+    toBeOneOf(received, argument) {
+      const validValues = Array.isArray(argument) ? argument : [argument];
+      let containsValidValue = false;
+
+      for (const validValue of validValues) {
+        try {
+          expect(received).toEqual(validValue);
+          containsValidValue = true; // eslint-disable-next-line no-empty
+        } catch (e) {}
+      }
+
+      if (containsValidValue) {
+        return {
+          message: () => `expected ${JSON.stringify(received)} not to be one of [${validValues.join(', ')}]`,
+          pass: true
+        };
+      }
+
+      return {
+        message: () => `expected ${JSON.stringify(received)} to be one of [${validValues.join(', ')}]`,
+        pass: false
+      };
+    },
+
+    toBeType(received, argument) {
+      const initialType = typeof received;
+      const isArray = Array.isArray(received) ? 'array' : initialType;
+      const type = initialType === 'object' ? isArray : initialType;
+      return type === argument ? {
+        message: () => `expected ${received} to be type ${argument}`,
+        pass: true
+      } : {
+        message: () => `expected ${received} to be type ${argument}`,
+        pass: false
+      };
+    },
+
+    toBeNumberString(received) {
+      const message = () => `expected ${received} to be a number in a string type`;
+
+      return /^-?(0|[1-9][0-9]*)$/g.test(received) ? {
+        message,
+        pass: true
+      } : {
+        message,
+        pass: false
+      };
+    }
+
+  });
+}
+/**
+ * Sleep for N miliseconds
+ *
+ * @param ms Number of miliseconds to sleep
+ */
+
+export function sleep(ms) {
+  return __awaiter(this, void 0, void 0, function* () {
+    return new Promise(resolve => setTimeout(() => resolve(), ms));
+  });
+}
+/**
+ * Helper function that reads whole content of ReadableStream
+ * @param stream
+ */
+
+export function readWholeUint8ArrayReadableStream(stream) {
+  return __awaiter(this, void 0, void 0, function* () {
+    const reader = stream.getReader();
+    let buff = [];
+    let readResult;
+
+    do {
+      readResult = yield reader.read();
+      if (readResult.value) buff = [...buff, ...readResult.value];
+    } while (!readResult.done);
+
+    return new Uint8Array(buff);
+  });
+}
+export function createRandomNodeReadable(totalSize, chunkSize = 1000) {
+  if (totalSize % chunkSize !== 0) {
+    throw new Error(`totalSize ${totalSize} is not dividable without remainder by chunkSize ${chunkSize}`);
+  }
+
+  const stream = new Readable(); // eslint-disable-next-line @typescript-eslint/no-empty-function
+
+  stream._read = () => {};
+
+  for (let i = 0; i < totalSize / chunkSize; i++) {
+    stream.push(randomByteArray(chunkSize));
+  }
+
+  stream.push(null);
+  return stream;
+}
+export function createReadableStream(iterable) {
+  const iter = iterable[Symbol.iterator]();
+  return new ReadableStreamPolyfill({
+    pull(controller) {
+      return __awaiter(this, void 0, void 0, function* () {
+        const result = iter.next();
+
+        if (result.done) {
+          controller.close();
+          return;
+        }
+
+        controller.enqueue(result.value);
+      });
+    }
+
+  });
+}
+/**
+ * Lehmer random number generator with seed (minstd_rand in C++11)
+ * !!! Very fast but not well distributed pseudo-random function !!!
+ *
+ * @param seed Seed for the pseudo-random generator
+ */
+
+function lrng(seed) {
+  return () => (Math.pow(2, 31) - 1 & (seed = Math.imul(48271, seed))) / Math.pow(2, 31);
+}
+/**
+ * Utility function for generating random Buffer
+ * !!! IT IS NOT CRYPTO SAFE !!!
+ * For that use `crypto.randomBytes()`
+ *
+ * @param length Number of bytes to generate
+ * @param seed Seed for the pseudo-random generator
+ */
+
+
+export function randomByteArray(length, seed = 500) {
+  const rand = lrng(seed);
+  const buf = new Uint8Array(length);
+
+  for (let i = 0; i < length; ++i) {
+    buf[i] = rand() * 0xff << 0;
+  }
+
+  return buf;
+}
+/**
+ * Returns a url for testing the Bee public API
+ */
+
+export function beeUrl() {
+  return process.env.BEE_API_URL || 'http://127.0.0.1:1633';
+}
+export function beeKy() {
+  return ky.create({
+    prefixUrl: beeUrl(),
+    timeout: false
+  });
+}
+/**
+ * Returns a url of another peer for testing the Bee public API
+ */
+
+export function beePeerUrl() {
+  return process.env.BEE_PEER_API_URL || 'http://127.0.0.1:11633';
+}
+export function beePeerKy() {
+  return ky.create({
+    prefixUrl: beePeerUrl(),
+    timeout: false
+  });
+}
+/**
+ * Helper function that create monster batch for all the tests.
+ * There is semaphore mechanism that allows only creation of one batch across all the
+ * parallel running tests that have to wait until it is created.
+ */
+
+export function getPostageBatch(url = beeDebugUrl()) {
+  let stamp;
+
+  switch (url) {
+    case beeDebugUrl():
+      stamp = process.env.BEE_POSTAGE;
+      break;
+
+    case beePeerDebugUrl():
+      stamp = process.env.BEE_PEER_POSTAGE;
+      break;
+
+    default:
+      throw new Error('Unknown URL ' + url);
+  }
+
+  if (!stamp) {
+    throw new Error('There is no postage stamp configured for URL ' + url);
+  }
+
+  return stamp;
+}
+/**
+ * Returns a url for testing the Bee Debug API
+ */
+
+export function beeDebugUrl() {
+  return process.env.BEE_DEBUG_API_URL || 'http://127.0.0.1:1635';
+}
+export function beeDebugKy() {
+  return ky.create({
+    prefixUrl: beeDebugUrl(),
+    timeout: false
+  });
+}
+/**
+ * Returns a url for testing the Bee Debug API
+ */
+
+export function beePeerDebugUrl() {
+  return process.env.BEE_PEER_DEBUG_API_URL || 'http://127.0.0.1:11635';
+}
+export function beePeerDebugKy() {
+  return ky.create({
+    prefixUrl: beePeerDebugUrl(),
+    timeout: false
+  });
+}
+/**
+ * Try to delete a chunk from local storage, ignoring all errors
+ *
+ * @param address  Swarm address of chunk
+ */
+
+export function tryDeleteChunkFromLocalStorage(address) {
+  return __awaiter(this, void 0, void 0, function* () {
+    if (typeof address !== 'string') {
+      assertBytes(address, 32);
+      address = bytesToHex(address);
+    }
+
+    try {
+      yield deleteChunkFromLocalStorage(beeDebugKy(), address);
+    } catch (e) {
+      // ignore not found errors
+      if (e instanceof BeeResponseError && e.status === 404) {
+        return;
+      }
+
+      throw e;
+    }
+  });
+}
+/**
+ * Formatting utility for displaying long strings like hexstrings.
+ *
+ * @param inputStr
+ * @param len
+ */
+
+export function shorten(inputStr, len = 17) {
+  const str = typeof inputStr === 'string' ? inputStr : inputStr.toString();
+
+  if (str.length <= len) {
+    return str;
+  }
+
+  return `${str.slice(0, 6)}...${str.slice(-6)} (length: ${str.length})`;
+}
+
+function timeout(ms, message = 'Execution reached timeout!') {
+  return __awaiter(this, void 0, void 0, function* () {
+    yield sleep(ms);
+    throw new Error(message);
+  });
+}
+
+export function waitForBatchToBeUsable(batchId, pollingInterval = 200) {
+  return __awaiter(this, void 0, void 0, function* () {
+    yield Promise.race([timeout(USABLE_TIMEOUT, 'Awaiting of usable postage batch timed out!'), () => __awaiter(this, void 0, void 0, function* () {
+      let stamp;
+
+      do {
+        yield sleep(pollingInterval);
+        stamp = yield stamps.getPostageBatch(beeDebugKy(), batchId);
+      } while (!stamp.usable);
+    })]);
+  });
+}
+const DEFAULT_BATCH_AMOUNT = '1';
+const DEFAULT_BATCH_DEPTH = 17;
+/**
+ * Returns already existing batch or will create one.
+ *
+ * If some specification is passed then it is guaranteed that the batch will have this property(ies)
+ *
+ * @param amount
+ * @param depth
+ * @param immutable
+ */
+
+export function getOrCreatePostageBatch(amount, depth, immutable) {
+  return __awaiter(this, void 0, void 0, function* () {
+    // Non-usable stamps are ignored by Bee
+    const allUsableStamps = (yield stamps.getAllPostageBatches(beeDebugKy())).filter(stamp => stamp.usable);
+
+    if (allUsableStamps.length === 0) {
+      const batchId = yield stamps.createPostageBatch(beeDebugKy(), amount !== null && amount !== void 0 ? amount : DEFAULT_BATCH_AMOUNT, depth !== null && depth !== void 0 ? depth : DEFAULT_BATCH_DEPTH);
+      yield waitForBatchToBeUsable(batchId);
+      return stamps.getPostageBatch(beeDebugKy(), batchId);
+    } // User does not want any specific batch, lets give him the first one
+
+
+    if (amount === undefined && depth === undefined && immutable === undefined) {
+      return allUsableStamps[0];
+    } // User wants some specific batch
+
+
+    for (const stamp of allUsableStamps) {
+      let meetingAllCriteria = false;
+
+      if (amount !== undefined) {
+        meetingAllCriteria = amount === stamp.amount;
+      } else {
+        meetingAllCriteria = true;
+      }
+
+      if (depth !== undefined) {
+        meetingAllCriteria = meetingAllCriteria && depth === stamp.depth;
+      }
+
+      if (immutable !== undefined) {
+        meetingAllCriteria = meetingAllCriteria && immutable === stamp.immutableFlag;
+      }
+
+      if (meetingAllCriteria) {
+        return stamp;
+      }
+    } // No stamp meeting the criteria was found ==> we need to create a new one
+
+
+    const batchId = yield stamps.createPostageBatch(beeDebugKy(), amount !== null && amount !== void 0 ? amount : DEFAULT_BATCH_AMOUNT, depth !== null && depth !== void 0 ? depth : DEFAULT_BATCH_DEPTH);
+    yield waitForBatchToBeUsable(batchId);
+    return stamps.getPostageBatch(beeDebugKy(), batchId);
+  });
+}
+export function makeTestTarget(target) {
+  return target.slice(0, 2);
+}
+export const invalidReference = '0000000000000000000000000000000000000000000000000000000000000000';
+export const okResponse = {
+  code: 200,
+  message: 'OK'
+};
+export const createdResponse = {
+  code: 201,
+  message: 'Created'
+};
+const USABLE_TIMEOUT = 7000;
+export const ERR_TIMEOUT = 40000;
+export const BIG_FILE_TIMEOUT = 100000;
+export const PSS_TIMEOUT = 120000;
+export const FEED_TIMEOUT = 120000;
+export const BLOCKCHAIN_TRANSACTION_TIMEOUT = 40000;
+export const WAITING_USABLE_STAMP_TIMEOUT = 130000;
+export const testChunkPayload = new Uint8Array([1, 2, 3]); // span is the payload length encoded as uint64 little endian
+
+export const testChunkSpan = new Uint8Array([testChunkPayload.length, 0, 0, 0, 0, 0, 0, 0]);
+export const testChunkData = new Uint8Array([...testChunkSpan, ...testChunkPayload]); // the hash is hardcoded because we would need the bmt hasher otherwise
+
+export const testChunkHash = 'ca6357a08e317d15ec560fef34e4c45f8f19f01c372aa70f1da72bfa7f1a4338';
+export const testAddress = 'ca6357a08e317d15ec560fef34e4c45f8f19f01c372aa70f1da72bfa7f1a4338';
+export const testBatchId = 'ca6357a08e317d15ec560fef34e4c45f8f19f01c372aa70f1da72bfa7f1a4338';
+export const testJsonPayload = [{
+  some: 'object'
+}];
+export const testJsonStringPayload = JSON.stringify(testJsonPayload);
+export const testJsonHash = '872a858115b8bee4408b1427b49e472883fdc2512d5a8f2d428b97ecc8f7ccfa';
+export const testJsonCid = 'bah5acgzaq4vilaivxc7oiqelcqt3jhshfcb73qsrfvni6lkcrol6zshxzt5a';
+export const testJsonEns = 'testing.eth';
+export const testIdentity = {
+  privateKey: '634fb5a872396d9693e5c9f9d7233cfa93f395c093371017ff44aa9ae6564cdd',
+  publicKey: '03c32bb011339667a487b6c1c35061f15f7edc36aa9a0f8648aba07a4b8bd741b4',
+  address: '8d3766440f0d7b949a5e32995d09619a7f86e632'
+};

package/dist/types/{bee-debug.d.ts → src/bee-debug.d.ts}

@@ -1,4 +1,4 @@
-import type { Address, Peer, BalanceResponse, PeerBalance, ChequebookAddressResponse, ChequebookBalanceResponse, LastChequesResponse, LastChequesForPeerResponse, LastCashoutActionResponse, Settlements, AllSettlements, RemovePeerResponse, Topology, PingResponse, Health, NodeAddresses, ReserveState, ChainState, NumberString, ExtendedTag, PostageBatchBuckets, PostageBatch, TransactionInfo, TransactionHash, NodeInfo, BeeVersions } from './types';
+import type { Address, Peer, BalanceResponse, PeerBalance, ChequebookAddressResponse, ChequebookBalanceResponse, LastChequesResponse, LastChequesForPeerResponse, LastCashoutActionResponse, Settlements, AllSettlements, RemovePeerResponse, Topology, PingResponse, Health, NodeAddresses, ReserveState, ChainState, NumberString, ExtendedTag, PostageBatchBuckets, PostageBatch, TransactionInfo, TransactionHash, NodeInfo, BeeVersions, WalletBalance } from './types';
 import { BatchId, BeeOptions, CashoutOptions, PostageBatchOptions, RequestOptions, Tag } from './types';
 export declare class BeeDebug {
     /**
@@ -181,6 +181,12 @@ export declare class BeeDebug {
      * Get chain state
      */
     getChainState(options?: RequestOptions): Promise<ChainState>;
+    /**
+     * Get wallet balances for xDai and BZZ of the Bee node
+     *
+     * @param options
+     */
+    getWalletBalance(options?: RequestOptions): Promise<WalletBalance>;
     /**
      * Creates new postage batch from the funds that the node has available in its Ethereum account.
      *
@@ -279,5 +285,6 @@ export declare class BeeDebug {
      * @param gasPrice
      */
     cancelPendingTransaction(transactionHash: TransactionHash | string, gasPrice?: NumberString, options?: RequestOptions): Promise<TransactionHash>;
+    private waitForUsablePostageStamp;
     private getKy;
 }

package/dist/types/{bee.d.ts → src/bee.d.ts}

@@ -1,7 +1,8 @@
+import { Index, IndexBytes } from './feed';
 import { FeedType } from './feed/type';
 import { EthAddress } from './utils/eth';
-import { AllTagsOptions, Collection, Readable, 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';
+import type { AddressPrefix, AnyJson, BatchId, BeeOptions, CollectionUploadOptions, Data, FeedReader, FeedWriter, FileData, FileUploadOptions, JsonFeedOptions, Pin, PssMessageHandler, PssSubscription, PublicKey, Reference, Signer, SOCReader, SOCWriter, Tag, Topic, UploadOptions, UploadResultWithCid } from './types';
+import { AllTagsOptions, Collection, Readable, ReferenceCidOrEns, ReferenceOrEns, RequestOptions, UploadResult } 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.
      *
@@ -94,30 +101,33 @@ export declare class Bee {
      * @see [Bee API reference - `POST /bzz`](https://docs.ethswarm.org/api/#tag/File/paths/~1bzz/post)
      * @returns reference is a content hash of the file
      */
-    uploadFile(postageBatchId: string | BatchId, data: string | Uint8Array | Readable | File, name?: string, options?: FileUploadOptions): Promise<UploadResult>;
+    uploadFile(postageBatchId: string | BatchId, data: string | Uint8Array | Readable | File, name?: string, options?: FileUploadOptions): Promise<UploadResultWithCid>;
     /**
      * Download single file.
      *
-     * @param reference Bee file reference
+     * @param reference Bee file reference in hex string (either 64 or 128 chars long), ENS domain or Swarm CID.
      * @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: ReferenceCidOrEns | 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), ENS domain or Swarm CID.
      * @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: ReferenceCidOrEns | string, path?: string, options?: RequestOptions): Promise<FileData<ReadableStream<Uint8Array>>>;
     /**
      * Upload collection of files to a Bee node
      *
@@ -134,7 +144,7 @@ export declare class Bee {
      * @see [Bee docs - Upload directory](https://docs.ethswarm.org/docs/access-the-swarm/upload-a-directory/)
      * @see [Bee API reference - `POST /bzz`](https://docs.ethswarm.org/api/#tag/Collection/paths/~1bzz/post)
      */
-    uploadFiles(postageBatchId: string | BatchId, fileList: FileList | File[], options?: CollectionUploadOptions): Promise<UploadResult>;
+    uploadFiles(postageBatchId: string | BatchId, fileList: FileList | File[], options?: CollectionUploadOptions): Promise<UploadResultWithCid>;
     /**
      * Upload Collection that you can assembly yourself.
      *
@@ -145,7 +155,7 @@ export declare class Bee {
      * @param collection
      * @param options Collections and request options
      */
-    uploadCollection(postageBatchId: string | BatchId, collection: Collection<Uint8Array | Readable>, options?: CollectionUploadOptions): Promise<UploadResult>;
+    uploadCollection(postageBatchId: string | BatchId, collection: Collection<Uint8Array | Readable>, options?: CollectionUploadOptions): Promise<UploadResultWithCid>;
     /**
      * Upload collection of files.
      *
@@ -162,7 +172,7 @@ export declare class Bee {
      * @see [Bee docs - Upload directory](https://docs.ethswarm.org/docs/access-the-swarm/upload-a-directory/)
      * @see [Bee API reference - `POST /bzz`](https://docs.ethswarm.org/api/#tag/Collection/paths/~1bzz/post)
      */
-    uploadFilesFromDirectory(postageBatchId: string | BatchId, dir: string, options?: CollectionUploadOptions): Promise<UploadResult>;
+    uploadFilesFromDirectory(postageBatchId: string | BatchId, dir: string, options?: CollectionUploadOptions): Promise<UploadResultWithCid>;
     /**
      * Create a new Tag which is meant for tracking progres of syncing data across network.
      *
@@ -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.
      *
@@ -381,6 +411,7 @@ export declare class Bee {
      *
      * @see [Bee docs - Feeds](https://docs.ethswarm.org/docs/dapps-on-swarm/feeds)
      * @see [Bee API reference - `POST /feeds`](https://docs.ethswarm.org/api/#tag/Feed/paths/~1feeds~1{owner}~1{topic}/post)
+     * TODO: Once breaking add support for Feed CID
      */
     createFeedManifest(postageBatchId: string | BatchId, type: FeedType, topic: Topic | Uint8Array | string, owner: EthAddress | Uint8Array | string, options?: RequestOptions): Promise<Reference>;
     /**