@ethersphere/bee-js 8.3.1 → 9.0.2

package/dist/mjs/chunk/bmt.js

@@ -1,14 +1,8 @@
-// For ESM compatibility
-import pkg from 'js-sha3';
-const {
-  keccak256
-} = pkg;
+import { Binary } from 'cafe-utility';
 import { BeeArgumentError } from "../utils/error.js";
-import { keccak256Hash } from "../utils/hash.js";
+import { Reference, Span } from "../utils/typed-bytes.js";
 const MAX_CHUNK_PAYLOAD_SIZE = 4096;
 const SEGMENT_SIZE = 32;
-const SEGMENT_PAIR_SIZE = 2 * SEGMENT_SIZE;
-const HASH_SIZE = 32;
 /**
  * Calculate a Binary Merkle Tree hash for a chunk
  *
@@ -23,28 +17,18 @@ const HASH_SIZE = 32;
  *
  * @returns the keccak256 hash in a byte array
  */
-export function bmtHash(chunkContent) {
-  const span = chunkContent.slice(0, 8);
-  const payload = chunkContent.slice(8);
-  const rootHash = bmtRootHash(payload);
-  const chunkHashInput = new Uint8Array([...span, ...rootHash]);
-  const chunkHash = keccak256Hash(chunkHashInput);
-  return chunkHash;
+export function calculateChunkAddress(chunkContent) {
+  const span = chunkContent.slice(0, Span.LENGTH);
+  const payload = chunkContent.slice(Span.LENGTH);
+  const rootHash = calculateBmtRootHash(payload);
+  const chunkHash = Binary.keccak256(Binary.concatBytes(span, rootHash));
+  return new Reference(chunkHash);
 }
-function bmtRootHash(payload) {
+function calculateBmtRootHash(payload) {
   if (payload.length > MAX_CHUNK_PAYLOAD_SIZE) {
-    throw new BeeArgumentError('invalid data length', payload);
+    throw new BeeArgumentError(`payload size ${payload.length} exceeds maximum chunk payload size ${MAX_CHUNK_PAYLOAD_SIZE}`, payload);
   }
-  // create an input buffer padded with zeros
-  let input = new Uint8Array([...payload, ...new Uint8Array(MAX_CHUNK_PAYLOAD_SIZE - payload.length)]);
-  while (input.length !== HASH_SIZE) {
-    const output = new Uint8Array(input.length / 2);
-    // in each round we hash the segment pairs together
-    for (let offset = 0; offset < input.length; offset += SEGMENT_PAIR_SIZE) {
-      const hashNumbers = keccak256.array(input.slice(offset, offset + SEGMENT_PAIR_SIZE));
-      output.set(hashNumbers, offset / 2);
-    }
-    input = output;
-  }
-  return input;
+  const input = new Uint8Array(MAX_CHUNK_PAYLOAD_SIZE);
+  input.set(payload);
+  return Binary.log2Reduce(Binary.partition(input, SEGMENT_SIZE), (a, b) => Binary.keccak256(Binary.concatBytes(a, b)));
 }

package/dist/mjs/chunk/cac.js

@@ -1,49 +1,41 @@
 import { Binary } from 'cafe-utility';
-import { assertFlexBytes, bytesEqual, flexBytesAtOffset } from "../utils/bytes.js";
-import { BeeError } from "../utils/error.js";
-import { bmtHash } from "./bmt.js";
-import { SPAN_SIZE, makeSpan } from "./span.js";
+import { Bytes } from "../utils/bytes.js";
+import { Span } from "../utils/typed-bytes.js";
+import { calculateChunkAddress } from "./bmt.js";
 export const MIN_PAYLOAD_SIZE = 1;
 export const MAX_PAYLOAD_SIZE = 4096;
-const CAC_SPAN_OFFSET = 0;
-const CAC_PAYLOAD_OFFSET = CAC_SPAN_OFFSET + SPAN_SIZE;
+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) {
-  const span = makeSpan(payloadBytes.length);
-  assertFlexBytes(payloadBytes, MIN_PAYLOAD_SIZE, MAX_PAYLOAD_SIZE);
-  const data = Binary.concatBytes(span, 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: () => span,
-    payload: () => flexBytesAtOffset(data, CAC_PAYLOAD_OFFSET, MIN_PAYLOAD_SIZE, MAX_PAYLOAD_SIZE),
-    address: () => bmtHash(data)
+    span,
+    payload: Bytes.fromSlice(data, Span.LENGTH),
+    address: calculateChunkAddress(data)
   };
 }
-/**
- * Type guard for valid content addressed chunk data
- *
- * @param data          The chunk data
- * @param chunkAddress  The address of the chunk
- */
-export function isValidChunkData(data, chunkAddress) {
-  if (!(data instanceof Uint8Array)) return false;
-  const address = bmtHash(data);
-  return bytesEqual(address, chunkAddress);
-}
-/**
- * Asserts if data are representing given address of its chunk.
- *
- * @param data          The chunk data
- * @param chunkAddress  The address of the chunk
- *
- * @returns a valid content addressed chunk or throws error
- */
-export function assertValidChunkData(data, chunkAddress) {
-  if (!isValidChunkData(data, chunkAddress)) {
-    throw new BeeError('Address of content address chunk does not match given data!');
+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}]`);
   }
+  const span = Span.fromSlice(chunkBytes, 0);
+  const data = Binary.concatBytes(span.toUint8Array(), chunkBytes.slice(Span.LENGTH));
+  return {
+    data,
+    span,
+    payload: Bytes.fromSlice(data, Span.LENGTH),
+    address: calculateChunkAddress(data)
+  };
 }

package/dist/mjs/chunk/soc.js

@@ -1,27 +1,21 @@
 import { Binary } from 'cafe-utility';
 import * as chunkAPI from "../modules/chunk.js";
 import * as socAPI from "../modules/soc.js";
-import { bytesAtOffset, bytesEqual, flexBytesAtOffset } from "../utils/bytes.js";
+import { Bytes } from "../utils/bytes.js";
 import { BeeError } from "../utils/error.js";
-import { keccak256Hash } from "../utils/hash.js";
-import { bytesToHex } from "../utils/hex.js";
-import { bmtHash } from "./bmt.js";
-import { MAX_PAYLOAD_SIZE, MIN_PAYLOAD_SIZE, assertValidChunkData, makeContentAddressedChunk } from "./cac.js";
-import { recoverAddress, sign } from "./signer.js";
-import { SPAN_SIZE } from "./span.js";
-const IDENTIFIER_SIZE = 32;
-const SIGNATURE_SIZE = 65;
-const SOC_IDENTIFIER_OFFSET = 0;
-const SOC_SIGNATURE_OFFSET = SOC_IDENTIFIER_OFFSET + IDENTIFIER_SIZE;
-const SOC_SPAN_OFFSET = SOC_SIGNATURE_OFFSET + SIGNATURE_SIZE;
-const SOC_PAYLOAD_OFFSET = SOC_SPAN_OFFSET + SPAN_SIZE;
+import { EthAddress, Identifier, PrivateKey, Reference, Signature, Span } from "../utils/typed-bytes.js";
+import { calculateChunkAddress } from "./bmt.js";
+import { asContentAddressedChunk, 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;
 function recoverChunkOwner(data) {
   const cacData = data.slice(SOC_SPAN_OFFSET);
-  const chunkAddress = bmtHash(cacData);
-  const signature = bytesAtOffset(data, SOC_SIGNATURE_OFFSET, SIGNATURE_SIZE);
-  const identifier = bytesAtOffset(data, SOC_IDENTIFIER_OFFSET, IDENTIFIER_SIZE);
-  const digest = keccak256Hash(identifier, chunkAddress);
-  const ownerAddress = recoverAddress(signature, digest);
+  const chunkAddress = calculateChunkAddress(cacData);
+  const signature = Signature.fromSlice(data, SOC_SIGNATURE_OFFSET);
+  const identifier = Bytes.fromSlice(data, 0, Identifier.LENGTH);
+  const digest = Binary.concatBytes(identifier.toUint8Array(), chunkAddress.toUint8Array());
+  const ownerAddress = signature.recoverPublicKey(digest).address();
   return ownerAddress;
 }
 /**
@@ -33,50 +27,53 @@ function recoverChunkOwner(data) {
  * @returns a single owner chunk or throws error
  */
 export function makeSingleOwnerChunkFromData(data, address) {
+  data = data instanceof Bytes ? data.toUint8Array() : data;
+  address = new Reference(address);
   const ownerAddress = recoverChunkOwner(data);
-  const identifier = bytesAtOffset(data, SOC_IDENTIFIER_OFFSET, IDENTIFIER_SIZE);
-  const socAddress = keccak256Hash(identifier, ownerAddress);
-  if (!bytesEqual(address, socAddress)) {
+  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!');
   }
-  const signature = () => bytesAtOffset(data, SOC_SIGNATURE_OFFSET, SIGNATURE_SIZE);
-  const span = () => bytesAtOffset(data, SOC_SPAN_OFFSET, SPAN_SIZE);
-  const payload = () => flexBytesAtOffset(data, SOC_PAYLOAD_OFFSET, MIN_PAYLOAD_SIZE, MAX_PAYLOAD_SIZE);
+  const signature = Signature.fromSlice(data, SOC_SIGNATURE_OFFSET);
+  const span = Span.fromSlice(data, SOC_SPAN_OFFSET);
+  const payload = Bytes.fromSlice(data, SOC_PAYLOAD_OFFSET);
   return {
     data,
-    identifier: () => identifier,
+    identifier,
     signature,
     span,
     payload,
-    address: () => socAddress,
-    owner: () => ownerAddress
+    address: socAddress,
+    owner: ownerAddress
   };
 }
 export function makeSOCAddress(identifier, address) {
-  return keccak256Hash(identifier, address);
+  return new Reference(Binary.keccak256(Binary.concatBytes(identifier.toUint8Array(), address.toUint8Array())));
 }
 /**
  * Creates a single owner chunk object
  *
  * @param chunk       A chunk object used for the span and payload
  * @param identifier  The identifier of the chunk
- * @param signer      The singer interface for signing the chunk
+ * @param signer      The signer interface for signing the chunk
  */
-export async function makeSingleOwnerChunk(chunk, identifier, signer) {
-  const chunkAddress = chunk.address();
-  assertValidChunkData(chunk.data, chunkAddress);
-  const digest = keccak256Hash(identifier, chunkAddress);
-  const signature = await sign(signer, digest);
-  const data = Binary.concatBytes(identifier, signature, chunk.span(), chunk.payload());
-  const address = makeSOCAddress(identifier, signer.address);
+export function makeSingleOwnerChunk(chunk, 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);
   return {
     data,
-    identifier: () => identifier,
-    signature: () => signature,
-    span: () => chunk.span(),
-    payload: () => chunk.payload(),
-    address: () => address,
-    owner: () => signer.address
+    identifier,
+    signature,
+    span,
+    payload,
+    address,
+    owner: signer.publicKey().address()
   };
 }
 /**
@@ -86,40 +83,47 @@ export async function makeSingleOwnerChunk(chunk, identifier, signer) {
  *
  * @param requestOptions  Options for making requests
  * @param chunk           A chunk object
- * @param postageBatchId  Postage BatchId that will be assigned to uploaded data
+ * @param stamp  Postage BatchId that will be assigned to uploaded data
  * @param options         Upload 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, stamp, options);
+  const data = Binary.concatBytes(chunk.span.toUint8Array(), chunk.payload.toUint8Array());
+  return socAPI.upload(requestOptions, chunk.owner, chunk.identifier, chunk.signature, data, stamp, options);
 }
 /**
  * Helper function to create and upload SOC.
  *
  * @param requestOptions  Options for making requests
- * @param signer          The singer interface for signing the chunk
+ * @param signer          The signer interface for signing the chunk
  * @param postageBatchId
  * @param identifier      The identifier of the chunk
  * @param data            The chunk data
  * @param options
  */
 export async function uploadSingleOwnerChunkData(requestOptions, signer, stamp, identifier, data, options) {
+  signer = new PrivateKey(signer);
+  identifier = new Identifier(identifier);
   const cac = makeContentAddressedChunk(data);
-  const soc = await makeSingleOwnerChunk(cac, identifier, signer);
+  const soc = makeSingleOwnerChunk(cac, identifier, signer);
+  return uploadSingleOwnerChunk(requestOptions, soc, stamp, options);
+}
+export async function uploadSingleOwnerChunkWithWrappedChunk(requestOptions, signer, stamp, identifier, rootChunk, options) {
+  signer = new PrivateKey(signer);
+  identifier = new Identifier(identifier);
+  const soc = makeSingleOwnerChunk(asContentAddressedChunk(rootChunk), identifier, signer);
   return uploadSingleOwnerChunk(requestOptions, soc, stamp, options);
 }
 /**
  * Helper function to download SOC.
  *
  * @param url           The url of the Bee service
- * @param ownerAddress  The singer interface for signing the chunk
+ * @param ownerAddress  The signer interface for signing the chunk
  * @param identifier    The identifier of the chunk
  */
 export async function downloadSingleOwnerChunk(requestOptions, ownerAddress, identifier) {
+  identifier = new Identifier(identifier);
+  ownerAddress = new EthAddress(ownerAddress);
   const address = makeSOCAddress(identifier, ownerAddress);
-  const data = await chunkAPI.download(requestOptions, bytesToHex(address));
-  return makeSingleOwnerChunkFromData(data, address);
+  const cac = await chunkAPI.download(requestOptions, address.toHex());
+  return makeSingleOwnerChunkFromData(cac, address);
 }

package/dist/mjs/feed/identifier.js

@@ -1,29 +1,6 @@
 import { Binary } from 'cafe-utility';
-import { FEED_INDEX_HEX_LENGTH } from "../types/index.js";
-import { keccak256Hash } from "../utils/hash.js";
-import { hexToBytes, makeHexString } from "../utils/hex.js";
-function isEpoch(epoch) {
-  return typeof epoch === 'object' && epoch !== null && 'time' in epoch && 'level' in epoch;
-}
-function hashFeedIdentifier(topic, index) {
-  return keccak256Hash(hexToBytes(topic), index);
-}
-function makeSequentialFeedIdentifier(topic, index) {
-  const indexBytes = Binary.numberToUint64BE(index);
-  return hashFeedIdentifier(topic, indexBytes);
-}
-function makeFeedIndexBytes(s) {
-  const hex = makeHexString(s, FEED_INDEX_HEX_LENGTH);
-  return hexToBytes(hex);
-}
+import { FeedIndex, Identifier } from "../utils/typed-bytes.js";
 export function makeFeedIdentifier(topic, index) {
-  if (typeof index === 'number') {
-    return makeSequentialFeedIdentifier(topic, index);
-  } else if (typeof index === 'string') {
-    const indexBytes = makeFeedIndexBytes(index);
-    return hashFeedIdentifier(topic, indexBytes);
-  } else if (isEpoch(index)) {
-    throw new TypeError('epoch is not yet implemented');
-  }
-  return hashFeedIdentifier(topic, index);
+  index = typeof index === 'number' ? FeedIndex.fromBigInt(BigInt(index)) : index;
+  return new Identifier(Binary.keccak256(Binary.concatBytes(topic.toUint8Array(), index.toUint8Array())));
 }

package/dist/mjs/feed/index.js

@@ -1,86 +1,133 @@
-import { Binary } from 'cafe-utility';
-import { makeSingleOwnerChunkFromData, uploadSingleOwnerChunkData } from "../chunk/soc.js";
+import { Binary, Optional, Types } from 'cafe-utility';
+import { asContentAddressedChunk } from "../chunk/cac.js";
+import { makeSingleOwnerChunkFromData, uploadSingleOwnerChunkData, uploadSingleOwnerChunkWithWrappedChunk } from "../chunk/soc.js";
+import * as bytes from "../modules/bytes.js";
 import * as chunkAPI from "../modules/chunk.js";
-import { fetchLatestFeedUpdate } from "../modules/feed.js";
-import { FEED_INDEX_HEX_LENGTH } from "../types/index.js";
-import { bytesAtOffset, makeBytes } from "../utils/bytes.js";
+import { fetchLatestFeedUpdate, probeFeed } from "../modules/feed.js";
+import { Bytes } from "../utils/bytes.js";
 import { BeeResponseError } from "../utils/error.js";
-import { makeHexEthAddress } from "../utils/eth.js";
-import { keccak256Hash } from "../utils/hash.js";
-import { bytesToHex, hexToBytes, makeHexString } from "../utils/hex.js";
-import { makeBytesReference } from "../utils/reference.js";
-import { assertAddress } from "../utils/type.js";
+import { ResourceLocator } from "../utils/resource-locator.js";
+import { FeedIndex, Identifier, Reference, Signature } from "../utils/typed-bytes.js";
 import { makeFeedIdentifier } from "./identifier.js";
 const TIMESTAMP_PAYLOAD_OFFSET = 0;
 const TIMESTAMP_PAYLOAD_SIZE = 8;
 const REFERENCE_PAYLOAD_OFFSET = TIMESTAMP_PAYLOAD_SIZE;
-export async function findNextIndex(requestOptions, owner, topic, options) {
+export async function findNextIndex(requestOptions, owner, topic) {
   try {
-    const feedUpdate = await fetchLatestFeedUpdate(requestOptions, owner, topic, options);
-    return makeHexString(feedUpdate.feedIndexNext, FEED_INDEX_HEX_LENGTH);
+    const feedUpdate = await fetchLatestFeedUpdate(requestOptions, owner, topic);
+    if (!feedUpdate.feedIndexNext) {
+      throw Error('Feed index next is not defined. This should happen when fetching an exact index.');
+    }
+    return feedUpdate.feedIndexNext;
   } catch (e) {
     if (e instanceof BeeResponseError) {
-      return bytesToHex(makeBytes(8));
+      return FeedIndex.fromBigInt(0n);
     }
     throw e;
   }
 }
-export async function updateFeed(requestOptions, signer, topic, reference, postageBatchId, options) {
-  const ownerHex = makeHexEthAddress(signer.address);
-  const nextIndex = options?.index ?? (await findNextIndex(requestOptions, ownerHex, topic, options));
+export async function updateFeedWithReference(requestOptions, signer, topic, reference, postageBatchId, options) {
+  reference = new Reference(reference);
+  const nextIndex = options?.index ?? (await findNextIndex(requestOptions, signer.publicKey().address(), topic));
   const identifier = makeFeedIdentifier(topic, nextIndex);
   const at = options?.at ?? Date.now() / 1000.0;
-  const timestamp = Binary.numberToUint64BE(Math.floor(at));
-  const payloadBytes = Binary.concatBytes(timestamp, reference);
+  const timestamp = Binary.numberToUint64(BigInt(Math.floor(at)), 'BE');
+  const payloadBytes = Binary.concatBytes(timestamp, reference.toUint8Array());
   return uploadSingleOwnerChunkData(requestOptions, signer, postageBatchId, identifier, payloadBytes, options);
 }
+export async function updateFeedWithPayload(requestOptions, signer, topic, data, postageBatchId, options) {
+  const nextIndex = options?.index ?? (await findNextIndex(requestOptions, signer.publicKey().address(), topic));
+  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);
+    return uploadSingleOwnerChunkWithWrappedChunk(requestOptions, signer, postageBatchId, identifier, rootChunk, options);
+  }
+  return uploadSingleOwnerChunkData(requestOptions, signer, postageBatchId, identifier, Types.isString(data) ? Bytes.fromUtf8(data).toUint8Array() : data, options);
+}
 export function getFeedUpdateChunkReference(owner, topic, index) {
   const identifier = makeFeedIdentifier(topic, index);
-  return keccak256Hash(identifier, owner);
+  return new Reference(Binary.keccak256(Binary.concatBytes(identifier.toUint8Array(), owner.toUint8Array())));
 }
-export async function downloadFeedUpdate(requestOptions, owner, topic, index) {
+export async function downloadFeedUpdate(requestOptions, owner, topic, index, hasTimestamp = false) {
+  index = typeof index === 'number' ? FeedIndex.fromBigInt(BigInt(index)) : index;
   const address = getFeedUpdateChunkReference(owner, topic, index);
-  const addressHex = bytesToHex(address);
-  const data = await chunkAPI.download(requestOptions, addressHex);
+  const data = await chunkAPI.download(requestOptions, address.toHex());
   const soc = makeSingleOwnerChunkFromData(data, address);
-  const payload = soc.payload();
-  const timestampBytes = bytesAtOffset(payload, TIMESTAMP_PAYLOAD_OFFSET, TIMESTAMP_PAYLOAD_SIZE);
-  const timestamp = Binary.uint64BEToNumber(timestampBytes);
-  const reference = makeBytesReference(payload, REFERENCE_PAYLOAD_OFFSET);
+  let timestamp = Optional.empty();
+  if (hasTimestamp) {
+    const timestampBytes = Bytes.fromSlice(soc.payload.toUint8Array(), TIMESTAMP_PAYLOAD_OFFSET, TIMESTAMP_PAYLOAD_SIZE);
+    timestamp = Optional.of(Number(Binary.uint64ToNumber(timestampBytes.toUint8Array(), 'BE')));
+  }
   return {
     timestamp,
-    reference
+    payload: new Bytes(soc.payload.offset(hasTimestamp ? REFERENCE_PAYLOAD_OFFSET : 0))
   };
 }
-export function makeFeedReader(requestOptions, type, topic, owner) {
+export async function downloadFeedUpdateAsCAC(requestOptions, owner, topic, index) {
+  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));
+}
+export function makeFeedReader(requestOptions, topic, owner) {
+  // TODO: remove after enough time has passed in deprecated version
+  const download = async options => {
+    if (options?.index === undefined) {
+      return fetchLatestFeedUpdate(requestOptions, owner, topic);
+    }
+    const update = await downloadFeedUpdate(requestOptions, owner, topic, options.index, options.hasTimestamp ?? true);
+    const feedIndex = typeof options.index === 'number' ? FeedIndex.fromBigInt(BigInt(options.index)) : options.index;
+    return {
+      payload: update.payload,
+      feedIndex
+    };
+  };
+  const downloadPayload = async options => {
+    if (options?.index === undefined) {
+      return fetchLatestFeedUpdate(requestOptions, owner, topic);
+    }
+    const cac = await downloadFeedUpdateAsCAC(requestOptions, owner, topic, options.index);
+    const payload = cac.span.toBigInt() <= 4096n ? cac.payload : await bytes.download(requestOptions, new ResourceLocator(cac.address));
+    const feedIndex = typeof options.index === 'number' ? FeedIndex.fromBigInt(BigInt(options.index)) : options.index;
+    return {
+      payload,
+      feedIndex
+    };
+  };
+  const downloadReference = async options => {
+    let index = options?.index;
+    if (index === undefined) {
+      index = (await probeFeed(requestOptions, owner, topic)).feedIndex;
+    }
+    const payload = await download({
+      ...options,
+      index: index
+    });
+    return {
+      reference: new Reference(payload.payload.toUint8Array()),
+      feedIndex: payload.feedIndex
+    };
+  };
   return {
-    type,
+    download,
+    downloadPayload,
+    downloadReference,
     owner,
-    topic,
-    async download(options) {
-      if (!options?.index && options?.index !== 0) {
-        return fetchLatestFeedUpdate(requestOptions, owner, topic);
-      }
-      const update = await downloadFeedUpdate(requestOptions, hexToBytes(owner), topic, options.index);
-      return {
-        reference: bytesToHex(update.reference),
-        feedIndex: options.index,
-        feedIndexNext: ''
-      };
-    }
+    topic
   };
 }
-export function makeFeedWriter(requestOptions, type, topic, signer) {
+export function makeFeedWriter(requestOptions, topic, signer) {
   const upload = async (postageBatchId, reference, options) => {
-    assertAddress(postageBatchId);
-    const canonicalReference = makeBytesReference(reference);
-    return updateFeed(requestOptions, signer, topic, canonicalReference, postageBatchId, {
-      ...options,
-      type
-    });
+    return updateFeedWithReference(requestOptions, signer, topic, reference, postageBatchId, options);
+  };
+  const uploadPayload = async (postageBatchId, data, options) => {
+    return updateFeedWithPayload(requestOptions, signer, topic, data, postageBatchId, options);
   };
   return {
-    ...makeFeedReader(requestOptions, type, topic, makeHexEthAddress(signer.address)),
-    upload
+    ...makeFeedReader(requestOptions, topic, signer.publicKey().address()),
+    upload,
+    uploadReference: upload,
+    uploadPayload
   };
 }

package/dist/mjs/feed/retrievable.js

@@ -1,18 +1,6 @@
-import { Binary } from 'cafe-utility';
-import { bytesToHex } from "../utils/hex.js";
+import { Objects } from 'cafe-utility';
+import { FeedIndex } from "../utils/typed-bytes.js";
 import { getFeedUpdateChunkReference } from "./index.js";
-function makeNumericIndex(index) {
-  if (index instanceof Uint8Array) {
-    return Binary.uint64BEToNumber(index);
-  }
-  if (typeof index === 'string') {
-    return parseInt(index);
-  }
-  if (typeof index === 'number') {
-    return index;
-  }
-  throw new TypeError('Unknown type of index!');
-}
 /**
  * Function that checks if a chunk is retrievable by actually downloading it.
  * The /stewardship/{reference} endpoint does not support verification of chunks, but only manifest's references.
@@ -21,12 +9,13 @@ function makeNumericIndex(index) {
  * @param ref
  * @param options
  */
-async function isChunkRetrievable(bee, ref, requestOptions) {
+async function isChunkRetrievable(bee, reference, options, requestOptions) {
   try {
-    await bee.downloadChunk(ref, requestOptions);
+    await bee.downloadChunk(reference, options, requestOptions);
     return true;
   } catch (e) {
-    if (e?.status === 404 || e?.status === 500) {
+    const status = Objects.getDeep(e, 'status');
+    if (status === 404 || status === 500) {
       return false;
     }
     throw e;
@@ -40,14 +29,14 @@ async function isChunkRetrievable(bee, ref, requestOptions) {
  * @param index
  */
 function getAllSequenceUpdateReferences(owner, topic, index) {
-  const numIndex = makeNumericIndex(index);
-  const updateReferences = new Array(numIndex + 1);
-  for (let i = 0; i <= numIndex; i++) {
-    updateReferences[i] = bytesToHex(getFeedUpdateChunkReference(owner, topic, i));
+  const count = index.toBigInt();
+  const updateReferences = [];
+  for (let i = 0n; i <= count; i++) {
+    updateReferences.push(getFeedUpdateChunkReference(owner, topic, FeedIndex.fromBigInt(i)));
   }
   return updateReferences;
 }
-export async function areAllSequentialFeedsUpdateRetrievable(bee, owner, topic, index, requestOptions) {
-  const chunkRetrievablePromises = getAllSequenceUpdateReferences(owner, topic, index).map(async ref => isChunkRetrievable(bee, ref, requestOptions));
+export async function areAllSequentialFeedsUpdateRetrievable(bee, owner, topic, index, options, requestOptions) {
+  const chunkRetrievablePromises = getAllSequenceUpdateReferences(owner, topic, index).map(async reference => isChunkRetrievable(bee, reference, options, requestOptions));
   return (await Promise.all(chunkRetrievablePromises)).every(result => result);
 }

package/dist/mjs/index.js

@@ -1,7 +1,16 @@
 import { Bee } from "./bee.js";
+import { BeeDev } from "./bee-dev.js";
+import { Stamper } from "./stamper/stamper.js";
+export { MerkleTree } from 'cafe-utility';
+export { MantarayNode } from "./manifest/manifest.js";
 export { SUPPORTED_BEE_VERSION, SUPPORTED_BEE_VERSION_EXACT } from "./modules/debug/status.js";
 export * from "./types/index.js";
+export { Bytes } from "./utils/bytes.js";
 export * from "./utils/constants.js";
+export { Duration } from "./utils/duration.js";
 export * from "./utils/error.js";
 export * as Utils from "./utils/expose.js";
-export { Bee };
+export { Size } from "./utils/size.js";
+export * from "./utils/tokens.js";
+export * from "./utils/typed-bytes.js";
+export { Bee, BeeDev, Stamper };