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

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

@@ -23,7 +23,6 @@ const HASH_SIZE = 32;
  *
  * @returns the keccak256 hash in a byte array
  */
-
 export function bmtHash(chunkContent) {
   const span = chunkContent.slice(0, 8);
   const payload = chunkContent.slice(8);
@@ -32,25 +31,20 @@ export function bmtHash(chunkContent) {
   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
-
-
+  }
+  // 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
-
+    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/{src → mjs}/chunk/cac.js

@@ -12,7 +12,6 @@ const CAC_PAYLOAD_OFFSET = CAC_SPAN_OFFSET + SPAN_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);
@@ -30,7 +29,6 @@ export function makeContentAddressedChunk(payloadBytes) {
  * @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);
@@ -44,7 +42,6 @@ export function isValidChunkData(data, chunkAddress) {
  *
  * @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/{src → mjs}/chunk/signer.js

@@ -10,7 +10,6 @@ import { hexToBytes, makeHexString } from "../utils/hex.js";
 import { SIGNATURE_BYTES_LENGTH, SIGNATURE_HEX_LENGTH } from "../types/index.js";
 import { isStrictlyObject } from "../utils/type.js";
 const UNCOMPRESSED_RECOVERY_ID = 27;
-
 function hashWithEthereumPrefix(data) {
   const ethereumSignedMessagePrefix = `\x19Ethereum Signed Message:\n${data.length}`;
   const prefixBytes = new TextEncoder().encode(ethereumSignedMessagePrefix);
@@ -23,8 +22,6 @@ function hashWithEthereumPrefix(data) {
  * @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);
@@ -33,15 +30,12 @@ export function defaultSign(data, privateKey) {
     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);
@@ -57,8 +51,6 @@ function publicKeyToAddress(pubKey) {
  *
  * @returns the recovered address
  */
-
-
 export function recoverAddress(signature, digest) {
   const curve = new ec('secp256k1');
   const sig = {
@@ -75,13 +67,12 @@ export function recoverAddress(signature, digest) {
  *
  * @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.bytes(), privateKey),
+    sign: digest => defaultSign(digest, privateKey),
     address
   };
 }
@@ -89,13 +80,10 @@ 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!');
   }
@@ -104,28 +92,23 @@ 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/{src → mjs}/chunk/soc.js

@@ -1,22 +1,21 @@
+import * as chunkAPI from "../modules/chunk.js";
+import * as socAPI from "../modules/soc.js";
 import { bytesAtOffset, bytesEqual, flexBytesAtOffset } from "../utils/bytes.js";
-import { bmtHash } from "./bmt.js";
-import { recoverAddress, sign } from "./signer.js";
-import { keccak256Hash } from "../utils/hash.js";
-import { SPAN_SIZE } from "./span.js";
-import { serializeBytes } from "./serialize.js";
 import { BeeError } from "../utils/error.js";
-import { makeContentAddressedChunk, MAX_PAYLOAD_SIZE, MIN_PAYLOAD_SIZE, assertValidChunkData } from "./cac.js";
+import { keccak256Hash } from "../utils/hash.js";
 import { bytesToHex } from "../utils/hex.js";
-import * as socAPI from "../modules/soc.js";
-import * as chunkAPI from "../modules/chunk.js";
 import { assertAddress } from "../utils/type.js";
+import { bmtHash } from "./bmt.js";
+import { assertValidChunkData, makeContentAddressedChunk, MAX_PAYLOAD_SIZE, MIN_PAYLOAD_SIZE } from "./cac.js";
+import { serializeBytes } from "./serialize.js";
+import { recoverAddress, sign } from "./signer.js";
+import { SPAN_SIZE } from "./span.js";
 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);
@@ -34,23 +33,16 @@ function recoverChunkOwner(data) {
  *
  * @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,
@@ -71,7 +63,6 @@ export function makeSOCAddress(identifier, address) {
  * @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);
@@ -94,35 +85,33 @@ export async function makeSingleOwnerChunk(chunk, identifier, signer) {
  *
  * It uses the Chunk API and calculates the address before uploading.
  *
- * @param ky              Ky instance
+ * @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
  */
-
-export async function uploadSingleOwnerChunk(ky, chunk, postageBatchId, options) {
+export async function uploadSingleOwnerChunk(requestOptions, 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);
+  return socAPI.upload(requestOptions, owner, identifier, signature, data, postageBatchId, options);
 }
 /**
  * Helper function to create and upload SOC.
  *
- * @param ky              Ky instance
+ * @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
  */
-
-export async function uploadSingleOwnerChunkData(ky, signer, postageBatchId, identifier, data, options) {
+export async function uploadSingleOwnerChunkData(requestOptions, signer, postageBatchId, identifier, data, options) {
   assertAddress(postageBatchId);
   const cac = makeContentAddressedChunk(data);
   const soc = await makeSingleOwnerChunk(cac, identifier, signer);
-  return uploadSingleOwnerChunk(ky, soc, postageBatchId, options);
+  return uploadSingleOwnerChunk(requestOptions, soc, postageBatchId, options);
 }
 /**
  * Helper function to download SOC.
@@ -131,9 +120,8 @@ export async function uploadSingleOwnerChunkData(ky, signer, postageBatchId, ide
  * @param ownerAddress  The singer interface for signing the chunk
  * @param identifier    The identifier of the chunk
  */
-
-export async function downloadSingleOwnerChunk(ky, ownerAddress, identifier) {
+export async function downloadSingleOwnerChunk(requestOptions, ownerAddress, identifier) {
   const address = makeSOCAddress(identifier, ownerAddress);
-  const data = await chunkAPI.download(ky, bytesToHex(address));
-  return makeSingleOwnerChunkFromData(data.bytes(), address);
+  const data = await chunkAPI.download(requestOptions, bytesToHex(address));
+  return makeSingleOwnerChunkFromData(data, address);
 }

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

@@ -1,6 +1,6 @@
 import { BeeArgumentError } from "../utils/error.js";
-export const SPAN_SIZE = 8; // we limit the maximum span size in 32 bits to avoid BigInt compatibility issues
-
+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
@@ -9,16 +9,13 @@ const MAX_SPAN_LENGTH = 2 ** 32 - 1;
  *
  * @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;

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

@@ -2,25 +2,20 @@ import { FEED_INDEX_HEX_LENGTH } from "../types/index.js";
 import { keccak256Hash } from "../utils/hash.js";
 import { hexToBytes, makeHexString } from "../utils/hex.js";
 import { writeUint64BigEndian } from "../utils/uint64.js";
-
 function isEpoch(epoch) {
   return typeof epoch === 'object' && epoch !== null && 'time' in epoch && 'level' in epoch;
 }
-
 function hashFeedIdentifier(topic, index) {
   return keccak256Hash(hexToBytes(topic), index);
 }
-
 function makeSequentialFeedIdentifier(topic, index) {
   const indexBytes = writeUint64BigEndian(index);
   return hashFeedIdentifier(topic, indexBytes);
 }
-
 function makeFeedIndexBytes(s) {
   const hex = makeHexString(s, FEED_INDEX_HEX_LENGTH);
   return hexToBytes(hex);
 }
-
 export function makeFeedIdentifier(topic, index) {
   if (typeof index === 'number') {
     return makeSequentialFeedIdentifier(topic, index);
@@ -30,6 +25,5 @@ export function makeFeedIdentifier(topic, index) {
   } else if (isEpoch(index)) {
     throw new TypeError('epoch is not yet implemented');
   }
-
   return hashFeedIdentifier(topic, index);
 }

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

@@ -1,50 +1,48 @@
-import { keccak256Hash } from "../utils/hash.js";
 import { serializeBytes } from "../chunk/serialize.js";
-import { fetchLatestFeedUpdate } from "../modules/feed.js";
 import { makeSingleOwnerChunkFromData, uploadSingleOwnerChunkData } from "../chunk/soc.js";
+import * as chunkAPI from "../modules/chunk.js";
+import { fetchLatestFeedUpdate } from "../modules/feed.js";
 import { FEED_INDEX_HEX_LENGTH } from "../types/index.js";
 import { bytesAtOffset, makeBytes } from "../utils/bytes.js";
-import { BeeResponseError } from "../utils/error.js";
-import { bytesToHex, hexToBytes, makeHexString } from "../utils/hex.js";
-import { readUint64BigEndian, writeUint64BigEndian } from "../utils/uint64.js";
-import * as chunkAPI from "../modules/chunk.js";
 import { makeHexEthAddress } from "../utils/eth.js";
+import { keccak256Hash } from "../utils/hash.js";
+import { bytesToHex, hexToBytes, makeHexString } from "../utils/hex.js";
+import { makeBytesReference } from "../utils/reference.js";
 import { assertAddress } from "../utils/type.js";
+import { readUint64BigEndian, writeUint64BigEndian } from "../utils/uint64.js";
 import { makeFeedIdentifier } from "./identifier.js";
-import { makeBytesReference } from "../utils/reference.js";
 const TIMESTAMP_PAYLOAD_OFFSET = 0;
 const TIMESTAMP_PAYLOAD_SIZE = 8;
 const REFERENCE_PAYLOAD_OFFSET = TIMESTAMP_PAYLOAD_SIZE;
-export async function findNextIndex(ky, owner, topic, options) {
+export async function findNextIndex(requestOptions, owner, topic, options) {
   try {
-    const feedUpdate = await fetchLatestFeedUpdate(ky, owner, topic, options);
+    const feedUpdate = await fetchLatestFeedUpdate(requestOptions, owner, topic, options);
     return makeHexString(feedUpdate.feedIndexNext, FEED_INDEX_HEX_LENGTH);
   } catch (e) {
-    if (e instanceof BeeResponseError && e.status === 404) {
+    if (e?.response?.status === 404) {
       return bytesToHex(makeBytes(8));
     }
-
     throw e;
   }
 }
-export async function updateFeed(ky, signer, topic, reference, postageBatchId, options, index = 'latest') {
+export async function updateFeed(requestOptions, signer, topic, reference, postageBatchId, options, index = 'latest') {
   const ownerHex = makeHexEthAddress(signer.address);
-  const nextIndex = index === 'latest' ? await findNextIndex(ky, ownerHex, topic, options) : index;
+  const nextIndex = index === 'latest' ? await findNextIndex(requestOptions, ownerHex, topic, options) : index;
   const identifier = makeFeedIdentifier(topic, nextIndex);
   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);
+  return uploadSingleOwnerChunkData(requestOptions, signer, postageBatchId, identifier, payloadBytes, options);
 }
 export function getFeedUpdateChunkReference(owner, topic, index) {
   const identifier = makeFeedIdentifier(topic, index);
   return keccak256Hash(identifier, owner);
 }
-export async function downloadFeedUpdate(ky, owner, topic, index) {
+export async function downloadFeedUpdate(requestOptions, owner, topic, index) {
   const address = getFeedUpdateChunkReference(owner, topic, index);
   const addressHex = bytesToHex(address);
-  const data = await chunkAPI.download(ky, addressHex);
-  const soc = makeSingleOwnerChunkFromData(data.bytes(), address);
+  const data = await chunkAPI.download(requestOptions, addressHex);
+  const soc = makeSingleOwnerChunkFromData(data, address);
   const payload = soc.payload();
   const timestampBytes = bytesAtOffset(payload, TIMESTAMP_PAYLOAD_OFFSET, TIMESTAMP_PAYLOAD_SIZE);
   const timestamp = readUint64BigEndian(timestampBytes);
@@ -54,39 +52,38 @@ export async function downloadFeedUpdate(ky, owner, topic, index) {
     reference
   };
 }
-export function makeFeedReader(ky, type, topic, owner) {
+export function makeFeedReader(requestOptions, type, topic, owner) {
   return {
     type,
     owner,
     topic,
-
     async download(options) {
       if (!options?.index) {
-        return fetchLatestFeedUpdate(ky, owner, topic, { ...options,
+        return fetchLatestFeedUpdate(requestOptions, owner, topic, {
+          ...options,
           type
         });
       }
-
-      const update = await downloadFeedUpdate(ky, hexToBytes(owner), topic, options.index);
+      const update = await downloadFeedUpdate(requestOptions, hexToBytes(owner), topic, options.index);
       return {
         reference: bytesToHex(update.reference),
         feedIndex: options.index,
         feedIndexNext: ''
       };
     }
-
   };
 }
-export function makeFeedWriter(ky, type, topic, signer) {
+export function makeFeedWriter(requestOptions, type, topic, signer) {
   const upload = async (postageBatchId, reference, options) => {
     assertAddress(postageBatchId);
     const canonicalReference = makeBytesReference(reference);
-    return updateFeed(ky, signer, topic, canonicalReference, postageBatchId, { ...options,
+    return updateFeed(requestOptions, signer, topic, canonicalReference, postageBatchId, {
+      ...options,
       type
     });
   };
-
-  return { ...makeFeedReader(ky, type, topic, makeHexEthAddress(signer.address)),
+  return {
+    ...makeFeedReader(requestOptions, type, topic, makeHexEthAddress(signer.address)),
     upload
   };
 }

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

@@ -1,5 +1,4 @@
 import { isError } from "../utils/type.js";
-
 function serializeJson(data) {
   try {
     const jsonString = JSON.stringify(data);
@@ -8,20 +7,18 @@ function serializeJson(data) {
     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) {
+export async function setJsonData(bee, writer, postageBatchId, data, options, requestOptions) {
   const serializedData = serializeJson(data);
   const {
     reference
-  } = await bee.uploadData(postageBatchId, serializedData, options);
+  } = await bee.uploadData(postageBatchId, serializedData, options, requestOptions);
   return writer.upload(postageBatchId, reference);
 }

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

@@ -1,20 +1,16 @@
-import { getFeedUpdateChunkReference } from "./index.js";
-import { readUint64BigEndian } from "../utils/uint64.js";
 import { bytesToHex } from "../utils/hex.js";
-
+import { readUint64BigEndian } from "../utils/uint64.js";
+import { getFeedUpdateChunkReference } from "./index.js";
 function makeNumericIndex(index) {
   if (index instanceof Uint8Array) {
     return readUint64BigEndian(index);
   }
-
   if (typeof index === 'string') {
     return parseInt(index);
   }
-
   if (typeof index === 'number') {
     return index;
   }
-
   throw new TypeError('Unknown type of index!');
 }
 /**
@@ -25,19 +21,14 @@ function makeNumericIndex(index) {
  * @param ref
  * @param options
  */
-
-
-async function isChunkRetrievable(bee, ref, options) {
+async function isChunkRetrievable(bee, ref, requestOptions) {
   try {
-    await bee.downloadChunk(ref, options);
+    await bee.downloadChunk(ref, requestOptions);
     return true;
   } catch (e) {
-    const err = e;
-
-    if (err.status === 404) {
+    if (e?.response?.status === 404) {
       return false;
     }
-
     throw e;
   }
 }
@@ -48,20 +39,15 @@ async function isChunkRetrievable(bee, ref, options) {
  * @param topic
  * @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] = bytesToHex(getFeedUpdateChunkReference(owner, topic, i));
   }
-
   return updateReferences;
 }
-
-export async function areAllSequentialFeedsUpdateRetrievable(bee, owner, topic, index, options) {
-  const chunkRetrievablePromises = getAllSequenceUpdateReferences(owner, topic, index).map(async ref => isChunkRetrievable(bee, ref, options));
+export async function areAllSequentialFeedsUpdateRetrievable(bee, owner, topic, index, requestOptions) {
+  const chunkRetrievablePromises = getAllSequenceUpdateReferences(owner, topic, index).map(async ref => isChunkRetrievable(bee, ref, requestOptions));
   return (await Promise.all(chunkRetrievablePromises)).every(result => result);
 }

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

@@ -9,13 +9,11 @@ export function makeTopic(topic) {
     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/{src → mjs}/index.js

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

package/dist/{src → mjs}/modules/bytes.js

@@ -1,32 +1,30 @@
-import { prepareData } from "../utils/data.js";
+import { wrapBytesWithHelpers } from "../utils/bytes.js";
 import { extractUploadHeaders } from "../utils/headers.js";
 import { http } from "../utils/http.js";
-import { wrapBytesWithHelpers } from "../utils/bytes.js";
 import { makeTagUid } from "../utils/type.js";
 const endpoint = 'bytes';
 /**
  * Upload data to a Bee node
  *
- * @param ky              Ky instance
+ * @param kyOptions Ky Options for making requests
  * @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,
+export async function upload(requestOptions, data, postageBatchId, options) {
+  const response = await http(requestOptions, {
+    url: endpoint,
     method: 'post',
     responseType: 'json',
-    body: await prepareData(data),
+    data,
     headers: {
       'content-type': 'application/octet-stream',
       ...extractUploadHeaders(postageBatchId, options)
     }
   });
   return {
-    reference: response.parsedData.reference,
-    tagUid: makeTagUid(response.headers.get('swarm-tag'))
+    reference: response.data.reference,
+    tagUid: makeTagUid(response.headers['swarm-tag'])
   };
 }
 /**
@@ -35,13 +33,12 @@ export async function upload(ky, data, postageBatchId, options) {
  * @param ky
  * @param hash Bee content reference
  */
-
-export async function download(ky, hash) {
-  const response = await http(ky, {
+export async function download(requestOptions, hash) {
+  const response = await http(requestOptions, {
     responseType: 'arraybuffer',
-    path: `${endpoint}/${hash}`
+    url: `${endpoint}/${hash}`
   });
-  return wrapBytesWithHelpers(new Uint8Array(response.parsedData));
+  return wrapBytesWithHelpers(new Uint8Array(response.data));
 }
 /**
  * Download data as a readable stream
@@ -49,11 +46,10 @@ export async function download(ky, hash) {
  * @param ky
  * @param hash Bee content reference
  */
-
-export async function downloadReadable(ky, hash) {
-  const response = await http(ky, {
+export async function downloadReadable(requestOptions, hash) {
+  const response = await http(requestOptions, {
     responseType: 'stream',
-    path: `${endpoint}/${hash}`
+    url: `${endpoint}/${hash}`
   });
-  return response.parsedData;
+  return response.data;
 }