@ethersphere/bee-js 6.0.0-pre.0 → 6.0.0-pre.10

package/dist/cjs/chunk/bmt.js

@@ -0,0 +1,55 @@
+"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;
+const error_1 = require("../utils/error");
+const hash_1 = require("../utils/hash");
+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
+ *
+ * The BMT chunk address is the hash of the 8 byte span and the root
+ * hash of a binary Merkle tree (BMT) built on the 32-byte segments
+ * of the underlying data.
+ *
+ * If the chunk content is less than 4k, the hash is calculated as
+ * if the chunk was padded with all zeros up to 4096 bytes.
+ *
+ * @param chunkContent Chunk data including span and payload as well
+ *
+ * @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;
+}
+exports.bmtHash = bmtHash;
+function bmtRootHash(payload) {
+    if (payload.length > MAX_CHUNK_PAYLOAD_SIZE) {
+        throw new error_1.BeeArgumentError('invalid data length', 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;
+}

package/dist/cjs/chunk/cac.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertValidChunkData = exports.isValidChunkData = exports.makeContentAddressedChunk = exports.MAX_PAYLOAD_SIZE = exports.MIN_PAYLOAD_SIZE = void 0;
+const error_1 = require("../utils/error");
+const bmt_1 = require("./bmt");
+const bytes_1 = require("../utils/bytes");
+const serialize_1 = require("./serialize");
+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;
+/**
+ * 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 = (0, serialize_1.serializeBytes)(span, 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),
+    };
+}
+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!');
+    }
+}
+exports.assertValidChunkData = assertValidChunkData;

package/dist/cjs/chunk/serialize.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeBytes = void 0;
+/**
+ * Helper function for serialize byte arrays
+ *
+ * @param arrays Any number of byte array arguments
+ */
+function serializeBytes(...arrays) {
+    const length = arrays.reduce((prev, curr) => prev + curr.length, 0);
+    const buffer = new Uint8Array(length);
+    let offset = 0;
+    arrays.forEach(arr => {
+        buffer.set(arr, offset);
+        offset += arr.length;
+    });
+    return buffer;
+}
+exports.serializeBytes = serializeBytes;

package/dist/cjs/chunk/signer.js

@@ -0,0 +1,126 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sign = exports.makeSigner = exports.assertSigner = exports.makePrivateKeySigner = exports.recoverAddress = exports.defaultSign = void 0;
+// For ESM compatibility
+const elliptic_1 = __importDefault(require("elliptic"));
+const { ec } = elliptic_1.default;
+const error_1 = require("../utils/error");
+const bytes_1 = require("../utils/bytes");
+const hash_1 = require("../utils/hash");
+const hex_1 = require("../utils/hex");
+const types_1 = require("../types");
+const type_1 = require("../utils/type");
+const UNCOMPRESSED_RECOVERY_ID = 27;
+function hashWithEthereumPrefix(data) {
+    const ethereumSignedMessagePrefix = `\x19Ethereum Signed Message:\n${data.length}`;
+    const prefixBytes = new TextEncoder().encode(ethereumSignedMessagePrefix);
+    return (0, hash_1.keccak256Hash)(prefixBytes, data);
+}
+/**
+ * The default signer function that can be used for integrating with
+ * other applications (e.g. wallets).
+ *
+ * @param data      The data to be signed
+ * @param privateKey  The private key used for signing the data
+ */
+function defaultSign(data, privateKey) {
+    const curve = new ec('secp256k1');
+    const keyPair = curve.keyFromPrivate(privateKey);
+    const hashedDigest = hashWithEthereumPrefix(data);
+    const sigRaw = curve.sign(hashedDigest, keyPair, { canonical: true, pers: undefined });
+    if (sigRaw.recoveryParam === null) {
+        throw new error_1.BeeError('signDigest recovery param was null');
+    }
+    const signature = new Uint8Array([
+        ...sigRaw.r.toArray('be', 32),
+        ...sigRaw.s.toArray('be', 32),
+        sigRaw.recoveryParam + UNCOMPRESSED_RECOVERY_ID,
+    ]);
+    return signature;
+}
+exports.defaultSign = defaultSign;
+function publicKeyToAddress(pubKey) {
+    const pubBytes = pubKey.encode('array', false);
+    return (0, hash_1.keccak256Hash)(pubBytes.slice(1)).slice(12);
+}
+/**
+ * Recovers the ethereum address from a given signature.
+ *
+ * Can be used for verifying a piece of data when the public key is
+ * known.
+ *
+ * @param signature The signature
+ * @param digest    The digest of the data
+ *
+ * @returns the recovered address
+ */
+function recoverAddress(signature, digest) {
+    const curve = new ec('secp256k1');
+    const sig = {
+        r: signature.slice(0, 32),
+        s: signature.slice(32, 64),
+    };
+    const recoveryParam = signature[64] - UNCOMPRESSED_RECOVERY_ID;
+    const hash = hashWithEthereumPrefix(digest);
+    const recPubKey = curve.recoverPubKey(hash, sig, recoveryParam);
+    return publicKeyToAddress(recPubKey);
+}
+exports.recoverAddress = recoverAddress;
+/**
+ * Creates a singer object that can be used when the private key is known.
+ *
+ * @param privateKey The private key
+ */
+function makePrivateKeySigner(privateKey) {
+    const curve = new ec('secp256k1');
+    const keyPair = curve.keyFromPrivate(privateKey);
+    const address = publicKeyToAddress(keyPair.getPublic());
+    return {
+        sign: (digest) => defaultSign(digest, privateKey),
+        address,
+    };
+}
+exports.makePrivateKeySigner = makePrivateKeySigner;
+function assertSigner(signer) {
+    if (!(0, type_1.isStrictlyObject)(signer)) {
+        throw new TypeError('Signer must be an object!');
+    }
+    const typedSigner = signer;
+    if (!(0, bytes_1.isBytes)(typedSigner.address, 20)) {
+        throw new TypeError("Signer's address must be Uint8Array with 20 bytes!");
+    }
+    if (typeof typedSigner.sign !== 'function') {
+        throw new TypeError('Signer sign property needs to be function!');
+    }
+}
+exports.assertSigner = assertSigner;
+function makeSigner(signer) {
+    if (typeof signer === 'string') {
+        const hexKey = (0, hex_1.makeHexString)(signer, 64);
+        const keyBytes = (0, hex_1.hexToBytes)(hexKey); // HexString is verified for 64 length => 32 is guaranteed
+        return makePrivateKeySigner(keyBytes);
+    }
+    else if (signer instanceof Uint8Array) {
+        (0, bytes_1.assertBytes)(signer, 32);
+        return makePrivateKeySigner(signer);
+    }
+    assertSigner(signer);
+    return signer;
+}
+exports.makeSigner = makeSigner;
+async function sign(signer, data) {
+    const result = await signer.sign((0, bytes_1.wrapBytesWithHelpers)(data));
+    if (typeof result === 'string') {
+        const hexString = (0, hex_1.makeHexString)(result, types_1.SIGNATURE_HEX_LENGTH);
+        return (0, hex_1.hexToBytes)(hexString);
+    }
+    if (result instanceof Uint8Array) {
+        (0, bytes_1.assertBytes)(result, types_1.SIGNATURE_BYTES_LENGTH);
+        return result;
+    }
+    throw new TypeError('Invalid output of sign function!');
+}
+exports.sign = sign;

package/dist/cjs/chunk/soc.js

@@ -0,0 +1,159 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadSingleOwnerChunk = exports.uploadSingleOwnerChunkData = exports.uploadSingleOwnerChunk = exports.makeSingleOwnerChunk = exports.makeSOCAddress = exports.makeSingleOwnerChunkFromData = void 0;
+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 type_1 = require("../utils/type");
+const bmt_1 = require("./bmt");
+const cac_1 = require("./cac");
+const serialize_1 = require("./serialize");
+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;
+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);
+    return ownerAddress;
+}
+/**
+ * Verifies if the data is a valid single owner chunk
+ *
+ * @param data    The chunk data
+ * @param address The address of the single owner chunk
+ *
+ * @returns a single owner chunk or throws error
+ */
+function makeSingleOwnerChunkFromData(data, 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)) {
+        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);
+    return {
+        data,
+        identifier: () => identifier,
+        signature,
+        span,
+        payload,
+        address: () => socAddress,
+        owner: () => ownerAddress,
+    };
+}
+exports.makeSingleOwnerChunkFromData = makeSingleOwnerChunkFromData;
+function makeSOCAddress(identifier, address) {
+    return (0, hash_1.keccak256Hash)(identifier, address);
+}
+exports.makeSOCAddress = makeSOCAddress;
+/**
+ * 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
+ */
+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 = (0, serialize_1.serializeBytes)(identifier, signature, chunk.span(), chunk.payload());
+    const address = makeSOCAddress(identifier, signer.address);
+    return {
+        data,
+        identifier: () => identifier,
+        signature: () => signature,
+        span: () => chunk.span(),
+        payload: () => chunk.payload(),
+        address: () => address,
+        owner: () => signer.address,
+    };
+}
+exports.makeSingleOwnerChunk = makeSingleOwnerChunk;
+/**
+ * Helper function to upload a chunk.
+ *
+ * It uses the Chunk API and calculates the address before uploading.
+ *
+ * @param kyOptions Ky Options for making requests
+ * @param chunk           A chunk object
+ * @param postageBatchId  Postage BatchId that will be assigned to uploaded data
+ * @param options         Upload options
+ */
+async function uploadSingleOwnerChunk(requestOptions, chunk, postageBatchId, 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 = (0, serialize_1.serializeBytes)(chunk.span(), chunk.payload());
+    return socAPI.upload(requestOptions, owner, identifier, signature, data, postageBatchId, options);
+}
+exports.uploadSingleOwnerChunk = uploadSingleOwnerChunk;
+/**
+ * Helper function to create and upload SOC.
+ *
+ * @param kyOptions Ky Options for making requests
+ * @param signer          The singer 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, postageBatchId, identifier, data, options) {
+    (0, type_1.assertAddress)(postageBatchId);
+    const cac = (0, cac_1.makeContentAddressedChunk)(data);
+    const soc = await makeSingleOwnerChunk(cac, identifier, signer);
+    return uploadSingleOwnerChunk(requestOptions, soc, postageBatchId, options);
+}
+exports.uploadSingleOwnerChunkData = uploadSingleOwnerChunkData;
+/**
+ * Helper function to download SOC.
+ *
+ * @param url           The url of the Bee service
+ * @param ownerAddress  The singer interface for signing the chunk
+ * @param identifier    The identifier of the chunk
+ */
+async function downloadSingleOwnerChunk(requestOptions, ownerAddress, identifier) {
+    const address = makeSOCAddress(identifier, ownerAddress);
+    const data = await chunkAPI.download(requestOptions, (0, hex_1.bytesToHex)(address));
+    return makeSingleOwnerChunkFromData(data, address);
+}
+exports.downloadSingleOwnerChunk = downloadSingleOwnerChunk;

package/dist/cjs/chunk/span.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeSpan = exports.SPAN_SIZE = void 0;
+const error_1 = require("../utils/error");
+exports.SPAN_SIZE = 8;
+// we limit the maximum span size in 32 bits to avoid BigInt compatibility issues
+const MAX_SPAN_LENGTH = 2 ** 32 - 1;
+/**
+ * Create a span for storing the length of the chunk
+ *
+ * The length is encoded in 64-bit little endian.
+ *
+ * @param length The length of the span
+ */
+function makeSpan(length) {
+    if (length <= 0) {
+        throw new error_1.BeeArgumentError('invalid length for span', length);
+    }
+    if (length > MAX_SPAN_LENGTH) {
+        throw new error_1.BeeArgumentError('invalid length (> MAX_SPAN_LENGTH)', length);
+    }
+    const span = new Uint8Array(exports.SPAN_SIZE);
+    const dataView = new DataView(span.buffer);
+    const littleEndian = true;
+    const lengthLower32 = length & 0xffffffff;
+    dataView.setUint32(0, lengthLower32, littleEndian);
+    return span;
+}
+exports.makeSpan = makeSpan;

package/dist/cjs/feed/identifier.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeFeedIdentifier = void 0;
+const types_1 = require("../types");
+const hash_1 = require("../utils/hash");
+const hex_1 = require("../utils/hex");
+const uint64_1 = require("../utils/uint64");
+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 = (0, uint64_1.writeUint64BigEndian)(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);
+}
+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);
+}
+exports.makeFeedIdentifier = makeFeedIdentifier;

package/dist/cjs/feed/index.js

@@ -0,0 +1,116 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeFeedWriter = exports.makeFeedReader = exports.downloadFeedUpdate = exports.getFeedUpdateChunkReference = exports.updateFeed = exports.findNextIndex = void 0;
+const serialize_1 = require("../chunk/serialize");
+const soc_1 = require("../chunk/soc");
+const chunkAPI = __importStar(require("../modules/chunk"));
+const feed_1 = require("../modules/feed");
+const types_1 = require("../types");
+const bytes_1 = require("../utils/bytes");
+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 uint64_1 = require("../utils/uint64");
+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) {
+    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);
+    }
+    catch (e) {
+        if (e?.response?.status === 404) {
+            return (0, hex_1.bytesToHex)((0, bytes_1.makeBytes)(8));
+        }
+        throw e;
+    }
+}
+exports.findNextIndex = findNextIndex;
+async function updateFeed(requestOptions, signer, topic, reference, postageBatchId, options, index = 'latest') {
+    const ownerHex = (0, eth_1.makeHexEthAddress)(signer.address);
+    const nextIndex = index === 'latest' ? await findNextIndex(requestOptions, ownerHex, topic, options) : index;
+    const identifier = (0, identifier_1.makeFeedIdentifier)(topic, nextIndex);
+    const at = options?.at ?? Date.now() / 1000.0;
+    const timestamp = (0, uint64_1.writeUint64BigEndian)(at);
+    const payloadBytes = (0, serialize_1.serializeBytes)(timestamp, reference);
+    return (0, soc_1.uploadSingleOwnerChunkData)(requestOptions, signer, postageBatchId, identifier, payloadBytes, options);
+}
+exports.updateFeed = updateFeed;
+function getFeedUpdateChunkReference(owner, topic, index) {
+    const identifier = (0, identifier_1.makeFeedIdentifier)(topic, index);
+    return (0, hash_1.keccak256Hash)(identifier, owner);
+}
+exports.getFeedUpdateChunkReference = getFeedUpdateChunkReference;
+async function downloadFeedUpdate(requestOptions, owner, topic, index) {
+    const address = getFeedUpdateChunkReference(owner, topic, index);
+    const addressHex = (0, hex_1.bytesToHex)(address);
+    const data = await chunkAPI.download(requestOptions, addressHex);
+    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 = (0, uint64_1.readUint64BigEndian)(timestampBytes);
+    const reference = (0, reference_1.makeBytesReference)(payload, REFERENCE_PAYLOAD_OFFSET);
+    return {
+        timestamp,
+        reference,
+    };
+}
+exports.downloadFeedUpdate = downloadFeedUpdate;
+function makeFeedReader(requestOptions, type, topic, owner) {
+    return {
+        type,
+        owner,
+        topic,
+        async download(options) {
+            if (!options?.index) {
+                return (0, feed_1.fetchLatestFeedUpdate)(requestOptions, owner, topic, { ...options, type });
+            }
+            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) {
+    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 {
+        ...makeFeedReader(requestOptions, type, topic, (0, eth_1.makeHexEthAddress)(signer.address)),
+        upload,
+    };
+}
+exports.makeFeedWriter = makeFeedWriter;

package/dist/cjs/feed/json.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setJsonData = exports.getJsonData = void 0;
+const type_1 = require("../utils/type");
+function serializeJson(data) {
+    try {
+        const jsonString = JSON.stringify(data);
+        return new TextEncoder().encode(jsonString);
+    }
+    catch (e) {
+        if ((0, type_1.isError)(e)) {
+            e.message = `JsonFeed: ${e.message}`;
+        }
+        throw e;
+    }
+}
+async function getJsonData(bee, reader) {
+    const feedUpdate = await reader.download();
+    const retrievedData = await bee.downloadData(feedUpdate.reference);
+    return retrievedData.json();
+}
+exports.getJsonData = getJsonData;
+async function setJsonData(bee, writer, postageBatchId, data, options, requestOptions) {
+    const serializedData = serializeJson(data);
+    const { reference } = await bee.uploadData(postageBatchId, serializedData, options, requestOptions);
+    return writer.upload(postageBatchId, reference);
+}
+exports.setJsonData = setJsonData;