@ethersphere/bee-js 4.0.0 → 4.1.0

package/dist/mjs/{bee-debug.js → src/bee-debug.js}

@@ -37,13 +37,14 @@ import * as settlements from "./modules/debug/settlements.js";
 import * as status from "./modules/debug/status.js";
 import * as transactions from "./modules/debug/transactions.js";
 import * as states from "./modules/debug/states.js";
-import { BeeArgumentError } from "./utils/error.js";
+import { BeeArgumentError, BeeError } from "./utils/error.js";
 import { assertBeeUrl, stripLastSlash } from "./utils/url.js";
-import { assertAddress, assertBatchId, assertBoolean, assertCashoutOptions, assertNonNegativeInteger, assertRequestOptions, assertTransactionHash, isTag } from "./utils/type.js";
+import { assertAddress, assertBatchId, assertCashoutOptions, assertNonNegativeInteger, assertPositiveInteger, assertPostageBatchOptions, assertRequestOptions, assertTransactionHash, isTag } from "./utils/type.js";
 import { STAMPS_DEPTH_MAX, STAMPS_DEPTH_MIN } from "./types/index.js";
 import * as tag from "./modules/debug/tag.js";
 import * as stamps from "./modules/debug/stamps.js";
 import { makeDefaultKy, wrapRequestClosure, wrapResponseClosure } from "./utils/http.js";
+import { sleep } from "../test/utils.js";
 export class BeeDebug {
   constructor(url, options) {
     var _a;
@@ -501,6 +502,19 @@ export class BeeDebug {
       return states.getChainState(this.getKy(options));
     });
   }
+  /**
+   * Get wallet balances for xDai and BZZ of the Bee node
+   *
+   * @param options
+   */
+
+
+  getWalletBalance(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+      assertRequestOptions(options);
+      return states.getWalletBalance(this.getKy(options));
+    });
+  }
   /**
    * Creates new postage batch from the funds that the node has available in its Ethereum account.
    *
@@ -522,8 +536,8 @@ export class BeeDebug {
 
   createPostageBatch(amount, depth, options) {
     return __awaiter(this, void 0, void 0, function* () {
-      assertRequestOptions(options);
-      assertNonNegativeInteger(amount);
+      assertPostageBatchOptions(options);
+      assertPositiveInteger(amount);
       assertNonNegativeInteger(depth);
 
       if (depth < STAMPS_DEPTH_MIN) {
@@ -534,15 +548,13 @@ export class BeeDebug {
         throw new BeeArgumentError(`Depth has to be at most ${STAMPS_DEPTH_MAX}`, depth);
       }
 
-      if (options === null || options === void 0 ? void 0 : options.gasPrice) {
-        assertNonNegativeInteger(options.gasPrice);
-      }
+      const stamp = yield stamps.createPostageBatch(this.getKy(options), amount, depth, options);
 
-      if ((options === null || options === void 0 ? void 0 : options.immutableFlag) !== undefined) {
-        assertBoolean(options.immutableFlag);
+      if (options === null || options === void 0 ? void 0 : options.waitForUsable) {
+        yield this.waitForUsablePostageStamp(stamp, options === null || options === void 0 ? void 0 : options.waitForUsableTimeout);
       }
 
-      return stamps.createPostageBatch(this.getKy(options), amount, depth, options);
+      return stamp;
     });
   }
   /**
@@ -703,6 +715,24 @@ export class BeeDebug {
     });
   }
 
+  waitForUsablePostageStamp(id, timeout = 120000) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const TIME_STEP = 1500;
+
+      for (let time = 0; time < timeout; time += TIME_STEP) {
+        const stamp = yield this.getPostageBatch(id);
+
+        if (stamp.usable) {
+          return;
+        }
+
+        yield sleep(TIME_STEP);
+      }
+
+      throw new BeeError('Timeout on waiting for postage stamp to become usable');
+    });
+  }
+
   getKy(options) {
     if (!options) {
       return this.ky;

package/dist/mjs/{bee.js → src/bee.js}

@@ -50,14 +50,15 @@ 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, assertReferenceOrEns, assertRequestOptions, assertUploadOptions, makeTagUid } from "./utils/type.js";
-import { setJsonData, getJsonData } from "./feed/json.js";
-import { makeCollectionFromFileList, assertCollection } from "./utils/collection.js";
+import { addCidConversionFunction, assertAddressPrefix, assertAllTagsOptions, assertBatchId, assertCollectionUploadOptions, assertData, assertFileData, assertFileUploadOptions, assertPssMessageHandler, assertPublicKey, assertReference, assertReferenceOrEns, assertRequestOptions, assertUploadOptions, makeReferenceOrEns, makeTagUid } from "./utils/type.js";
+import { getJsonData, setJsonData } from "./feed/json.js";
+import { assertCollection, makeCollectionFromFileList } 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";
+import { ReferenceType } from '@ethersphere/swarm-cid';
 /**
  * The main component that abstracts operations available on the main Bee API.
  *
@@ -254,21 +255,21 @@ export class Bee {
         const fileOptions = Object.assign({
           contentType
         }, options);
-        return bzz.uploadFile(this.getKy(options), fileData, postageBatchId, fileName, fileOptions);
+        return addCidConversionFunction(yield bzz.uploadFile(this.getKy(options), fileData, postageBatchId, fileName, fileOptions), ReferenceType.MANIFEST);
       } else if (isReadable(data) && (options === null || options === void 0 ? void 0 : options.tag) && !options.size) {
         // TODO: Needed until https://github.com/ethersphere/bee/issues/2317 is resolved
         const result = yield bzz.uploadFile(this.getKy(options), data, postageBatchId, name, options);
         yield this.updateTag(options.tag, result.reference);
-        return result;
+        return addCidConversionFunction(result, ReferenceType.MANIFEST);
       } else {
-        return bzz.uploadFile(this.getKy(options), data, postageBatchId, name, options);
+        return addCidConversionFunction(yield bzz.uploadFile(this.getKy(options), data, postageBatchId, name, options), ReferenceType.MANIFEST);
       }
     });
   }
   /**
    * Download single file.
    *
-   * @param reference Bee file reference in hex string (either 64 or 128 chars long) or ENS domain.
+   * @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
@@ -282,14 +283,14 @@ export class Bee {
   downloadFile(reference, path = '', options) {
     return __awaiter(this, void 0, void 0, function* () {
       assertRequestOptions(options);
-      assertReferenceOrEns(reference);
+      reference = makeReferenceOrEns(reference, ReferenceType.MANIFEST);
       return bzz.downloadFile(this.getKy(options), reference, path);
     });
   }
   /**
    * Download single file as a readable stream
    *
-   * @param reference Bee file reference in hex string (either 64 or 128 chars long) or ENS domain.
+   * @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
@@ -303,7 +304,7 @@ export class Bee {
   downloadReadableFile(reference, path = '', options) {
     return __awaiter(this, void 0, void 0, function* () {
       assertRequestOptions(options);
-      assertReferenceOrEns(reference);
+      reference = makeReferenceOrEns(reference, ReferenceType.MANIFEST);
       return bzz.downloadFileReadable(this.getKy(options), reference, path);
     });
   }
@@ -330,7 +331,7 @@ export class Bee {
       assertBatchId(postageBatchId);
       if (options) assertCollectionUploadOptions(options);
       const data = yield makeCollectionFromFileList(fileList);
-      return bzz.uploadCollection(this.getKy(options), data, postageBatchId, options);
+      return addCidConversionFunction(yield bzz.uploadCollection(this.getKy(options), data, postageBatchId, options), ReferenceType.MANIFEST);
     });
   }
   /**
@@ -350,7 +351,7 @@ export class Bee {
       assertBatchId(postageBatchId);
       assertCollection(collection);
       if (options) assertCollectionUploadOptions(options);
-      return bzz.uploadCollection(this.ky, collection, postageBatchId, options);
+      return addCidConversionFunction(yield bzz.uploadCollection(this.ky, collection, postageBatchId, options), ReferenceType.MANIFEST);
     });
   }
   /**
@@ -376,7 +377,7 @@ export class Bee {
       assertBatchId(postageBatchId);
       if (options) assertCollectionUploadOptions(options);
       const data = yield makeCollectionFromFS(dir);
-      return bzz.uploadCollection(this.getKy(options), data, postageBatchId, options);
+      return addCidConversionFunction(yield bzz.uploadCollection(this.getKy(options), data, postageBatchId, options), ReferenceType.MANIFEST);
     });
   }
   /**
@@ -832,6 +833,7 @@ export 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
    */
 
 

package/dist/mjs/{modules → src/modules}/debug/states.js

@@ -32,6 +32,7 @@ var __awaiter = this && this.__awaiter || function (thisArg, _arguments, P, gene
 
 import { http } from "../../utils/http.js";
 const RESERVE_STATE_ENDPOINT = 'reservestate';
+const WALLET_ENDPOINT = 'wallet';
 const CHAIN_STATE_ENDPOINT = 'chainstate';
 /**
  * Get state of reserve
@@ -64,4 +65,20 @@ export function getChainState(ky) {
     });
     return response.data;
   });
+}
+/**
+ * Get wallet balances for xDai and BZZ of the node
+ *
+ * @param ky Ky debug instance
+ */
+
+export function getWalletBalance(ky) {
+  return __awaiter(this, void 0, void 0, function* () {
+    const response = yield http(ky, {
+      method: 'get',
+      path: `${WALLET_ENDPOINT}`,
+      responseType: 'json'
+    });
+    return response.data;
+  });
 }

package/dist/mjs/{utils → src/utils}/http.js

@@ -191,6 +191,13 @@ export function http(ky, config) {
       } else if (isHttpRequestError(e)) {
         throw new BeeRequestError(e.message, config);
       } else {
+        // Node 18 has native `fetch` implementation called Undici. Errors from this implementation have top level generic
+        // message "fetch failed" with the more specific error placed into `cause` property. Instead of "fetch failed" we
+        // expose the underlying problem.
+        if (e.cause) {
+          throw new BeeError(e.cause.message);
+        }
+
         throw new BeeError(e.message);
       }
     }

package/dist/mjs/{utils → src/utils}/type.js

@@ -1,8 +1,9 @@
 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 { BeeArgumentError, BeeError } from "./error.js";
 import { isFile } from "./file.js";
 import { assertHexString, assertPrefixedHexString, isHexString } from "./hex.js";
 import { isReadable } from "./stream.js";
+import { decodeCid, encodeReference } from '@ethersphere/swarm-cid';
 export function isUint8Array(obj) {
   return obj instanceof Uint8Array;
 }
@@ -51,6 +52,10 @@ export function assertNonNegativeInteger(value, name = 'Value') {
   assertInteger(value, name);
   if (Number(value) < 0) throw new BeeArgumentError(`${name} has to be bigger or equal to zero`, value);
 }
+export function assertPositiveInteger(value, name = 'Value') {
+  assertInteger(value, name);
+  if (Number(value) <= 0) throw new BeeArgumentError(`${name} has to be bigger then zero`, value);
+}
 export function assertReference(value) {
   try {
     assertHexString(value, REFERENCE_HEX_LENGTH);
@@ -84,10 +89,24 @@ export function assertReferenceOrEns(value) {
    * ethswarm.something- - INVALID
    * ethswarm.-something - INVALID
    * ethswarm.some-thing - VALID
+   *
+   * The idea of this regex is to match strings that are 1 to 63 characters long and do not start or end with dash character
+   *
+   * This part matches 2-63 character string that does not start or end with -
+   * [^-.\/?:\s][^.\/?:\s]{0,61}[^-.\/?:\s]   <regexp1>
+   *
+   * For 1 character long string we use the part after |
+   * [^-.\/?:\s]   <regexp2>
+   *
+   * This is terminated in a group with . character an repeated at least once
+   * (<regexp1>|<regexp2>\.)+
+   *
+   * This covers everything but top level domain which is 2 to 63 characters long so we can just use the <regexp2> again
+   * ^(<regexp1>|<regexp2>\.)+<regexp1>$
    */
 
 
-  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
+  const DOMAIN_REGEX = /^(?:(?:[^-.\/?:\s][^.\/?:\s]{0,61}[^-.\/?:\s]|[^-.\/?:\s]{1,2})\.)+[^-.\/?:\s][^.\/?:\s]{0,61}[^-.\/?:\s]$/; // 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.
 
@@ -95,6 +114,49 @@ export function assertReferenceOrEns(value) {
     throw new TypeError('ReferenceOrEns is not valid Reference, but also not valid ENS domain.');
   }
 }
+/**
+ * Function that mainly converts Swarm CID into hex encoded Swarm Reference
+ *
+ * @param value
+ * @param expectedCidType
+ */
+
+export function makeReferenceOrEns(value, expectedCidType) {
+  var _a;
+
+  if (typeof value !== 'string') {
+    throw new TypeError('ReferenceCidOrEns has to be a string!');
+  }
+
+  try {
+    const result = decodeCid(value);
+
+    if (result.type !== expectedCidType) {
+      throw new BeeError(`CID was expected to be of type ${expectedCidType}, but got instead ${(_a = result.type) !== null && _a !== void 0 ? _a : 'non-Swarm CID'}`);
+    }
+
+    return result.reference;
+  } catch (e) {
+    if (e instanceof BeeError) throw e;
+  }
+
+  assertReferenceOrEns(value);
+  return value;
+}
+/**
+ * Function that adds getter which converts the reference into CID base32 encoded string.
+ * @param result
+ * @param cidType Type as described in the @ethersphere/swarm-cids-js -> ReferenceType
+ */
+
+export function addCidConversionFunction(result, cidType) {
+  return Object.assign(Object.assign({}, result), {
+    get cid() {
+      return encodeReference(result.reference, cidType).toString();
+    }
+
+  });
+}
 export function assertAddress(value) {
   assertHexString(value, ADDRESS_HEX_LENGTH, 'Address');
 }
@@ -258,6 +320,14 @@ export function assertPostageBatchOptions(value) {
   if ((options === null || options === void 0 ? void 0 : options.immutableFlag) !== undefined) {
     assertBoolean(options.immutableFlag);
   }
+
+  if ((options === null || options === void 0 ? void 0 : options.waitForUsable) !== undefined) {
+    assertBoolean(options.waitForUsable);
+  }
+
+  if ((options === null || options === void 0 ? void 0 : options.waitForUsableTimeout) !== undefined) {
+    assertNonNegativeInteger(options.waitForUsableTimeout, 'options.waitForUsableTimeout');
+  }
 }
 export function assertCashoutOptions(value) {
   if (value === undefined) {