@upcoming/bee-js 9.9.1 → 11.1.0

package/dist/mjs/chunk/cac.js

@@ -1,41 +1,32 @@
-import { Binary } from 'cafe-utility';
+import { Binary, Types } from 'cafe-utility';
 import { Bytes } from "../utils/bytes.js";
 import { Span } from "../utils/typed-bytes.js";
 import { calculateChunkAddress } from "./bmt.js";
+import { makeSingleOwnerChunk } from "./soc.js";
 export const MIN_PAYLOAD_SIZE = 1;
 export const MAX_PAYLOAD_SIZE = 4096;
-const ENCODER = new TextEncoder();
-/**
- * Creates a content addressed chunk and verifies the payload size.
- *
- * @param payloadBytes the data to be stored in the chunk
- */
-export function makeContentAddressedChunk(payloadBytes) {
-  if (!(payloadBytes instanceof Uint8Array)) {
-    payloadBytes = ENCODER.encode(payloadBytes);
-  }
-  if (payloadBytes.length < MIN_PAYLOAD_SIZE || payloadBytes.length > MAX_PAYLOAD_SIZE) {
-    throw new RangeError(`payload size ${payloadBytes.length} exceeds limits [${MIN_PAYLOAD_SIZE}, ${MAX_PAYLOAD_SIZE}]`);
-  }
-  const span = Span.fromBigInt(BigInt(payloadBytes.length));
-  const data = Binary.concatBytes(span.toUint8Array(), payloadBytes);
-  return {
-    data,
-    span,
-    payload: Bytes.fromSlice(data, Span.LENGTH),
-    address: calculateChunkAddress(data)
-  };
+export function unmarshalContentAddressedChunk(data) {
+  data = new Bytes(data);
+  return makeContentAddressedChunk(data.toUint8Array().slice(Span.LENGTH), Span.fromSlice(data.toUint8Array(), 0));
 }
-export function asContentAddressedChunk(chunkBytes) {
-  if (chunkBytes.length < MIN_PAYLOAD_SIZE + Span.LENGTH || chunkBytes.length > MAX_PAYLOAD_SIZE + Span.LENGTH) {
-    throw new RangeError(`chunk size ${chunkBytes.length} exceeds limits [${MIN_PAYLOAD_SIZE + Span.LENGTH}, ${Span.LENGTH}]`);
+export function makeContentAddressedChunk(rawPayload, span) {
+  if (Types.isString(rawPayload)) {
+    rawPayload = Bytes.fromUtf8(rawPayload);
+  }
+  if (rawPayload.length < MIN_PAYLOAD_SIZE || rawPayload.length > MAX_PAYLOAD_SIZE) {
+    throw new RangeError(`payload size ${rawPayload.length} exceeds limits [${MIN_PAYLOAD_SIZE}, ${MAX_PAYLOAD_SIZE}]`);
   }
-  const span = Span.fromSlice(chunkBytes, 0);
-  const data = Binary.concatBytes(span.toUint8Array(), chunkBytes.slice(Span.LENGTH));
+  const typedSpan = span ? typeof span === 'bigint' ? Span.fromBigInt(span) : span : Span.fromBigInt(BigInt(rawPayload.length));
+  const payload = new Bytes(rawPayload);
+  const data = Binary.concatBytes(typedSpan.toUint8Array(), payload.toUint8Array());
+  const address = calculateChunkAddress(data);
   return {
     data,
-    span,
-    payload: Bytes.fromSlice(data, Span.LENGTH),
-    address: calculateChunkAddress(data)
+    span: typedSpan,
+    payload,
+    address,
+    toSingleOwnerChunk: (identifier, signer) => {
+      return makeSingleOwnerChunk(address, typedSpan, payload, identifier, signer);
+    }
   };
 }

package/dist/mjs/chunk/soc.js

@@ -5,10 +5,10 @@ import { Bytes } from "../utils/bytes.js";
 import { BeeError } from "../utils/error.js";
 import { EthAddress, Identifier, PrivateKey, Reference, Signature, Span } from "../utils/typed-bytes.js";
 import { calculateChunkAddress } from "./bmt.js";
-import { asContentAddressedChunk, makeContentAddressedChunk } from "./cac.js";
+import { makeContentAddressedChunk } from "./cac.js";
 const SOC_SIGNATURE_OFFSET = Identifier.LENGTH;
-const SOC_SPAN_OFFSET = SOC_SIGNATURE_OFFSET + Signature.LENGTH;
-const SOC_PAYLOAD_OFFSET = SOC_SPAN_OFFSET + Span.LENGTH;
+const SOC_SPAN_OFFSET = Identifier.LENGTH + Signature.LENGTH;
+const SOC_PAYLOAD_OFFSET = Identifier.LENGTH + Signature.LENGTH + Span.LENGTH;
 function recoverChunkOwner(data) {
   const cacData = data.slice(SOC_SPAN_OFFSET);
   const chunkAddress = calculateChunkAddress(cacData);
@@ -19,21 +19,22 @@ function recoverChunkOwner(data) {
   return ownerAddress;
 }
 /**
- * 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 function makeSingleOwnerChunkFromData(data, address) {
+export function unmarshalSingleOwnerChunk(data, address) {
   data = data instanceof Bytes ? data.toUint8Array() : data;
   address = new Reference(address);
   const ownerAddress = recoverChunkOwner(data);
   const identifier = Bytes.fromSlice(data, 0, Identifier.LENGTH);
   const socAddress = new Reference(Binary.keccak256(Binary.concatBytes(identifier.toUint8Array(), ownerAddress.toUint8Array())));
   if (!Binary.equals(address.toUint8Array(), socAddress.toUint8Array())) {
-    throw new BeeError('SOC Data does not match given address!');
+    throw new BeeError('SOC data does not match given address!');
   }
   const signature = Signature.fromSlice(data, SOC_SIGNATURE_OFFSET);
   const span = Span.fromSlice(data, SOC_SPAN_OFFSET);
@@ -58,21 +59,19 @@ export function makeSOCAddress(identifier, address) {
  * @param identifier  The identifier of the chunk
  * @param signer      The signer interface for signing the chunk
  */
-export function makeSingleOwnerChunk(chunk, identifier, signer) {
+export function makeSingleOwnerChunk(address, span, payload, identifier, signer) {
   identifier = new Identifier(identifier);
   signer = new PrivateKey(signer);
-  const address = makeSOCAddress(identifier, signer.publicKey().address());
-  const signature = signer.sign(Binary.concatBytes(identifier.toUint8Array(), chunk.address.toUint8Array()));
-  const data = Binary.concatBytes(identifier.toUint8Array(), signature.toUint8Array(), chunk.data);
-  const span = Span.fromSlice(chunk.data, 0);
-  const payload = Bytes.fromSlice(chunk.data, Span.LENGTH);
+  const socAddress = makeSOCAddress(identifier, signer.publicKey().address());
+  const signature = signer.sign(Binary.concatBytes(identifier.toUint8Array(), address.toUint8Array()));
+  const data = Binary.concatBytes(identifier.toUint8Array(), signature.toUint8Array(), span.toUint8Array(), payload.toUint8Array());
   return {
     data,
     identifier,
     signature,
     span,
     payload,
-    address,
+    address: socAddress,
     owner: signer.publicKey().address()
   };
 }
@@ -104,13 +103,13 @@ export async function uploadSingleOwnerChunkData(requestOptions, signer, stamp,
   signer = new PrivateKey(signer);
   identifier = new Identifier(identifier);
   const cac = makeContentAddressedChunk(data);
-  const soc = makeSingleOwnerChunk(cac, identifier, signer);
+  const soc = cac.toSingleOwnerChunk(identifier, signer);
   return uploadSingleOwnerChunk(requestOptions, soc, stamp, options);
 }
-export async function uploadSingleOwnerChunkWithWrappedChunk(requestOptions, signer, stamp, identifier, rootChunk, options) {
+export async function uploadSingleOwnerChunkWithWrappedChunk(requestOptions, signer, stamp, identifier, wrappedChunk, options) {
   signer = new PrivateKey(signer);
   identifier = new Identifier(identifier);
-  const soc = makeSingleOwnerChunk(asContentAddressedChunk(rootChunk), identifier, signer);
+  const soc = wrappedChunk.toSingleOwnerChunk(identifier, signer);
   return uploadSingleOwnerChunk(requestOptions, soc, stamp, options);
 }
 /**
@@ -125,5 +124,5 @@ export async function downloadSingleOwnerChunk(requestOptions, ownerAddress, ide
   ownerAddress = new EthAddress(ownerAddress);
   const address = makeSOCAddress(identifier, ownerAddress);
   const cac = await chunkAPI.download(requestOptions, address.toHex());
-  return makeSingleOwnerChunkFromData(cac, address);
+  return unmarshalSingleOwnerChunk(cac, address);
 }

package/dist/mjs/feed/index.js

@@ -1,13 +1,13 @@
 import { Binary, Optional, Types } from 'cafe-utility';
-import { asContentAddressedChunk } from "../chunk/cac.js";
-import { makeSingleOwnerChunkFromData, uploadSingleOwnerChunkData, uploadSingleOwnerChunkWithWrappedChunk } from "../chunk/soc.js";
+import { makeContentAddressedChunk, unmarshalContentAddressedChunk } from "../chunk/cac.js";
+import { unmarshalSingleOwnerChunk, uploadSingleOwnerChunkData, uploadSingleOwnerChunkWithWrappedChunk } from "../chunk/soc.js";
 import * as bytes from "../modules/bytes.js";
 import * as chunkAPI from "../modules/chunk.js";
 import { fetchLatestFeedUpdate, probeFeed } from "../modules/feed.js";
 import { Bytes } from "../utils/bytes.js";
 import { BeeResponseError } from "../utils/error.js";
 import { ResourceLocator } from "../utils/resource-locator.js";
-import { FeedIndex, Identifier, Reference, Signature } from "../utils/typed-bytes.js";
+import { FeedIndex, Reference } from "../utils/typed-bytes.js";
 import { makeFeedIdentifier } from "./identifier.js";
 const TIMESTAMP_PAYLOAD_OFFSET = 0;
 const TIMESTAMP_PAYLOAD_SIZE = 8;
@@ -40,7 +40,7 @@ export async function updateFeedWithPayload(requestOptions, signer, topic, data,
   const identifier = makeFeedIdentifier(topic, nextIndex);
   if (data.length > 4096) {
     const uploadResult = await bytes.upload(requestOptions, data, postageBatchId, options);
-    const rootChunk = await chunkAPI.download(requestOptions, uploadResult.reference);
+    const rootChunk = unmarshalContentAddressedChunk(await chunkAPI.download(requestOptions, uploadResult.reference));
     return uploadSingleOwnerChunkWithWrappedChunk(requestOptions, signer, postageBatchId, identifier, rootChunk, options);
   }
   return uploadSingleOwnerChunkData(requestOptions, signer, postageBatchId, identifier, Types.isString(data) ? Bytes.fromUtf8(data).toUint8Array() : data, options);
@@ -53,7 +53,7 @@ export async function downloadFeedUpdate(requestOptions, owner, topic, index, ha
   index = typeof index === 'number' ? FeedIndex.fromBigInt(BigInt(index)) : index;
   const address = getFeedUpdateChunkReference(owner, topic, index);
   const data = await chunkAPI.download(requestOptions, address.toHex());
-  const soc = makeSingleOwnerChunkFromData(data, address);
+  const soc = unmarshalSingleOwnerChunk(data, address);
   let timestamp = Optional.empty();
   if (hasTimestamp) {
     const timestampBytes = Bytes.fromSlice(soc.payload.toUint8Array(), TIMESTAMP_PAYLOAD_OFFSET, TIMESTAMP_PAYLOAD_SIZE);
@@ -68,7 +68,8 @@ export async function downloadFeedUpdateAsCAC(requestOptions, owner, topic, inde
   index = typeof index === 'number' ? FeedIndex.fromBigInt(BigInt(index)) : index;
   const address = getFeedUpdateChunkReference(owner, topic, index);
   const data = await chunkAPI.download(requestOptions, address);
-  return asContentAddressedChunk(data.slice(Identifier.LENGTH + Signature.LENGTH));
+  const soc = unmarshalSingleOwnerChunk(data, address);
+  return makeContentAddressedChunk(soc.payload, soc.span);
 }
 export function makeFeedReader(requestOptions, topic, owner) {
   // TODO: remove after enough time has passed in deprecated version

package/dist/mjs/manifest/manifest.js

@@ -320,7 +320,17 @@ export class MantarayNode {
    */
   async saveRecursively(bee, postageBatchId, options, requestOptions) {
     for (const fork of this.forks.values()) {
-      await fork.node.saveRecursively(bee, postageBatchId, options, requestOptions);
+      const uploadResult = await fork.node.saveRecursively(bee, postageBatchId, options, requestOptions);
+      if (options?.act) {
+        let historyAddress;
+        uploadResult.historyAddress.ifPresent(ref => historyAddress = ref);
+        if (historyAddress) {
+          if (!fork.node.metadata) {
+            fork.node.metadata = {};
+          }
+          fork.node.metadata['swarm-act-history-address'] = historyAddress.toHex();
+        }
+      }
     }
     const result = await bee.uploadData(postageBatchId, await this.marshal(), options, requestOptions);
     this.selfAddress = result.reference.toUint8Array();
@@ -334,7 +344,14 @@ export class MantarayNode {
       if (!fork.node.selfAddress) {
         throw Error('MantarayNode#loadRecursively fork.node.selfAddress is not set');
       }
-      const node = await MantarayNode.unmarshal(bee, fork.node.selfAddress, options, requestOptions);
+      let downloadOptions = options;
+      if (fork.node.metadata && fork.node.metadata['swarm-act-history-address']) {
+        downloadOptions = {
+          ...options,
+          actHistoryAddress: fork.node.metadata['swarm-act-history-address']
+        };
+      }
+      const node = await MantarayNode.unmarshal(bee, fork.node.selfAddress, downloadOptions, requestOptions);
       fork.node.targetAddress = node.targetAddress;
       fork.node.forks = node.forks;
       fork.node.path = fork.prefix;

package/dist/mjs/modules/debug/chequebook.js

@@ -19,9 +19,9 @@ export async function getChequebookAddress(requestOptions) {
     name: 'response.data'
   });
   return {
-    chequebookAddress: Types.asString(body.chequebookAddress, {
+    chequebookAddress: new EthAddress(Types.asString(body.chequebookAddress, {
       name: 'chequebookAddress'
-    })
+    }))
   };
 }
 /**

package/dist/mjs/modules/debug/stamps.js

@@ -1,11 +1,8 @@
 import { Types } from 'cafe-utility';
-import { Duration } from "../../utils/duration.js";
 import { http } from "../../utils/http.js";
-import { Size } from "../../utils/size.js";
-import { getStampEffectiveBytes, getStampTheoreticalBytes, getStampUsage } from "../../utils/stamps.js";
+import { mapPostageBatch } from "../../utils/stamps.js";
 import { asNumberString } from "../../utils/type.js";
 import { BatchId, EthAddress } from "../../utils/typed-bytes.js";
-import { normalizeBatchTTL } from "../../utils/workaround.js";
 const STAMPS_ENDPOINT = 'stamps';
 const BATCHES_ENDPOINT = 'batches';
 export async function getGlobalPostageBatches(requestOptions) {
@@ -63,53 +60,9 @@ export async function getAllPostageBatches(requestOptions) {
   }).map(x => Types.asObject(x, {
     name: 'stamp'
   }));
-  return stamps.map(x => {
-    const utilization = Types.asNumber(x.utilization, {
-      name: 'utilization'
-    });
-    const depth = Types.asNumber(x.depth, {
-      name: 'depth'
-    });
-    const bucketDepth = Types.asNumber(x.bucketDepth, {
-      name: 'bucketDepth'
-    });
-    const usage = getStampUsage(utilization, depth, bucketDepth);
-    const batchTTL = normalizeBatchTTL(Types.asNumber(x.batchTTL, {
-      name: 'batchTTL'
-    }));
-    const duration = Duration.fromSeconds(batchTTL);
-    return {
-      batchID: new BatchId(Types.asString(x.batchID, {
-        name: 'batchID'
-      })),
-      utilization,
-      usable: Types.asBoolean(x.usable, {
-        name: 'usable'
-      }),
-      label: Types.asEmptiableString(x.label, {
-        name: 'label'
-      }),
-      depth,
-      amount: asNumberString(x.amount, {
-        name: 'amount'
-      }),
-      bucketDepth,
-      blockNumber: Types.asNumber(x.blockNumber, {
-        name: 'blockNumber'
-      }),
-      immutableFlag: Types.asBoolean(x.immutableFlag, {
-        name: 'immutableFlag'
-      }),
-      usage,
-      usageText: `${Math.round(usage * 100)}%`,
-      size: Size.fromBytes(getStampEffectiveBytes(depth)),
-      remainingSize: Size.fromBytes(Math.ceil(getStampEffectiveBytes(depth) * (1 - usage))),
-      theoreticalSize: Size.fromBytes(getStampTheoreticalBytes(depth)),
-      duration
-    };
-  });
+  return stamps.map(x => mapPostageBatch(validateRawPostageBatch(x)));
 }
-export async function getPostageBatch(requestOptions, postageBatchId) {
+export async function getPostageBatch(requestOptions, postageBatchId, encryption, erasureCodeLevel) {
   const response = await http(requestOptions, {
     method: 'get',
     url: `${STAMPS_ENDPOINT}/${postageBatchId}`,
@@ -118,49 +71,7 @@ export async function getPostageBatch(requestOptions, postageBatchId) {
   const body = Types.asObject(response.data, {
     name: 'response.data'
   });
-  const utilization = Types.asNumber(body.utilization, {
-    name: 'utilization'
-  });
-  const depth = Types.asNumber(body.depth, {
-    name: 'depth'
-  });
-  const bucketDepth = Types.asNumber(body.bucketDepth, {
-    name: 'bucketDepth'
-  });
-  const usage = getStampUsage(utilization, depth, bucketDepth);
-  const batchTTL = normalizeBatchTTL(Types.asNumber(body.batchTTL, {
-    name: 'batchTTL'
-  }));
-  const duration = Duration.fromSeconds(batchTTL);
-  return {
-    batchID: new BatchId(Types.asString(body.batchID, {
-      name: 'batchID'
-    })),
-    utilization,
-    usable: Types.asBoolean(body.usable, {
-      name: 'usable'
-    }),
-    label: Types.asEmptiableString(body.label, {
-      name: 'label'
-    }),
-    depth,
-    amount: asNumberString(body.amount, {
-      name: 'amount'
-    }),
-    bucketDepth,
-    blockNumber: Types.asNumber(body.blockNumber, {
-      name: 'blockNumber'
-    }),
-    immutableFlag: Types.asBoolean(body.immutableFlag, {
-      name: 'immutableFlag'
-    }),
-    usage,
-    usageText: `${Math.round(usage * 100)}%`,
-    size: Size.fromBytes(getStampEffectiveBytes(depth)),
-    remainingSize: Size.fromBytes(Math.ceil(getStampEffectiveBytes(depth) * (1 - usage))),
-    theoreticalSize: Size.fromBytes(getStampTheoreticalBytes(depth)),
-    duration
-  };
+  return mapPostageBatch(validateRawPostageBatch(body), encryption, erasureCodeLevel);
 }
 export async function getPostageBatchBuckets(requestOptions, postageBatchId) {
   const response = await http(requestOptions, {
@@ -244,4 +155,38 @@ export async function diluteBatch(requestOptions, id, depth) {
   return new BatchId(Types.asString(body.batchID, {
     name: 'batchID'
   }));
+}
+function validateRawPostageBatch(raw) {
+  return {
+    amount: asNumberString(raw.amount, {
+      name: 'amount'
+    }),
+    batchID: Types.asString(raw.batchID, {
+      name: 'batchID'
+    }),
+    batchTTL: Types.asNumber(raw.batchTTL, {
+      name: 'batchTTL'
+    }),
+    bucketDepth: Types.asNumber(raw.bucketDepth, {
+      name: 'bucketDepth'
+    }),
+    blockNumber: Types.asNumber(raw.blockNumber, {
+      name: 'blockNumber'
+    }),
+    depth: Types.asNumber(raw.depth, {
+      name: 'depth'
+    }),
+    immutableFlag: Types.asBoolean(raw.immutableFlag, {
+      name: 'immutableFlag'
+    }),
+    label: Types.asEmptiableString(raw.label, {
+      name: 'label'
+    }),
+    usable: Types.asBoolean(raw.usable, {
+      name: 'usable'
+    }),
+    utilization: Types.asNumber(raw.utilization, {
+      name: 'utilization'
+    })
+  };
 }

package/dist/mjs/modules/debug/states.js

@@ -30,6 +30,9 @@ export async function getReserveState(requestOptions) {
     }),
     storageRadius: Types.asNumber(body.storageRadius, {
       name: 'storageRadius'
+    }),
+    reserveCapacityDoubling: Types.asNumber(body.reserveCapacityDoubling, {
+      name: 'reserveCapacityDoubling'
     })
   };
 }

package/dist/mjs/modules/debug/status.js

@@ -2,7 +2,7 @@ import { Types } from 'cafe-utility';
 import getMajorSemver from 'semver/functions/major.js';
 import { toBeeMode } from "../../types/debug.js";
 import { http } from "../../utils/http.js";
-export const SUPPORTED_BEE_VERSION_EXACT = '2.6.0-d0aa8b93';
+export const SUPPORTED_BEE_VERSION_EXACT = '2.7.0-6ddf9b45';
 export const SUPPORTED_BEE_VERSION = SUPPORTED_BEE_VERSION_EXACT.split('-')[0];
 export const SUPPORTED_API_VERSION = '7.3.0';
 const NODE_INFO_URL = 'node';

package/dist/mjs/types/index.js

@@ -4,16 +4,21 @@ export const BRANCHES = 128;
 export const CHUNK_SIZE = SECTION_SIZE * BRANCHES;
 export const PSS_TARGET_HEX_LENGTH_MAX = 4;
 /**
- * Minimal depth that can be used for creation of postage batch
+ * Minimum postage batch depth.
  */
 export const STAMPS_DEPTH_MIN = 17;
 /**
- * Maximal depth that can be used for creation of postage batch
+ * Maximum postage batch depth.
  */
 export const STAMPS_DEPTH_MAX = 255;
+/**
+ * Minimum tags API page size.
+ */
 export const TAGS_LIMIT_MIN = 1;
+/**
+ * Maximum tags API page size.
+ */
 export const TAGS_LIMIT_MAX = 1000;
-export const FEED_INDEX_HEX_LENGTH = 16;
 /**
  * Add redundancy to the data being uploaded so that downloaders can download it with better UX.
  * 0 value is default and does not add any redundancy to the file.

package/dist/mjs/utils/bytes.js

@@ -1,8 +1,13 @@
-import { Binary, Types } from 'cafe-utility';
+import { Binary, Objects, Types } from 'cafe-utility';
+import _debug from 'debug';
+const debug = _debug('bee-js:bytes');
 const DECODER = new TextDecoder();
 const ENCODER = new TextEncoder();
 export class Bytes {
   constructor(bytes, byteLength) {
+    if (!bytes) {
+      throw Error(`Bytes#constructor: constructor parameter is falsy: ${bytes}`);
+    }
     if (bytes instanceof Bytes) {
       this.bytes = bytes.bytes;
     } else if (typeof bytes === 'string') {
@@ -11,8 +16,20 @@ export class Bytes {
       }));
     } else if (bytes instanceof ArrayBuffer) {
       this.bytes = new Uint8Array(bytes);
-    } else {
+    } else if (bytes instanceof Uint8Array) {
       this.bytes = bytes;
+    } else {
+      const unknownInput = bytes;
+      const toHex = Objects.getDeep(unknownInput, 'toHex');
+      if (Types.isFunction(toHex)) {
+        const hex = toHex.call(unknownInput);
+        this.bytes = Binary.hexToUint8Array(Types.asHexString(hex, {
+          name: 'Bytes#constructor(bytes)'
+        }));
+      } else {
+        debug('bytes', bytes);
+        throw new Error(`Bytes#constructor: unsupported type: ${typeof bytes}`);
+      }
     }
     this.length = this.bytes.length;
     if (byteLength) {

package/dist/mjs/utils/chunk-stream.browser.js

@@ -12,6 +12,10 @@ export async function streamDirectory(_bee, _dir, _postageBatchId, _onUploadProg
   throw new Error('Streaming directories is not supported in browsers!');
 }
 export async function streamFiles(bee, files, postageBatchId, onUploadProgress, options, requestOptions) {
+  const signal = requestOptions?.signal;
+  if (signal?.aborted) {
+    throw new Error('Request aborted');
+  }
   const queue = new AsyncQueue(64, 64);
   let total = 0;
   let processed = 0;
@@ -21,15 +25,28 @@ export async function streamFiles(bee, files, postageBatchId, onUploadProgress,
   postageBatchId = new BatchId(postageBatchId);
   async function onChunk(chunk) {
     await queue.enqueue(async () => {
-      await bee.uploadChunk(postageBatchId, chunk.build(), options, requestOptions);
-      onUploadProgress?.({
-        total,
-        processed: ++processed
-      });
+      if (signal?.aborted) {
+        return;
+      }
+      try {
+        await bee.uploadChunk(postageBatchId, chunk.build(), options, requestOptions);
+        onUploadProgress?.({
+          total,
+          processed: ++processed
+        });
+      } catch (err) {
+        if (signal?.aborted) {
+          return;
+        }
+        throw err;
+      }
     });
   }
   const mantaray = new MantarayNode();
   for (const file of files) {
+    if (signal?.aborted) {
+      throw new Error('Request aborted');
+    }
     const rootChunk = await new Promise((resolve, reject) => {
       const tree = new MerkleTree(onChunk);
       let offset = 0;
@@ -38,6 +55,10 @@ export async function streamFiles(bee, files, postageBatchId, onUploadProgress,
         reject(reader.error);
       };
       const readNextChunk = async () => {
+        if (signal?.aborted) {
+          reject(new Error('Request aborted'));
+          return;
+        }
         if (offset >= file.size) {
           const rootChunk = await tree.finalize();
           resolve(rootChunk);
@@ -75,6 +96,9 @@ export async function streamFiles(bee, files, postageBatchId, onUploadProgress,
       });
     }
   }
+  if (signal?.aborted) {
+    throw new Error('Request aborted');
+  }
   return mantaray.saveRecursively(bee, postageBatchId, options, requestOptions);
 }
 function maybeEnrichMime(mime) {

package/dist/mjs/utils/duration.js

@@ -3,7 +3,7 @@ export class Duration {
   constructor(seconds) {
     this.seconds = Math.ceil(seconds);
     if (seconds < 0) {
-      throw Error('Duration cannot be negative');
+      this.seconds = 0;
     }
   }
   static fromMilliseconds(milliseconds) {
@@ -27,6 +27,32 @@ export class Duration {
   static fromEndDate(endDate, startDate) {
     return new Duration((endDate.getTime() - (startDate ?? new Date()).getTime()) / 1000);
   }
+  /**
+   * Parses a duration string and returns a `Duration` instance.
+   *
+   * Case insensitive. E.g. both `"28h"` and `"1D"` are valid.
+   *
+   * Whitespaces are ignored. E.g. both `"5 d"` and `"2weeks"` are valid.
+   *
+   * Decimal numbers are supported. E.g. `"1.5h"` is valid.
+   *
+   * Supported units:
+   *
+   * - ms, milli, millis, millisecond, milliseconds
+   * - s, sec, second, seconds
+   * - m, min, minute, minutes
+   * - h, hour, hours
+   * - d, day, days
+   * - w, week, weeks
+   * - month, months
+   * - y, year, years
+   *
+   * @param duration - A string representing a duration
+   * @returns a `Duration` instance
+   */
+  static parseFromString(duration) {
+    return Duration.fromSeconds(Dates.make(duration) / 1000);
+  }
   toSeconds() {
     return this.seconds;
   }

package/dist/mjs/utils/expose.js

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