@ethersphere/bee-js 8.1.0 → 8.2.0

package/dist/mjs/bee.js

@@ -20,6 +20,7 @@ import * as states from "./modules/debug/states.js";
 import * as debugStatus from "./modules/debug/status.js";
 import * as debugTag from "./modules/debug/tag.js";
 import * as transactions from "./modules/debug/transactions.js";
+import { postEnvelope } from "./modules/envelope.js";
 import { createFeedManifest } from "./modules/feed.js";
 import * as grantee from "./modules/grantee.js";
 import * as pinning from "./modules/pinning.js";
@@ -84,6 +85,16 @@ export class Bee {
     }
     return bytes.upload(this.getRequestOptionsForCall(requestOptions), data, postageBatchId, options);
   }
+  /**
+   * Requests content length for a `/bytes` reference
+   *
+   * @see [Bee API reference - `HEAD /bytes/`](https://docs.ethswarm.org/api/#tag/Bytes/paths/~1bytes~1%7Breference%7D/head)
+   */
+  async probeData(reference, options) {
+    assertRequestOptions(options);
+    assertReferenceOrEns(reference);
+    return bytes.head(this.getRequestOptionsForCall(options), reference);
+  }
   /**
    * Download data as a byte array
    *
@@ -125,8 +136,7 @@ export 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)
    */
-  async uploadChunk(postageBatchId, data, options, requestOptions) {
-    assertBatchId(postageBatchId);
+  async uploadChunk(stamp, data, options, requestOptions) {
     assertRequestOptions(requestOptions);
     if (!(data instanceof Uint8Array)) {
       throw new TypeError('Data has to be Uint8Array instance!');
@@ -140,7 +150,7 @@ export class Bee {
     if (options) {
       assertUploadOptions(options);
     }
-    return chunk.upload(this.getRequestOptionsForCall(requestOptions), data, postageBatchId, options);
+    return chunk.upload(this.getRequestOptionsForCall(requestOptions), data, stamp, options);
   }
   /**
    * Download chunk as a byte array
@@ -698,13 +708,12 @@ export class Bee {
    * @see [Bee docs - Feeds](https://docs.ethswarm.org/docs/develop/tools-and-features/feeds)
    * @see [Bee API reference - `POST /feeds`](https://docs.ethswarm.org/api/#tag/Feed/paths/~1feeds~1{owner}~1{topic}/post)
    */
-  async createFeedManifest(postageBatchId, type, topic, owner, options) {
+  async createFeedManifest(stamp, type, topic, owner, options) {
     assertRequestOptions(options);
     assertFeedType(type);
-    assertBatchId(postageBatchId);
     const canonicalTopic = makeTopic(topic);
     const canonicalOwner = makeHexEthAddress(owner);
-    const reference = await createFeedManifest(this.getRequestOptionsForCall(options), canonicalOwner, canonicalTopic, postageBatchId);
+    const reference = await createFeedManifest(this.getRequestOptionsForCall(options), canonicalOwner, canonicalTopic, stamp);
     return addCidConversionFunction({
       reference
     }, ReferenceType.FEED);
@@ -853,6 +862,10 @@ export class Bee {
       upload: uploadSingleOwnerChunkData.bind(null, this.getRequestOptionsForCall(options), canonicalSigner)
     };
   }
+  async createEnvelope(postageBatchId, reference, options) {
+    assertRequestOptions(options);
+    return postEnvelope(this.getRequestOptionsForCall(options), postageBatchId, reference);
+  }
   /**
    * Ping the Bee node to see if there is a live Bee node on the given URL.
    *

package/dist/mjs/chunk/soc.js

@@ -5,7 +5,6 @@ import { bytesAtOffset, bytesEqual, flexBytesAtOffset } from "../utils/bytes.js"
 import { BeeError } from "../utils/error.js";
 import { keccak256Hash } from "../utils/hash.js";
 import { bytesToHex } from "../utils/hex.js";
-import { assertAddress } from "../utils/type.js";
 import { bmtHash } from "./bmt.js";
 import { MAX_PAYLOAD_SIZE, MIN_PAYLOAD_SIZE, assertValidChunkData, makeContentAddressedChunk } from "./cac.js";
 import { recoverAddress, sign } from "./signer.js";
@@ -90,12 +89,12 @@ export async function makeSingleOwnerChunk(chunk, identifier, signer) {
  * @param postageBatchId  Postage BatchId that will be assigned to uploaded data
  * @param options         Upload options
  */
-export async function uploadSingleOwnerChunk(requestOptions, chunk, postageBatchId, options) {
+export async function uploadSingleOwnerChunk(requestOptions, chunk, stamp, options) {
   const owner = bytesToHex(chunk.owner());
   const identifier = bytesToHex(chunk.identifier());
   const signature = bytesToHex(chunk.signature());
   const data = Binary.concatBytes(chunk.span(), chunk.payload());
-  return socAPI.upload(requestOptions, owner, identifier, signature, data, postageBatchId, options);
+  return socAPI.upload(requestOptions, owner, identifier, signature, data, stamp, options);
 }
 /**
  * Helper function to create and upload SOC.
@@ -107,11 +106,10 @@ export async function uploadSingleOwnerChunk(requestOptions, chunk, postageBatch
  * @param data            The chunk data
  * @param options
  */
-export async function uploadSingleOwnerChunkData(requestOptions, signer, postageBatchId, identifier, data, options) {
-  assertAddress(postageBatchId);
+export async function uploadSingleOwnerChunkData(requestOptions, signer, stamp, identifier, data, options) {
   const cac = makeContentAddressedChunk(data);
   const soc = await makeSingleOwnerChunk(cac, identifier, signer);
-  return uploadSingleOwnerChunk(requestOptions, soc, postageBatchId, options);
+  return uploadSingleOwnerChunk(requestOptions, soc, stamp, options);
 }
 /**
  * Helper function to download SOC.

package/dist/mjs/modules/bytes.js

@@ -28,6 +28,22 @@ export async function upload(requestOptions, data, postageBatchId, options) {
     historyAddress: response.headers['swarm-act-history-address'] || ''
   };
 }
+/**
+ * Requests content length for a reference
+ *
+ * @param requestOptions Options for making requests
+ * @param hash Bee content reference
+ */
+export async function head(requestOptions, hash) {
+  const response = await http(requestOptions, {
+    url: `${endpoint}/${hash}`,
+    method: 'head',
+    responseType: 'json'
+  });
+  return {
+    contentLength: parseInt(response.headers['content-length'])
+  };
+}
 /**
  * Download data as a byte array
  *

package/dist/mjs/modules/chunk.js

@@ -11,18 +11,18 @@ const endpoint = 'chunks';
  * Upload expects the chuck data to be set accordingly.
  *
  * @param requestOptions Options for making requests
- * @param data    Chunk data to be uploaded
- * @param postageBatchId  Postage BatchId that will be assigned to uploaded data
+ * @param data Chunk data to be uploaded
+ * @param stamp BatchId or marshaled stamp to be used for the upload
  * @param options Additional options like tag, encryption, pinning
  */
-export async function upload(requestOptions, data, postageBatchId, options) {
+export async function upload(requestOptions, data, stamp, options) {
   const response = await http(requestOptions, {
     method: 'post',
     url: `${endpoint}`,
     data,
     headers: {
       'content-type': 'application/octet-stream',
-      ...extractUploadHeaders(postageBatchId, options)
+      ...extractUploadHeaders(stamp, options)
     },
     responseType: 'json'
   });

package/dist/mjs/modules/envelope.js

@@ -0,0 +1,33 @@
+import { Binary, Types } from 'cafe-utility';
+import { http } from "../utils/http.js";
+const ENVELOPE_ENDPOINT = 'envelope';
+export async function postEnvelope(requestOptions, postageBatchId, reference) {
+  const {
+    data
+  } = await http(requestOptions, {
+    method: 'post',
+    responseType: 'json',
+    url: `${ENVELOPE_ENDPOINT}/${reference}`,
+    headers: {
+      'swarm-postage-batch-id': postageBatchId
+    }
+  });
+  return {
+    issuer: Binary.hexToUint8Array(Types.asHexString(data.issuer, {
+      name: 'issuer',
+      byteLength: 20
+    })),
+    index: Binary.hexToUint8Array(Types.asHexString(data.index, {
+      name: 'index',
+      byteLength: 8
+    })),
+    timestamp: Binary.hexToUint8Array(Types.asHexString(data.timestamp, {
+      name: 'timestamp',
+      byteLength: 8
+    })),
+    signature: Binary.hexToUint8Array(Types.asHexString(data.signature, {
+      name: 'signature',
+      byteLength: 65
+    }))
+  };
+}

package/dist/mjs/modules/feed.js

@@ -11,12 +11,12 @@ const feedEndpoint = 'feeds';
  * @param postageBatchId  Postage BatchId to be used to create the Feed Manifest
  * @param options         Additional options, like type (default: 'sequence')
  */
-export async function createFeedManifest(requestOptions, owner, topic, postageBatchId) {
+export async function createFeedManifest(requestOptions, owner, topic, stamp) {
   const response = await http(requestOptions, {
     method: 'post',
     responseType: 'json',
     url: `${feedEndpoint}/${owner}/${topic}`,
-    headers: extractUploadHeaders(postageBatchId)
+    headers: extractUploadHeaders(stamp)
   });
   return response.data.reference;
 }

package/dist/mjs/modules/soc.js

@@ -13,14 +13,14 @@ const socEndpoint = 'soc';
  * @param postageBatchId  Postage BatchId that will be assigned to uploaded data
  * @param options         Additional options like tag, encryption, pinning
  */
-export async function upload(requestOptions, owner, identifier, signature, data, postageBatchId, options) {
+export async function upload(requestOptions, owner, identifier, signature, data, stamp, options) {
   const response = await http(requestOptions, {
     method: 'post',
     url: `${socEndpoint}/${owner}/${identifier}`,
     data,
     headers: {
       'content-type': 'application/octet-stream',
-      ...extractUploadHeaders(postageBatchId, options)
+      ...extractUploadHeaders(stamp, options)
     },
     responseType: 'json',
     params: {

package/dist/mjs/utils/expose.js

@@ -6,4 +6,6 @@ export { capitalizeAddressERC55, ethToSwarmAddress, fromLittleEndian, isHexEthAd
 export { keccak256Hash } from "./hash.js";
 export { makeMaxTarget } from "./pss.js";
 export { getAmountForTtl, getDepthForCapacity, getStampCostInBzz, getStampCostInPlur, getStampEffectiveBytes, getStampMaximumCapacityBytes, getStampTtlSeconds, getStampUsage } from "./stamps.js";
-export { approximateOverheadForRedundancyLevel, getRedundancyStat, getRedundancyStats } from "./redundancy.js";
+export { approximateOverheadForRedundancyLevel, getRedundancyStat, getRedundancyStats } from "./redundancy.js";
+export const NULL_STAMP = '0000000000000000000000000000000000000000000000000000000000000000';
+export const NULL_TOPIC = '0000000000000000000000000000000000000000000000000000000000000000';

package/dist/mjs/utils/headers.js

@@ -1,3 +1,4 @@
+import { Binary } from 'cafe-utility';
 import { BeeError } from "./error.js";
 /**
  * Read the filename from the content-disposition header
@@ -35,13 +36,16 @@ export function readFileHeaders(headers) {
     contentType
   };
 }
-export function extractUploadHeaders(postageBatchId, options) {
-  if (!postageBatchId) {
-    throw new BeeError('Postage BatchID has to be specified!');
+export function extractUploadHeaders(stamp, options) {
+  if (!stamp) {
+    throw new BeeError('Stamp has to be specified!');
+  }
+  const headers = {};
+  if (stamp instanceof Uint8Array) {
+    headers['swarm-postage-stamp'] = Binary.uint8ArrayToHex(stamp);
+  } else {
+    headers['swarm-postage-batch-id'] = stamp;
   }
-  const headers = {
-    'swarm-postage-batch-id': postageBatchId
-  };
   if (options?.act) {
     headers['swarm-act'] = String(options.act);
   }

package/dist/mjs/utils/stamps.js

@@ -1,3 +1,4 @@
+import { Binary } from 'cafe-utility';
 /**
  * Utility function that calculates usage of postage batch based on its utilization, depth and bucket depth.
  *
@@ -100,4 +101,22 @@ export function getAmountForTtl(days) {
  */
 export function getDepthForCapacity(gigabytes) {
   return gigabytes <= 1 ? 18 : Math.ceil(Math.log2(Math.ceil(gigabytes)) + 18);
+}
+export function convertEnvelopeToMarshaledStamp(batchID, envelope) {
+  return marshalStamp(envelope.signature, Binary.hexToUint8Array(batchID), envelope.timestamp, envelope.index);
+}
+export function marshalStamp(signature, batchID, timestamp, index) {
+  if (signature.length !== 65) {
+    throw Error('invalid signature length');
+  }
+  if (batchID.length !== 32) {
+    throw Error('invalid batch ID length');
+  }
+  if (timestamp.length !== 8) {
+    throw Error('invalid timestamp length');
+  }
+  if (index.length !== 8) {
+    throw Error('invalid index length');
+  }
+  return Binary.concatBytes(batchID, index, timestamp, signature);
 }

package/dist/mjs/utils/type.js

@@ -7,9 +7,6 @@ import { assertHexString, assertPrefixedHexString, isHexString } from "./hex.js"
 export function isReadable(obj) {
   return typeof Readable !== 'undefined' && obj instanceof Readable;
 }
-export function isUint8Array(obj) {
-  return obj instanceof Uint8Array;
-}
 export function isInteger(value) {
   return typeof value === 'string' && /^-?(0|[1-9][0-9]*)$/g.test(value) || typeof value === 'number' && value > Number.MIN_SAFE_INTEGER && value < Number.MAX_SAFE_INTEGER && Number.isInteger(value);
 }

package/dist/types/bee.d.ts

@@ -2,7 +2,7 @@
 import { Readable } from 'stream';
 import { Index, IndexBytes } from './feed';
 import { FeedType } from './feed/type';
-import type { Address, AddressPrefix, AllSettlements, AnyJson, BalanceResponse, BatchId, BeeOptions, BeeRequestOptions, BeeVersions, ChainState, ChequebookAddressResponse, ChequebookBalanceResponse, CollectionUploadOptions, Data, DebugStatus, ExtendedTag, FeedReader, FeedWriter, FileData, FileUploadOptions, GetGranteesResult, GranteesResult, Health, JsonFeedOptions, LastCashoutActionResponse, LastChequesForPeerResponse, LastChequesResponse, NodeAddresses, NodeInfo, NumberString, Peer, PeerBalance, Pin, PingResponse, PostageBatch, PostageBatchBuckets, PssMessageHandler, PssSubscription, PublicKey, RedistributionState, Reference, RemovePeerResponse, ReserveState, SOCReader, SOCWriter, Settlements, Signer, Tag, Topic, Topology, TransactionHash, TransactionInfo, UploadOptions, UploadRedundancyOptions, UploadResultWithCid, WalletBalance } from './types';
+import type { Address, AddressPrefix, AllSettlements, AnyJson, BalanceResponse, BatchId, BeeOptions, BeeRequestOptions, BeeVersions, ChainState, ChequebookAddressResponse, ChequebookBalanceResponse, CollectionUploadOptions, Data, DebugStatus, Envelope, ExtendedTag, FeedReader, FeedWriter, FileData, FileUploadOptions, GetGranteesResult, GranteesResult, Health, JsonFeedOptions, LastCashoutActionResponse, LastChequesForPeerResponse, LastChequesResponse, NodeAddresses, NodeInfo, NumberString, Peer, PeerBalance, Pin, PingResponse, PostageBatch, PostageBatchBuckets, PssMessageHandler, PssSubscription, PublicKey, RedistributionState, Reference, ReferenceInformation, RemovePeerResponse, ReserveState, SOCReader, SOCWriter, Settlements, Signer, Tag, Topic, Topology, TransactionHash, TransactionInfo, UploadOptions, UploadRedundancyOptions, UploadResultWithCid, WalletBalance } from './types';
 import { AllTagsOptions, CashoutOptions, Collection, FeedManifestResult, PostageBatchOptions, ReferenceCidOrEns, ReferenceOrEns, TransactionOptions, UploadResult } from './types';
 import { EthAddress } from './utils/eth';
 /**
@@ -42,6 +42,12 @@ export declare class Bee {
      * @see [Bee API reference - `POST /bytes`](https://docs.ethswarm.org/api/#tag/Bytes/paths/~1bytes/post)
      */
     uploadData(postageBatchId: string | BatchId, data: string | Uint8Array, options?: UploadOptions & UploadRedundancyOptions, requestOptions?: BeeRequestOptions): Promise<UploadResult>;
+    /**
+     * Requests content length for a `/bytes` reference
+     *
+     * @see [Bee API reference - `HEAD /bytes/`](https://docs.ethswarm.org/api/#tag/Bytes/paths/~1bytes~1%7Breference%7D/head)
+     */
+    probeData(reference: ReferenceOrEns | string, options?: BeeRequestOptions): Promise<ReferenceInformation>;
     /**
      * Download data as a byte array
      *
@@ -75,7 +81,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(postageBatchId: string | BatchId, data: Uint8Array, options?: UploadOptions, requestOptions?: BeeRequestOptions): Promise<UploadResult>;
+    uploadChunk(stamp: BatchId | Uint8Array | string, data: Uint8Array, options?: UploadOptions, requestOptions?: BeeRequestOptions): Promise<UploadResult>;
     /**
      * Download chunk as a byte array
      *
@@ -423,7 +429,7 @@ export declare class Bee {
      * @see [Bee docs - Feeds](https://docs.ethswarm.org/docs/develop/tools-and-features/feeds)
      * @see [Bee API reference - `POST /feeds`](https://docs.ethswarm.org/api/#tag/Feed/paths/~1feeds~1{owner}~1{topic}/post)
      */
-    createFeedManifest(postageBatchId: string | BatchId, type: FeedType, topic: Topic | Uint8Array | string, owner: EthAddress | Uint8Array | string, options?: BeeRequestOptions): Promise<FeedManifestResult>;
+    createFeedManifest(stamp: BatchId | Uint8Array | string, type: FeedType, topic: Topic | Uint8Array | string, owner: EthAddress | Uint8Array | string, options?: BeeRequestOptions): Promise<FeedManifestResult>;
     /**
      * Make a new feed reader for downloading feed updates.
      *
@@ -510,6 +516,7 @@ export declare class Bee {
      * @see [Bee docs - Chunk Types](https://docs.ethswarm.org/docs/develop/tools-and-features/chunk-types#single-owner-chunks)
      */
     makeSOCWriter(signer?: Signer | Uint8Array | string, options?: BeeRequestOptions): SOCWriter;
+    createEnvelope(postageBatchId: BatchId, reference: Reference, options?: BeeRequestOptions): Promise<Envelope>;
     /**
      * Ping the Bee node to see if there is a live Bee node on the given URL.
      *

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

@@ -44,7 +44,7 @@ export declare function makeSingleOwnerChunk(chunk: Chunk, identifier: Identifie
  * @param postageBatchId  Postage BatchId that will be assigned to uploaded data
  * @param options         Upload options
  */
-export declare function uploadSingleOwnerChunk(requestOptions: BeeRequestOptions, chunk: SingleOwnerChunk, postageBatchId: BatchId, options?: UploadOptions): Promise<UploadResult>;
+export declare function uploadSingleOwnerChunk(requestOptions: BeeRequestOptions, chunk: SingleOwnerChunk, stamp: BatchId | Uint8Array | string, options?: UploadOptions): Promise<UploadResult>;
 /**
  * Helper function to create and upload SOC.
  *
@@ -55,7 +55,7 @@ export declare function uploadSingleOwnerChunk(requestOptions: BeeRequestOptions
  * @param data            The chunk data
  * @param options
  */
-export declare function uploadSingleOwnerChunkData(requestOptions: BeeRequestOptions, signer: Signer, postageBatchId: BatchId | string, identifier: Identifier, data: Uint8Array, options?: UploadOptions): Promise<UploadResult>;
+export declare function uploadSingleOwnerChunkData(requestOptions: BeeRequestOptions, signer: Signer, stamp: BatchId | Uint8Array | string, identifier: Identifier, data: Uint8Array, options?: UploadOptions): Promise<UploadResult>;
 /**
  * Helper function to download SOC.
  *

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

@@ -1,4 +1,4 @@
-import type { BatchId, BeeRequestOptions, Data, DownloadRedundancyOptions, ReferenceOrEns, UploadOptions, UploadRedundancyOptions } from '../types';
+import type { BatchId, BeeRequestOptions, Data, DownloadRedundancyOptions, ReferenceInformation, ReferenceOrEns, UploadOptions, UploadRedundancyOptions } from '../types';
 import { UploadResult } from '../types';
 /**
  * Upload data to a Bee node
@@ -9,6 +9,13 @@ import { UploadResult } from '../types';
  * @param options         Additional options like tag, encryption, pinning
  */
 export declare function upload(requestOptions: BeeRequestOptions, data: string | Uint8Array, postageBatchId: BatchId, options?: UploadOptions & UploadRedundancyOptions): Promise<UploadResult>;
+/**
+ * Requests content length for a reference
+ *
+ * @param requestOptions Options for making requests
+ * @param hash Bee content reference
+ */
+export declare function head(requestOptions: BeeRequestOptions, hash: ReferenceOrEns): Promise<ReferenceInformation>;
 /**
  * Download data as a byte array
  *

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

@@ -7,11 +7,11 @@ import type { BatchId, BeeRequestOptions, Data, ReferenceOrEns, UploadOptions, U
  * Upload expects the chuck data to be set accordingly.
  *
  * @param requestOptions Options for making requests
- * @param data    Chunk data to be uploaded
- * @param postageBatchId  Postage BatchId that will be assigned to uploaded data
+ * @param data Chunk data to be uploaded
+ * @param stamp BatchId or marshaled stamp to be used for the upload
  * @param options Additional options like tag, encryption, pinning
  */
-export declare function upload(requestOptions: BeeRequestOptions, data: Uint8Array, postageBatchId: BatchId, options?: UploadOptions): Promise<UploadResult>;
+export declare function upload(requestOptions: BeeRequestOptions, data: Uint8Array, stamp: BatchId | Uint8Array | string, options?: UploadOptions): Promise<UploadResult>;
 /**
  * Download chunk data as a byte array
  *

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

@@ -0,0 +1,2 @@
+import type { BatchId, BeeRequestOptions, Envelope, Reference } from '../types';
+export declare function postEnvelope(requestOptions: BeeRequestOptions, postageBatchId: BatchId, reference: Reference): Promise<Envelope>;

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

@@ -38,7 +38,7 @@ export interface FetchFeedUpdateResponse extends ReferenceResponse, FeedUpdateHe
  * @param postageBatchId  Postage BatchId to be used to create the Feed Manifest
  * @param options         Additional options, like type (default: 'sequence')
  */
-export declare function createFeedManifest(requestOptions: BeeRequestOptions, owner: HexEthAddress, topic: Topic, postageBatchId: BatchId): Promise<Reference>;
+export declare function createFeedManifest(requestOptions: BeeRequestOptions, owner: HexEthAddress, topic: Topic, stamp: BatchId | Uint8Array | string): Promise<Reference>;
 /**
  * Find and retrieve feed update
  *

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

@@ -10,4 +10,4 @@ import { BatchId, BeeRequestOptions, UploadOptions, UploadResult } from '../type
  * @param postageBatchId  Postage BatchId that will be assigned to uploaded data
  * @param options         Additional options like tag, encryption, pinning
  */
-export declare function upload(requestOptions: BeeRequestOptions, owner: string, identifier: string, signature: string, data: Uint8Array, postageBatchId: BatchId, options?: UploadOptions): Promise<UploadResult>;
+export declare function upload(requestOptions: BeeRequestOptions, owner: string, identifier: string, signature: string, data: Uint8Array, stamp: BatchId | Uint8Array | string, options?: UploadOptions): Promise<UploadResult>;

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

@@ -295,6 +295,9 @@ export interface FileData<T> extends FileHeaders {
 export interface Pin {
     reference: string;
 }
+export interface ReferenceInformation {
+    contentLength: number;
+}
 /**
  * Helper interface that adds utility functions
  * to work more conveniently with bytes in normal
@@ -446,7 +449,7 @@ export interface SOCWriter extends SOCReader {
      * @param data        The chunk payload data
      * @param options     Upload options
      */
-    upload: (postageBatchId: string | BatchId, identifier: Identifier, data: Uint8Array, options?: UploadOptions) => Promise<UploadResult>;
+    upload: (stamp: BatchId | Uint8Array | string, identifier: Identifier, data: Uint8Array, options?: UploadOptions) => Promise<UploadResult>;
 }
 /**
  * Interface representing Postage stamp batch.
@@ -519,6 +522,12 @@ export interface PostageBatchOptions {
      */
     waitForUsableTimeout?: number;
 }
+export interface Envelope {
+    issuer: Uint8Array;
+    index: Uint8Array;
+    timestamp: Uint8Array;
+    signature: Uint8Array;
+}
 /**
  * With this type a number should be represented in a string
  */

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

@@ -1,9 +1,12 @@
+import { BatchId, Topic } from '..';
 export { getCollectionSize } from './collection';
 export { getFolderSize } from './collection.node';
-export { Bytes, FlexBytes, assertBytes, assertFlexBytes, bytesAtOffset, bytesEqual, flexBytesAtOffset, isBytes, isFlexBytes, } from './bytes';
-export { HexString, PrefixedHexString, assertHexString, assertPrefixedHexString, bytesToHex, hexToBytes, intToHex, isHexString, makeHexString, } from './hex';
-export { EthAddress, capitalizeAddressERC55, ethToSwarmAddress, fromLittleEndian, isHexEthAddress, makeEthAddress, makeEthereumWalletSigner, makeHexEthAddress, toLittleEndian, } from './eth';
+export { assertBytes, assertFlexBytes, Bytes, bytesAtOffset, bytesEqual, FlexBytes, flexBytesAtOffset, isBytes, isFlexBytes, } from './bytes';
+export { assertHexString, assertPrefixedHexString, bytesToHex, HexString, hexToBytes, intToHex, isHexString, makeHexString, PrefixedHexString, } from './hex';
+export { capitalizeAddressERC55, EthAddress, ethToSwarmAddress, fromLittleEndian, isHexEthAddress, makeEthAddress, makeEthereumWalletSigner, makeHexEthAddress, toLittleEndian, } from './eth';
 export { keccak256Hash } from './hash';
 export { makeMaxTarget } from './pss';
 export { getAmountForTtl, getDepthForCapacity, getStampCostInBzz, getStampCostInPlur, getStampEffectiveBytes, getStampMaximumCapacityBytes, getStampTtlSeconds, getStampUsage, } from './stamps';
 export { approximateOverheadForRedundancyLevel, getRedundancyStat, getRedundancyStats } from './redundancy';
+export declare const NULL_STAMP: BatchId;
+export declare const NULL_TOPIC: Topic;

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

@@ -1,5 +1,5 @@
 import { BatchId, DownloadRedundancyOptions, FileHeaders, UploadOptions, UploadRedundancyOptions } from '../types';
 export declare function readFileHeaders(headers: Record<string, string>): FileHeaders;
-export declare function extractUploadHeaders(postageBatchId: BatchId, options?: UploadOptions): Record<string, string>;
+export declare function extractUploadHeaders(stamp: BatchId | Uint8Array | string, options?: UploadOptions): Record<string, string>;
 export declare function extractRedundantUploadHeaders(postageBatchId: BatchId, options?: UploadOptions & UploadRedundancyOptions): Record<string, string>;
 export declare function extractDownloadHeaders(options?: DownloadRedundancyOptions): Record<string, string>;

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

@@ -1,4 +1,4 @@
-import { NumberString } from '../types';
+import { BatchId, Envelope, NumberString } from '../types';
 /**
  * Utility function that calculates usage of postage batch based on its utilization, depth and bucket depth.
  *
@@ -62,3 +62,5 @@ export declare function getAmountForTtl(days: number): NumberString;
  * @returns {number} The calculated depth necessary to achieve the specified capacity.
  */
 export declare function getDepthForCapacity(gigabytes: number): number;
+export declare function convertEnvelopeToMarshaledStamp(batchID: BatchId, envelope: Envelope): Uint8Array;
+export declare function marshalStamp(signature: Uint8Array, batchID: Uint8Array, timestamp: Uint8Array, index: Uint8Array): Uint8Array;

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

@@ -3,7 +3,6 @@ import { ReferenceType } from '@ethersphere/swarm-cid';
 import { Readable } from 'stream';
 import { Address, AddressPrefix, AllTagsOptions, BatchId, BeeRequestOptions, CashoutOptions, CollectionUploadOptions, FileUploadOptions, NumberString, PostageBatchOptions, PssMessageHandler, PublicKey, Reference, ReferenceOrEns, Tag, TransactionHash, TransactionOptions, UploadOptions } from '../types';
 export declare function isReadable(obj: unknown): obj is Readable;
-export declare function isUint8Array(obj: unknown): obj is Uint8Array;
 export declare function isInteger(value: unknown): value is number | NumberString;
 export declare function isObject(value: unknown): value is Record<string, unknown>;
 export declare function isStrictlyObject(value: unknown): value is Record<string, unknown>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ethersphere/bee-js",
-  "version": "8.1.0",
+  "version": "8.2.0",
   "description": "Javascript client for Bee",
   "keywords": [
     "bee",
@@ -63,7 +63,7 @@
   "dependencies": {
     "@ethersphere/swarm-cid": "^0.1.0",
     "axios": "^0.28.1",
-    "cafe-utility": "^21.3.1",
+    "cafe-utility": "^23.7.0",
     "elliptic": "^6.5.4",
     "isomorphic-ws": "^4.0.1",
     "js-sha3": "^0.8.0",