@ethersphere/bee-js 6.9.1 → 7.0.0

package/dist/cjs/bee.js

@@ -36,6 +36,16 @@ const type_1 = require("./feed/type");
 const bytes = __importStar(require("./modules/bytes"));
 const bzz = __importStar(require("./modules/bzz"));
 const chunk = __importStar(require("./modules/chunk"));
+const balance = __importStar(require("./modules/debug/balance"));
+const chequebook = __importStar(require("./modules/debug/chequebook"));
+const connectivity = __importStar(require("./modules/debug/connectivity"));
+const settlements = __importStar(require("./modules/debug/settlements"));
+const stake = __importStar(require("./modules/debug/stake"));
+const stamps = __importStar(require("./modules/debug/stamps"));
+const states = __importStar(require("./modules/debug/states"));
+const debugStatus = __importStar(require("./modules/debug/status"));
+const debugTag = __importStar(require("./modules/debug/tag"));
+const transactions = __importStar(require("./modules/debug/transactions"));
 const feed_2 = require("./modules/feed");
 const pinning = __importStar(require("./modules/pinning"));
 const pss = __importStar(require("./modules/pss"));
@@ -50,7 +60,6 @@ const data_1 = require("./utils/data");
 const error_1 = require("./utils/error");
 const eth_1 = require("./utils/eth");
 const file_1 = require("./utils/file");
-const stream_1 = require("./utils/stream");
 const type_2 = require("./utils/type");
 const url_1 = require("./utils/url");
 /**
@@ -78,7 +87,6 @@ class Bee {
             timeout: options?.timeout ?? false,
             headers: options?.headers,
             onRequest: options?.onRequest,
-            adapter: options?.adapter,
         };
     }
     /**
@@ -201,7 +209,7 @@ class Bee {
             const fileOptions = { contentType, ...options };
             return (0, type_2.addCidConversionFunction)(await bzz.uploadFile(this.getRequestOptionsForCall(requestOptions), fileData, postageBatchId, fileName, fileOptions), swarm_cid_1.ReferenceType.MANIFEST);
         }
-        else if ((0, stream_1.isReadable)(data) && options?.tag && !options.size) {
+        else if ((0, type_2.isReadable)(data) && options?.tag && !options.size) {
             // TODO: Needed until https://github.com/ethersphere/bee/issues/2317 is resolved
             const result = await bzz.uploadFile(this.getRequestOptionsForCall(requestOptions), data, postageBatchId, name, options);
             await this.updateTag(options.tag, result.reference);
@@ -673,9 +681,7 @@ class Bee {
         (0, type_2.assertBatchId)(postageBatchId);
         const canonicalTopic = (0, topic_1.makeTopic)(topic);
         const canonicalOwner = (0, eth_1.makeHexEthAddress)(owner);
-        const reference = await (0, feed_2.createFeedManifest)(this.getRequestOptionsForCall(options), canonicalOwner, canonicalTopic, postageBatchId, {
-            type,
-        });
+        const reference = await (0, feed_2.createFeedManifest)(this.getRequestOptionsForCall(options), canonicalOwner, canonicalTopic, postageBatchId);
         return (0, type_2.addCidConversionFunction)({ reference }, swarm_cid_1.ReferenceType.FEED);
     }
     /**
@@ -851,6 +857,527 @@ class Bee {
         }
         return true;
     }
+    // Legacy debug API
+    async getNodeAddresses(options) {
+        (0, type_2.assertRequestOptions)(options);
+        return connectivity.getNodeAddresses(this.getRequestOptionsForCall(options));
+    }
+    async getBlocklist(options) {
+        (0, type_2.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) {
+        (0, type_2.assertRequestOptions)(options);
+        if ((0, type_2.isTag)(tagUid)) {
+            tagUid = tagUid.uid;
+        }
+        else if (typeof tagUid === 'number') {
+            (0, type_2.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) {
+        (0, type_2.assertRequestOptions)(options);
+        return connectivity.getPeers(this.getRequestOptionsForCall(options));
+    }
+    async removePeer(peer, options) {
+        (0, type_2.assertRequestOptions)(options);
+        (0, type_2.assertAddress)(peer);
+        return connectivity.removePeer(this.getRequestOptionsForCall(options), peer);
+    }
+    async getTopology(options) {
+        (0, type_2.assertRequestOptions)(options);
+        return connectivity.getTopology(this.getRequestOptionsForCall(options));
+    }
+    async pingPeer(peer, options) {
+        (0, type_2.assertRequestOptions)(options);
+        (0, type_2.assertAddress)(peer);
+        return connectivity.pingPeer(this.getRequestOptionsForCall(options), peer);
+    }
+    /*
+     * Balance endpoints
+     */
+    /**
+     * Get the balances with all known peers including prepaid services
+     */
+    async getAllBalances(options) {
+        (0, type_2.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) {
+        (0, type_2.assertRequestOptions)(options);
+        (0, type_2.assertAddress)(address);
+        return balance.getPeerBalance(this.getRequestOptionsForCall(options), address);
+    }
+    /**
+     * Get the past due consumption balances with all known peers
+     */
+    async getPastDueConsumptionBalances(options) {
+        (0, type_2.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) {
+        (0, type_2.assertRequestOptions)(options);
+        (0, type_2.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) {
+        (0, type_2.assertRequestOptions)(options);
+        return chequebook.getChequebookAddress(this.getRequestOptionsForCall(options));
+    }
+    /**
+     * Get the balance of the chequebook
+     */
+    async getChequebookBalance(options) {
+        (0, type_2.assertRequestOptions)(options);
+        return chequebook.getChequebookBalance(this.getRequestOptionsForCall(options));
+    }
+    /**
+     * Get last cheques for all peers
+     */
+    async getLastCheques(options) {
+        (0, type_2.assertRequestOptions)(options);
+        return chequebook.getLastCheques(this.getRequestOptionsForCall(options));
+    }
+    /**
+     * Get last cheques for the peer
+     *
+     * @param address  Swarm address of peer
+     */
+    async getLastChequesForPeer(address, options) {
+        (0, type_2.assertRequestOptions)(options);
+        (0, type_2.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) {
+        (0, type_2.assertRequestOptions)(options);
+        (0, type_2.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) {
+        (0, type_2.assertCashoutOptions)(options);
+        (0, type_2.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) {
+        (0, type_2.assertRequestOptions)(options);
+        (0, type_2.assertNonNegativeInteger)(amount);
+        if (gasPrice) {
+            (0, type_2.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) {
+        (0, type_2.assertRequestOptions)(options);
+        (0, type_2.assertNonNegativeInteger)(amount);
+        if (gasPrice) {
+            (0, type_2.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) {
+        (0, type_2.assertRequestOptions)(options);
+        (0, type_2.assertAddress)(address);
+        return settlements.getSettlements(this.getRequestOptionsForCall(options), address);
+    }
+    /**
+     * Get settlements with all known peers and total amount sent or received
+     */
+    async getAllSettlements(options) {
+        (0, type_2.assertRequestOptions)(options);
+        return settlements.getAllSettlements(this.getRequestOptionsForCall(options));
+    }
+    /**
+     * Get status of node
+     */
+    async getStatus(options) {
+        (0, type_2.assertRequestOptions)(options);
+        return debugStatus.getDebugStatus(this.getRequestOptionsForCall(options));
+    }
+    /**
+     * Get health of node
+     */
+    async getHealth(options) {
+        (0, type_2.assertRequestOptions)(options);
+        return debugStatus.getHealth(this.getRequestOptionsForCall(options));
+    }
+    /**
+     * Get readiness of node
+     */
+    async getReadiness(options) {
+        (0, type_2.assertRequestOptions)(options);
+        return debugStatus.getReadiness(this.getRequestOptionsForCall(options));
+    }
+    /**
+     * Get mode information of node
+     */
+    async getNodeInfo(options) {
+        (0, type_2.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) {
+        (0, type_2.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) {
+        (0, type_2.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) {
+        (0, type_2.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) {
+        (0, type_2.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) {
+        (0, type_2.assertRequestOptions)(options);
+        return debugStatus.getVersions(this.getRequestOptionsForCall(options));
+    }
+    /**
+     * Get reserve state
+     */
+    async getReserveState(options) {
+        (0, type_2.assertRequestOptions)(options);
+        return states.getReserveState(this.getRequestOptionsForCall(options));
+    }
+    /**
+     * Get chain state
+     */
+    async getChainState(options) {
+        (0, type_2.assertRequestOptions)(options);
+        return states.getChainState(this.getRequestOptionsForCall(options));
+    }
+    /**
+     * Get wallet balances for xDai and BZZ of the Bee node
+     *
+     * @param options
+     */
+    async getWalletBalance(options) {
+        (0, type_2.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) {
+        (0, type_2.assertPostageBatchOptions)(options);
+        (0, type_2.assertPositiveInteger)(amount);
+        (0, type_2.assertNonNegativeInteger)(depth);
+        if (depth < types_1.STAMPS_DEPTH_MIN) {
+            throw new error_1.BeeArgumentError(`Depth has to be at least ${types_1.STAMPS_DEPTH_MIN}`, depth);
+        }
+        if (depth > types_1.STAMPS_DEPTH_MAX) {
+            throw new error_1.BeeArgumentError(`Depth has to be at most ${types_1.STAMPS_DEPTH_MAX}`, depth);
+        }
+        if (parseInt(amount, 10) < types_1.STAMPS_AMOUNT_MIN) {
+            throw new error_1.BeeArgumentError(`Amount has to be at least ${types_1.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) {
+        (0, type_2.assertRequestOptions)(options);
+        (0, type_2.assertNonNegativeInteger)(amount, 'Amount');
+        (0, type_2.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) {
+        (0, type_2.assertRequestOptions)(options);
+        (0, type_2.assertNonNegativeInteger)(depth, 'Depth');
+        (0, type_2.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) {
+        (0, type_2.assertRequestOptions)(options);
+        (0, type_2.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) {
+        (0, type_2.assertRequestOptions)(options);
+        (0, type_2.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) {
+        (0, type_2.assertRequestOptions)(options);
+        return stamps.getAllPostageBatches(this.getRequestOptionsForCall(options));
+    }
+    /**
+     * Return all globally available postage batches.
+     */
+    async getAllGlobalPostageBatch(options) {
+        (0, type_2.assertRequestOptions)(options);
+        return stamps.getGlobalPostageBatches(this.getRequestOptionsForCall(options));
+    }
+    /**
+     * Return lists of all current pending transactions that the Bee made
+     */
+    async getAllPendingTransactions(options) {
+        (0, type_2.assertRequestOptions)(options);
+        return transactions.getAllTransactions(this.getRequestOptionsForCall(options));
+    }
+    /**
+     * Return transaction information for specific transaction
+     * @param transactionHash
+     */
+    async getPendingTransaction(transactionHash, options) {
+        (0, type_2.assertRequestOptions)(options);
+        (0, type_2.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) {
+        (0, type_2.assertRequestOptions)(options);
+        (0, type_2.assertTransactionHash)(transactionHash);
+        return transactions.rebroadcastTransaction(this.getRequestOptionsForCall(options), transactionHash);
+    }
+    /**
+     * Cancel currently pending transaction
+     * @param transactionHash
+     * @param gasPrice
+     */
+    async cancelPendingTransaction(transactionHash, gasPrice, options) {
+        (0, type_2.assertRequestOptions)(options);
+        (0, type_2.assertTransactionHash)(transactionHash);
+        if (gasPrice) {
+            (0, type_2.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) {
+        (0, type_2.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) {
+        (0, type_2.assertRequestOptions)(options);
+        (0, type_2.assertTransactionOptions)(options);
+        await stake.stake(this.getRequestOptionsForCall(requestOptions), amount, options);
+    }
+    /**
+     * Get current status of node in redistribution game
+     *
+     * @param options
+     */
+    async getRedistributionState(options) {
+        (0, type_2.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 cafe_utility_1.System.sleepMillis(TIME_STEP);
+        }
+        throw new error_1.BeeError('Timeout on waiting for postage stamp to become usable');
+    }
     /**
      * @param signer
      * @private

package/dist/cjs/chunk/cac.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.assertValidChunkData = exports.isValidChunkData = exports.makeContentAddressedChunk = exports.MAX_PAYLOAD_SIZE = exports.MIN_PAYLOAD_SIZE = void 0;
+const cafe_utility_1 = require("cafe-utility");
+const bytes_1 = require("../utils/bytes");
 const error_1 = require("../utils/error");
 const bmt_1 = require("./bmt");
-const bytes_1 = require("../utils/bytes");
-const serialize_1 = require("./serialize");
 const span_1 = require("./span");
 exports.MIN_PAYLOAD_SIZE = 1;
 exports.MAX_PAYLOAD_SIZE = 4096;
@@ -18,7 +18,7 @@ const CAC_PAYLOAD_OFFSET = CAC_SPAN_OFFSET + span_1.SPAN_SIZE;
 function makeContentAddressedChunk(payloadBytes) {
     const span = (0, span_1.makeSpan)(payloadBytes.length);
     (0, bytes_1.assertFlexBytes)(payloadBytes, exports.MIN_PAYLOAD_SIZE, exports.MAX_PAYLOAD_SIZE);
-    const data = (0, serialize_1.serializeBytes)(span, payloadBytes);
+    const data = cafe_utility_1.Binary.concatBytes(span, payloadBytes);
     return {
         data,
         span: () => span,

package/dist/cjs/chunk/soc.js

@@ -24,6 +24,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.downloadSingleOwnerChunk = exports.uploadSingleOwnerChunkData = exports.uploadSingleOwnerChunk = exports.makeSingleOwnerChunk = exports.makeSOCAddress = exports.makeSingleOwnerChunkFromData = void 0;
+const cafe_utility_1 = require("cafe-utility");
 const chunkAPI = __importStar(require("../modules/chunk"));
 const socAPI = __importStar(require("../modules/soc"));
 const bytes_1 = require("../utils/bytes");
@@ -33,7 +34,6 @@ const hex_1 = require("../utils/hex");
 const type_1 = require("../utils/type");
 const bmt_1 = require("./bmt");
 const cac_1 = require("./cac");
-const serialize_1 = require("./serialize");
 const signer_1 = require("./signer");
 const span_1 = require("./span");
 const IDENTIFIER_SIZE = 32;
@@ -96,7 +96,7 @@ async function makeSingleOwnerChunk(chunk, identifier, signer) {
     (0, cac_1.assertValidChunkData)(chunk.data, chunkAddress);
     const digest = (0, hash_1.keccak256Hash)(identifier, chunkAddress);
     const signature = await (0, signer_1.sign)(signer, digest);
-    const data = (0, serialize_1.serializeBytes)(identifier, signature, chunk.span(), chunk.payload());
+    const data = cafe_utility_1.Binary.concatBytes(identifier, signature, chunk.span(), chunk.payload());
     const address = makeSOCAddress(identifier, signer.address);
     return {
         data,
@@ -114,7 +114,7 @@ exports.makeSingleOwnerChunk = makeSingleOwnerChunk;
  *
  * 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
@@ -123,14 +123,14 @@ async function uploadSingleOwnerChunk(requestOptions, chunk, postageBatchId, opt
     const owner = (0, hex_1.bytesToHex)(chunk.owner());
     const identifier = (0, hex_1.bytesToHex)(chunk.identifier());
     const signature = (0, hex_1.bytesToHex)(chunk.signature());
-    const data = (0, serialize_1.serializeBytes)(chunk.span(), chunk.payload());
+    const data = cafe_utility_1.Binary.concatBytes(chunk.span(), chunk.payload());
     return socAPI.upload(requestOptions, owner, identifier, signature, data, postageBatchId, options);
 }
 exports.uploadSingleOwnerChunk = uploadSingleOwnerChunk;
 /**
  * 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/cjs/chunk/span.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeSpan = exports.SPAN_SIZE = void 0;
+const cafe_utility_1 = require("cafe-utility");
 const error_1 = require("../utils/error");
 exports.SPAN_SIZE = 8;
 // we limit the maximum span size in 32 bits to avoid BigInt compatibility issues
@@ -19,11 +20,6 @@ function makeSpan(length) {
     if (length > MAX_SPAN_LENGTH) {
         throw new error_1.BeeArgumentError('invalid length (> MAX_SPAN_LENGTH)', length);
     }
-    const span = new Uint8Array(exports.SPAN_SIZE);
-    const dataView = new DataView(span.buffer);
-    const littleEndian = true;
-    const lengthLower32 = length & 0xffffffff;
-    dataView.setUint32(0, lengthLower32, littleEndian);
-    return span;
+    return cafe_utility_1.Binary.numberToUint64LE(length);
 }
 exports.makeSpan = makeSpan;