@ethersphere/bee-js 6.9.0 → 7.0.0

package/dist/mjs/bee.js

@@ -1,5 +1,5 @@
 import { ReferenceType } from '@ethersphere/swarm-cid';
-import { Objects } from 'cafe-utility';
+import { Objects, System } from 'cafe-utility';
 import { makeSigner } from "./chunk/signer.js";
 import { downloadSingleOwnerChunk, uploadSingleOwnerChunkData } from "./chunk/soc.js";
 import { makeFeedReader, makeFeedWriter } from "./feed/index.js";
@@ -10,13 +10,23 @@ import { DEFAULT_FEED_TYPE, assertFeedType } from "./feed/type.js";
 import * as bytes from "./modules/bytes.js";
 import * as bzz from "./modules/bzz.js";
 import * as chunk from "./modules/chunk.js";
+import * as balance from "./modules/debug/balance.js";
+import * as chequebook from "./modules/debug/chequebook.js";
+import * as connectivity from "./modules/debug/connectivity.js";
+import * as settlements from "./modules/debug/settlements.js";
+import * as stake from "./modules/debug/stake.js";
+import * as stamps from "./modules/debug/stamps.js";
+import * as states from "./modules/debug/states.js";
+import * as debugStatus from "./modules/debug/status.js";
+import * as debugTag from "./modules/debug/tag.js";
+import * as transactions from "./modules/debug/transactions.js";
 import { createFeedManifest } from "./modules/feed.js";
 import * as pinning from "./modules/pinning.js";
 import * as pss from "./modules/pss.js";
 import * as status from "./modules/status.js";
 import * as stewardship from "./modules/stewardship.js";
 import * as tag from "./modules/tag.js";
-import { CHUNK_SIZE, SPAN_SIZE } from "./types/index.js";
+import { CHUNK_SIZE, SPAN_SIZE, STAMPS_AMOUNT_MIN, STAMPS_DEPTH_MAX, STAMPS_DEPTH_MIN } from "./types/index.js";
 import { wrapBytesWithHelpers } from "./utils/bytes.js";
 import { assertCollection, makeCollectionFromFileList } from "./utils/collection.js";
 import { makeCollectionFromFS } from "./utils/collection.node.js";
@@ -24,8 +34,7 @@ import { prepareWebsocketData } from "./utils/data.js";
 import { BeeArgumentError, BeeError } from "./utils/error.js";
 import { makeEthAddress, makeHexEthAddress } from "./utils/eth.js";
 import { fileArrayBuffer, isFile } from "./utils/file.js";
-import { isReadable } from "./utils/stream.js";
-import { addCidConversionFunction, assertAddressPrefix, assertAllTagsOptions, assertBatchId, assertCollectionUploadOptions, assertData, assertFileData, assertFileUploadOptions, assertPssMessageHandler, assertPublicKey, assertReference, assertReferenceOrEns, assertRequestOptions, assertUploadOptions, makeReferenceOrEns, makeTagUid } from "./utils/type.js";
+import { addCidConversionFunction, assertAddress, assertAddressPrefix, assertAllTagsOptions, assertBatchId, assertCashoutOptions, assertCollectionUploadOptions, assertData, assertFileData, assertFileUploadOptions, assertNonNegativeInteger, assertPositiveInteger, assertPostageBatchOptions, assertPssMessageHandler, assertPublicKey, assertReference, assertReferenceOrEns, assertRequestOptions, assertTransactionHash, assertTransactionOptions, assertUploadOptions, isReadable, isTag, makeReferenceOrEns, makeTagUid } from "./utils/type.js";
 import { assertBeeUrl, stripLastSlash } from "./utils/url.js";
 /**
  * The main component that abstracts operations available on the main Bee API.
@@ -51,8 +60,7 @@ export class Bee {
       baseURL: this.url,
       timeout: options?.timeout ?? false,
       headers: options?.headers,
-      onRequest: options?.onRequest,
-      adapter: options?.adapter
+      onRequest: options?.onRequest
     };
   }
   /**
@@ -638,9 +646,7 @@ export class Bee {
     assertBatchId(postageBatchId);
     const canonicalTopic = makeTopic(topic);
     const canonicalOwner = makeHexEthAddress(owner);
-    const reference = await createFeedManifest(this.getRequestOptionsForCall(options), canonicalOwner, canonicalTopic, postageBatchId, {
-      type
-    });
+    const reference = await createFeedManifest(this.getRequestOptionsForCall(options), canonicalOwner, canonicalTopic, postageBatchId);
     return addCidConversionFunction({
       reference
     }, ReferenceType.FEED);
@@ -814,6 +820,524 @@ export class Bee {
     }
     return true;
   }
+  // Legacy debug API
+  async getNodeAddresses(options) {
+    assertRequestOptions(options);
+    return connectivity.getNodeAddresses(this.getRequestOptionsForCall(options));
+  }
+  async getBlocklist(options) {
+    assertRequestOptions(options);
+    return connectivity.getBlocklist(this.getRequestOptionsForCall(options));
+  }
+  /**
+   * Retrieve tag extended information from Bee node
+   *
+   * @param tagUid UID or tag object to be retrieved
+   * @throws TypeError if tagUid is in not correct format
+   *
+   * @see [Bee docs - Syncing / Tags](https://docs.ethswarm.org/docs/access-the-swarm/syncing)
+   * @see [Bee API reference - `GET /tags/{uid}`](https://docs.ethswarm.org/debug-api/#tag/Tag)
+   *
+   */
+  async retrieveExtendedTag(tagUid, options) {
+    assertRequestOptions(options);
+    if (isTag(tagUid)) {
+      tagUid = tagUid.uid;
+    } else if (typeof tagUid === 'number') {
+      assertNonNegativeInteger(tagUid, 'UID');
+    } else {
+      throw new TypeError('tagUid has to be either Tag or a number (UID)!');
+    }
+    return debugTag.retrieveExtendedTag(this.getRequestOptionsForCall(options), tagUid);
+  }
+  /**
+   * Get list of peers for this node
+   */
+  async getPeers(options) {
+    assertRequestOptions(options);
+    return connectivity.getPeers(this.getRequestOptionsForCall(options));
+  }
+  async removePeer(peer, options) {
+    assertRequestOptions(options);
+    assertAddress(peer);
+    return connectivity.removePeer(this.getRequestOptionsForCall(options), peer);
+  }
+  async getTopology(options) {
+    assertRequestOptions(options);
+    return connectivity.getTopology(this.getRequestOptionsForCall(options));
+  }
+  async pingPeer(peer, options) {
+    assertRequestOptions(options);
+    assertAddress(peer);
+    return connectivity.pingPeer(this.getRequestOptionsForCall(options), peer);
+  }
+  /*
+   * Balance endpoints
+   */
+  /**
+   * Get the balances with all known peers including prepaid services
+   */
+  async getAllBalances(options) {
+    assertRequestOptions(options);
+    return balance.getAllBalances(this.getRequestOptionsForCall(options));
+  }
+  /**
+   * Get the balances with a specific peer including prepaid services
+   *
+   * @param address Swarm address of peer
+   */
+  async getPeerBalance(address, options) {
+    assertRequestOptions(options);
+    assertAddress(address);
+    return balance.getPeerBalance(this.getRequestOptionsForCall(options), address);
+  }
+  /**
+   * Get the past due consumption balances with all known peers
+   */
+  async getPastDueConsumptionBalances(options) {
+    assertRequestOptions(options);
+    return balance.getPastDueConsumptionBalances(this.getRequestOptionsForCall(options));
+  }
+  /**
+   * Get the past due consumption balance with a specific peer
+   *
+   * @param address Swarm address of peer
+   */
+  async getPastDueConsumptionPeerBalance(address, options) {
+    assertRequestOptions(options);
+    assertAddress(address);
+    return balance.getPastDueConsumptionPeerBalance(this.getRequestOptionsForCall(options), address);
+  }
+  /*
+   * Chequebook endpoints
+   */
+  /**
+   * Get the address of the chequebook contract used.
+   *
+   * **Warning:** The address is returned with 0x prefix unlike all other calls.
+   * https://github.com/ethersphere/bee/issues/1443
+   */
+  async getChequebookAddress(options) {
+    assertRequestOptions(options);
+    return chequebook.getChequebookAddress(this.getRequestOptionsForCall(options));
+  }
+  /**
+   * Get the balance of the chequebook
+   */
+  async getChequebookBalance(options) {
+    assertRequestOptions(options);
+    return chequebook.getChequebookBalance(this.getRequestOptionsForCall(options));
+  }
+  /**
+   * Get last cheques for all peers
+   */
+  async getLastCheques(options) {
+    assertRequestOptions(options);
+    return chequebook.getLastCheques(this.getRequestOptionsForCall(options));
+  }
+  /**
+   * Get last cheques for the peer
+   *
+   * @param address  Swarm address of peer
+   */
+  async getLastChequesForPeer(address, options) {
+    assertRequestOptions(options);
+    assertAddress(address);
+    return chequebook.getLastChequesForPeer(this.getRequestOptionsForCall(options), address);
+  }
+  /**
+   * Get last cashout action for the peer
+   *
+   * @param address  Swarm address of peer
+   */
+  async getLastCashoutAction(address, options) {
+    assertRequestOptions(options);
+    assertAddress(address);
+    return chequebook.getLastCashoutAction(this.getRequestOptionsForCall(options), address);
+  }
+  /**
+   * Cashout the last cheque for the peer
+   *
+   * @param address  Swarm address of peer
+   * @param options
+   * @param options.gasPrice Gas price for the cashout transaction in WEI
+   * @param options.gasLimit Gas limit for the cashout transaction in WEI
+   */
+  async cashoutLastCheque(address, options, requestOptions) {
+    assertCashoutOptions(options);
+    assertAddress(address);
+    return chequebook.cashoutLastCheque(this.getRequestOptionsForCall(requestOptions), address, options);
+  }
+  /**
+   * Deposit tokens from overlay address into chequebook
+   *
+   * @param amount  Amount of tokens to deposit (must be positive integer)
+   * @param gasPrice Gas Price in WEI for the transaction call
+   * @return string  Hash of the transaction
+   */
+  async depositTokens(amount, gasPrice, options) {
+    assertRequestOptions(options);
+    assertNonNegativeInteger(amount);
+    if (gasPrice) {
+      assertNonNegativeInteger(gasPrice);
+    }
+    return chequebook.depositTokens(this.getRequestOptionsForCall(options), amount, gasPrice);
+  }
+  /**
+   * Withdraw tokens from the chequebook to the overlay address
+   *
+   * @param amount  Amount of tokens to withdraw (must be positive integer)
+   * @param gasPrice Gas Price in WEI for the transaction call
+   * @return string  Hash of the transaction
+   */
+  async withdrawTokens(amount, gasPrice, options) {
+    assertRequestOptions(options);
+    assertNonNegativeInteger(amount);
+    if (gasPrice) {
+      assertNonNegativeInteger(gasPrice);
+    }
+    return chequebook.withdrawTokens(this.getRequestOptionsForCall(options), amount, gasPrice);
+  }
+  /*
+   * Settlements endpoint
+   */
+  /**
+   * Get amount of sent and received from settlements with a peer
+   *
+   * @param address  Swarm address of peer
+   */
+  async getSettlements(address, options) {
+    assertRequestOptions(options);
+    assertAddress(address);
+    return settlements.getSettlements(this.getRequestOptionsForCall(options), address);
+  }
+  /**
+   * Get settlements with all known peers and total amount sent or received
+   */
+  async getAllSettlements(options) {
+    assertRequestOptions(options);
+    return settlements.getAllSettlements(this.getRequestOptionsForCall(options));
+  }
+  /**
+   * Get status of node
+   */
+  async getStatus(options) {
+    assertRequestOptions(options);
+    return debugStatus.getDebugStatus(this.getRequestOptionsForCall(options));
+  }
+  /**
+   * Get health of node
+   */
+  async getHealth(options) {
+    assertRequestOptions(options);
+    return debugStatus.getHealth(this.getRequestOptionsForCall(options));
+  }
+  /**
+   * Get readiness of node
+   */
+  async getReadiness(options) {
+    assertRequestOptions(options);
+    return debugStatus.getReadiness(this.getRequestOptionsForCall(options));
+  }
+  /**
+   * Get mode information of node
+   */
+  async getNodeInfo(options) {
+    assertRequestOptions(options);
+    return debugStatus.getNodeInfo(this.getRequestOptionsForCall(options));
+  }
+  /**
+   * Connnects to a node and checks if it is a supported Bee version by the bee-js
+   *
+   * @returns true if the Bee node version is supported
+   * @deprecated Use `BeeDebug.isSupportedExactVersion()` instead
+   */
+  async isSupportedVersion(options) {
+    assertRequestOptions(options);
+    return debugStatus.isSupportedVersion(this.getRequestOptionsForCall(options));
+  }
+  /**
+   * Connects to a node and checks if its version matches with the one that bee-js supports.
+   *
+   * Be aware that this is the most strict version check and most probably
+   * you will want to use more relaxed API-versions based checks like
+   * `BeeDebug.isSupportedApiVersion()`, `BeeDebug.isSupportedMainApiVersion()` or `BeeDebug.isSupportedDebugApiVersion()`
+   * based on your use-case.
+   *
+   * @param options
+   */
+  async isSupportedExactVersion(options) {
+    assertRequestOptions(options);
+    return debugStatus.isSupportedExactVersion(this.getRequestOptionsForCall(options));
+  }
+  /**
+   * Connects to a node and checks if its main's API version matches with the one that bee-js supports.
+   *
+   * This is useful if you are not using `BeeDebug` class (for anything else then this check)
+   * and want to make sure about compatibility.
+   *
+   * @param options
+   */
+  async isSupportedMainApiVersion(options) {
+    assertRequestOptions(options);
+    return debugStatus.isSupportedMainApiVersion(this.getRequestOptionsForCall(options));
+  }
+  /**
+   *
+   * Connects to a node and checks if its Main API version matches with the one that bee-js supports.
+   *
+   * This should be the main way how to check compatibility for your app and Bee node.
+   *
+   * @param options
+   */
+  async isSupportedApiVersion(options) {
+    assertRequestOptions(options);
+    return debugStatus.isSupportedApiVersion(this.getRequestOptionsForCall(options));
+  }
+  /**
+   * Returns object with all versions specified by the connected Bee node (properties prefixed with `bee*`)
+   * and versions that bee-js supports (properties prefixed with `supported*`).
+   *
+   * @param options
+   */
+  async getVersions(options) {
+    assertRequestOptions(options);
+    return debugStatus.getVersions(this.getRequestOptionsForCall(options));
+  }
+  /**
+   * Get reserve state
+   */
+  async getReserveState(options) {
+    assertRequestOptions(options);
+    return states.getReserveState(this.getRequestOptionsForCall(options));
+  }
+  /**
+   * Get chain state
+   */
+  async getChainState(options) {
+    assertRequestOptions(options);
+    return states.getChainState(this.getRequestOptionsForCall(options));
+  }
+  /**
+   * Get wallet balances for xDai and BZZ of the Bee node
+   *
+   * @param options
+   */
+  async getWalletBalance(options) {
+    assertRequestOptions(options);
+    return states.getWalletBalance(this.getRequestOptionsForCall(options));
+  }
+  /**
+   * Creates new postage batch from the funds that the node has available in its Ethereum account.
+   *
+   * For better understanding what each parameter means and what are the optimal values please see
+   * [Bee docs - Keep your data alive / Postage stamps](https://docs.ethswarm.org/docs/access-the-swarm/keep-your-data-alive).
+   *
+   * **WARNING: THIS CREATES TRANSACTIONS THAT SPENDS MONEY**
+   *
+   * @param amount Amount that represents the value per chunk, has to be greater or equal zero.
+   * @param depth Logarithm of the number of chunks that can be stamped with the batch.
+   * @param options Options for creation of postage batch
+   * @throws BeeArgumentError when negative amount or depth is specified
+   * @throws TypeError if non-integer value is passed to amount or depth
+   *
+   * @see [Bee docs - Keep your data alive / Postage stamps](https://docs.ethswarm.org/docs/access-the-swarm/keep-your-data-alive)
+   * @see [Bee Debug API reference - `POST /stamps`](https://docs.ethswarm.org/debug-api/#tag/Postage-Stamps/paths/~1stamps~1{amount}~1{depth}/post)
+   */
+  async createPostageBatch(amount, depth, options, requestOptions) {
+    assertPostageBatchOptions(options);
+    assertPositiveInteger(amount);
+    assertNonNegativeInteger(depth);
+    if (depth < STAMPS_DEPTH_MIN) {
+      throw new BeeArgumentError(`Depth has to be at least ${STAMPS_DEPTH_MIN}`, depth);
+    }
+    if (depth > STAMPS_DEPTH_MAX) {
+      throw new BeeArgumentError(`Depth has to be at most ${STAMPS_DEPTH_MAX}`, depth);
+    }
+    if (parseInt(amount, 10) < STAMPS_AMOUNT_MIN) {
+      throw new BeeArgumentError(`Amount has to be at least ${STAMPS_AMOUNT_MIN} (1 day)`, amount);
+    }
+    const stamp = await stamps.createPostageBatch(this.getRequestOptionsForCall(requestOptions), amount, depth, options);
+    if (options?.waitForUsable !== false) {
+      await this.waitForUsablePostageStamp(stamp, options?.waitForUsableTimeout);
+    }
+    return stamp;
+  }
+  /**
+   * Topup a fresh amount of BZZ to given Postage Batch.
+   *
+   * For better understanding what each parameter means and what are the optimal values please see
+   * [Bee docs - Keep your data alive / Postage stamps](https://docs.ethswarm.org/docs/access-the-swarm/keep-your-data-alive).
+   *
+   * **WARNING: THIS CREATES TRANSACTIONS THAT SPENDS MONEY**
+   *
+   * @param postageBatchId Batch ID
+   * @param amount Amount to be added to the batch
+   * @param options Request options
+   *
+   * @see [Bee docs - Keep your data alive / Postage stamps](https://docs.ethswarm.org/docs/access-the-swarm/keep-your-data-alive)
+   * @see [Bee Debug API reference - `PATCH /stamps/topup/${id}/${amount}`](https://docs.ethswarm.org/debug-api/#tag/Postage-Stamps/paths/~1stamps~1topup~1{id}~1{amount}/patch)
+   */
+  async topUpBatch(postageBatchId, amount, options) {
+    assertRequestOptions(options);
+    assertNonNegativeInteger(amount, 'Amount');
+    assertBatchId(postageBatchId);
+    await stamps.topUpBatch(this.getRequestOptionsForCall(options), postageBatchId, amount);
+  }
+  /**
+   * Dilute given Postage Batch with new depth (that has to be bigger then the original depth), which allows
+   * the Postage Batch to be used for more chunks.
+   *
+   * For better understanding what each parameter means and what are the optimal values please see
+   * [Bee docs - Keep your data alive / Postage stamps](https://docs.ethswarm.org/docs/access-the-swarm/keep-your-data-alive).
+   *
+   * **WARNING: THIS CREATES TRANSACTIONS THAT SPENDS MONEY**
+   *
+   * @param postageBatchId Batch ID
+   * @param depth Amount to be added to the batch
+   * @param options Request options
+   *
+   * @see [Bee docs - Keep your data alive / Postage stamps](https://docs.ethswarm.org/docs/access-the-swarm/keep-your-data-alive)
+   * @see [Bee Debug API reference - `PATCH /stamps/topup/${id}/${amount}`](https://docs.ethswarm.org/debug-api/#tag/Postage-Stamps/paths/~1stamps~1topup~1{id}~1{amount}/patch)
+   */
+  async diluteBatch(postageBatchId, depth, options) {
+    assertRequestOptions(options);
+    assertNonNegativeInteger(depth, 'Depth');
+    assertBatchId(postageBatchId);
+    await stamps.diluteBatch(this.getRequestOptionsForCall(options), postageBatchId, depth);
+  }
+  /**
+   * Return details for specific postage batch.
+   *
+   * @param postageBatchId Batch ID
+   *
+   * @see [Bee docs - Keep your data alive / Postage stamps](https://docs.ethswarm.org/docs/access-the-swarm/keep-your-data-alive)
+   * @see [Bee Debug API reference - `GET /stamps/${id}`](https://docs.ethswarm.org/debug-api/#tag/Postage-Stamps/paths/~1stamps~1{id}/get)
+   */
+  async getPostageBatch(postageBatchId, options) {
+    assertRequestOptions(options);
+    assertBatchId(postageBatchId);
+    return stamps.getPostageBatch(this.getRequestOptionsForCall(options), postageBatchId);
+  }
+  /**
+   * Return detailed information related to buckets for specific postage batch.
+   *
+   * @param postageBatchId Batch ID
+   *
+   * @see [Bee docs - Keep your data alive / Postage stamps](https://docs.ethswarm.org/docs/access-the-swarm/keep-your-data-alive)
+   * @see [Bee Debug API reference - `GET /stamps/${id}/buckets`](https://docs.ethswarm.org/debug-api/#tag/Postage-Stamps/paths/~1stamps~1{id}~1buckets/get)
+   */
+  async getPostageBatchBuckets(postageBatchId, options) {
+    assertRequestOptions(options);
+    assertBatchId(postageBatchId);
+    return stamps.getPostageBatchBuckets(this.getRequestOptionsForCall(options), postageBatchId);
+  }
+  /**
+   * Return all postage batches that has the node available.
+   *
+   * @see [Bee docs - Keep your data alive / Postage stamps](https://docs.ethswarm.org/docs/access-the-swarm/keep-your-data-alive)
+   * @see [Bee Debug API reference - `GET /stamps`](https://docs.ethswarm.org/debug-api/#tag/Postage-Stamps/paths/~1stamps/get)
+   */
+  async getAllPostageBatch(options) {
+    assertRequestOptions(options);
+    return stamps.getAllPostageBatches(this.getRequestOptionsForCall(options));
+  }
+  /**
+   * Return all globally available postage batches.
+   */
+  async getAllGlobalPostageBatch(options) {
+    assertRequestOptions(options);
+    return stamps.getGlobalPostageBatches(this.getRequestOptionsForCall(options));
+  }
+  /**
+   * Return lists of all current pending transactions that the Bee made
+   */
+  async getAllPendingTransactions(options) {
+    assertRequestOptions(options);
+    return transactions.getAllTransactions(this.getRequestOptionsForCall(options));
+  }
+  /**
+   * Return transaction information for specific transaction
+   * @param transactionHash
+   */
+  async getPendingTransaction(transactionHash, options) {
+    assertRequestOptions(options);
+    assertTransactionHash(transactionHash);
+    return transactions.getTransaction(this.getRequestOptionsForCall(options), transactionHash);
+  }
+  /**
+   * Rebroadcast already created transaction.
+   * This is mainly needed when your transaction fall off mempool from other reason is not incorporated into block.
+   *
+   * @param transactionHash
+   */
+  async rebroadcastPendingTransaction(transactionHash, options) {
+    assertRequestOptions(options);
+    assertTransactionHash(transactionHash);
+    return transactions.rebroadcastTransaction(this.getRequestOptionsForCall(options), transactionHash);
+  }
+  /**
+   * Cancel currently pending transaction
+   * @param transactionHash
+   * @param gasPrice
+   */
+  async cancelPendingTransaction(transactionHash, gasPrice, options) {
+    assertRequestOptions(options);
+    assertTransactionHash(transactionHash);
+    if (gasPrice) {
+      assertNonNegativeInteger(gasPrice);
+    }
+    return transactions.cancelTransaction(this.getRequestOptionsForCall(options), transactionHash, gasPrice);
+  }
+  /**
+   * Gets the staked amount of BZZ (in PLUR unit) as number string.
+   *
+   * @param options
+   */
+  async getStake(options) {
+    assertRequestOptions(options);
+    return stake.getStake(this.getRequestOptionsForCall(options));
+  }
+  /**
+   * Deposits given amount of BZZ token (in PLUR unit).
+   *
+   * Be aware that staked BZZ tokens can **not** be withdrawn.
+   *
+   * @param amount Amount of BZZ token (in PLUR unit) to be staked. Minimum is 100_000_000_000_000_000 PLUR (10 BZZ).
+   * @param options
+   */
+  async depositStake(amount, options, requestOptions) {
+    assertRequestOptions(options);
+    assertTransactionOptions(options);
+    await stake.stake(this.getRequestOptionsForCall(requestOptions), amount, options);
+  }
+  /**
+   * Get current status of node in redistribution game
+   *
+   * @param options
+   */
+  async getRedistributionState(options) {
+    assertRequestOptions(options);
+    return stake.getRedistributionState(this.getRequestOptionsForCall(options));
+  }
+  async waitForUsablePostageStamp(id, timeout = 240000) {
+    const TIME_STEP = 2000;
+    for (let time = 0; time < timeout; time += TIME_STEP) {
+      try {
+        const stamp = await this.getPostageBatch(id);
+        if (stamp.usable) {
+          return;
+        }
+      } catch (error) {
+        const message = error?.response?.data?.message || error?.message || '';
+        if (!message.includes('batch not usable')) {
+          throw error;
+        }
+      }
+      await System.sleepMillis(TIME_STEP);
+    }
+    throw new BeeError('Timeout on waiting for postage stamp to become usable');
+  }
   /**
    * @param signer
    * @private

package/dist/mjs/chunk/cac.js

@@ -1,8 +1,8 @@
+import { Binary } from 'cafe-utility';
+import { assertFlexBytes, bytesEqual, flexBytesAtOffset } from "../utils/bytes.js";
 import { BeeError } from "../utils/error.js";
 import { bmtHash } from "./bmt.js";
-import { assertFlexBytes, bytesEqual, flexBytesAtOffset } from "../utils/bytes.js";
-import { serializeBytes } from "./serialize.js";
-import { makeSpan, SPAN_SIZE } from "./span.js";
+import { SPAN_SIZE, makeSpan } from "./span.js";
 export const MIN_PAYLOAD_SIZE = 1;
 export const MAX_PAYLOAD_SIZE = 4096;
 const CAC_SPAN_OFFSET = 0;
@@ -15,7 +15,7 @@ const CAC_PAYLOAD_OFFSET = CAC_SPAN_OFFSET + SPAN_SIZE;
 export function makeContentAddressedChunk(payloadBytes) {
   const span = makeSpan(payloadBytes.length);
   assertFlexBytes(payloadBytes, MIN_PAYLOAD_SIZE, MAX_PAYLOAD_SIZE);
-  const data = serializeBytes(span, payloadBytes);
+  const data = Binary.concatBytes(span, payloadBytes);
   return {
     data,
     span: () => span,

package/dist/mjs/chunk/soc.js

@@ -1,3 +1,4 @@
+import { Binary } from 'cafe-utility';
 import * as chunkAPI from "../modules/chunk.js";
 import * as socAPI from "../modules/soc.js";
 import { bytesAtOffset, bytesEqual, flexBytesAtOffset } from "../utils/bytes.js";
@@ -6,8 +7,7 @@ import { keccak256Hash } from "../utils/hash.js";
 import { bytesToHex } from "../utils/hex.js";
 import { assertAddress } from "../utils/type.js";
 import { bmtHash } from "./bmt.js";
-import { assertValidChunkData, makeContentAddressedChunk, MAX_PAYLOAD_SIZE, MIN_PAYLOAD_SIZE } from "./cac.js";
-import { serializeBytes } from "./serialize.js";
+import { MAX_PAYLOAD_SIZE, MIN_PAYLOAD_SIZE, assertValidChunkData, makeContentAddressedChunk } from "./cac.js";
 import { recoverAddress, sign } from "./signer.js";
 import { SPAN_SIZE } from "./span.js";
 const IDENTIFIER_SIZE = 32;
@@ -68,7 +68,7 @@ export async function makeSingleOwnerChunk(chunk, identifier, signer) {
   assertValidChunkData(chunk.data, chunkAddress);
   const digest = keccak256Hash(identifier, chunkAddress);
   const signature = await sign(signer, digest);
-  const data = serializeBytes(identifier, signature, chunk.span(), chunk.payload());
+  const data = Binary.concatBytes(identifier, signature, chunk.span(), chunk.payload());
   const address = makeSOCAddress(identifier, signer.address);
   return {
     data,
@@ -85,7 +85,7 @@ export async function makeSingleOwnerChunk(chunk, identifier, signer) {
  *
  * It uses the Chunk API and calculates the address before uploading.
  *
- * @param kyOptions Ky Options for making requests
+ * @param requestOptions  Options for making requests
  * @param chunk           A chunk object
  * @param postageBatchId  Postage BatchId that will be assigned to uploaded data
  * @param options         Upload options
@@ -94,13 +94,13 @@ export async function uploadSingleOwnerChunk(requestOptions, chunk, postageBatch
   const owner = bytesToHex(chunk.owner());
   const identifier = bytesToHex(chunk.identifier());
   const signature = bytesToHex(chunk.signature());
-  const data = serializeBytes(chunk.span(), chunk.payload());
+  const data = Binary.concatBytes(chunk.span(), chunk.payload());
   return socAPI.upload(requestOptions, owner, identifier, signature, data, postageBatchId, options);
 }
 /**
  * Helper function to create and upload SOC.
  *
- * @param kyOptions Ky Options for making requests
+ * @param requestOptions  Options for making requests
  * @param signer          The singer interface for signing the chunk
  * @param postageBatchId
  * @param identifier      The identifier of the chunk

package/dist/mjs/chunk/span.js

@@ -1,3 +1,4 @@
+import { Binary } from 'cafe-utility';
 import { BeeArgumentError } from "../utils/error.js";
 export const SPAN_SIZE = 8;
 // we limit the maximum span size in 32 bits to avoid BigInt compatibility issues
@@ -16,10 +17,5 @@ export function makeSpan(length) {
   if (length > MAX_SPAN_LENGTH) {
     throw new BeeArgumentError('invalid length (> MAX_SPAN_LENGTH)', length);
   }
-  const span = new Uint8Array(SPAN_SIZE);
-  const dataView = new DataView(span.buffer);
-  const littleEndian = true;
-  const lengthLower32 = length & 0xffffffff;
-  dataView.setUint32(0, lengthLower32, littleEndian);
-  return span;
+  return Binary.numberToUint64LE(length);
 }

package/dist/mjs/feed/identifier.js

@@ -1,7 +1,7 @@
+import { Binary } from 'cafe-utility';
 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;
 }
@@ -9,7 +9,7 @@ function hashFeedIdentifier(topic, index) {
   return keccak256Hash(hexToBytes(topic), index);
 }
 function makeSequentialFeedIdentifier(topic, index) {
-  const indexBytes = writeUint64BigEndian(index);
+  const indexBytes = Binary.numberToUint64BE(index);
   return hashFeedIdentifier(topic, indexBytes);
 }
 function makeFeedIndexBytes(s) {