@ethersphere/bee-js 5.1.1 → 5.1.2

package/dist/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/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/mjs/chunk/signer.js

@@ -1,36 +1,4 @@
-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());
-  });
-}; // For ESM compatibility
-
-
+// For ESM compatibility
 import pkg from 'elliptic';
 const {
   ec
@@ -42,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);
@@ -55,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);
@@ -65,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);
@@ -89,8 +51,6 @@ function publicKeyToAddress(pubKey) {
  *
  * @returns the recovered address
  */
-
-
 export function recoverAddress(signature, digest) {
   const curve = new ec('secp256k1');
   const sig = {
@@ -107,7 +67,6 @@ export function recoverAddress(signature, digest) {
  *
  * @param privateKey The private key
  */
-
 export function makePrivateKeySigner(privateKey) {
   const curve = new ec('secp256k1');
   const keyPair = curve.keyFromPrivate(privateKey);
@@ -121,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!');
   }
@@ -136,30 +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 function sign(signer, data) {
-  return __awaiter(this, void 0, void 0, function* () {
-    const result = yield 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!');
-  });
+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

@@ -1,35 +1,3 @@
-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());
-  });
-};
-
 import { bytesAtOffset, bytesEqual, flexBytesAtOffset } from "../utils/bytes.js";
 import { bmtHash } from "./bmt.js";
 import { recoverAddress, sign } from "./signer.js";
@@ -48,7 +16,6 @@ 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);
@@ -66,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,
@@ -103,64 +63,55 @@ export function makeSOCAddress(identifier, address) {
  * @param identifier  The identifier of the chunk
  * @param signer      The singer interface for signing the chunk
  */
-
-export function makeSingleOwnerChunk(chunk, identifier, signer) {
-  return __awaiter(this, void 0, void 0, function* () {
-    const chunkAddress = chunk.address();
-    assertValidChunkData(chunk.data, chunkAddress);
-    const digest = keccak256Hash(identifier, chunkAddress);
-    const signature = yield 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
-    };
-  });
+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 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 function uploadSingleOwnerChunk(ky, chunk, postageBatchId, options) {
-  return __awaiter(this, void 0, void 0, function* () {
-    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);
-  });
+export async function uploadSingleOwnerChunk(kyOptions, 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(kyOptions, 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 function uploadSingleOwnerChunkData(ky, signer, postageBatchId, identifier, data, options) {
-  return __awaiter(this, void 0, void 0, function* () {
-    assertAddress(postageBatchId);
-    const cac = makeContentAddressedChunk(data);
-    const soc = yield makeSingleOwnerChunk(cac, identifier, signer);
-    return uploadSingleOwnerChunk(ky, soc, postageBatchId, options);
-  });
+export async function uploadSingleOwnerChunkData(kyOptions, signer, postageBatchId, identifier, data, options) {
+  assertAddress(postageBatchId);
+  const cac = makeContentAddressedChunk(data);
+  const soc = await makeSingleOwnerChunk(cac, identifier, signer);
+  return uploadSingleOwnerChunk(kyOptions, soc, postageBatchId, options);
 }
 /**
  * Helper function to download SOC.
@@ -169,11 +120,8 @@ export function uploadSingleOwnerChunkData(ky, signer, postageBatchId, identifie
  * @param ownerAddress  The singer interface for signing the chunk
  * @param identifier    The identifier of the chunk
  */
-
-export function downloadSingleOwnerChunk(ky, ownerAddress, identifier) {
-  return __awaiter(this, void 0, void 0, function* () {
-    const address = makeSOCAddress(identifier, ownerAddress);
-    const data = yield chunkAPI.download(ky, bytesToHex(address));
-    return makeSingleOwnerChunkFromData(data, address);
-  });
+export async function downloadSingleOwnerChunk(kyOptions, ownerAddress, identifier) {
+  const address = makeSOCAddress(identifier, ownerAddress);
+  const data = await chunkAPI.download(kyOptions, bytesToHex(address));
+  return makeSingleOwnerChunkFromData(data, address);
 }

package/dist/mjs/chunk/span.js

@@ -1,7 +1,7 @@
 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
-
-const MAX_SPAN_LENGTH = Math.pow(2, 32) - 1;
+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 = Math.pow(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/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/mjs/feed/index.js

@@ -1,35 +1,3 @@
-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());
-  });
-};
-
 import { keccak256Hash } from "../utils/hash.js";
 import { serializeBytes } from "../chunk/serialize.js";
 import { fetchLatestFeedUpdate } from "../modules/feed.js";
@@ -47,88 +15,76 @@ import { makeBytesReference } from "../utils/reference.js";
 const TIMESTAMP_PAYLOAD_OFFSET = 0;
 const TIMESTAMP_PAYLOAD_SIZE = 8;
 const REFERENCE_PAYLOAD_OFFSET = TIMESTAMP_PAYLOAD_SIZE;
-export function findNextIndex(ky, owner, topic, options) {
-  return __awaiter(this, void 0, void 0, function* () {
-    try {
-      const feedUpdate = yield fetchLatestFeedUpdate(ky, owner, topic, options);
-      return makeHexString(feedUpdate.feedIndexNext, FEED_INDEX_HEX_LENGTH);
-    } catch (e) {
-      if (e instanceof BeeResponseError && e.status === 404) {
-        return bytesToHex(makeBytes(8));
-      }
-
-      throw e;
+export async function findNextIndex(kyOptions, owner, topic, options) {
+  try {
+    const feedUpdate = await fetchLatestFeedUpdate(kyOptions, owner, topic, options);
+    return makeHexString(feedUpdate.feedIndexNext, FEED_INDEX_HEX_LENGTH);
+  } catch (e) {
+    if (e instanceof BeeResponseError && e.status === 404) {
+      return bytesToHex(makeBytes(8));
     }
-  });
+    throw e;
+  }
 }
-export function updateFeed(ky, signer, topic, reference, postageBatchId, options, index = 'latest') {
-  var _a;
-
-  return __awaiter(this, void 0, void 0, function* () {
-    const ownerHex = makeHexEthAddress(signer.address);
-    const nextIndex = index === 'latest' ? yield findNextIndex(ky, ownerHex, topic, options) : index;
-    const identifier = makeFeedIdentifier(topic, nextIndex);
-    const at = (_a = options === null || options === void 0 ? void 0 : options.at) !== null && _a !== void 0 ? _a : Date.now() / 1000.0;
-    const timestamp = writeUint64BigEndian(at);
-    const payloadBytes = serializeBytes(timestamp, reference);
-    return uploadSingleOwnerChunkData(ky, signer, postageBatchId, identifier, payloadBytes, options);
-  });
+export async function updateFeed(kyOptions, signer, topic, reference, postageBatchId, options, index = 'latest') {
+  const ownerHex = makeHexEthAddress(signer.address);
+  const nextIndex = index === 'latest' ? await findNextIndex(kyOptions, 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(kyOptions, signer, postageBatchId, identifier, payloadBytes, options);
 }
 export function getFeedUpdateChunkReference(owner, topic, index) {
   const identifier = makeFeedIdentifier(topic, index);
   return keccak256Hash(identifier, owner);
 }
-export function downloadFeedUpdate(ky, owner, topic, index) {
-  return __awaiter(this, void 0, void 0, function* () {
-    const address = getFeedUpdateChunkReference(owner, topic, index);
-    const addressHex = bytesToHex(address);
-    const data = yield 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 = makeBytesReference(payload, REFERENCE_PAYLOAD_OFFSET);
-    return {
-      timestamp,
-      reference
-    };
-  });
+export async function downloadFeedUpdate(kyOptions, owner, topic, index) {
+  const address = getFeedUpdateChunkReference(owner, topic, index);
+  const addressHex = bytesToHex(address);
+  const data = await chunkAPI.download(kyOptions, 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 = makeBytesReference(payload, REFERENCE_PAYLOAD_OFFSET);
+  return {
+    timestamp,
+    reference
+  };
 }
-export function makeFeedReader(ky, type, topic, owner) {
+export function makeFeedReader(kyOptions, type, topic, owner) {
   return {
     type,
     owner,
     topic,
-
-    download(options) {
-      return __awaiter(this, void 0, void 0, function* () {
-        if (!(options === null || options === void 0 ? void 0 : options.index)) {
-          return fetchLatestFeedUpdate(ky, owner, topic, Object.assign(Object.assign({}, options), {
-            type
-          }));
-        }
-
-        const update = yield downloadFeedUpdate(ky, hexToBytes(owner), topic, options.index);
-        return {
-          reference: bytesToHex(update.reference),
-          feedIndex: options.index,
-          feedIndexNext: ''
-        };
-      });
+    async download(options) {
+      if (!options?.index) {
+        return fetchLatestFeedUpdate(kyOptions, owner, topic, {
+          ...options,
+          type
+        });
+      }
+      const update = await downloadFeedUpdate(kyOptions, hexToBytes(owner), topic, options.index);
+      return {
+        reference: bytesToHex(update.reference),
+        feedIndex: options.index,
+        feedIndexNext: ''
+      };
     }
-
   };
 }
-export function makeFeedWriter(ky, type, topic, signer) {
-  const upload = (postageBatchId, reference, options) => __awaiter(this, void 0, void 0, function* () {
+export function makeFeedWriter(kyOptions, type, topic, signer) {
+  const upload = async (postageBatchId, reference, options) => {
     assertAddress(postageBatchId);
     const canonicalReference = makeBytesReference(reference);
-    return updateFeed(ky, signer, topic, canonicalReference, postageBatchId, Object.assign(Object.assign({}, options), {
+    return updateFeed(kyOptions, signer, topic, canonicalReference, postageBatchId, {
+      ...options,
       type
-    }));
-  });
-
-  return Object.assign(Object.assign({}, makeFeedReader(ky, type, topic, makeHexEthAddress(signer.address))), {
+    });
+  };
+  return {
+    ...makeFeedReader(kyOptions, type, topic, makeHexEthAddress(signer.address)),
     upload
-  });
+  };
 }