@ethersphere/bee-js 8.3.1 → 9.0.2

package/dist/cjs/chunk/bmt.js

@@ -1,18 +1,11 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.bmtHash = void 0;
-// For ESM compatibility
-const js_sha3_1 = __importDefault(require("js-sha3"));
-const { keccak256 } = js_sha3_1.default;
+exports.calculateChunkAddress = void 0;
+const cafe_utility_1 = require("cafe-utility");
 const error_1 = require("../utils/error");
-const hash_1 = require("../utils/hash");
+const typed_bytes_1 = require("../utils/typed-bytes");
 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
  *
@@ -27,29 +20,19 @@ const HASH_SIZE = 32;
  *
  * @returns the keccak256 hash in a byte array
  */
-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 = (0, hash_1.keccak256Hash)(chunkHashInput);
-    return chunkHash;
+function calculateChunkAddress(chunkContent) {
+    const span = chunkContent.slice(0, typed_bytes_1.Span.LENGTH);
+    const payload = chunkContent.slice(typed_bytes_1.Span.LENGTH);
+    const rootHash = calculateBmtRootHash(payload);
+    const chunkHash = cafe_utility_1.Binary.keccak256(cafe_utility_1.Binary.concatBytes(span, rootHash));
+    return new typed_bytes_1.Reference(chunkHash);
 }
-exports.bmtHash = bmtHash;
-function bmtRootHash(payload) {
+exports.calculateChunkAddress = calculateChunkAddress;
+function calculateBmtRootHash(payload) {
     if (payload.length > MAX_CHUNK_PAYLOAD_SIZE) {
-        throw new error_1.BeeArgumentError('invalid data length', payload);
+        throw new error_1.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 cafe_utility_1.Binary.log2Reduce(cafe_utility_1.Binary.partition(input, SEGMENT_SIZE), (a, b) => cafe_utility_1.Binary.keccak256(cafe_utility_1.Binary.concatBytes(a, b)));
 }

package/dist/cjs/chunk/cac.js

@@ -1,56 +1,46 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertValidChunkData = exports.isValidChunkData = exports.makeContentAddressedChunk = exports.MAX_PAYLOAD_SIZE = exports.MIN_PAYLOAD_SIZE = void 0;
+exports.asContentAddressedChunk = exports.makeContentAddressedChunk = exports.MAX_PAYLOAD_SIZE = exports.MIN_PAYLOAD_SIZE = void 0;
 const cafe_utility_1 = require("cafe-utility");
 const bytes_1 = require("../utils/bytes");
-const error_1 = require("../utils/error");
+const typed_bytes_1 = require("../utils/typed-bytes");
 const bmt_1 = require("./bmt");
-const span_1 = require("./span");
 exports.MIN_PAYLOAD_SIZE = 1;
 exports.MAX_PAYLOAD_SIZE = 4096;
-const CAC_SPAN_OFFSET = 0;
-const CAC_PAYLOAD_OFFSET = CAC_SPAN_OFFSET + span_1.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
  */
 function makeContentAddressedChunk(payloadBytes) {
-    const span = (0, span_1.makeSpan)(payloadBytes.length);
-    (0, bytes_1.assertFlexBytes)(payloadBytes, exports.MIN_PAYLOAD_SIZE, exports.MAX_PAYLOAD_SIZE);
-    const data = cafe_utility_1.Binary.concatBytes(span, payloadBytes);
+    if (!(payloadBytes instanceof Uint8Array)) {
+        payloadBytes = ENCODER.encode(payloadBytes);
+    }
+    if (payloadBytes.length < exports.MIN_PAYLOAD_SIZE || payloadBytes.length > exports.MAX_PAYLOAD_SIZE) {
+        throw new RangeError(`payload size ${payloadBytes.length} exceeds limits [${exports.MIN_PAYLOAD_SIZE}, ${exports.MAX_PAYLOAD_SIZE}]`);
+    }
+    const span = typed_bytes_1.Span.fromBigInt(BigInt(payloadBytes.length));
+    const data = cafe_utility_1.Binary.concatBytes(span.toUint8Array(), payloadBytes);
     return {
         data,
-        span: () => span,
-        payload: () => (0, bytes_1.flexBytesAtOffset)(data, CAC_PAYLOAD_OFFSET, exports.MIN_PAYLOAD_SIZE, exports.MAX_PAYLOAD_SIZE),
-        address: () => (0, bmt_1.bmtHash)(data),
+        span,
+        payload: bytes_1.Bytes.fromSlice(data, typed_bytes_1.Span.LENGTH),
+        address: (0, bmt_1.calculateChunkAddress)(data),
     };
 }
 exports.makeContentAddressedChunk = makeContentAddressedChunk;
-/**
- * Type guard for valid content addressed chunk data
- *
- * @param data          The chunk data
- * @param chunkAddress  The address of the chunk
- */
-function isValidChunkData(data, chunkAddress) {
-    if (!(data instanceof Uint8Array))
-        return false;
-    const address = (0, bmt_1.bmtHash)(data);
-    return (0, bytes_1.bytesEqual)(address, chunkAddress);
-}
-exports.isValidChunkData = isValidChunkData;
-/**
- * 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
- */
-function assertValidChunkData(data, chunkAddress) {
-    if (!isValidChunkData(data, chunkAddress)) {
-        throw new error_1.BeeError('Address of content address chunk does not match given data!');
+function asContentAddressedChunk(chunkBytes) {
+    if (chunkBytes.length < exports.MIN_PAYLOAD_SIZE + typed_bytes_1.Span.LENGTH || chunkBytes.length > exports.MAX_PAYLOAD_SIZE + typed_bytes_1.Span.LENGTH) {
+        throw new RangeError(`chunk size ${chunkBytes.length} exceeds limits [${exports.MIN_PAYLOAD_SIZE + typed_bytes_1.Span.LENGTH}, ${typed_bytes_1.Span.LENGTH}]`);
     }
+    const span = typed_bytes_1.Span.fromSlice(chunkBytes, 0);
+    const data = cafe_utility_1.Binary.concatBytes(span.toUint8Array(), chunkBytes.slice(typed_bytes_1.Span.LENGTH));
+    return {
+        data,
+        span,
+        payload: bytes_1.Bytes.fromSlice(data, typed_bytes_1.Span.LENGTH),
+        address: (0, bmt_1.calculateChunkAddress)(data),
+    };
 }
-exports.assertValidChunkData = assertValidChunkData;
+exports.asContentAddressedChunk = asContentAddressedChunk;

package/dist/cjs/chunk/soc.js

@@ -23,31 +23,25 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.downloadSingleOwnerChunk = exports.uploadSingleOwnerChunkData = exports.uploadSingleOwnerChunk = exports.makeSingleOwnerChunk = exports.makeSOCAddress = exports.makeSingleOwnerChunkFromData = void 0;
+exports.downloadSingleOwnerChunk = exports.uploadSingleOwnerChunkWithWrappedChunk = exports.uploadSingleOwnerChunkData = exports.uploadSingleOwnerChunk = exports.makeSingleOwnerChunk = exports.makeSOCAddress = exports.makeSingleOwnerChunkFromData = void 0;
 const cafe_utility_1 = require("cafe-utility");
 const chunkAPI = __importStar(require("../modules/chunk"));
 const socAPI = __importStar(require("../modules/soc"));
 const bytes_1 = require("../utils/bytes");
 const error_1 = require("../utils/error");
-const hash_1 = require("../utils/hash");
-const hex_1 = require("../utils/hex");
+const typed_bytes_1 = require("../utils/typed-bytes");
 const bmt_1 = require("./bmt");
 const cac_1 = require("./cac");
-const signer_1 = require("./signer");
-const span_1 = require("./span");
-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_1.SPAN_SIZE;
+const SOC_SIGNATURE_OFFSET = typed_bytes_1.Identifier.LENGTH;
+const SOC_SPAN_OFFSET = SOC_SIGNATURE_OFFSET + typed_bytes_1.Signature.LENGTH;
+const SOC_PAYLOAD_OFFSET = SOC_SPAN_OFFSET + typed_bytes_1.Span.LENGTH;
 function recoverChunkOwner(data) {
     const cacData = data.slice(SOC_SPAN_OFFSET);
-    const chunkAddress = (0, bmt_1.bmtHash)(cacData);
-    const signature = (0, bytes_1.bytesAtOffset)(data, SOC_SIGNATURE_OFFSET, SIGNATURE_SIZE);
-    const identifier = (0, bytes_1.bytesAtOffset)(data, SOC_IDENTIFIER_OFFSET, IDENTIFIER_SIZE);
-    const digest = (0, hash_1.keccak256Hash)(identifier, chunkAddress);
-    const ownerAddress = (0, signer_1.recoverAddress)(signature, digest);
+    const chunkAddress = (0, bmt_1.calculateChunkAddress)(cacData);
+    const signature = typed_bytes_1.Signature.fromSlice(data, SOC_SIGNATURE_OFFSET);
+    const identifier = bytes_1.Bytes.fromSlice(data, 0, typed_bytes_1.Identifier.LENGTH);
+    const digest = cafe_utility_1.Binary.concatBytes(identifier.toUint8Array(), chunkAddress.toUint8Array());
+    const ownerAddress = signature.recoverPublicKey(digest).address();
     return ownerAddress;
 }
 /**
@@ -59,28 +53,30 @@ function recoverChunkOwner(data) {
  * @returns a single owner chunk or throws error
  */
 function makeSingleOwnerChunkFromData(data, address) {
+    data = data instanceof bytes_1.Bytes ? data.toUint8Array() : data;
+    address = new typed_bytes_1.Reference(address);
     const ownerAddress = recoverChunkOwner(data);
-    const identifier = (0, bytes_1.bytesAtOffset)(data, SOC_IDENTIFIER_OFFSET, IDENTIFIER_SIZE);
-    const socAddress = (0, hash_1.keccak256Hash)(identifier, ownerAddress);
-    if (!(0, bytes_1.bytesEqual)(address, socAddress)) {
+    const identifier = bytes_1.Bytes.fromSlice(data, 0, typed_bytes_1.Identifier.LENGTH);
+    const socAddress = new typed_bytes_1.Reference(cafe_utility_1.Binary.keccak256(cafe_utility_1.Binary.concatBytes(identifier.toUint8Array(), ownerAddress.toUint8Array())));
+    if (!cafe_utility_1.Binary.equals(address.toUint8Array(), socAddress.toUint8Array())) {
         throw new error_1.BeeError('SOC Data does not match given address!');
     }
-    const signature = () => (0, bytes_1.bytesAtOffset)(data, SOC_SIGNATURE_OFFSET, SIGNATURE_SIZE);
-    const span = () => (0, bytes_1.bytesAtOffset)(data, SOC_SPAN_OFFSET, span_1.SPAN_SIZE);
-    const payload = () => (0, bytes_1.flexBytesAtOffset)(data, SOC_PAYLOAD_OFFSET, cac_1.MIN_PAYLOAD_SIZE, cac_1.MAX_PAYLOAD_SIZE);
+    const signature = typed_bytes_1.Signature.fromSlice(data, SOC_SIGNATURE_OFFSET);
+    const span = typed_bytes_1.Span.fromSlice(data, SOC_SPAN_OFFSET);
+    const payload = bytes_1.Bytes.fromSlice(data, SOC_PAYLOAD_OFFSET);
     return {
         data,
-        identifier: () => identifier,
+        identifier,
         signature,
         span,
         payload,
-        address: () => socAddress,
-        owner: () => ownerAddress,
+        address: socAddress,
+        owner: ownerAddress,
     };
 }
 exports.makeSingleOwnerChunkFromData = makeSingleOwnerChunkFromData;
 function makeSOCAddress(identifier, address) {
-    return (0, hash_1.keccak256Hash)(identifier, address);
+    return new typed_bytes_1.Reference(cafe_utility_1.Binary.keccak256(cafe_utility_1.Binary.concatBytes(identifier.toUint8Array(), address.toUint8Array())));
 }
 exports.makeSOCAddress = makeSOCAddress;
 /**
@@ -88,23 +84,24 @@ exports.makeSOCAddress = makeSOCAddress;
  *
  * @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
  */
-async function makeSingleOwnerChunk(chunk, identifier, signer) {
-    const chunkAddress = chunk.address();
-    (0, cac_1.assertValidChunkData)(chunk.data, chunkAddress);
-    const digest = (0, hash_1.keccak256Hash)(identifier, chunkAddress);
-    const signature = await (0, signer_1.sign)(signer, digest);
-    const data = cafe_utility_1.Binary.concatBytes(identifier, signature, chunk.span(), chunk.payload());
-    const address = makeSOCAddress(identifier, signer.address);
+function makeSingleOwnerChunk(chunk, identifier, signer) {
+    identifier = new typed_bytes_1.Identifier(identifier);
+    signer = new typed_bytes_1.PrivateKey(signer);
+    const address = makeSOCAddress(identifier, signer.publicKey().address());
+    const signature = signer.sign(cafe_utility_1.Binary.concatBytes(identifier.toUint8Array(), chunk.address.toUint8Array()));
+    const data = cafe_utility_1.Binary.concatBytes(identifier.toUint8Array(), signature.toUint8Array(), chunk.data);
+    const span = typed_bytes_1.Span.fromSlice(chunk.data, 0);
+    const payload = bytes_1.Bytes.fromSlice(chunk.data, typed_bytes_1.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(),
     };
 }
 exports.makeSingleOwnerChunk = makeSingleOwnerChunk;
@@ -115,43 +112,51 @@ exports.makeSingleOwnerChunk = makeSingleOwnerChunk;
  *
  * @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
  */
 async function uploadSingleOwnerChunk(requestOptions, chunk, stamp, options) {
-    const owner = (0, hex_1.bytesToHex)(chunk.owner());
-    const identifier = (0, hex_1.bytesToHex)(chunk.identifier());
-    const signature = (0, hex_1.bytesToHex)(chunk.signature());
-    const data = cafe_utility_1.Binary.concatBytes(chunk.span(), chunk.payload());
-    return socAPI.upload(requestOptions, owner, identifier, signature, data, stamp, options);
+    const data = cafe_utility_1.Binary.concatBytes(chunk.span.toUint8Array(), chunk.payload.toUint8Array());
+    return socAPI.upload(requestOptions, chunk.owner, chunk.identifier, chunk.signature, data, stamp, options);
 }
 exports.uploadSingleOwnerChunk = uploadSingleOwnerChunk;
 /**
  * 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
  */
 async function uploadSingleOwnerChunkData(requestOptions, signer, stamp, identifier, data, options) {
+    signer = new typed_bytes_1.PrivateKey(signer);
+    identifier = new typed_bytes_1.Identifier(identifier);
     const cac = (0, cac_1.makeContentAddressedChunk)(data);
-    const soc = await makeSingleOwnerChunk(cac, identifier, signer);
+    const soc = makeSingleOwnerChunk(cac, identifier, signer);
     return uploadSingleOwnerChunk(requestOptions, soc, stamp, options);
 }
 exports.uploadSingleOwnerChunkData = uploadSingleOwnerChunkData;
+async function uploadSingleOwnerChunkWithWrappedChunk(requestOptions, signer, stamp, identifier, rootChunk, options) {
+    signer = new typed_bytes_1.PrivateKey(signer);
+    identifier = new typed_bytes_1.Identifier(identifier);
+    const soc = makeSingleOwnerChunk((0, cac_1.asContentAddressedChunk)(rootChunk), identifier, signer);
+    return uploadSingleOwnerChunk(requestOptions, soc, stamp, options);
+}
+exports.uploadSingleOwnerChunkWithWrappedChunk = uploadSingleOwnerChunkWithWrappedChunk;
 /**
  * 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
  */
 async function downloadSingleOwnerChunk(requestOptions, ownerAddress, identifier) {
+    identifier = new typed_bytes_1.Identifier(identifier);
+    ownerAddress = new typed_bytes_1.EthAddress(ownerAddress);
     const address = makeSOCAddress(identifier, ownerAddress);
-    const data = await chunkAPI.download(requestOptions, (0, hex_1.bytesToHex)(address));
-    return makeSingleOwnerChunkFromData(data, address);
+    const cac = await chunkAPI.download(requestOptions, address.toHex());
+    return makeSingleOwnerChunkFromData(cac, address);
 }
 exports.downloadSingleOwnerChunk = downloadSingleOwnerChunk;

package/dist/cjs/feed/identifier.js

@@ -2,34 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeFeedIdentifier = void 0;
 const cafe_utility_1 = require("cafe-utility");
-const types_1 = require("../types");
-const hash_1 = require("../utils/hash");
-const hex_1 = require("../utils/hex");
-function isEpoch(epoch) {
-    return typeof epoch === 'object' && epoch !== null && 'time' in epoch && 'level' in epoch;
-}
-function hashFeedIdentifier(topic, index) {
-    return (0, hash_1.keccak256Hash)((0, hex_1.hexToBytes)(topic), index);
-}
-function makeSequentialFeedIdentifier(topic, index) {
-    const indexBytes = cafe_utility_1.Binary.numberToUint64BE(index);
-    return hashFeedIdentifier(topic, indexBytes);
-}
-function makeFeedIndexBytes(s) {
-    const hex = (0, hex_1.makeHexString)(s, types_1.FEED_INDEX_HEX_LENGTH);
-    return (0, hex_1.hexToBytes)(hex);
-}
+const typed_bytes_1 = require("../utils/typed-bytes");
 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' ? typed_bytes_1.FeedIndex.fromBigInt(BigInt(index)) : index;
+    return new typed_bytes_1.Identifier(cafe_utility_1.Binary.keccak256(cafe_utility_1.Binary.concatBytes(topic.toUint8Array(), index.toUint8Array())));
 }
 exports.makeFeedIdentifier = makeFeedIdentifier;

package/dist/cjs/feed/index.js

@@ -23,94 +23,145 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeFeedWriter = exports.makeFeedReader = exports.downloadFeedUpdate = exports.getFeedUpdateChunkReference = exports.updateFeed = exports.findNextIndex = void 0;
+exports.makeFeedWriter = exports.makeFeedReader = exports.downloadFeedUpdateAsCAC = exports.downloadFeedUpdate = exports.getFeedUpdateChunkReference = exports.updateFeedWithPayload = exports.updateFeedWithReference = exports.findNextIndex = void 0;
 const cafe_utility_1 = require("cafe-utility");
+const cac_1 = require("../chunk/cac");
 const soc_1 = require("../chunk/soc");
+const bytes = __importStar(require("../modules/bytes"));
 const chunkAPI = __importStar(require("../modules/chunk"));
 const feed_1 = require("../modules/feed");
-const types_1 = require("../types");
 const bytes_1 = require("../utils/bytes");
 const error_1 = require("../utils/error");
-const eth_1 = require("../utils/eth");
-const hash_1 = require("../utils/hash");
-const hex_1 = require("../utils/hex");
-const reference_1 = require("../utils/reference");
-const type_1 = require("../utils/type");
+const resource_locator_1 = require("../utils/resource-locator");
+const typed_bytes_1 = require("../utils/typed-bytes");
 const identifier_1 = require("./identifier");
 const TIMESTAMP_PAYLOAD_OFFSET = 0;
 const TIMESTAMP_PAYLOAD_SIZE = 8;
 const REFERENCE_PAYLOAD_OFFSET = TIMESTAMP_PAYLOAD_SIZE;
-async function findNextIndex(requestOptions, owner, topic, options) {
+async function findNextIndex(requestOptions, owner, topic) {
     try {
-        const feedUpdate = await (0, feed_1.fetchLatestFeedUpdate)(requestOptions, owner, topic, options);
-        return (0, hex_1.makeHexString)(feedUpdate.feedIndexNext, types_1.FEED_INDEX_HEX_LENGTH);
+        const feedUpdate = await (0, feed_1.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 error_1.BeeResponseError) {
-            return (0, hex_1.bytesToHex)((0, bytes_1.makeBytes)(8));
+            return typed_bytes_1.FeedIndex.fromBigInt(0n);
         }
         throw e;
     }
 }
 exports.findNextIndex = findNextIndex;
-async function updateFeed(requestOptions, signer, topic, reference, postageBatchId, options) {
-    const ownerHex = (0, eth_1.makeHexEthAddress)(signer.address);
-    const nextIndex = options?.index ?? (await findNextIndex(requestOptions, ownerHex, topic, options));
+async function updateFeedWithReference(requestOptions, signer, topic, reference, postageBatchId, options) {
+    reference = new typed_bytes_1.Reference(reference);
+    const nextIndex = options?.index ?? (await findNextIndex(requestOptions, signer.publicKey().address(), topic));
     const identifier = (0, identifier_1.makeFeedIdentifier)(topic, nextIndex);
     const at = options?.at ?? Date.now() / 1000.0;
-    const timestamp = cafe_utility_1.Binary.numberToUint64BE(Math.floor(at));
-    const payloadBytes = cafe_utility_1.Binary.concatBytes(timestamp, reference);
+    const timestamp = cafe_utility_1.Binary.numberToUint64(BigInt(Math.floor(at)), 'BE');
+    const payloadBytes = cafe_utility_1.Binary.concatBytes(timestamp, reference.toUint8Array());
     return (0, soc_1.uploadSingleOwnerChunkData)(requestOptions, signer, postageBatchId, identifier, payloadBytes, options);
 }
-exports.updateFeed = updateFeed;
+exports.updateFeedWithReference = updateFeedWithReference;
+async function updateFeedWithPayload(requestOptions, signer, topic, data, postageBatchId, options) {
+    const nextIndex = options?.index ?? (await findNextIndex(requestOptions, signer.publicKey().address(), topic));
+    const identifier = (0, identifier_1.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 (0, soc_1.uploadSingleOwnerChunkWithWrappedChunk)(requestOptions, signer, postageBatchId, identifier, rootChunk, options);
+    }
+    return (0, soc_1.uploadSingleOwnerChunkData)(requestOptions, signer, postageBatchId, identifier, cafe_utility_1.Types.isString(data) ? bytes_1.Bytes.fromUtf8(data).toUint8Array() : data, options);
+}
+exports.updateFeedWithPayload = updateFeedWithPayload;
 function getFeedUpdateChunkReference(owner, topic, index) {
     const identifier = (0, identifier_1.makeFeedIdentifier)(topic, index);
-    return (0, hash_1.keccak256Hash)(identifier, owner);
+    return new typed_bytes_1.Reference(cafe_utility_1.Binary.keccak256(cafe_utility_1.Binary.concatBytes(identifier.toUint8Array(), owner.toUint8Array())));
 }
 exports.getFeedUpdateChunkReference = getFeedUpdateChunkReference;
-async function downloadFeedUpdate(requestOptions, owner, topic, index) {
+async function downloadFeedUpdate(requestOptions, owner, topic, index, hasTimestamp = false) {
+    index = typeof index === 'number' ? typed_bytes_1.FeedIndex.fromBigInt(BigInt(index)) : index;
     const address = getFeedUpdateChunkReference(owner, topic, index);
-    const addressHex = (0, hex_1.bytesToHex)(address);
-    const data = await chunkAPI.download(requestOptions, addressHex);
+    const data = await chunkAPI.download(requestOptions, address.toHex());
     const soc = (0, soc_1.makeSingleOwnerChunkFromData)(data, address);
-    const payload = soc.payload();
-    const timestampBytes = (0, bytes_1.bytesAtOffset)(payload, TIMESTAMP_PAYLOAD_OFFSET, TIMESTAMP_PAYLOAD_SIZE);
-    const timestamp = cafe_utility_1.Binary.uint64BEToNumber(timestampBytes);
-    const reference = (0, reference_1.makeBytesReference)(payload, REFERENCE_PAYLOAD_OFFSET);
+    let timestamp = cafe_utility_1.Optional.empty();
+    if (hasTimestamp) {
+        const timestampBytes = bytes_1.Bytes.fromSlice(soc.payload.toUint8Array(), TIMESTAMP_PAYLOAD_OFFSET, TIMESTAMP_PAYLOAD_SIZE);
+        timestamp = cafe_utility_1.Optional.of(Number(cafe_utility_1.Binary.uint64ToNumber(timestampBytes.toUint8Array(), 'BE')));
+    }
     return {
         timestamp,
-        reference,
+        payload: new bytes_1.Bytes(soc.payload.offset(hasTimestamp ? REFERENCE_PAYLOAD_OFFSET : 0)),
     };
 }
 exports.downloadFeedUpdate = downloadFeedUpdate;
-function makeFeedReader(requestOptions, type, topic, owner) {
+async function downloadFeedUpdateAsCAC(requestOptions, owner, topic, index) {
+    index = typeof index === 'number' ? typed_bytes_1.FeedIndex.fromBigInt(BigInt(index)) : index;
+    const address = getFeedUpdateChunkReference(owner, topic, index);
+    const data = await chunkAPI.download(requestOptions, address);
+    return (0, cac_1.asContentAddressedChunk)(data.slice(typed_bytes_1.Identifier.LENGTH + typed_bytes_1.Signature.LENGTH));
+}
+exports.downloadFeedUpdateAsCAC = downloadFeedUpdateAsCAC;
+function makeFeedReader(requestOptions, topic, owner) {
+    // TODO: remove after enough time has passed in deprecated version
+    const download = async (options) => {
+        if (options?.index === undefined) {
+            return (0, feed_1.fetchLatestFeedUpdate)(requestOptions, owner, topic);
+        }
+        const update = await downloadFeedUpdate(requestOptions, owner, topic, options.index, options.hasTimestamp ?? true);
+        const feedIndex = typeof options.index === 'number' ? typed_bytes_1.FeedIndex.fromBigInt(BigInt(options.index)) : options.index;
+        return {
+            payload: update.payload,
+            feedIndex,
+        };
+    };
+    const downloadPayload = async (options) => {
+        if (options?.index === undefined) {
+            return (0, feed_1.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 resource_locator_1.ResourceLocator(cac.address));
+        const feedIndex = typeof options.index === 'number' ? typed_bytes_1.FeedIndex.fromBigInt(BigInt(options.index)) : options.index;
+        return {
+            payload,
+            feedIndex,
+        };
+    };
+    const downloadReference = async (options) => {
+        let index = options?.index;
+        if (index === undefined) {
+            index = (await (0, feed_1.probeFeed)(requestOptions, owner, topic)).feedIndex;
+        }
+        const payload = await download({ ...options, index: index });
+        return {
+            reference: new typed_bytes_1.Reference(payload.payload.toUint8Array()),
+            feedIndex: payload.feedIndex,
+        };
+    };
     return {
-        type,
+        download,
+        downloadPayload,
+        downloadReference,
         owner,
         topic,
-        async download(options) {
-            if (!options?.index && options?.index !== 0) {
-                return (0, feed_1.fetchLatestFeedUpdate)(requestOptions, owner, topic);
-            }
-            const update = await downloadFeedUpdate(requestOptions, (0, hex_1.hexToBytes)(owner), topic, options.index);
-            return {
-                reference: (0, hex_1.bytesToHex)(update.reference),
-                feedIndex: options.index,
-                feedIndexNext: '',
-            };
-        },
     };
 }
 exports.makeFeedReader = makeFeedReader;
-function makeFeedWriter(requestOptions, type, topic, signer) {
+function makeFeedWriter(requestOptions, topic, signer) {
     const upload = async (postageBatchId, reference, options) => {
-        (0, type_1.assertAddress)(postageBatchId);
-        const canonicalReference = (0, reference_1.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, (0, eth_1.makeHexEthAddress)(signer.address)),
+        ...makeFeedReader(requestOptions, topic, signer.publicKey().address()),
         upload,
+        uploadReference: upload,
+        uploadPayload,
     };
 }
 exports.makeFeedWriter = makeFeedWriter;

package/dist/cjs/feed/retrievable.js

@@ -2,20 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.areAllSequentialFeedsUpdateRetrievable = void 0;
 const cafe_utility_1 = require("cafe-utility");
-const hex_1 = require("../utils/hex");
+const typed_bytes_1 = require("../utils/typed-bytes");
 const index_1 = require("./index");
-function makeNumericIndex(index) {
-    if (index instanceof Uint8Array) {
-        return cafe_utility_1.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.
@@ -24,13 +12,14 @@ 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 = cafe_utility_1.Objects.getDeep(e, 'status');
+        if (status === 404 || status === 500) {
             return false;
         }
         throw e;
@@ -44,15 +33,15 @@ 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] = (0, hex_1.bytesToHex)((0, index_1.getFeedUpdateChunkReference)(owner, topic, i));
+    const count = index.toBigInt();
+    const updateReferences = [];
+    for (let i = 0n; i <= count; i++) {
+        updateReferences.push((0, index_1.getFeedUpdateChunkReference)(owner, topic, typed_bytes_1.FeedIndex.fromBigInt(i)));
     }
     return updateReferences;
 }
-async function areAllSequentialFeedsUpdateRetrievable(bee, owner, topic, index, requestOptions) {
-    const chunkRetrievablePromises = getAllSequenceUpdateReferences(owner, topic, index).map(async (ref) => isChunkRetrievable(bee, ref, requestOptions));
+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);
 }
 exports.areAllSequentialFeedsUpdateRetrievable = areAllSequentialFeedsUpdateRetrievable;