@upcoming/bee-js 10.1.2 → 12.0.0

package/dist/mjs/utils/http.js

@@ -10,6 +10,7 @@ const MAX_FAILED_ATTEMPTS = 100000;
 const DELAY_FAST = 200;
 const DELAY_SLOW = 1000;
 const DELAY_THRESHOLD = Dates.minutes(1) / DELAY_FAST;
+const ABORT_ERROR_MESSAGE = 'Request aborted';
 export const DEFAULT_HTTP_CONFIG = {
   headers: {
     accept: 'application/json, text/plain, */*'
@@ -17,6 +18,11 @@ export const DEFAULT_HTTP_CONFIG = {
   maxBodyLength: Infinity,
   maxContentLength: Infinity
 };
+function throwIfAborted(signal, config, responseData, responseStatus) {
+  if (signal?.aborted) {
+    throw new BeeResponseError(config.method || 'get', config.url || '<unknown>', ABORT_ERROR_MESSAGE, responseData, responseStatus, 'ERR_CANCELED');
+  }
+}
 /**
  * Main function to make HTTP requests.
  * @param options User defined settings
@@ -24,9 +30,11 @@ 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.slice(requestConfig.data.byteOffset, requestConfig.data.byteOffset + requestConfig.data.byteLength);
+  if (options.signal) {
+    requestConfig.signal = options.signal;
+    throwIfAborted(options.signal, config);
   }
+  maybeReplaceBodyBuffers(requestConfig);
   if (requestConfig.params) {
     const keys = Object.keys(requestConfig.params);
     for (const key of keys) {
@@ -38,6 +46,7 @@ export async function http(options, config) {
   }
   let failedAttempts = 0;
   while (failedAttempts < MAX_FAILED_ATTEMPTS) {
+    throwIfAborted(options.signal, config);
     try {
       debug(`${requestConfig.method || 'get'} ${Strings.joinUrl([requestConfig.baseURL, requestConfig.url])}`, {
         headers: {
@@ -50,11 +59,16 @@ export async function http(options, config) {
       return response;
     } catch (e) {
       if (e instanceof AxiosError) {
+        if (e.code === 'ERR_CANCELED') {
+          throwIfAborted({
+            aborted: true
+          }, config, e.response?.data, e.response?.status);
+        }
         if (e.code === 'ECONNABORTED' && options.endlesslyRetry) {
           failedAttempts++;
           await System.sleepMillis(failedAttempts < DELAY_THRESHOLD ? DELAY_FAST : DELAY_SLOW);
         } else {
-          throw new BeeResponseError(config.method || 'get', config.url || '<unknown>', e.message, e.response?.data, e.response?.status, e.code);
+          throw new BeeResponseError(config.method || 'get', config.url || '<unknown>', e.message, e.response?.data, e.response?.status, e.response?.statusText);
         }
       } else {
         throw e;
@@ -74,4 +88,12 @@ function maybeRunOnRequestHook(options, requestConfig) {
       params: requestConfig.params
     });
   }
+}
+function maybeReplaceBodyBuffers(config) {
+  if (config.data && config.data instanceof Uint8Array) {
+    config.data = config.data.buffer.slice(config.data.byteOffset, config.data.byteOffset + config.data.byteLength);
+  }
+  if (config.data && typeof Buffer !== 'undefined' && Buffer.isBuffer(config.data)) {
+    config.data = config.data.buffer.slice(config.data.byteOffset, config.data.byteOffset + config.data.byteLength);
+  }
 }

package/dist/mjs/utils/stamps.js

@@ -2,8 +2,11 @@ import { Binary } from 'cafe-utility';
 import { capacityBreakpoints } from "../types/index.js";
 import { Bytes, parseSizeToBytes } from "./bytes.js";
 import { Duration } from "./duration.js";
+import { Size } from "./size.js";
 import { BZZ } from "./tokens.js";
 import { asNumberString } from "./type.js";
+import { BatchId } from "./typed-bytes.js";
+import { normalizeBatchTTL } from "./workaround.js";
 const MAX_UTILIZATION = 0.9;
 /**
  * Utility function that calculates usage of postage batch based on its utilization, depth and bucket depth.
@@ -137,4 +140,49 @@ export function marshalStamp(signature, batchId, timestamp, index) {
     throw Error('invalid index length');
   }
   return new Bytes(Binary.concatBytes(batchId, index, timestamp, signature));
+}
+export function mapPostageBatch(raw, encryption, erasureCodeLevel) {
+  const usage = getStampUsage(raw.utilization, raw.depth, raw.bucketDepth);
+  const batchTTL = normalizeBatchTTL(raw.batchTTL);
+  const duration = Duration.fromSeconds(batchTTL);
+  const effectiveBytes = getStampEffectiveBytes(raw.depth, encryption, erasureCodeLevel);
+  return {
+    batchID: new BatchId(raw.batchID),
+    utilization: raw.utilization,
+    usable: raw.usable,
+    label: raw.label,
+    depth: raw.depth,
+    amount: asNumberString(raw.amount),
+    bucketDepth: raw.bucketDepth,
+    blockNumber: raw.blockNumber,
+    immutableFlag: raw.immutableFlag,
+    usage,
+    usageText: `${Math.round(usage * 100)}%`,
+    size: Size.fromBytes(effectiveBytes),
+    remainingSize: Size.fromBytes(Math.ceil(effectiveBytes * (1 - usage))),
+    theoreticalSize: Size.fromBytes(getStampTheoreticalBytes(raw.depth)),
+    duration,
+    calculateSize(encryption, redundancyLevel) {
+      const effectiveBytes = getStampEffectiveBytes(raw.depth, encryption, redundancyLevel);
+      return Size.fromBytes(effectiveBytes);
+    },
+    calculateRemainingSize(encryption, redundancyLevel) {
+      const effectiveBytes = getStampEffectiveBytes(raw.depth, encryption, redundancyLevel);
+      return Size.fromBytes(Math.ceil(effectiveBytes * (1 - this.usage)));
+    }
+  };
+}
+export function unmapPostageBatch(batch) {
+  return {
+    batchID: batch.batchID.toHex(),
+    utilization: batch.utilization,
+    usable: batch.usable,
+    label: batch.label,
+    depth: batch.depth,
+    amount: batch.amount,
+    bucketDepth: batch.bucketDepth,
+    blockNumber: batch.blockNumber,
+    immutableFlag: batch.immutableFlag,
+    batchTTL: batch.duration.toSeconds()
+  };
 }

package/dist/mjs/utils/type.js

@@ -34,7 +34,8 @@ export function prepareBeeRequestOptions(value) {
     httpsAgent: object.httpsAgent,
     endlesslyRetry: Types.asOptional(x => Types.asBoolean(x, {
       name: 'endlesslyRetry'
-    }), object.endlesslyRetry)
+    }), object.endlesslyRetry),
+    signal: object.signal
   };
 }
 export function prepareDownloadOptions(value) {

package/dist/mjs/utils/workaround.js

@@ -6,8 +6,11 @@ export function normalizeBatchTTL(batchTTL) {
   if (batchTTL < 1) {
     return 1;
   }
-  if (batchTTL > 315569260) {
-    return 315569260;
+  // Cap `batchTTL` (represents seconds) to 100 years.
+  // We can assume `storagePrice` is invalid (e.g. 1).
+  // This is needed to prevent Date objects breaking.
+  if (batchTTL > 3155695200) {
+    return 3155695200;
   }
   return batchTTL;
 }

package/dist/types/bee.d.ts

@@ -1,6 +1,6 @@
-/// <reference types="node" />
 import { Readable } from 'stream';
 import { Chunk } from './chunk/cac';
+import { SingleOwnerChunk } from './chunk/soc';
 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, RedundancyLevel, RedundantUploadOptions, ReferenceInformation, RemovePeerResponse, ReserveState, SOCReader, SOCWriter, Settlements, Tag, Topology, TransactionInfo, UploadOptions, WalletBalance } from './types';
 import { AllTagsOptions, Collection, PostageBatchOptions, TransactionOptions, UploadResult } from './types';
@@ -8,7 +8,7 @@ import { Bytes } from './utils/bytes';
 import { Duration } from './utils/duration';
 import { Size } from './utils/size';
 import { BZZ, DAI } from './utils/tokens';
-import { BatchId, EthAddress, FeedIndex, Identifier, PeerAddress, PrivateKey, PublicKey, Reference, Topic, TransactionId } from './utils/typed-bytes';
+import { BatchId, EthAddress, FeedIndex, Identifier, PeerAddress, PrivateKey, PublicKey, Reference, Span, Topic, TransactionId } from './utils/typed-bytes';
 import { UploadProgress } from './utils/upload-progress';
 /**
  * The main component that abstracts operations available on the Bee API.
@@ -123,7 +123,7 @@ export declare class Bee {
      * Chunks uploaded with this method should be retrieved with the {@link downloadChunk} method.
      *
      * @param stamp Postage Batch ID or an Envelope created with the {@link createEnvelope} method.
-     * @param data    Raw chunk to be uploaded
+     * @param data    Raw chunk to be uploaded (Content Addressed Chunk or Single Owner Chunk)
      * @param options Additional options like tag, encryption, pinning, content-type and request options
      * @param requestOptions Options for making requests, such as timeouts, custom HTTP agents, headers, etc.
      *
@@ -131,7 +131,7 @@ export declare class Bee {
      * @see [Bee docs - Upload and download](https://docs.ethswarm.org/docs/develop/access-the-swarm/upload-and-download)
      * @see [Bee API reference - `POST /chunks`](https://docs.ethswarm.org/api/#tag/Chunk/paths/~1chunks/post)
      */
-    uploadChunk(stamp: EnvelopeWithBatchId | BatchId | Uint8Array | string, data: Uint8Array | Chunk, options?: UploadOptions, requestOptions?: BeeRequestOptions): Promise<UploadResult>;
+    uploadChunk(stamp: EnvelopeWithBatchId | BatchId | Uint8Array | string, data: Uint8Array | Chunk | SingleOwnerChunk, options?: UploadOptions, requestOptions?: BeeRequestOptions): Promise<UploadResult>;
     /**
      * Downloads a chunk as a `Uint8Array`.
      *
@@ -608,6 +608,57 @@ export declare class Bee {
      */
     makeFeedWriter(topic: Topic | Uint8Array | string, signer?: PrivateKey | Uint8Array | string, requestOptions?: BeeRequestOptions): FeedWriter;
     fetchLatestFeedUpdate(topic: Topic | Uint8Array | string, owner: EthAddress | Uint8Array | string, requestOptions?: BeeRequestOptions): Promise<FeedPayloadResult>;
+    /**
+     * Creates a Content Addressed Chunk.
+     *
+     * To be uploaded with the {@link uploadChunk} method.
+     *
+     * Payload size must be between 1 and 4096 bytes.
+     *
+     * @param rawPayload Data to be stored in the chunk. If the data is a string, it will be converted to UTF-8 bytes.
+     * @param span       Optional span for the chunk. If not provided, it will be set to the length of the payload.
+     */
+    makeContentAddressedChunk(rawPayload: Bytes | Uint8Array | string, span?: Span | bigint): Chunk;
+    /**
+     * Attempts to unmarshal arbitrary data into a Content Addressed Chunk.
+     * Throws an error if the data is not a valid CAC.
+     *
+     * @param data The chunk data (`span` and `payload`)
+     */
+    unmarshalContentAddressedChunk(data: Bytes | Uint8Array): Chunk;
+    /**
+     * Creates a Single Owner Chunk.
+     *
+     * To be uploaded with the {@link uploadChunk} method.
+     *
+     * Identical to chaining `makeContentAddressedChunk` and `toSingleOwnerChunk`.
+     *
+     * Payload size must be between 1 and 4096 bytes.
+     *
+     * @param address     Address of the Content Addressed Chunk
+     * @param span        Span of the Content Addressed Chunk
+     * @param payload     Payload of the Content Addressed Chunk
+     * @param identifier  The identifier of the chunk
+     * @param signer      The signer interface for signing the chunk
+     */
+    makeSingleOwnerChunk(address: Reference, span: Span, payload: Bytes, identifier: Identifier | Uint8Array | string, signer: PrivateKey | Uint8Array | string): SingleOwnerChunk;
+    /**
+     * Calculates the address of a Single Owner Chunk based on its identifier and owner address.
+     *
+     * @param identifier
+     * @param address
+     */
+    calculateSingleOwnerChunkAddress(identifier: Identifier, address: EthAddress): Reference;
+    /**
+     * Attempts to unmarshal arbitrary data into a Single Owner Chunk.
+     * Throws an error if the data is not a valid SOC.
+     *
+     * @param data    The chunk data
+     * @param address The address of the single owner chunk
+     *
+     * @returns a single owner chunk or throws error
+     */
+    unmarshalSingleOwnerChunk(data: Bytes | Uint8Array, address: Reference | Uint8Array | string): SingleOwnerChunk;
     /**
      * Returns an object for reading single owner chunks
      *
@@ -1103,6 +1154,18 @@ export declare class Bee {
      * @returns
      */
     getDurationExtensionCost(postageBatchId: BatchId | Uint8Array | string, duration: Duration, requestOptions?: BeeRequestOptions): Promise<BZZ>;
+    /**
+     * Calculates the `amount` and expected duration extension for topping up a postage batch with a given BZZ value.
+     *
+     * @param postageBatchId
+     * @param bzz The amount of BZZ to spend on the top-up.
+     * @param requestOptions Options for making requests, such as timeouts, custom HTTP agents, headers, etc.
+     * @returns An object with `amount` (to pass to {@link topUpBatch}) and `duration` (the expected TTL extension).
+     */
+    calculateTopUpForBzz(postageBatchId: BatchId | Uint8Array | string, bzz: BZZ, requestOptions?: BeeRequestOptions): Promise<{
+        amount: bigint;
+        duration: Duration;
+    }>;
     /**
      * Increases the duration of a postage batch by increasing its amount.
      *

package/dist/types/chunk/cac.d.ts

@@ -1,26 +1,40 @@
 import { Bytes } from '../utils/bytes';
-import { Reference, Span } from '../utils/typed-bytes';
+import { Identifier, PrivateKey, Reference, Span } from '../utils/typed-bytes';
+import { SingleOwnerChunk } from './soc';
 export declare const MIN_PAYLOAD_SIZE = 1;
 export declare const MAX_PAYLOAD_SIZE = 4096;
 /**
- * General chunk interface for Swarm
+ * Content Addressed Chunk (CAC) is the immutable building block of Swarm,
+ * holding at most 4096 bytes of payload.
  *
- * It stores the serialized data and provides functions to access
- * the fields of a chunk.
+ * - `span` indicates the size of the `payload` in bytes.
+ * - `payload` contains the actual data or the body of the chunk.
+ * - `data` contains the full chunk data - `span` and `payload`.
+ * - `address` is the Swarm hash (or reference) of the chunk.
  *
- * It also provides an address function to calculate the address of
- * the chunk that is required for the Chunk API.
+ * The `toSingleOwnerChunk` method allows converting the CAC into a Single Owner Chunk (SOC).
  */
 export interface Chunk {
+    /**
+     * Contains the full chunk data - `span` + `payload`.
+     */
     readonly data: Uint8Array;
+    /**
+     * Indicates the size of the `payload` in bytes.
+     */
     span: Span;
+    /**
+     * Contains the actual data or the body of the chunk.
+     */
     payload: Bytes;
+    /**
+     * The Swarm hash (or reference) of the chunk.
+     */
     address: Reference;
+    /**
+     * Converts the CAC into a Single Owner Chunk (SOC).
+     */
+    toSingleOwnerChunk: (identifier: Identifier | Uint8Array | string, signer: PrivateKey | Uint8Array | string) => SingleOwnerChunk;
 }
-/**
- * Creates a content addressed chunk and verifies the payload size.
- *
- * @param payloadBytes the data to be stored in the chunk
- */
-export declare function makeContentAddressedChunk(payloadBytes: Uint8Array | string): Chunk;
-export declare function asContentAddressedChunk(chunkBytes: Uint8Array): Chunk;
+export declare function unmarshalContentAddressedChunk(data: Bytes | Uint8Array): Chunk;
+export declare function makeContentAddressedChunk(rawPayload: Bytes | Uint8Array | string, span?: Span | bigint): Chunk;

package/dist/types/chunk/soc.d.ts

@@ -1,29 +1,61 @@
 import { BeeRequestOptions, UploadOptions, UploadResult } from '../types';
 import { Bytes } from '../utils/bytes';
-import { BatchId, EthAddress, Identifier, PrivateKey, Reference, Signature } from '../utils/typed-bytes';
+import { BatchId, EthAddress, Identifier, PrivateKey, Reference, Signature, Span } from '../utils/typed-bytes';
 import { Chunk } from './cac';
 /**
- * With single owner chunks, a user can assign arbitrary data to an
- * address and attest chunk integrity with their digital signature.
+ * Single Owner Chunk (SOC) is a chunk type where the address is determined by the owner and an arbitrary identifier.
+ * Its integrity is attested by the owner's digital signature.
  *
- * This interface extends the Chunk interface so it has the same
- * properties, but the address calculation is based on the identifier
- * and the owner of the chunk.
+ * Similar to Content Addressed Chunks (CAC), SOCs have a maximum payload size of 4096 bytes.
+ *
+ * - `span` indicates the size of the `payload` in bytes.
+ * - `payload` contains the actual data or the body of the chunk.
+ * - `data` contains the full chunk data - `span` and `payload`.
+ * - `address` is the Swarm hash (or reference) of the chunk.
+ * - `identifier` is an arbitrary identifier selected by the uploader.
+ * - `signature` is the digital signature of the owner over the identifier and the underlying CAC address.
+ * - `owner` is the Ethereum address of the chunk owner.
  */
-export interface SingleOwnerChunk extends Chunk {
+export interface SingleOwnerChunk {
+    /**
+     * Contains the full chunk data - `span` + `payload`.
+     */
+    readonly data: Uint8Array;
+    /**
+     * Indicates the size of the `payload` in bytes.
+     */
+    span: Span;
+    /**
+     * Contains the actual data or the body of the chunk.
+     */
+    payload: Bytes;
+    /**
+     * The Swarm hash (or reference) of the chunk.
+     */
+    address: Reference;
+    /**
+     * An arbitrary identifier selected by the uploader.
+     */
     identifier: Identifier;
+    /**
+     * The digital signature of the owner over the identifier and the underlying CAC address.
+     */
     signature: Signature;
+    /**
+     * The Ethereum address of the chunk owner.
+     */
     owner: EthAddress;
 }
 /**
- * Verifies if the data is a valid single owner chunk
+ * Unmarshals arbitrary data into a Single Owner Chunk.
+ * Throws an error if the data is not a valid SOC.
  *
  * @param data    The chunk data
  * @param address The address of the single owner chunk
  *
  * @returns a single owner chunk or throws error
  */
-export declare function makeSingleOwnerChunkFromData(data: Bytes | Uint8Array, address: Reference | Uint8Array | string): SingleOwnerChunk;
+export declare function unmarshalSingleOwnerChunk(data: Bytes | Uint8Array, address: Reference | Uint8Array | string): SingleOwnerChunk;
 export declare function makeSOCAddress(identifier: Identifier, address: EthAddress): Reference;
 /**
  * Creates a single owner chunk object
@@ -32,7 +64,7 @@ export declare function makeSOCAddress(identifier: Identifier, address: EthAddre
  * @param identifier  The identifier of the chunk
  * @param signer      The signer interface for signing the chunk
  */
-export declare function makeSingleOwnerChunk(chunk: Chunk, identifier: Identifier | Uint8Array | string, signer: PrivateKey | Uint8Array | string): SingleOwnerChunk;
+export declare function makeSingleOwnerChunk(address: Reference, span: Span, payload: Bytes, identifier: Identifier | Uint8Array | string, signer: PrivateKey | Uint8Array | string): SingleOwnerChunk;
 /**
  * Helper function to upload a chunk.
  *
@@ -55,7 +87,7 @@ export declare function uploadSingleOwnerChunk(requestOptions: BeeRequestOptions
  * @param options
  */
 export declare function uploadSingleOwnerChunkData(requestOptions: BeeRequestOptions, signer: PrivateKey | Uint8Array | string, stamp: BatchId | Uint8Array | string, identifier: Identifier | Uint8Array | string, data: Uint8Array, options?: UploadOptions): Promise<UploadResult>;
-export declare function uploadSingleOwnerChunkWithWrappedChunk(requestOptions: BeeRequestOptions, signer: PrivateKey | Uint8Array | string, stamp: BatchId | Uint8Array | string, identifier: Identifier | Uint8Array | string, rootChunk: Uint8Array, options?: UploadOptions): Promise<UploadResult>;
+export declare function uploadSingleOwnerChunkWithWrappedChunk(requestOptions: BeeRequestOptions, signer: PrivateKey | Uint8Array | string, stamp: BatchId | Uint8Array | string, identifier: Identifier | Uint8Array | string, wrappedChunk: Chunk, options?: UploadOptions): Promise<UploadResult>;
 /**
  * Helper function to download SOC.
  *

package/dist/types/index.d.ts

@@ -2,6 +2,8 @@ import { Bee } from './bee';
 import { BeeDev } from './bee-dev';
 import { Stamper } from './stamper/stamper';
 export { MerkleTree } from 'cafe-utility';
+export type { Chunk } from './chunk/cac';
+export type { SingleOwnerChunk } from './chunk/soc';
 export { MantarayNode } from './manifest/manifest';
 export { SUPPORTED_BEE_VERSION, SUPPORTED_BEE_VERSION_EXACT } from './modules/debug/status';
 export * from './types';
@@ -13,6 +15,7 @@ export * as Utils from './utils/expose';
 export { Size } from './utils/size';
 export * from './utils/tokens';
 export * from './utils/typed-bytes';
+export type { UploadProgress } from './utils/upload-progress';
 export { Bee, BeeDev, Stamper };
 declare global {
     interface Window {

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

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { Readable } from 'stream';
 import { BeeRequestOptions, Collection, CollectionUploadOptions, DownloadOptions, FileData, FileUploadOptions, UploadResult } from '../types';
 import { Bytes } from '../utils/bytes';

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

@@ -1,7 +1,7 @@
 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.6.0-d0aa8b93";
+export declare const SUPPORTED_BEE_VERSION_EXACT = "2.7.0-6ddf9b45";
 export declare const SUPPORTED_BEE_VERSION: string;
 export declare const SUPPORTED_API_VERSION = "7.3.0";
 export declare function getDebugStatus(requestOptions: BeeRequestOptions): Promise<DebugStatus>;

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

@@ -1,4 +1,3 @@
-/// <reference types="ws" />
 import WebSocket from 'isomorphic-ws';
 import { BeeRequestOptions, UploadOptions } from '..';
 import { SingleOwnerChunk } from '../chunk/soc';

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

@@ -1,4 +1,3 @@
-/// <reference types="ws" />
 import WebSocket from 'isomorphic-ws';
 import type { BeeRequestOptions } from '../types';
 import { BatchId, PublicKey, Topic } from '../utils/typed-bytes';

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

@@ -212,6 +212,7 @@ export interface ReserveState {
     radius: number;
     storageRadius: number;
     commitment: number;
+    reserveCapacityDoubling: number;
 }
 export interface ChainState {
     chainTip: number;

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

@@ -39,6 +39,7 @@ export type BeeRequestOptions = {
     httpAgent?: unknown;
     httpsAgent?: unknown;
     endlesslyRetry?: boolean;
+    signal?: AbortSignal;
 };
 /**
  * Options for the Bee client which affect all method calls *(unless overridden in the method call itself)*.

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

@@ -2,6 +2,6 @@ import { BatchId, Topic } from './typed-bytes';
 export declare const SWARM_GATEWAY_URL = "https://api.gateway.ethswarm.org";
 export declare const NULL_STAMP: BatchId;
 export declare const NULL_TOPIC: Topic;
-export declare const NULL_ADDRESS: Uint8Array;
-export declare const NULL_IDENTIFIER: Uint8Array;
-export declare const NULL_OWNER: Uint8Array;
+export declare const NULL_ADDRESS: Uint8Array<ArrayBuffer>;
+export declare const NULL_IDENTIFIER: Uint8Array<ArrayBuffer>;
+export declare const NULL_OWNER: Uint8Array<ArrayBuffer>;

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

@@ -8,8 +8,8 @@ export declare class BeeArgumentError extends BeeError {
 export declare class BeeResponseError extends BeeError {
     method: string;
     url: string;
-    responseBody?: unknown;
+    responseBody?: unknown | undefined;
     status?: number | undefined;
     statusText?: string | undefined;
-    constructor(method: string, url: string, message: string, responseBody?: unknown, status?: number | undefined, statusText?: string | undefined);
+    constructor(method: string, url: string, message: string, responseBody?: unknown | undefined, status?: number | undefined, statusText?: string | undefined);
 }

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

@@ -2,4 +2,4 @@ export { getCollectionSize, makeCollectionFromFileList } from './collection';
 export { getFolderSize } from './collection.node';
 export { makeMaxTarget } from './pss';
 export { approximateOverheadForRedundancyLevel, getRedundancyStat, getRedundancyStats } from './redundancy';
-export { getAmountForDuration, getDepthForSize, getStampCost, getStampDuration, getStampEffectiveBytes, getStampEffectiveBytesBreakpoints, getStampTheoreticalBytes, getStampUsage, } from './stamps';
+export { convertEnvelopeToMarshaledStamp, getAmountForDuration, getDepthForSize, getStampCost, getStampDuration, getStampEffectiveBytes, getStampEffectiveBytesBreakpoints, getStampTheoreticalBytes, getStampUsage, mapPostageBatch, unmapPostageBatch, } from './stamps';

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

@@ -1,4 +1,4 @@
-import { EnvelopeWithBatchId, NumberString, RedundancyLevel } from '../types';
+import { EnvelopeWithBatchId, NumberString, PostageBatch, RedundancyLevel } from '../types';
 import { Bytes } from './bytes';
 import { Duration } from './duration';
 import { Size } from './size';
@@ -58,3 +58,17 @@ export declare function getAmountForDuration(duration: Duration, pricePerBlock:
 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;
+export interface RawPostageBatch {
+    batchID: string;
+    utilization: number;
+    usable: boolean;
+    label: string;
+    depth: number;
+    amount: string;
+    bucketDepth: number;
+    blockNumber: number;
+    immutableFlag: boolean;
+    batchTTL: number;
+}
+export declare function mapPostageBatch(raw: RawPostageBatch, encryption?: boolean, erasureCodeLevel?: RedundancyLevel): PostageBatch;
+export declare function unmapPostageBatch(batch: PostageBatch): RawPostageBatch;

package/dist/types/utils/tar-uploader.browser.d.ts

@@ -1,3 +1,3 @@
 import { BeeRequestOptions, Collection, CollectionUploadOptions } from '..';
 import { BatchId } from './typed-bytes';
-export declare function uploadTar(requestOptions: BeeRequestOptions, collection: Collection, postageBatchId: BatchId, options?: CollectionUploadOptions): Promise<import("axios").AxiosResponse<unknown, any>>;
+export declare function uploadTar(requestOptions: BeeRequestOptions, collection: Collection, postageBatchId: BatchId, options?: CollectionUploadOptions): Promise<import("axios").AxiosResponse<unknown, any, {}>>;

package/dist/types/utils/tar-uploader.d.ts

@@ -1,3 +1,3 @@
 import { BeeRequestOptions, Collection, CollectionUploadOptions } from '..';
 import { BatchId } from './typed-bytes';
-export declare function uploadTar(requestOptions: BeeRequestOptions, collection: Collection, postageBatchId: BatchId, options?: CollectionUploadOptions): Promise<import("axios").AxiosResponse<unknown, any>>;
+export declare function uploadTar(requestOptions: BeeRequestOptions, collection: Collection, postageBatchId: BatchId, options?: CollectionUploadOptions): Promise<import("axios").AxiosResponse<unknown, any, {}>>;

package/dist/types/utils/tar.browser.d.ts

@@ -1,7 +1,7 @@
 export declare class TarStream {
     pieces: Uint8Array[];
     currentFileSize: number;
-    get output(): Uint8Array;
+    get output(): Uint8Array<ArrayBufferLike>;
     beginFile(path: string, size: number): void;
     appendFile(data: Uint8Array): Promise<void>;
     endFile(): Promise<void>;

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

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { PassThrough } from 'stream';
 export declare class TarStream {
     output: PassThrough;

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

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import * as stream from 'stream';
 import { AllTagsOptions, BeeRequestOptions, CollectionUploadOptions, DownloadOptions, FileUploadOptions, GsocMessageHandler, NumberString, PostageBatchOptions, PssMessageHandler, RedundantUploadOptions, Tag, TransactionOptions, UploadOptions } from '../types';
 export declare function isReadable(value: unknown): value is stream.Readable;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@upcoming/bee-js",
-  "version": "10.1.2",
+  "version": "12.0.0",
   "description": "Javascript client for Bee",
   "keywords": [
     "bee",
@@ -50,19 +50,19 @@
     "dist"
   ],
   "scripts": {
-    "prepublishOnly": "cross-env NODE_ENV=production npm run build",
+    "prepublishOnly": "NODE_ENV=production npm run build",
     "build": "rimraf dist && npm run build:node && npm run build:types && npm run build:browser",
     "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 --forceExit",
+    "test": "TS_NODE_PROJECT=tsconfig.test.json jest --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": "^32.2.0",
+    "axios": "^1.15.1",
+    "cafe-utility": "^33.6.1",
     "debug": "^4.4.1",
     "isomorphic-ws": "^4.0.1",
     "semver": "^7.3.5",
@@ -77,10 +77,8 @@
     "@babel/preset-typescript": "^7.18.6",
     "@commitlint/cli": "^17.0.2",
     "@commitlint/config-conventional": "^17.4.2",
-    "@jest/types": "^29.6.3",
-    "@naholyr/cross-env": "^1.0.0",
     "@types/debug": "^4.1.12",
-    "@types/jest": "^29.5.13",
+    "@types/jest": "^30.0.0",
     "@types/node": "^18.11.11",
     "@types/semver": "^7.3.9",
     "@types/ws": "^8.5.3",
@@ -88,20 +86,19 @@
     "@typescript-eslint/parser": "^5.46.0",
     "babel-loader": "^9.1.0",
     "babel-plugin-add-import-extension": "^1.6.0",
-    "cross-env": "^7.0.3",
     "depcheck": "^1.4.7",
     "eslint": "^8.13.0",
     "eslint-config-prettier": "^8.5.0",
     "eslint-plugin-prettier": "^4.0.0",
     "eslint-plugin-unused-imports": "^2.0.0",
     "husky": "^8.0.1",
-    "jest": "^29.7.0",
+    "jest": "^30.2.0",
     "prettier": "^2.6.2",
     "rimraf": "^3.0.2",
     "terser-webpack-plugin": "^5.3.1",
-    "ts-jest": "^29.2.5",
-    "ts-node": "^10.9.1",
-    "typescript": "^4.9.5",
+    "ts-jest": "^29.4.6",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.9.3",
     "webpack": "^5.75.0",
     "webpack-cli": "^5.0.1"
   }