@ethersphere/bee-js 8.1.0 → 8.3.0

package/dist/mjs/bee.js

@@ -1,4 +1,3 @@
-import { ReferenceType } from '@ethersphere/swarm-cid';
 import { Objects, System } from 'cafe-utility';
 import { makeSigner } from "./chunk/signer.js";
 import { downloadSingleOwnerChunk, uploadSingleOwnerChunkData } from "./chunk/soc.js";
@@ -20,6 +19,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";
@@ -61,7 +61,9 @@ export class Bee {
       baseURL: this.url,
       timeout: options?.timeout ?? false,
       headers: options?.headers,
-      onRequest: options?.onRequest
+      onRequest: options?.onRequest,
+      httpAgent: options?.httpAgent,
+      httpsAgent: options?.httpsAgent
     };
   }
   /**
@@ -84,6 +86,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 +137,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 +151,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
@@ -235,14 +246,14 @@ export class Bee {
         contentType,
         ...options
       };
-      return addCidConversionFunction(await bzz.uploadFile(this.getRequestOptionsForCall(requestOptions), fileData, postageBatchId, fileName, fileOptions), ReferenceType.MANIFEST);
+      return addCidConversionFunction(await bzz.uploadFile(this.getRequestOptionsForCall(requestOptions), fileData, postageBatchId, fileName, fileOptions), 'manifest');
     } else if (isReadable(data) && options?.tag && !options.size) {
       // TODO: Needed until https://github.com/ethersphere/bee/issues/2317 is resolved
       const result = await bzz.uploadFile(this.getRequestOptionsForCall(requestOptions), data, postageBatchId, name, options);
       await this.updateTag(options.tag, result.reference);
-      return addCidConversionFunction(result, ReferenceType.MANIFEST);
+      return addCidConversionFunction(result, 'manifest');
     } else {
-      return addCidConversionFunction(await bzz.uploadFile(this.getRequestOptionsForCall(requestOptions), data, postageBatchId, name, options), ReferenceType.MANIFEST);
+      return addCidConversionFunction(await bzz.uploadFile(this.getRequestOptionsForCall(requestOptions), data, postageBatchId, name, options), 'manifest');
     }
   }
   /**
@@ -259,7 +270,7 @@ export class Bee {
    */
   async downloadFile(reference, path = '', options) {
     assertRequestOptions(options);
-    reference = makeReferenceOrEns(reference, ReferenceType.MANIFEST);
+    reference = makeReferenceOrEns(reference, 'manifest');
     return bzz.downloadFile(this.getRequestOptionsForCall(options), reference, path);
   }
   /**
@@ -276,7 +287,7 @@ export class Bee {
    */
   async downloadReadableFile(reference, path = '', options) {
     assertRequestOptions(options);
-    reference = makeReferenceOrEns(reference, ReferenceType.MANIFEST);
+    reference = makeReferenceOrEns(reference, 'manifest');
     return bzz.downloadFileReadable(this.getRequestOptionsForCall(options), reference, path);
   }
   /**
@@ -302,7 +313,7 @@ export class Bee {
       assertCollectionUploadOptions(options);
     }
     const data = await makeCollectionFromFileList(fileList);
-    return addCidConversionFunction(await bzz.uploadCollection(this.getRequestOptionsForCall(requestOptions), data, postageBatchId, options), ReferenceType.MANIFEST);
+    return addCidConversionFunction(await bzz.uploadCollection(this.getRequestOptionsForCall(requestOptions), data, postageBatchId, options), 'manifest');
   }
   /**
    * Upload Collection that you can assembly yourself.
@@ -319,7 +330,7 @@ export class Bee {
     assertBatchId(postageBatchId);
     assertCollection(collection);
     if (options) assertCollectionUploadOptions(options);
-    return addCidConversionFunction(await bzz.uploadCollection(this.getRequestOptionsForCall(this.requestOptions), collection, postageBatchId, options), ReferenceType.MANIFEST);
+    return addCidConversionFunction(await bzz.uploadCollection(this.getRequestOptionsForCall(this.requestOptions), collection, postageBatchId, options), 'manifest');
   }
   /**
    * Upload collection of files.
@@ -342,7 +353,7 @@ export class Bee {
     assertRequestOptions(requestOptions);
     if (options) assertCollectionUploadOptions(options);
     const data = await makeCollectionFromFS(dir);
-    return addCidConversionFunction(await bzz.uploadCollection(this.getRequestOptionsForCall(requestOptions), data, postageBatchId, options), ReferenceType.MANIFEST);
+    return addCidConversionFunction(await bzz.uploadCollection(this.getRequestOptionsForCall(requestOptions), data, postageBatchId, options), 'manifest');
   }
   /**
    * Create a new Tag which is meant for tracking progres of syncing data across network.
@@ -698,16 +709,15 @@ 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);
+    }, 'feed');
   }
   /**
    * Make a new feed reader for downloading feed updates.
@@ -853,6 +863,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/index.js

@@ -1,6 +1,7 @@
 import { Bee } from "./bee.js";
 export { SUPPORTED_BEE_VERSION, SUPPORTED_BEE_VERSION_EXACT } from "./modules/debug/status.js";
 export * from "./types/index.js";
+export * from "./utils/constants.js";
 export * from "./utils/error.js";
 export * as Utils from "./utils/expose.js";
 export { Bee };

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/grantee.js

@@ -10,7 +10,7 @@ export async function getGrantees(reference, requestOptions) {
   return {
     status: response.status,
     statusText: response.statusText,
-    data: response.data.data
+    data: response.data
   };
 }
 export async function createGrantees(requestOptions, postageBatchId, grantees) {
@@ -18,7 +18,7 @@ export async function createGrantees(requestOptions, postageBatchId, grantees) {
     method: 'post',
     url: granteeEndpoint,
     data: {
-      grantees: grantees
+      grantees
     },
     headers: {
       ...extractRedundantUploadHeaders(postageBatchId)

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/cid.js

@@ -0,0 +1,33 @@
+import { Binary } from 'cafe-utility';
+export const SWARM_MANIFEST_CODEC = 0xfa;
+export const SWARM_FEED_CODEC = 0xfb;
+const CODEC_TABLE = {
+  [SWARM_MANIFEST_CODEC]: 'manifest',
+  [SWARM_FEED_CODEC]: 'feed'
+};
+export function convertReferenceToCid(reference, type) {
+  if (reference.length !== 64) {
+    throw TypeError('Only 32-byte, non-encrypted references are supported');
+  }
+  const base32 = 'b';
+  const version = new Uint8Array([1]);
+  const codec = new Uint8Array([type === 'feed' ? SWARM_FEED_CODEC : SWARM_MANIFEST_CODEC]);
+  const unknown = new Uint8Array([1]);
+  const sha256 = new Uint8Array([27]);
+  const size = new Uint8Array([32]);
+  const header = Binary.uint8ArrayToBase32(Binary.concatBytes(version, codec, unknown, sha256, size)).replace(/\=+$/, '');
+  const hash = Binary.uint8ArrayToBase32(Binary.hexToUint8Array(reference)).replace(/\=+$/, '');
+  return `${base32}${header}${hash}`.toLowerCase();
+}
+export function convertCidToReference(cid) {
+  const bytes = Binary.base32ToUint8Array(cid.toUpperCase().slice(1));
+  const codec = bytes[1];
+  if (!CODEC_TABLE[codec]) {
+    throw new Error('Unknown codec');
+  }
+  const reference = bytes.slice(-32);
+  return {
+    type: CODEC_TABLE[codec],
+    reference: Binary.uint8ArrayToHex(reference)
+  };
+}

package/dist/mjs/utils/constants.js

@@ -0,0 +1,3 @@
+export const SWARM_GATEWAY_URL = 'https://api.gateway.ethswarm.org';
+export const NULL_STAMP = '0000000000000000000000000000000000000000000000000000000000000000';
+export const NULL_TOPIC = '0000000000000000000000000000000000000000000000000000000000000000';

package/dist/mjs/utils/expose.js

@@ -6,4 +6,5 @@ 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 { convertCidToReference, convertReferenceToCid } from "./cid.js";

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/http.js

@@ -21,13 +21,6 @@ export async function http(options, config) {
     const requestConfig = Objects.deepMerge3(DEFAULT_HTTP_CONFIG, config, options);
     maybeRunOnRequestHook(options, requestConfig);
     const response = await axios(requestConfig);
-    // Axios does not parse array of strings as JSON
-    if (Array.isArray(response.data) && response.data.every(element => typeof element === 'string')) {
-      const array = response.data;
-      response.data = {
-        data: array
-      };
-    }
     // TODO: https://github.com/axios/axios/pull/6253
     return response;
   } catch (e) {

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/tar.browser.js

@@ -12,6 +12,9 @@ export class TarStream {
     });
   }
   beginFile(path, size) {
+    if (path.length > 100) {
+      throw new Error(`File name too long: ${path}`);
+    }
     const header = createHeader(path, size);
     this.pieces.push(header);
     this.currentFileSize = 0;

package/dist/mjs/utils/tar.js

@@ -5,6 +5,9 @@ export class TarStream {
     this.currentFileSize = 0;
   }
   beginFile(path, size) {
+    if (path.length > 100) {
+      throw new Error(`File name too long: ${path}`);
+    }
     const header = createHeader(path, size);
     this.output.write(header);
     this.currentFileSize = 0;

package/dist/mjs/utils/type.js

@@ -1,15 +1,12 @@
-import { decodeCid, encodeReference } from '@ethersphere/swarm-cid';
 import { Readable } from 'stream';
 import { ADDRESS_HEX_LENGTH, BATCH_ID_HEX_LENGTH, ENCRYPTED_REFERENCE_HEX_LENGTH, PSS_TARGET_HEX_LENGTH_MAX, PUBKEY_HEX_LENGTH, REFERENCE_HEX_LENGTH, TAGS_LIMIT_MAX, TAGS_LIMIT_MIN } from "../types/index.js";
+import { convertCidToReference, convertReferenceToCid } from "./cid.js";
 import { BeeArgumentError, BeeError } from "./error.js";
 import { isFile } from "./file.js";
 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);
 }
@@ -113,7 +110,7 @@ export function makeReferenceOrEns(value, expectedCidType) {
     throw new TypeError('ReferenceCidOrEns has to be a string!');
   }
   try {
-    const result = decodeCid(value);
+    const result = convertCidToReference(value);
     if (result.type !== expectedCidType) {
       throw new BeeError(`CID was expected to be of type ${expectedCidType}, but got instead ${result.type ?? 'non-Swarm CID'}`);
     }
@@ -127,13 +124,13 @@ export function makeReferenceOrEns(value, expectedCidType) {
 /**
  * Function that adds getter which converts the reference into CID base32 encoded string.
  * @param result
- * @param cidType Type as described in the @ethersphere/swarm-cids-js -> ReferenceType
+ * @param cidType feed or manifest
  */
 export function addCidConversionFunction(result, cidType) {
   return {
     ...result,
     cid() {
-      return encodeReference(result.reference, cidType).toString();
+      return convertReferenceToCid(result.reference, cidType);
     }
   };
 }

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/index.d.ts

@@ -1,6 +1,7 @@
 import { Bee } from './bee';
 export { SUPPORTED_BEE_VERSION, SUPPORTED_BEE_VERSION_EXACT } from './modules/debug/status';
 export * from './types';
+export * from './utils/constants';
 export * from './utils/error';
 export * as Utils from './utils/expose';
 export { Bee };

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
  *