@upcoming/bee-js 9.4.1 → 9.7.0

package/dist/mjs/utils/bytes.js

@@ -67,4 +67,21 @@ export class Bytes {
   represent() {
     return this.toHex();
   }
+}
+export function parseSizeToBytes(sizeStr) {
+  const units = {
+    B: 1,
+    kB: 1000,
+    MB: 1000 ** 2,
+    GB: 1000 ** 3,
+    TB: 1000 ** 4,
+    PB: 1000 ** 5
+  };
+  const match = sizeStr.match(/^([\d.]+)\s*(B|kB|MB|GB|TB|PB)$/);
+  if (!match) {
+    throw new Error(`Invalid size format: ${sizeStr}`);
+  }
+  const value = parseFloat(match[1]);
+  const unit = match[2];
+  return Math.ceil(value * units[unit]);
 }

package/dist/mjs/utils/http.js

@@ -23,7 +23,7 @@ export const DEFAULT_HTTP_CONFIG = {
 export async function http(options, config) {
   const requestConfig = Objects.deepMerge3(DEFAULT_HTTP_CONFIG, config, options);
   if (requestConfig.data && typeof Buffer !== 'undefined' && Buffer.isBuffer(requestConfig.data)) {
-    requestConfig.data = requestConfig.data.buffer;
+    requestConfig.data = requestConfig.data.buffer.slice(requestConfig.data.byteOffset, requestConfig.data.byteOffset + requestConfig.data.byteLength);
   }
   if (requestConfig.params) {
     const keys = Object.keys(requestConfig.params);
@@ -59,7 +59,7 @@ function maybeRunOnRequestHook(options, requestConfig) {
   if (options.onRequest) {
     options.onRequest({
       method: requestConfig.method || 'GET',
-      url: Strings.joinUrl(requestConfig.baseURL, requestConfig.url),
+      url: Strings.joinUrl([requestConfig.baseURL, requestConfig.url]),
       headers: {
         ...requestConfig.headers
       },

package/dist/mjs/utils/stamps.js

@@ -1,5 +1,6 @@
 import { Binary } from 'cafe-utility';
-import { Bytes } from "./bytes.js";
+import { capacityBreakpoints } from "../types/index.js";
+import { Bytes, parseSizeToBytes } from "./bytes.js";
 import { Duration } from "./duration.js";
 import { BZZ } from "./tokens.js";
 import { asNumberString } from "./type.js";
@@ -37,24 +38,33 @@ const effectiveSizeBreakpoints = [[17, 0.00004089], [18, 0.00609], [19, 0.10249]
  *
  * @returns {number} The effective size of the postage batch in bytes.
  */
-export function getStampEffectiveBytes(depth) {
+export function getStampEffectiveBytes(depth, encryption, erasureCodeLevel) {
   if (depth < 17) {
     return 0;
   }
-  const breakpoint = effectiveSizeBreakpoints.find(([d, size]) => {
-    if (depth === d) {
-      return size;
+  if (encryption !== undefined && erasureCodeLevel !== undefined) {
+    const encryptionKey = encryption ? 'ENCRYPTION_ON' : 'ENCRYPTION_OFF';
+    const breakpoints = capacityBreakpoints[encryptionKey][erasureCodeLevel];
+    const entry = breakpoints.find(item => item.batchDepth === depth);
+    if (entry?.effectiveVolume) {
+      return parseSizeToBytes(entry.effectiveVolume);
+    }
+  } else {
+    const breakpoint = effectiveSizeBreakpoints.find(([d, size]) => {
+      if (depth === d) {
+        return size;
+      }
+    });
+    if (breakpoint) {
+      return breakpoint[1] * 1000 * 1000 * 1000;
     }
-  });
-  if (breakpoint) {
-    return breakpoint[1] * 1000 * 1000 * 1000;
   }
   return Math.ceil(getStampTheoreticalBytes(depth) * MAX_UTILIZATION);
 }
-export function getStampEffectiveBytesBreakpoints() {
+export function getStampEffectiveBytesBreakpoints(encryption, erasureCodeLevel) {
   const map = new Map();
   for (let i = 17; i < 35; i++) {
-    map.set(i, getStampEffectiveBytes(i));
+    map.set(i, getStampEffectiveBytes(i, encryption, erasureCodeLevel));
   }
   return map;
 }
@@ -91,10 +101,21 @@ export function getAmountForDuration(duration, pricePerBlock, blockTime) {
  * @param size The effective size of the postage batch
  * @returns
  */
-export function getDepthForSize(size) {
-  for (const [depth, sizeBreakpoint] of effectiveSizeBreakpoints) {
-    if (size.toBytes() <= sizeBreakpoint * 1000 * 1000 * 1000) {
-      return depth;
+export function getDepthForSize(size, encryption, erasureCodeLevel) {
+  if (encryption !== undefined && erasureCodeLevel !== undefined) {
+    const encryptionKey = encryption ? 'ENCRYPTION_ON' : 'ENCRYPTION_OFF';
+    const breakpoints = capacityBreakpoints[encryptionKey][erasureCodeLevel];
+    const entry = breakpoints.find(item => {
+      return size.toBytes() <= parseSizeToBytes(item.effectiveVolume);
+    });
+    if (entry?.effectiveVolume) {
+      return entry.batchDepth;
+    }
+  } else {
+    for (const [depth, sizeBreakpoint] of effectiveSizeBreakpoints) {
+      if (size.toBytes() <= sizeBreakpoint * 1000 * 1000 * 1000) {
+        return depth;
+      }
     }
   }
   return 35;

package/dist/types/bee.d.ts

@@ -2,12 +2,12 @@
 import { Readable } from 'stream';
 import { Chunk } from './chunk/cac';
 import { FeedPayloadResult } from './modules/feed';
-import type { AllSettlements, BalanceResponse, BeeOptions, BeeRequestOptions, BeeVersions, ChainState, ChequebookAddressResponse, ChequebookBalanceResponse, CollectionUploadOptions, DebugStatus, DownloadOptions, EnvelopeWithBatchId, FeedReader, FeedWriter, FileData, FileUploadOptions, GetGranteesResult, GlobalPostageBatch, GranteesResult, GsocMessageHandler, GsocSubscription, Health, LastCashoutActionResponse, LastChequesForPeerResponse, LastChequesResponse, NodeAddresses, NodeInfo, NumberString, Peer, PeerBalance, Pin, PingResponse, PostageBatch, PostageBatchBuckets, PssMessageHandler, PssSubscription, Readiness, RedistributionState, RedundantUploadOptions, ReferenceInformation, RemovePeerResponse, ReserveState, SOCReader, SOCWriter, Settlements, Tag, Topology, TransactionInfo, UploadOptions, WalletBalance } from './types';
+import type { AllSettlements, BalanceResponse, BeeOptions, BeeRequestOptions, BeeVersions, ChainState, ChequebookAddressResponse, ChequebookBalanceResponse, CollectionUploadOptions, DebugStatus, DownloadOptions, EnvelopeWithBatchId, FeedReader, FeedWriter, FileData, FileUploadOptions, GetGranteesResult, GlobalPostageBatch, GranteesResult, GsocMessageHandler, GsocSubscription, Health, LastCashoutActionResponse, LastChequesForPeerResponse, LastChequesResponse, NodeAddresses, NodeInfo, NumberString, Peer, PeerBalance, Pin, PingResponse, PostageBatch, PostageBatchBuckets, PssMessageHandler, PssSubscription, Readiness, RedistributionState, RedundancyLevel, RedundantUploadOptions, ReferenceInformation, RemovePeerResponse, ReserveState, SOCReader, SOCWriter, Settlements, Tag, Topology, TransactionInfo, UploadOptions, WalletBalance } from './types';
 import { AllTagsOptions, Collection, PostageBatchOptions, TransactionOptions, UploadResult } from './types';
 import { Bytes } from './utils/bytes';
 import { Duration } from './utils/duration';
 import { Size } from './utils/size';
-import { BZZ } from './utils/tokens';
+import { BZZ, DAI } from './utils/tokens';
 import { BatchId, EthAddress, FeedIndex, Identifier, PeerAddress, PrivateKey, PublicKey, Reference, Topic, TransactionId } from './utils/typed-bytes';
 import { UploadProgress } from './utils/upload-progress';
 /**
@@ -497,6 +497,15 @@ export declare class Bee {
      * @returns true if successful, false on error
      */
     isConnected(options?: BeeRequestOptions): Promise<boolean>;
+    /**
+     * Checks the `/gateway` endpoint to see if the remote API is a gateway.
+     *
+     * Do note that this is not a standard way to check for gateway nodes,
+     * but some of the gateway tooling expose this endpoint.
+     *
+     * @param options
+     */
+    isGateway(options?: BeeRequestOptions): Promise<boolean>;
     getNodeAddresses(options?: BeeRequestOptions): Promise<NodeAddresses>;
     getBlocklist(options?: BeeRequestOptions): Promise<Peer[]>;
     /**
@@ -563,21 +572,41 @@ export declare class Bee {
      */
     cashoutLastCheque(address: PeerAddress | string, options?: TransactionOptions, requestOptions?: BeeRequestOptions): Promise<TransactionId>;
     /**
-     * Deposit tokens from overlay address into chequebook
+     * Deposit tokens from node wallet 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
+     * @deprecated Use `depositBZZToChequebook` instead.
      */
     depositTokens(amount: BZZ | NumberString | string | bigint, gasPrice?: NumberString | string | bigint, options?: BeeRequestOptions): Promise<TransactionId>;
     /**
-     * Withdraw tokens from the chequebook to the overlay address
+     * Deposit tokens from node wallet 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
+     */
+    depositBZZToChequebook(amount: BZZ | NumberString | string | bigint, gasPrice?: NumberString | string | bigint, options?: BeeRequestOptions): Promise<TransactionId>;
+    /**
+     * Withdraw tokens from the chequebook to the node wallet
      *
      * @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
+     * @deprecated Use `withdrawBZZFromChequebook` instead.
      */
     withdrawTokens(amount: BZZ | NumberString | string | bigint, gasPrice?: NumberString | string | bigint, options?: BeeRequestOptions): Promise<TransactionId>;
+    /**
+     * Withdraw tokens from the chequebook to the node wallet
+     *
+     * @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
+     */
+    withdrawBZZFromChequebook(amount: BZZ | NumberString | string | bigint, gasPrice?: NumberString | string | bigint, options?: BeeRequestOptions): Promise<TransactionId>;
+    withdrawBZZToExternalWallet(amount: BZZ | NumberString | string | bigint, address: EthAddress | Uint8Array | string, options?: BeeRequestOptions): Promise<TransactionId>;
+    withdrawDAIToExternalWallet(amount: DAI | NumberString | string | bigint, address: EthAddress | Uint8Array | string, options?: BeeRequestOptions): Promise<TransactionId>;
     /**
      * Get amount of sent and received from settlements with a peer
      *
@@ -635,7 +664,7 @@ export declare class Bee {
      */
     getChainState(options?: BeeRequestOptions): Promise<ChainState>;
     /**
-     * Get wallet balances for xDai and BZZ of the Bee node
+     * Get wallet balances for DAI and BZZ of the Bee node
      *
      * @param options
      */
@@ -658,12 +687,12 @@ export declare class Bee {
      * @see [Bee Debug API reference - `POST /stamps`](https://docs.ethswarm.org/api/#tag/Postage-Stamps/paths/~1stamps~1{amount}~1{depth}/post)
      */
     createPostageBatch(amount: NumberString | string | bigint, depth: number, options?: PostageBatchOptions, requestOptions?: BeeRequestOptions): Promise<BatchId>;
-    buyStorage(size: Size, duration: Duration, options?: PostageBatchOptions, requestOptions?: BeeRequestOptions): Promise<BatchId>;
-    getStorageCost(size: Size, duration: Duration, options?: BeeRequestOptions): Promise<BZZ>;
-    extendStorageSize(postageBatchId: BatchId | Uint8Array | string, size: Size, options?: BeeRequestOptions): Promise<BatchId>;
+    buyStorage(size: Size, duration: Duration, options?: PostageBatchOptions, requestOptions?: BeeRequestOptions, encryption?: boolean, erasureCodeLevel?: RedundancyLevel): Promise<BatchId>;
+    getStorageCost(size: Size, duration: Duration, options?: BeeRequestOptions, encryption?: boolean, erasureCodeLevel?: RedundancyLevel): Promise<BZZ>;
+    extendStorageSize(postageBatchId: BatchId | Uint8Array | string, size: Size, options?: BeeRequestOptions, encryption?: boolean, erasureCodeLevel?: RedundancyLevel): Promise<BatchId>;
     extendStorageDuration(postageBatchId: BatchId | Uint8Array | string, duration: Duration, options?: BeeRequestOptions): Promise<BatchId>;
-    getExtensionCost(postageBatchId: BatchId | Uint8Array | string, size: Size, duration: Duration, options?: BeeRequestOptions): Promise<BZZ>;
-    getSizeExtensionCost(postageBatchId: BatchId | Uint8Array | string, size: Size, options?: BeeRequestOptions): Promise<BZZ>;
+    getExtensionCost(postageBatchId: BatchId | Uint8Array | string, size: Size, duration: Duration, options?: BeeRequestOptions, encryption?: boolean, erasureCodeLevel?: RedundancyLevel): Promise<BZZ>;
+    getSizeExtensionCost(postageBatchId: BatchId | Uint8Array | string, size: Size, options?: BeeRequestOptions, encryption?: boolean, erasureCodeLevel?: RedundancyLevel): Promise<BZZ>;
     getDurationExtensionCost(postageBatchId: BatchId | Uint8Array | string, duration: Duration, options?: BeeRequestOptions): Promise<BZZ>;
     /**
      * Topup a fresh amount of BZZ to given Postage Batch.
@@ -753,30 +782,52 @@ export declare class Bee {
      */
     rebroadcastPendingTransaction(transactionHash: TransactionId | Uint8Array | string, options?: BeeRequestOptions): Promise<TransactionId>;
     /**
-     * Cancel currently pending transaction
+     * Cancels a currently pending transaction
      * @param transactionHash
      * @param gasPrice
      */
     cancelPendingTransaction(transactionHash: TransactionId | Uint8Array | string, gasPrice?: NumberString | string | bigint, options?: BeeRequestOptions): Promise<TransactionId>;
     /**
-     * Gets the staked amount of BZZ (in PLUR unit) as number string.
+     * Gets the amount of staked BZZ
      *
-     * @param options
+     * @param options HTTP request options, such as `headers` or `timeout`
      */
     getStake(options?: BeeRequestOptions): Promise<BZZ>;
     /**
-     * Deposits given amount of BZZ token (in PLUR unit).
+     * Gets the amount of withdrawable staked BZZ.
+     *
+     * @param options HTTP request options, such as `headers` or `timeout`
+     */
+    getWithdrawableStake(options?: BeeRequestOptions): Promise<BZZ>;
+    /**
+     * Withdraws ALL surplus staked BZZ to the node wallet.
+     *
+     * Use the `getWithdrawableStake` method to check how much surplus stake is available.
+     *
+     * @param options HTTP request options, such as `headers` or `timeout`
+     */
+    withdrawSurplusStake(options?: BeeRequestOptions): Promise<TransactionId>;
+    /**
+     * Withdraws all staked BZZ to the node wallet.
+     *
+     * **Only available when the staking contract is paused and is in the process of being migrated to a new contract!**
+     *
+     * @param options HTTP request options, such as `headers` or `timeout`
+     */
+    migrateStake(options?: BeeRequestOptions): Promise<TransactionId>;
+    /**
+     * Stakes the given amount of BZZ. Initial deposit must be at least 10 BZZ.
      *
      * 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
+     * @param amount Amount of BZZ tokens to be staked. If not providing a `BZZ` instance, the amount is denoted in PLUR.
+     * @param options HTTP request options, such as `headers` or `timeout`
      */
     depositStake(amount: BZZ | NumberString | string | bigint, options?: TransactionOptions, requestOptions?: BeeRequestOptions): Promise<TransactionId>;
     /**
-     * Get current status of node in redistribution game
+     * Gets current status of node in redistribution game
      *
-     * @param options
+     * @param options HTTP request options, such as `headers` or `timeout`
      */
     getRedistributionState(options?: BeeRequestOptions): Promise<RedistributionState>;
     private waitForUsablePostageStamp;

package/dist/types/manifest/manifest.d.ts

@@ -9,7 +9,7 @@ export declare class Fork {
     constructor(prefix: Uint8Array, node: MantarayNode);
     static split(a: Fork, b: Fork): Fork;
     marshal(): Uint8Array;
-    static unmarshal(reader: Uint8ArrayReader): Fork;
+    static unmarshal(reader: Uint8ArrayReader, addressLength: number): Fork;
 }
 interface MantarayNodeOptions {
     selfAddress?: Uint8Array;

package/dist/types/modules/debug/stake.d.ts

@@ -2,17 +2,24 @@ import { BeeRequestOptions, NumberString, RedistributionState, TransactionOption
 import { BZZ } from '../../utils/tokens';
 import { TransactionId } from '../../utils/typed-bytes';
 /**
- * Gets the staked amount
+ * Gets the amount of staked BZZ
  *
  * @param requestOptions Options for making requests
  */
 export declare function getStake(requestOptions: BeeRequestOptions): Promise<BZZ>;
+/**
+ * Gets the amount of withdrawable staked BZZ
+ *
+ * @param requestOptions Options for making requests
+ */
+export declare function getWithdrawableStake(requestOptions: BeeRequestOptions): Promise<BZZ>;
+export declare function withdrawSurplusStake(requestOptions: BeeRequestOptions): Promise<TransactionId>;
+export declare function migrateStake(requestOptions: BeeRequestOptions): Promise<TransactionId>;
 /**
  * Stake given amount of tokens.
  *
  * @param requestOptions Options for making requests
  * @param amount
- * @param options
  */
 export declare function stake(requestOptions: BeeRequestOptions, amount: NumberString | string | bigint, options?: TransactionOptions): Promise<TransactionId>;
 /**

package/dist/types/modules/debug/states.d.ts

@@ -1,4 +1,6 @@
 import { BeeRequestOptions, ChainState, ReserveState, WalletBalance } from '../../types';
+import { BZZ, DAI } from '../../utils/tokens';
+import { EthAddress, TransactionId } from '../../utils/typed-bytes';
 /**
  * Get state of reserve
  *
@@ -17,3 +19,5 @@ export declare function getChainState(requestOptions: BeeRequestOptions): Promis
  * @param requestOptions Options for making requests
  */
 export declare function getWalletBalance(requestOptions: BeeRequestOptions): Promise<WalletBalance>;
+export declare function withdrawBZZ(requestOptions: BeeRequestOptions, amount: BZZ, address: EthAddress): Promise<TransactionId>;
+export declare function withdrawDAI(requestOptions: BeeRequestOptions, amount: DAI, address: EthAddress): Promise<TransactionId>;

package/dist/types/modules/debug/status.d.ts

@@ -1,9 +1,9 @@
 import { BeeRequestOptions } from '../../index';
 import type { DebugStatus, Health, NodeInfo, Readiness } from '../../types/debug';
 import { BeeVersions } from '../../types/debug';
-export declare const SUPPORTED_BEE_VERSION_EXACT = "2.4.0-390a402e";
+export declare const SUPPORTED_BEE_VERSION_EXACT = "2.6.0-d0aa8b93";
 export declare const SUPPORTED_BEE_VERSION: string;
-export declare const SUPPORTED_API_VERSION = "7.2.0";
+export declare const SUPPORTED_API_VERSION = "7.3.0";
 export declare function getDebugStatus(requestOptions: BeeRequestOptions): Promise<DebugStatus>;
 /**
  * Get health of node

package/dist/types/modules/status.d.ts

@@ -5,3 +5,4 @@ import { BeeRequestOptions } from '../index';
  * @param requestOptions Options for making requests
  */
 export declare function checkConnection(requestOptions: BeeRequestOptions): Promise<void> | never;
+export declare function isGateway(requestOptions: BeeRequestOptions): Promise<boolean>;

package/dist/types/types/debug.d.ts

@@ -88,6 +88,7 @@ export interface DebugStatus {
     isReachable: boolean;
     lastSyncedBlock: number;
     committedDepth: number;
+    isWarmingUp: boolean;
 }
 export interface Health {
     status: 'ok';

package/dist/types/types/index.d.ts

@@ -484,3 +484,69 @@ export interface EnvelopeWithBatchId extends Envelope {
 export type NumberString = string & {
     __numberString: never;
 };
+export declare const capacityBreakpoints: {
+    ENCRYPTION_OFF: {
+        0: {
+            theoreticalVolume: string;
+            effectiveVolume: string;
+            batchDepth: number;
+            utilizationRate: string;
+        }[];
+        1: {
+            theoreticalVolume: string;
+            effectiveVolume: string;
+            batchDepth: number;
+            utilizationRate: string;
+        }[];
+        2: {
+            theoreticalVolume: string;
+            effectiveVolume: string;
+            batchDepth: number;
+            utilizationRate: string;
+        }[];
+        3: {
+            theoreticalVolume: string;
+            effectiveVolume: string;
+            batchDepth: number;
+            utilizationRate: string;
+        }[];
+        4: {
+            theoreticalVolume: string;
+            effectiveVolume: string;
+            batchDepth: number;
+            utilizationRate: string;
+        }[];
+    };
+    ENCRYPTION_ON: {
+        0: {
+            theoreticalVolume: string;
+            effectiveVolume: string;
+            batchDepth: number;
+            utilizationRate: string;
+        }[];
+        1: {
+            theoreticalVolume: string;
+            effectiveVolume: string;
+            batchDepth: number;
+            utilizationRate: string;
+        }[];
+        2: {
+            theoreticalVolume: string;
+            effectiveVolume: string;
+            batchDepth: number;
+            utilizationRate: string;
+        }[];
+        3: {
+            theoreticalVolume: string;
+            effectiveVolume: string;
+            batchDepth: number;
+            utilizationRate: string;
+        }[];
+        4: {
+            theoreticalVolume: string;
+            effectiveVolume: string;
+            batchDepth: number;
+            utilizationRate: string;
+        }[];
+    };
+};

package/dist/types/utils/bytes.d.ts

@@ -16,3 +16,4 @@ export declare class Bytes {
     equals(other: Bytes | Uint8Array | string): boolean;
     represent(): string;
 }
+export declare function parseSizeToBytes(sizeStr: string): number;

package/dist/types/utils/stamps.d.ts

@@ -1,4 +1,4 @@
-import { EnvelopeWithBatchId, NumberString } from '../types';
+import { EnvelopeWithBatchId, NumberString, RedundancyLevel } from '../types';
 import { Bytes } from './bytes';
 import { Duration } from './duration';
 import { Size } from './size';
@@ -27,8 +27,8 @@ export declare function getStampTheoreticalBytes(depth: number): number;
  *
  * @returns {number} The effective size of the postage batch in bytes.
  */
-export declare function getStampEffectiveBytes(depth: number): number;
-export declare function getStampEffectiveBytesBreakpoints(): Map<number, number>;
+export declare function getStampEffectiveBytes(depth: number, encryption?: boolean, erasureCodeLevel?: RedundancyLevel): number;
+export declare function getStampEffectiveBytesBreakpoints(encryption: boolean, erasureCodeLevel?: RedundancyLevel): Map<number, number>;
 /**
  * Utility function that calculates the cost of a postage batch based on its depth and amount.
  */
@@ -55,6 +55,6 @@ export declare function getAmountForDuration(duration: Duration, pricePerBlock:
  * @param size The effective size of the postage batch
  * @returns
  */
-export declare function getDepthForSize(size: Size): number;
+export declare function getDepthForSize(size: Size, encryption?: boolean, erasureCodeLevel?: RedundancyLevel): number;
 export declare function convertEnvelopeToMarshaledStamp(envelope: EnvelopeWithBatchId): Bytes;
 export declare function marshalStamp(signature: Uint8Array, batchId: Uint8Array, timestamp: Uint8Array, index: Uint8Array): Bytes;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@upcoming/bee-js",
-  "version": "9.4.1",
+  "version": "9.7.0",
   "description": "Javascript client for Bee",
   "keywords": [
     "bee",
@@ -55,14 +55,14 @@
     "build:node": "tsc -p tsconfig.json && tsc -p tsconfig-mjs.json && ./build-fixup && babel --plugins \"babel-plugin-add-import-extension\" --out-dir dist/mjs/ dist/mjs/",
     "build:types": "tsc --emitDeclarationOnly --declaration --outDir dist/types",
     "build:browser": "webpack --progress",
-    "test": "jest --config=jest.config.ts --runInBand --verbose",
+    "test": "jest --config=jest.config.ts --runInBand --verbose --forceExit",
     "check": "tsc --project tsconfig.test.json",
     "lint": "eslint \"src/**/*.ts\" \"test/**/*.ts\" && prettier --check \"src/**/*.ts\" \"test/**/*.ts\"",
     "depcheck": "depcheck ."
   },
   "dependencies": {
     "axios": "^0.30.0",
-    "cafe-utility": "^28.1.0",
+    "cafe-utility": "^31.0.0",
     "isomorphic-ws": "^4.0.1",
     "semver": "^7.3.5",
     "ws": "^8.7.0"