@ethersphere/bee-js 3.3.4 → 4.1.0

package/dist/mjs/src/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 → 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/{modules → src/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.1-d0a77598';
-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 → src/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 → src/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 → src/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 → 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/src/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 → 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 } from "./hex.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);
@@ -58,6 +63,100 @@ 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
+   *
+   * 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][^.\/?:\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.
+
+  if (!DOMAIN_REGEX.test(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');
 }
@@ -221,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) {