@ethersphere/bee-js 3.0.0 → 3.3.1

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,137 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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;
+function sign(signer, data) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const result = yield 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,172 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadSingleOwnerChunk = exports.uploadSingleOwnerChunkData = exports.uploadSingleOwnerChunk = exports.makeSingleOwnerChunk = exports.makeSOCAddress = exports.makeSingleOwnerChunkFromData = void 0;
+const bytes_1 = require("../utils/bytes");
+const bmt_1 = require("./bmt");
+const signer_1 = require("./signer");
+const hash_1 = require("../utils/hash");
+const span_1 = require("./span");
+const serialize_1 = require("./serialize");
+const error_1 = require("../utils/error");
+const cac_1 = require("./cac");
+const hex_1 = require("../utils/hex");
+const socAPI = __importStar(require("../modules/soc"));
+const chunkAPI = __importStar(require("../modules/chunk"));
+const type_1 = require("../utils/type");
+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
+ */
+function makeSingleOwnerChunk(chunk, identifier, signer) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const chunkAddress = chunk.address();
+        (0, cac_1.assertValidChunkData)(chunk.data, chunkAddress);
+        const digest = (0, hash_1.keccak256Hash)(identifier, chunkAddress);
+        const signature = yield (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 ky              Ky instance
+ * @param chunk           A chunk object
+ * @param postageBatchId  Postage BatchId that will be assigned to uploaded data
+ * @param options         Upload options
+ */
+function uploadSingleOwnerChunk(ky, chunk, postageBatchId, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        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(ky, owner, identifier, signature, data, postageBatchId, options);
+    });
+}
+exports.uploadSingleOwnerChunk = uploadSingleOwnerChunk;
+/**
+ * Helper function to create and upload SOC.
+ *
+ * @param ky              Ky instance
+ * @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
+ */
+function uploadSingleOwnerChunkData(ky, signer, postageBatchId, identifier, data, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        (0, type_1.assertAddress)(postageBatchId);
+        const cac = (0, cac_1.makeContentAddressedChunk)(data);
+        const soc = yield makeSingleOwnerChunk(cac, identifier, signer);
+        return uploadSingleOwnerChunk(ky, 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
+ */
+function downloadSingleOwnerChunk(ky, ownerAddress, identifier) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const address = makeSOCAddress(identifier, ownerAddress);
+        const data = yield chunkAPI.download(ky, (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 = Math.pow(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/index.js

@@ -0,0 +1,184 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeFeedWriter = exports.makeFeedReader = exports.downloadFeedUpdate = exports.verifyChunkReference = exports.updateFeed = exports.findNextIndex = exports.uploadFeedUpdate = exports.makeFeedIdentifier = exports.makeFeedIndexBytes = exports.makeSequentialFeedIdentifier = exports.isEpoch = void 0;
+const hash_1 = require("../utils/hash");
+const serialize_1 = require("../chunk/serialize");
+const soc_1 = require("../chunk/soc");
+const feed_1 = require("../modules/feed");
+const types_1 = require("../types");
+const bytes_1 = require("../utils/bytes");
+const error_1 = require("../utils/error");
+const hex_1 = require("../utils/hex");
+const uint64_1 = require("../utils/uint64");
+const chunkAPI = __importStar(require("../modules/chunk"));
+const eth_1 = require("../utils/eth");
+const type_1 = require("../utils/type");
+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;
+function isEpoch(epoch) {
+    return typeof epoch === 'object' && epoch !== null && 'time' in epoch && 'level' in epoch;
+}
+exports.isEpoch = isEpoch;
+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);
+}
+exports.makeSequentialFeedIdentifier = makeSequentialFeedIdentifier;
+function makeFeedIndexBytes(s) {
+    const hex = (0, hex_1.makeHexString)(s, INDEX_HEX_LENGTH);
+    return (0, hex_1.hexToBytes)(hex);
+}
+exports.makeFeedIndexBytes = makeFeedIndexBytes;
+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;
+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 = (0, uint64_1.writeUint64BigEndian)(at);
+        const payloadBytes = (0, serialize_1.serializeBytes)(timestamp, reference);
+        return (0, soc_1.uploadSingleOwnerChunkData)(ky, signer, postageBatchId, identifier, payloadBytes, options);
+    });
+}
+exports.uploadFeedUpdate = uploadFeedUpdate;
+function findNextIndex(ky, owner, topic, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const feedUpdate = yield (0, feed_1.fetchFeedUpdate)(ky, owner, topic, options);
+            return (0, hex_1.makeHexString)(feedUpdate.feedIndexNext, INDEX_HEX_LENGTH);
+        }
+        catch (e) {
+            if (e instanceof error_1.BeeResponseError && e.status === 404) {
+                return (0, hex_1.bytesToHex)((0, bytes_1.makeBytes)(8));
+            }
+            throw e;
+        }
+    });
+}
+exports.findNextIndex = findNextIndex;
+function updateFeed(ky, signer, topic, reference, postageBatchId, options) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const ownerHex = (0, eth_1.makeHexEthAddress)(signer.address);
+        const nextIndex = yield findNextIndex(ky, ownerHex, topic, options);
+        return uploadFeedUpdate(ky, signer, topic, nextIndex, reference, postageBatchId, options);
+    });
+}
+exports.updateFeed = updateFeed;
+function verifyChunkReferenceAtOffset(offset, data) {
+    try {
+        return (0, bytes_1.bytesAtOffset)(data, offset, REFERENCE_PAYLOAD_MAX_SIZE);
+    }
+    catch (e) {
+        return (0, bytes_1.bytesAtOffset)(data, offset, REFERENCE_PAYLOAD_MIN_SIZE);
+    }
+}
+function verifyChunkReference(data) {
+    return verifyChunkReferenceAtOffset(0, data);
+}
+exports.verifyChunkReference = verifyChunkReference;
+function downloadFeedUpdate(ky, owner, topic, index) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const identifier = makeFeedIdentifier(topic, index);
+        const address = (0, hash_1.keccak256Hash)(identifier, owner);
+        const addressHex = (0, hex_1.bytesToHex)(address);
+        const data = yield chunkAPI.download(ky, 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 = verifyChunkReferenceAtOffset(REFERENCE_PAYLOAD_OFFSET, payload);
+        return {
+            timestamp,
+            reference,
+        };
+    });
+}
+exports.downloadFeedUpdate = downloadFeedUpdate;
+function makeFeedReader(ky, type, topic, owner) {
+    const download = (options) => __awaiter(this, void 0, void 0, function* () { return (0, feed_1.fetchFeedUpdate)(ky, owner, topic, Object.assign(Object.assign({}, options), { type })); });
+    return {
+        type,
+        owner,
+        topic,
+        download,
+    };
+}
+exports.makeFeedReader = makeFeedReader;
+function makeChunkReference(reference) {
+    if (typeof reference === 'string') {
+        try {
+            // Non-encrypted chunk hex string reference
+            const hexReference = (0, hex_1.makeHexString)(reference, types_1.REFERENCE_HEX_LENGTH);
+            return (0, hex_1.hexToBytes)(hexReference);
+        }
+        catch (e) {
+            if (!(e instanceof TypeError)) {
+                throw e;
+            }
+            // Encrypted chunk hex string reference
+            const hexReference = (0, hex_1.makeHexString)(reference, types_1.ENCRYPTED_REFERENCE_HEX_LENGTH);
+            return (0, hex_1.hexToBytes)(hexReference);
+        }
+    }
+    else if (reference instanceof Uint8Array) {
+        return verifyChunkReference(reference);
+    }
+    throw new TypeError('invalid chunk reference');
+}
+function makeFeedWriter(ky, type, topic, signer) {
+    const upload = (postageBatchId, reference, options) => __awaiter(this, void 0, void 0, function* () {
+        (0, type_1.assertAddress)(postageBatchId);
+        const canonicalReference = makeChunkReference(reference);
+        return updateFeed(ky, signer, topic, canonicalReference, postageBatchId, Object.assign(Object.assign({}, options), { type }));
+    });
+    return Object.assign(Object.assign({}, makeFeedReader(ky, type, topic, (0, eth_1.makeHexEthAddress)(signer.address))), { upload });
+}
+exports.makeFeedWriter = makeFeedWriter;