@ethersphere/bee-js 3.2.0 → 3.3.0

package/dist/mjs/chunk/bmt.js

@@ -0,0 +1,46 @@
+import { keccak256 } from 'js-sha3';
+import { BeeArgumentError } from '../utils/error';
+import { keccak256Hash } from '../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
+ */
+export function bmtHash(chunkContent) {
+    const span = chunkContent.slice(0, 8);
+    const payload = chunkContent.slice(8);
+    const rootHash = bmtRootHash(payload);
+    const chunkHashInput = new Uint8Array([...span, ...rootHash]);
+    const chunkHash = keccak256Hash(chunkHashInput);
+    return chunkHash;
+}
+function bmtRootHash(payload) {
+    if (payload.length > MAX_CHUNK_PAYLOAD_SIZE) {
+        throw new 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/mjs/chunk/cac.js

@@ -0,0 +1,50 @@
+import { BeeError } from '../utils/error';
+import { bmtHash } from './bmt';
+import { bytesEqual, flexBytesAtOffset, assertFlexBytes } from '../utils/bytes';
+import { serializeBytes } from './serialize';
+import { makeSpan, SPAN_SIZE } from './span';
+export const MIN_PAYLOAD_SIZE = 1;
+export const MAX_PAYLOAD_SIZE = 4096;
+const CAC_SPAN_OFFSET = 0;
+const CAC_PAYLOAD_OFFSET = CAC_SPAN_OFFSET + SPAN_SIZE;
+/**
+ * Creates a content addressed chunk and verifies the payload size.
+ *
+ * @param payloadBytes the data to be stored in the chunk
+ */
+export function makeContentAddressedChunk(payloadBytes) {
+    const span = makeSpan(payloadBytes.length);
+    assertFlexBytes(payloadBytes, MIN_PAYLOAD_SIZE, MAX_PAYLOAD_SIZE);
+    const data = serializeBytes(span, payloadBytes);
+    return {
+        data,
+        span: () => span,
+        payload: () => flexBytesAtOffset(data, CAC_PAYLOAD_OFFSET, MIN_PAYLOAD_SIZE, MAX_PAYLOAD_SIZE),
+        address: () => bmtHash(data),
+    };
+}
+/**
+ * Type guard for valid content addressed chunk data
+ *
+ * @param data          The chunk data
+ * @param chunkAddress  The address of the chunk
+ */
+export function isValidChunkData(data, chunkAddress) {
+    if (!(data instanceof Uint8Array))
+        return false;
+    const address = bmtHash(data);
+    return bytesEqual(address, chunkAddress);
+}
+/**
+ * Asserts if data are representing given address of its chunk.
+ *
+ * @param data          The chunk data
+ * @param chunkAddress  The address of the chunk
+ *
+ * @returns a valid content addressed chunk or throws error
+ */
+export function assertValidChunkData(data, chunkAddress) {
+    if (!isValidChunkData(data, chunkAddress)) {
+        throw new BeeError('Address of content address chunk does not match given data!');
+    }
+}

package/dist/mjs/chunk/serialize.js

@@ -0,0 +1,15 @@
+/**
+ * Helper function for serialize byte arrays
+ *
+ * @param arrays Any number of byte array arguments
+ */
+export 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;
+}

package/dist/mjs/chunk/signer.js

@@ -0,0 +1,112 @@
+import { ec } from 'elliptic';
+import { BeeError } from '../utils/error';
+import { isBytes, assertBytes, wrapBytesWithHelpers } from '../utils/bytes';
+import { keccak256Hash } from '../utils/hash';
+import { hexToBytes, makeHexString } from '../utils/hex';
+import { SIGNATURE_BYTES_LENGTH, SIGNATURE_HEX_LENGTH } from '../types';
+import { isStrictlyObject } from '../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 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
+ */
+export 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 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;
+}
+function publicKeyToAddress(pubKey) {
+    const pubBytes = pubKey.encode('array', false);
+    return 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
+ */
+export 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);
+}
+/**
+ * Creates a singer object that can be used when the private key is known.
+ *
+ * @param privateKey The private key
+ */
+export 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,
+    };
+}
+export function assertSigner(signer) {
+    if (!isStrictlyObject(signer)) {
+        throw new TypeError('Signer must be an object!');
+    }
+    const typedSigner = signer;
+    if (!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!');
+    }
+}
+export function makeSigner(signer) {
+    if (typeof signer === 'string') {
+        const hexKey = makeHexString(signer, 64);
+        const keyBytes = hexToBytes(hexKey); // HexString is verified for 64 length => 32 is guaranteed
+        return makePrivateKeySigner(keyBytes);
+    }
+    else if (signer instanceof Uint8Array) {
+        assertBytes(signer, 32);
+        return makePrivateKeySigner(signer);
+    }
+    assertSigner(signer);
+    return signer;
+}
+export async function sign(signer, data) {
+    const result = await signer.sign(wrapBytesWithHelpers(data));
+    if (typeof result === 'string') {
+        const hexString = makeHexString(result, SIGNATURE_HEX_LENGTH);
+        return hexToBytes(hexString);
+    }
+    if (result instanceof Uint8Array) {
+        assertBytes(result, SIGNATURE_BYTES_LENGTH);
+        return result;
+    }
+    throw new TypeError('Invalid output of sign function!');
+}

package/dist/mjs/chunk/soc.js

@@ -0,0 +1,127 @@
+import { bytesAtOffset, bytesEqual, flexBytesAtOffset } from '../utils/bytes';
+import { bmtHash } from './bmt';
+import { recoverAddress, sign } from './signer';
+import { keccak256Hash } from '../utils/hash';
+import { SPAN_SIZE } from './span';
+import { serializeBytes } from './serialize';
+import { BeeError } from '../utils/error';
+import { makeContentAddressedChunk, MAX_PAYLOAD_SIZE, MIN_PAYLOAD_SIZE, assertValidChunkData, } from './cac';
+import { bytesToHex } from '../utils/hex';
+import * as socAPI from '../modules/soc';
+import * as chunkAPI from '../modules/chunk';
+import { assertAddress } from '../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_SIZE;
+function recoverChunkOwner(data) {
+    const cacData = data.slice(SOC_SPAN_OFFSET);
+    const chunkAddress = bmtHash(cacData);
+    const signature = bytesAtOffset(data, SOC_SIGNATURE_OFFSET, SIGNATURE_SIZE);
+    const identifier = bytesAtOffset(data, SOC_IDENTIFIER_OFFSET, IDENTIFIER_SIZE);
+    const digest = keccak256Hash(identifier, chunkAddress);
+    const ownerAddress = recoverAddress(signature, digest);
+    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
+ */
+export function makeSingleOwnerChunkFromData(data, address) {
+    const ownerAddress = recoverChunkOwner(data);
+    const identifier = bytesAtOffset(data, SOC_IDENTIFIER_OFFSET, IDENTIFIER_SIZE);
+    const socAddress = keccak256Hash(identifier, ownerAddress);
+    if (!bytesEqual(address, socAddress)) {
+        throw new BeeError('SOC Data does not match given address!');
+    }
+    const signature = () => bytesAtOffset(data, SOC_SIGNATURE_OFFSET, SIGNATURE_SIZE);
+    const span = () => bytesAtOffset(data, SOC_SPAN_OFFSET, SPAN_SIZE);
+    const payload = () => flexBytesAtOffset(data, SOC_PAYLOAD_OFFSET, MIN_PAYLOAD_SIZE, MAX_PAYLOAD_SIZE);
+    return {
+        data,
+        identifier: () => identifier,
+        signature,
+        span,
+        payload,
+        address: () => socAddress,
+        owner: () => ownerAddress,
+    };
+}
+export function makeSOCAddress(identifier, address) {
+    return keccak256Hash(identifier, address);
+}
+/**
+ * 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
+ */
+export async function makeSingleOwnerChunk(chunk, identifier, signer) {
+    const chunkAddress = chunk.address();
+    assertValidChunkData(chunk.data, chunkAddress);
+    const digest = keccak256Hash(identifier, chunkAddress);
+    const signature = await sign(signer, digest);
+    const data = 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,
+    };
+}
+/**
+ * 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
+ */
+export async function uploadSingleOwnerChunk(ky, chunk, postageBatchId, options) {
+    const owner = bytesToHex(chunk.owner());
+    const identifier = bytesToHex(chunk.identifier());
+    const signature = bytesToHex(chunk.signature());
+    const data = serializeBytes(chunk.span(), chunk.payload());
+    return socAPI.upload(ky, owner, identifier, signature, data, postageBatchId, options);
+}
+/**
+ * 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
+ */
+export async function uploadSingleOwnerChunkData(ky, signer, postageBatchId, identifier, data, options) {
+    assertAddress(postageBatchId);
+    const cac = makeContentAddressedChunk(data);
+    const soc = await makeSingleOwnerChunk(cac, identifier, signer);
+    return uploadSingleOwnerChunk(ky, soc, postageBatchId, options);
+}
+/**
+ * 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
+ */
+export async function downloadSingleOwnerChunk(ky, ownerAddress, identifier) {
+    const address = makeSOCAddress(identifier, ownerAddress);
+    const data = await chunkAPI.download(ky, bytesToHex(address));
+    return makeSingleOwnerChunkFromData(data, address);
+}

package/dist/mjs/chunk/span.js

@@ -0,0 +1,25 @@
+import { BeeArgumentError } from '../utils/error';
+export const 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
+ */
+export function makeSpan(length) {
+    if (length <= 0) {
+        throw new BeeArgumentError('invalid length for span', length);
+    }
+    if (length > MAX_SPAN_LENGTH) {
+        throw new BeeArgumentError('invalid length (> MAX_SPAN_LENGTH)', length);
+    }
+    const span = new Uint8Array(SPAN_SIZE);
+    const dataView = new DataView(span.buffer);
+    const littleEndian = true;
+    const lengthLower32 = length & 0xffffffff;
+    dataView.setUint32(0, lengthLower32, littleEndian);
+    return span;
+}

package/dist/mjs/feed/index.js

@@ -0,0 +1,136 @@
+import { keccak256Hash } from '../utils/hash';
+import { serializeBytes } from '../chunk/serialize';
+import { uploadSingleOwnerChunkData, makeSingleOwnerChunkFromData } from '../chunk/soc';
+import { fetchFeedUpdate } from '../modules/feed';
+import { REFERENCE_HEX_LENGTH, ENCRYPTED_REFERENCE_HEX_LENGTH, } from '../types';
+import { makeBytes, bytesAtOffset } from '../utils/bytes';
+import { BeeResponseError } from '../utils/error';
+import { bytesToHex, hexToBytes, makeHexString } from '../utils/hex';
+import { readUint64BigEndian, writeUint64BigEndian } from '../utils/uint64';
+import * as chunkAPI from '../modules/chunk';
+import { makeHexEthAddress } from '../utils/eth';
+import { assertAddress } from '../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;
+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 async function uploadFeedUpdate(ky, signer, topic, index, reference, postageBatchId, options) {
+    const identifier = makeFeedIdentifier(topic, index);
+    const at = options?.at ?? Date.now() / 1000.0;
+    const timestamp = writeUint64BigEndian(at);
+    const payloadBytes = serializeBytes(timestamp, reference);
+    return uploadSingleOwnerChunkData(ky, signer, postageBatchId, identifier, payloadBytes, options);
+}
+export async function findNextIndex(ky, owner, topic, options) {
+    try {
+        const feedUpdate = await fetchFeedUpdate(ky, owner, topic, options);
+        return makeHexString(feedUpdate.feedIndexNext, INDEX_HEX_LENGTH);
+    }
+    catch (e) {
+        if (e instanceof BeeResponseError && e.status === 404) {
+            return bytesToHex(makeBytes(8));
+        }
+        throw e;
+    }
+}
+export async function updateFeed(ky, signer, topic, reference, postageBatchId, options) {
+    const ownerHex = makeHexEthAddress(signer.address);
+    const nextIndex = await findNextIndex(ky, ownerHex, topic, options);
+    return uploadFeedUpdate(ky, signer, topic, nextIndex, reference, postageBatchId, 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 async function downloadFeedUpdate(ky, owner, topic, index) {
+    const identifier = makeFeedIdentifier(topic, index);
+    const address = keccak256Hash(identifier, owner);
+    const addressHex = bytesToHex(address);
+    const data = await 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);
+    return {
+        timestamp,
+        reference,
+    };
+}
+export function makeFeedReader(ky, type, topic, owner) {
+    const download = async (options) => fetchFeedUpdate(ky, owner, topic, { ...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);
+        }
+    }
+    else if (reference instanceof Uint8Array) {
+        return verifyChunkReference(reference);
+    }
+    throw new TypeError('invalid chunk reference');
+}
+export function makeFeedWriter(ky, type, topic, signer) {
+    const upload = async (postageBatchId, reference, options) => {
+        assertAddress(postageBatchId);
+        const canonicalReference = makeChunkReference(reference);
+        return updateFeed(ky, signer, topic, canonicalReference, postageBatchId, { ...options, type });
+    };
+    return {
+        ...makeFeedReader(ky, type, topic, makeHexEthAddress(signer.address)),
+        upload,
+    };
+}

package/dist/mjs/feed/json.js

@@ -0,0 +1,23 @@
+import { isError } from '../utils/type';
+function serializeJson(data) {
+    try {
+        const jsonString = JSON.stringify(data);
+        return new TextEncoder().encode(jsonString);
+    }
+    catch (e) {
+        if (isError(e)) {
+            e.message = `JsonFeed: ${e.message}`;
+        }
+        throw e;
+    }
+}
+export async function getJsonData(bee, reader) {
+    const feedUpdate = await reader.download();
+    const retrievedData = await bee.downloadData(feedUpdate.reference);
+    return retrievedData.json();
+}
+export async function setJsonData(bee, writer, postageBatchId, data, options) {
+    const serializedData = serializeJson(data);
+    const { reference } = await bee.uploadData(postageBatchId, serializedData, options);
+    return writer.upload(postageBatchId, reference);
+}

package/dist/mjs/feed/topic.js

@@ -0,0 +1,20 @@
+import { keccak256Hash } from '../utils/hash';
+import { assertBytes } from '../utils/bytes';
+import { makeHexString, bytesToHex } from '../utils/hex';
+import { TOPIC_BYTES_LENGTH, TOPIC_HEX_LENGTH } from '../types';
+export function makeTopic(topic) {
+    if (typeof topic === 'string') {
+        return makeHexString(topic, TOPIC_HEX_LENGTH);
+    }
+    else if (topic instanceof Uint8Array) {
+        assertBytes(topic, TOPIC_BYTES_LENGTH);
+        return bytesToHex(topic, TOPIC_HEX_LENGTH);
+    }
+    throw new TypeError('invalid topic');
+}
+export function makeTopicFromString(s) {
+    if (typeof s !== 'string') {
+        throw new TypeError('topic has to be string!');
+    }
+    return bytesToHex(keccak256Hash(s), TOPIC_HEX_LENGTH);
+}

package/dist/mjs/feed/type.js

@@ -0,0 +1,10 @@
+const feedTypes = ['sequence', 'epoch'];
+export const DEFAULT_FEED_TYPE = 'sequence';
+export function isFeedType(type) {
+    return typeof type === 'string' && feedTypes.includes(type);
+}
+export function assertFeedType(type) {
+    if (!isFeedType(type)) {
+        throw new TypeError('invalid feed type');
+    }
+}

package/dist/mjs/index.js

@@ -0,0 +1,7 @@
+import { Bee } from './bee';
+import { BeeDebug } from './bee-debug';
+export * as Utils from './utils/expose';
+export * from './types';
+export * from './utils/error';
+export { SUPPORTED_BEE_VERSION, SUPPORTED_BEE_VERSION_EXACT } from './modules/debug/status';
+export { Bee, BeeDebug };

package/dist/mjs/modules/bytes.js

@@ -0,0 +1,56 @@
+import { prepareData } from '../utils/data';
+import { extractUploadHeaders } from '../utils/headers';
+import { http } from '../utils/http';
+import { wrapBytesWithHelpers } from '../utils/bytes';
+import { makeTagUid } from '../utils/type';
+const endpoint = 'bytes';
+/**
+ * Upload data to a Bee node
+ *
+ * @param ky              Ky instance
+ * @param data            Data to be uploaded
+ * @param postageBatchId  Postage BatchId that will be assigned to uploaded data
+ * @param options         Additional options like tag, encryption, pinning
+ */
+export async function upload(ky, data, postageBatchId, options) {
+    const response = await http(ky, {
+        path: endpoint,
+        method: 'post',
+        responseType: 'json',
+        body: await prepareData(data),
+        headers: {
+            'content-type': 'application/octet-stream',
+            ...extractUploadHeaders(postageBatchId, options),
+        },
+    });
+    return {
+        reference: response.data.reference,
+        tagUid: makeTagUid(response.headers.get('swarm-tag')),
+    };
+}
+/**
+ * Download data as a byte array
+ *
+ * @param ky
+ * @param hash Bee content reference
+ */
+export async function download(ky, hash) {
+    const response = await http(ky, {
+        responseType: 'arraybuffer',
+        path: `${endpoint}/${hash}`,
+    });
+    return wrapBytesWithHelpers(new Uint8Array(response.data));
+}
+/**
+ * Download data as a readable stream
+ *
+ * @param ky
+ * @param hash Bee content reference
+ */
+export async function downloadReadable(ky, hash) {
+    const response = await http(ky, {
+        responseType: 'stream',
+        path: `${endpoint}/${hash}`,
+    });
+    return response.data;
+}