@ethersphere/bee-js 3.3.4 → 4.1.0

package/dist/mjs/{bee-debug.js → src/bee-debug.js}

@@ -37,13 +37,14 @@ import * as settlements from "./modules/debug/settlements.js";
 import * as status from "./modules/debug/status.js";
 import * as transactions from "./modules/debug/transactions.js";
 import * as states from "./modules/debug/states.js";
-import { BeeArgumentError } from "./utils/error.js";
+import { BeeArgumentError, BeeError } from "./utils/error.js";
 import { assertBeeUrl, stripLastSlash } from "./utils/url.js";
-import { assertAddress, assertBatchId, assertBoolean, assertCashoutOptions, assertNonNegativeInteger, assertRequestOptions, assertTransactionHash, isTag } from "./utils/type.js";
+import { assertAddress, assertBatchId, assertCashoutOptions, assertNonNegativeInteger, assertPositiveInteger, assertPostageBatchOptions, assertRequestOptions, assertTransactionHash, isTag } from "./utils/type.js";
 import { STAMPS_DEPTH_MAX, STAMPS_DEPTH_MIN } from "./types/index.js";
 import * as tag from "./modules/debug/tag.js";
 import * as stamps from "./modules/debug/stamps.js";
 import { makeDefaultKy, wrapRequestClosure, wrapResponseClosure } from "./utils/http.js";
+import { sleep } from "../test/utils.js";
 export class BeeDebug {
   constructor(url, options) {
     var _a;
@@ -501,6 +502,19 @@ export class BeeDebug {
       return states.getChainState(this.getKy(options));
     });
   }
+  /**
+   * Get wallet balances for xDai and BZZ of the Bee node
+   *
+   * @param options
+   */
+
+
+  getWalletBalance(options) {
+    return __awaiter(this, void 0, void 0, function* () {
+      assertRequestOptions(options);
+      return states.getWalletBalance(this.getKy(options));
+    });
+  }
   /**
    * Creates new postage batch from the funds that the node has available in its Ethereum account.
    *
@@ -522,8 +536,8 @@ export class BeeDebug {
 
   createPostageBatch(amount, depth, options) {
     return __awaiter(this, void 0, void 0, function* () {
-      assertRequestOptions(options);
-      assertNonNegativeInteger(amount);
+      assertPostageBatchOptions(options);
+      assertPositiveInteger(amount);
       assertNonNegativeInteger(depth);
 
       if (depth < STAMPS_DEPTH_MIN) {
@@ -534,15 +548,13 @@ export class BeeDebug {
         throw new BeeArgumentError(`Depth has to be at most ${STAMPS_DEPTH_MAX}`, depth);
       }
 
-      if (options === null || options === void 0 ? void 0 : options.gasPrice) {
-        assertNonNegativeInteger(options.gasPrice);
-      }
+      const stamp = yield stamps.createPostageBatch(this.getKy(options), amount, depth, options);
 
-      if ((options === null || options === void 0 ? void 0 : options.immutableFlag) !== undefined) {
-        assertBoolean(options.immutableFlag);
+      if (options === null || options === void 0 ? void 0 : options.waitForUsable) {
+        yield this.waitForUsablePostageStamp(stamp, options === null || options === void 0 ? void 0 : options.waitForUsableTimeout);
       }
 
-      return stamps.createPostageBatch(this.getKy(options), amount, depth, options);
+      return stamp;
     });
   }
   /**
@@ -703,6 +715,24 @@ export class BeeDebug {
     });
   }
 
+  waitForUsablePostageStamp(id, timeout = 120000) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const TIME_STEP = 1500;
+
+      for (let time = 0; time < timeout; time += TIME_STEP) {
+        const stamp = yield this.getPostageBatch(id);
+
+        if (stamp.usable) {
+          return;
+        }
+
+        yield sleep(TIME_STEP);
+      }
+
+      throw new BeeError('Timeout on waiting for postage stamp to become usable');
+    });
+  }
+
   getKy(options) {
     if (!options) {
       return this.ky;

package/dist/mjs/{bee.js → src/bee.js}

@@ -50,13 +50,15 @@ import { createFeedManifest } from "./modules/feed.js";
 import { assertBeeUrl, stripLastSlash } from "./utils/url.js";
 import { makeEthAddress, makeHexEthAddress } from "./utils/eth.js";
 import { wrapBytesWithHelpers } from "./utils/bytes.js";
-import { assertAddressPrefix, assertAllTagsOptions, assertBatchId, assertCollectionUploadOptions, assertData, assertFileData, assertFileUploadOptions, assertPssMessageHandler, assertPublicKey, assertReference, assertRequestOptions, assertUploadOptions, makeTagUid } from "./utils/type.js";
-import { setJsonData, getJsonData } from "./feed/json.js";
-import { makeCollectionFromFileList, assertCollection } from "./utils/collection.js";
+import { addCidConversionFunction, assertAddressPrefix, assertAllTagsOptions, assertBatchId, assertCollectionUploadOptions, assertData, assertFileData, assertFileUploadOptions, assertPssMessageHandler, assertPublicKey, assertReference, assertReferenceOrEns, assertRequestOptions, assertUploadOptions, makeReferenceOrEns, makeTagUid } from "./utils/type.js";
+import { getJsonData, setJsonData } from "./feed/json.js";
+import { assertCollection, makeCollectionFromFileList } from "./utils/collection.js";
 import { makeCollectionFromFS } from "./utils/collection.node.js";
 import { CHUNK_SIZE, SPAN_SIZE } from "./types/index.js";
 import { makeDefaultKy, wrapRequestClosure, wrapResponseClosure } from "./utils/http.js";
 import { isReadable } from "./utils/stream.js";
+import { areAllSequentialFeedsUpdateRetrievable } from "./feed/retrievable.js";
+import { ReferenceType } from '@ethersphere/swarm-cid';
 /**
  * The main component that abstracts operations available on the main Bee API.
  *
@@ -131,8 +133,10 @@ export class Bee {
   /**
    * Download data as a byte array
    *
-   * @param reference Bee data reference
+   * @param reference Bee data reference in hex string (either 64 or 128 chars long) or ENS domain.
    * @param options Options that affects the request behavior
+   * @throws TypeError if some of the input parameters is not expected type
+   * @throws BeeArgumentError if there is passed ENS domain with invalid unicode characters
    * @see [Bee docs - Upload and download](https://docs.ethswarm.org/docs/access-the-swarm/upload-and-download)
    * @see [Bee API reference - `GET /bytes`](https://docs.ethswarm.org/api/#tag/Bytes/paths/~1bytes~1{reference}/get)
    */
@@ -141,15 +145,17 @@ export class Bee {
   downloadData(reference, options) {
     return __awaiter(this, void 0, void 0, function* () {
       assertRequestOptions(options);
-      assertReference(reference);
+      assertReferenceOrEns(reference);
       return bytes.download(this.getKy(options), reference);
     });
   }
   /**
    * Download data as a Readable stream
    *
-   * @param reference Bee data reference
+   * @param reference Bee data reference in hex string (either 64 or 128 chars long) or ENS domain.
    * @param options Options that affects the request behavior
+   * @throws TypeError if some of the input parameters is not expected type
+   * @throws BeeArgumentError if there is passed ENS domain with invalid unicode characters
    * @see [Bee docs - Upload and download](https://docs.ethswarm.org/docs/access-the-swarm/upload-and-download)
    * @see [Bee API reference - `GET /bytes`](https://docs.ethswarm.org/api/#tag/Bytes/paths/~1bytes~1{reference}/get)
    */
@@ -158,7 +164,7 @@ export class Bee {
   downloadReadableData(reference, options) {
     return __awaiter(this, void 0, void 0, function* () {
       assertRequestOptions(options);
-      assertReference(reference);
+      assertReferenceOrEns(reference);
       return bytes.downloadReadable(this.getKy(options), reference);
     });
   }
@@ -198,8 +204,10 @@ export class Bee {
   /**
    * Download chunk as a byte array
    *
-   * @param reference Bee chunk reference
+   * @param reference Bee chunk reference in hex string (either 64 or 128 chars long) or ENS domain.
    * @param options Options that affects the request behavior
+   * @throws TypeError if some of the input parameters is not expected type
+   * @throws BeeArgumentError if there is passed ENS domain with invalid unicode characters
    * @see [Bee docs - Upload and download](https://docs.ethswarm.org/docs/access-the-swarm/upload-and-download)
    * @see [Bee API reference - `GET /chunks`](https://docs.ethswarm.org/api/#tag/Chunk/paths/~1chunks~1{reference}/get)
    */
@@ -208,7 +216,7 @@ export class Bee {
   downloadChunk(reference, options) {
     return __awaiter(this, void 0, void 0, function* () {
       assertRequestOptions(options);
-      assertReference(reference);
+      assertReferenceOrEns(reference);
       return chunk.download(this.getKy(options), reference);
     });
   }
@@ -247,24 +255,25 @@ export class Bee {
         const fileOptions = Object.assign({
           contentType
         }, options);
-        return bzz.uploadFile(this.getKy(options), fileData, postageBatchId, fileName, fileOptions);
+        return addCidConversionFunction(yield bzz.uploadFile(this.getKy(options), fileData, postageBatchId, fileName, fileOptions), ReferenceType.MANIFEST);
       } else if (isReadable(data) && (options === null || options === void 0 ? void 0 : options.tag) && !options.size) {
         // TODO: Needed until https://github.com/ethersphere/bee/issues/2317 is resolved
         const result = yield bzz.uploadFile(this.getKy(options), data, postageBatchId, name, options);
         yield this.updateTag(options.tag, result.reference);
-        return result;
+        return addCidConversionFunction(result, ReferenceType.MANIFEST);
       } else {
-        return bzz.uploadFile(this.getKy(options), data, postageBatchId, name, options);
+        return addCidConversionFunction(yield bzz.uploadFile(this.getKy(options), data, postageBatchId, name, options), ReferenceType.MANIFEST);
       }
     });
   }
   /**
    * Download single file.
    *
-   * @param reference Bee file reference
+   * @param reference Bee file reference in hex string (either 64 or 128 chars long), ENS domain or Swarm CID.
    * @param path If reference points to manifest, then this parameter defines path to the file
    * @param options Options that affects the request behavior
-   *
+   * @throws TypeError if some of the input parameters is not expected type
+   * @throws BeeArgumentError if there is passed ENS domain with invalid unicode characters
    * @see Data
    * @see [Bee docs - Upload and download](https://docs.ethswarm.org/docs/access-the-swarm/upload-and-download)
    * @see [Bee API reference - `GET /bzz`](https://docs.ethswarm.org/api/#tag/Collection/paths/~1bzz~1{reference}~1{path}/get)
@@ -274,16 +283,18 @@ export class Bee {
   downloadFile(reference, path = '', options) {
     return __awaiter(this, void 0, void 0, function* () {
       assertRequestOptions(options);
-      assertReference(reference);
+      reference = makeReferenceOrEns(reference, ReferenceType.MANIFEST);
       return bzz.downloadFile(this.getKy(options), reference, path);
     });
   }
   /**
    * Download single file as a readable stream
    *
-   * @param reference Hash reference to file
+   * @param reference Bee file reference in hex string (either 64 or 128 chars long), ENS domain or Swarm CID.
    * @param path If reference points to manifest / collections, then this parameter defines path to the file
    * @param options Options that affects the request behavior
+   * @throws TypeError if some of the input parameters is not expected type
+   * @throws BeeArgumentError if there is passed ENS domain with invalid unicode characters
    *
    * @see [Bee docs - Upload and download](https://docs.ethswarm.org/docs/access-the-swarm/upload-and-download)
    * @see [Bee API reference - `GET /bzz`](https://docs.ethswarm.org/api/#tag/Collection/paths/~1bzz~1{reference}~1{path}/get)
@@ -293,7 +304,7 @@ export class Bee {
   downloadReadableFile(reference, path = '', options) {
     return __awaiter(this, void 0, void 0, function* () {
       assertRequestOptions(options);
-      assertReference(reference);
+      reference = makeReferenceOrEns(reference, ReferenceType.MANIFEST);
       return bzz.downloadFileReadable(this.getKy(options), reference, path);
     });
   }
@@ -320,7 +331,7 @@ export class Bee {
       assertBatchId(postageBatchId);
       if (options) assertCollectionUploadOptions(options);
       const data = yield makeCollectionFromFileList(fileList);
-      return bzz.uploadCollection(this.getKy(options), data, postageBatchId, options);
+      return addCidConversionFunction(yield bzz.uploadCollection(this.getKy(options), data, postageBatchId, options), ReferenceType.MANIFEST);
     });
   }
   /**
@@ -340,7 +351,7 @@ export class Bee {
       assertBatchId(postageBatchId);
       assertCollection(collection);
       if (options) assertCollectionUploadOptions(options);
-      return bzz.uploadCollection(this.ky, collection, postageBatchId, options);
+      return addCidConversionFunction(yield bzz.uploadCollection(this.ky, collection, postageBatchId, options), ReferenceType.MANIFEST);
     });
   }
   /**
@@ -366,7 +377,7 @@ export class Bee {
       assertBatchId(postageBatchId);
       if (options) assertCollectionUploadOptions(options);
       const data = yield makeCollectionFromFS(dir);
-      return bzz.uploadCollection(this.getKy(options), data, postageBatchId, options);
+      return addCidConversionFunction(yield bzz.uploadCollection(this.getKy(options), data, postageBatchId, options), ReferenceType.MANIFEST);
     });
   }
   /**
@@ -541,9 +552,10 @@ export class Bee {
    *
    * **Warning! Not allowed when node is in Gateway mode!**
    *
-   * @param reference Bee data reference
+   * @param reference Bee data reference in hex string (either 64 or 128 chars long) or ENS domain.
    * @param options Options that affects the request behavior
-   * @throws TypeError if reference is in not correct format
+   * @throws TypeError if some of the input parameters is not expected type
+   * @throws BeeArgumentError if there is passed ENS domain with invalid unicode characters
    *
    * @see [Bee docs - Pinning](https://docs.ethswarm.org/docs/access-the-swarm/pinning)
    */
@@ -559,10 +571,11 @@ export class Bee {
   /**
    * Instructs the Bee node to reupload a locally pinned data into the network.
    *
-   * @param reference
+   * @param reference Bee data reference to be re-uploaded in hex string (either 64 or 128 chars long) or ENS domain.
    * @param options Options that affects the request behavior
    * @throws BeeArgumentError if the reference is not locally pinned
-   * @throws TypeError if reference is in not correct format
+   * @throws TypeError if some of the input parameters is not expected type
+   * @throws BeeArgumentError if there is passed ENS domain with invalid unicode characters
    *
    * @see [Bee API reference - `PUT /stewardship`](https://docs.ethswarm.org/api/#tag/Stewardship/paths/~1stewardship~1{reference}/put)
    */
@@ -571,15 +584,17 @@ export class Bee {
   reuploadPinnedData(reference, options) {
     return __awaiter(this, void 0, void 0, function* () {
       assertRequestOptions(options);
-      assertReference(reference);
+      assertReferenceOrEns(reference);
       yield stewardship.reupload(this.getKy(options), reference);
     });
   }
   /**
    * Checks if content specified by reference is retrievable from the network.
    *
-   * @param reference The checked content
+   * @param reference Bee data reference to be checked in hex string (either 64 or 128 chars long) or ENS domain.
    * @param options Options that affects the request behavior
+   * @throws TypeError if some of the input parameters is not expected type
+   * @throws BeeArgumentError if there is passed ENS domain with invalid unicode characters
    *
    * @see [Bee API reference - `GET /stewardship`](https://docs.ethswarm.org/api/#tag/Stewardship/paths/~1stewardship~1{reference}/get)
    */
@@ -588,10 +603,54 @@ export class Bee {
   isReferenceRetrievable(reference, options) {
     return __awaiter(this, void 0, void 0, function* () {
       assertRequestOptions(options);
-      assertReference(reference);
+      assertReferenceOrEns(reference);
       return stewardship.isRetrievable(this.getKy(options), reference);
     });
   }
+  /**
+   * Functions that validates if feed is retrievable in the network.
+   *
+   * If no index is passed then it check for "latest" update, which is a weaker guarantee as nobody can be really
+   * sure what is the "latest" update.
+   *
+   * If index is passed then it validates all previous sequence index chunks if they are available as they are required
+   * to correctly resolve the feed upto the given index update.
+   *
+   * @param type
+   * @param owner
+   * @param topic
+   * @param index
+   * @param options
+   */
+
+
+  isFeedRetrievable(type, owner, topic, index, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+      const canonicalOwner = makeEthAddress(owner);
+      const canonicalTopic = makeTopic(topic);
+
+      if (!index) {
+        try {
+          yield this.makeFeedReader(type, canonicalTopic, canonicalOwner).download();
+          return true;
+        } catch (e) {
+          const err = e; // Only if the error is "not-found" then we return false otherwise we re-throw the error
+
+          if ((err === null || err === void 0 ? void 0 : err.status) === 404) {
+            return false;
+          }
+
+          throw e;
+        }
+      }
+
+      if (type !== 'sequence') {
+        throw new BeeError('Only Sequence type of Feeds is supported at the moment');
+      }
+
+      return areAllSequentialFeedsUpdateRetrievable(this, canonicalOwner, canonicalTopic, index, options);
+    });
+  }
   /**
    * Send data to recipient or target with Postal Service for Swarm.
    *
@@ -774,6 +833,7 @@ export class Bee {
    *
    * @see [Bee docs - Feeds](https://docs.ethswarm.org/docs/dapps-on-swarm/feeds)
    * @see [Bee API reference - `POST /feeds`](https://docs.ethswarm.org/api/#tag/Feed/paths/~1feeds~1{owner}~1{topic}/post)
+   * TODO: Once breaking add support for Feed CID
    */
 
 

package/dist/mjs/{chunk → src/chunk}/cac.js

@@ -1,6 +1,6 @@
 import { BeeError } from "../utils/error.js";
 import { bmtHash } from "./bmt.js";
-import { bytesEqual, flexBytesAtOffset, assertFlexBytes } from "../utils/bytes.js";
+import { assertFlexBytes, bytesEqual, flexBytesAtOffset } from "../utils/bytes.js";
 import { serializeBytes } from "./serialize.js";
 import { makeSpan, SPAN_SIZE } from "./span.js";
 export const MIN_PAYLOAD_SIZE = 1;

package/dist/mjs/src/feed/identifier.js

@@ -0,0 +1,35 @@
+import { FEED_INDEX_HEX_LENGTH } from "../types/index.js";
+import { keccak256Hash } from "../utils/hash.js";
+import { hexToBytes, makeHexString } from "../utils/hex.js";
+import { writeUint64BigEndian } from "../utils/uint64.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 = writeUint64BigEndian(index);
+  return hashFeedIdentifier(topic, indexBytes);
+}
+
+function makeFeedIndexBytes(s) {
+  const hex = makeHexString(s, FEED_INDEX_HEX_LENGTH);
+  return hexToBytes(hex);
+}
+
+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);
+}

package/dist/mjs/{feed → src/feed}/index.js

@@ -32,66 +32,26 @@ var __awaiter = this && this.__awaiter || function (thisArg, _arguments, P, gene
 
 import { keccak256Hash } from "../utils/hash.js";
 import { serializeBytes } from "../chunk/serialize.js";
-import { uploadSingleOwnerChunkData, makeSingleOwnerChunkFromData } from "../chunk/soc.js";
-import { fetchFeedUpdate } from "../modules/feed.js";
-import { REFERENCE_HEX_LENGTH, ENCRYPTED_REFERENCE_HEX_LENGTH } from "../types/index.js";
-import { makeBytes, bytesAtOffset } from "../utils/bytes.js";
+import { fetchLatestFeedUpdate } from "../modules/feed.js";
+import { makeSingleOwnerChunkFromData, uploadSingleOwnerChunkData } from "../chunk/soc.js";
+import { FEED_INDEX_HEX_LENGTH } from "../types/index.js";
+import { bytesAtOffset, makeBytes } from "../utils/bytes.js";
 import { BeeResponseError } from "../utils/error.js";
 import { bytesToHex, hexToBytes, makeHexString } from "../utils/hex.js";
 import { readUint64BigEndian, writeUint64BigEndian } from "../utils/uint64.js";
 import * as chunkAPI from "../modules/chunk.js";
 import { makeHexEthAddress } from "../utils/eth.js";
 import { assertAddress } from "../utils/type.js";
+import { makeFeedIdentifier } from "./identifier.js";
+import { makeBytesReference } from "../utils/reference.js";
 const TIMESTAMP_PAYLOAD_OFFSET = 0;
 const TIMESTAMP_PAYLOAD_SIZE = 8;
 const REFERENCE_PAYLOAD_OFFSET = TIMESTAMP_PAYLOAD_SIZE;
-const REFERENCE_PAYLOAD_MIN_SIZE = 32;
-const REFERENCE_PAYLOAD_MAX_SIZE = 64;
-const INDEX_HEX_LENGTH = 16;
-export function isEpoch(epoch) {
-  return typeof epoch === 'object' && epoch !== null && 'time' in epoch && 'level' in epoch;
-}
-
-function hashFeedIdentifier(topic, index) {
-  return keccak256Hash(hexToBytes(topic), index);
-}
-
-export function makeSequentialFeedIdentifier(topic, index) {
-  const indexBytes = writeUint64BigEndian(index);
-  return hashFeedIdentifier(topic, indexBytes);
-}
-export function makeFeedIndexBytes(s) {
-  const hex = makeHexString(s, INDEX_HEX_LENGTH);
-  return hexToBytes(hex);
-}
-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);
-}
-export function uploadFeedUpdate(ky, signer, topic, index, reference, postageBatchId, options) {
-  var _a;
-
-  return __awaiter(this, void 0, void 0, function* () {
-    const identifier = makeFeedIdentifier(topic, index);
-    const at = (_a = options === null || options === void 0 ? void 0 : options.at) !== null && _a !== void 0 ? _a : Date.now() / 1000.0;
-    const timestamp = writeUint64BigEndian(at);
-    const payloadBytes = serializeBytes(timestamp, reference);
-    return uploadSingleOwnerChunkData(ky, signer, postageBatchId, identifier, payloadBytes, options);
-  });
-}
 export function findNextIndex(ky, owner, topic, options) {
   return __awaiter(this, void 0, void 0, function* () {
     try {
-      const feedUpdate = yield fetchFeedUpdate(ky, owner, topic, options);
-      return makeHexString(feedUpdate.feedIndexNext, INDEX_HEX_LENGTH);
+      const feedUpdate = yield fetchLatestFeedUpdate(ky, owner, topic, options);
+      return makeHexString(feedUpdate.feedIndexNext, FEED_INDEX_HEX_LENGTH);
     } catch (e) {
       if (e instanceof BeeResponseError && e.status === 404) {
         return bytesToHex(makeBytes(8));
@@ -101,36 +61,33 @@ export function findNextIndex(ky, owner, topic, options) {
     }
   });
 }
-export function updateFeed(ky, signer, topic, reference, postageBatchId, options) {
+export function updateFeed(ky, signer, topic, reference, postageBatchId, options, index = 'latest') {
+  var _a;
+
   return __awaiter(this, void 0, void 0, function* () {
     const ownerHex = makeHexEthAddress(signer.address);
-    const nextIndex = yield findNextIndex(ky, ownerHex, topic, options);
-    return uploadFeedUpdate(ky, signer, topic, nextIndex, reference, postageBatchId, options);
+    const nextIndex = index === 'latest' ? yield findNextIndex(ky, ownerHex, topic, options) : index;
+    const identifier = makeFeedIdentifier(topic, nextIndex);
+    const at = (_a = options === null || options === void 0 ? void 0 : options.at) !== null && _a !== void 0 ? _a : Date.now() / 1000.0;
+    const timestamp = writeUint64BigEndian(at);
+    const payloadBytes = serializeBytes(timestamp, reference);
+    return uploadSingleOwnerChunkData(ky, signer, postageBatchId, identifier, payloadBytes, options);
   });
 }
-
-function verifyChunkReferenceAtOffset(offset, data) {
-  try {
-    return bytesAtOffset(data, offset, REFERENCE_PAYLOAD_MAX_SIZE);
-  } catch (e) {
-    return bytesAtOffset(data, offset, REFERENCE_PAYLOAD_MIN_SIZE);
-  }
-}
-
-export function verifyChunkReference(data) {
-  return verifyChunkReferenceAtOffset(0, data);
+export function getFeedUpdateChunkReference(owner, topic, index) {
+  const identifier = makeFeedIdentifier(topic, index);
+  return keccak256Hash(identifier, owner);
 }
 export function downloadFeedUpdate(ky, owner, topic, index) {
   return __awaiter(this, void 0, void 0, function* () {
-    const identifier = makeFeedIdentifier(topic, index);
-    const address = keccak256Hash(identifier, owner);
+    const address = getFeedUpdateChunkReference(owner, topic, index);
     const addressHex = bytesToHex(address);
     const data = yield chunkAPI.download(ky, addressHex);
     const soc = makeSingleOwnerChunkFromData(data, address);
     const payload = soc.payload();
     const timestampBytes = bytesAtOffset(payload, TIMESTAMP_PAYLOAD_OFFSET, TIMESTAMP_PAYLOAD_SIZE);
     const timestamp = readUint64BigEndian(timestampBytes);
-    const reference = verifyChunkReferenceAtOffset(REFERENCE_PAYLOAD_OFFSET, payload);
+    const reference = makeBytesReference(payload, REFERENCE_PAYLOAD_OFFSET);
     return {
       timestamp,
       reference
@@ -138,46 +95,34 @@ export function downloadFeedUpdate(ky, owner, topic, index) {
   });
 }
 export function makeFeedReader(ky, type, topic, owner) {
-  const download = options => __awaiter(this, void 0, void 0, function* () {
-    return fetchFeedUpdate(ky, owner, topic, Object.assign(Object.assign({}, options), {
-      type
-    }));
-  });
-
   return {
     type,
     owner,
     topic,
-    download
-  };
-}
-
-function makeChunkReference(reference) {
-  if (typeof reference === 'string') {
-    try {
-      // Non-encrypted chunk hex string reference
-      const hexReference = makeHexString(reference, REFERENCE_HEX_LENGTH);
-      return hexToBytes(hexReference);
-    } catch (e) {
-      if (!(e instanceof TypeError)) {
-        throw e;
-      } // Encrypted chunk hex string reference
-
 
-      const hexReference = makeHexString(reference, ENCRYPTED_REFERENCE_HEX_LENGTH);
-      return hexToBytes(hexReference);
+    download(options) {
+      return __awaiter(this, void 0, void 0, function* () {
+        if (!(options === null || options === void 0 ? void 0 : options.index)) {
+          return fetchLatestFeedUpdate(ky, owner, topic, Object.assign(Object.assign({}, options), {
+            type
+          }));
+        }
+
+        const update = yield downloadFeedUpdate(ky, hexToBytes(owner), topic, options.index);
+        return {
+          reference: bytesToHex(update.reference),
+          feedIndex: options.index,
+          feedIndexNext: ''
+        };
+      });
     }
-  } else if (reference instanceof Uint8Array) {
-    return verifyChunkReference(reference);
-  }
 
-  throw new TypeError('invalid chunk reference');
+  };
 }
-
 export function makeFeedWriter(ky, type, topic, signer) {
   const upload = (postageBatchId, reference, options) => __awaiter(this, void 0, void 0, function* () {
     assertAddress(postageBatchId);
-    const canonicalReference = makeChunkReference(reference);
+    const canonicalReference = makeBytesReference(reference);
     return updateFeed(ky, signer, topic, canonicalReference, postageBatchId, Object.assign(Object.assign({}, options), {
       type
     }));