@ethersphere/bee-js 8.3.1 → 9.0.2

package/dist/mjs/manifest/manifest.js

@@ -0,0 +1,371 @@
+import { Binary, MerkleTree, Optional, Uint8ArrayReader } from 'cafe-utility';
+import { NULL_ADDRESS } from "../index.js";
+import { Reference } from "../utils/typed-bytes.js";
+const ENCODER = new TextEncoder();
+const DECODER = new TextDecoder();
+const TYPE_VALUE = 2;
+const TYPE_EDGE = 4;
+const TYPE_WITH_PATH_SEPARATOR = 8;
+const TYPE_WITH_METADATA = 16;
+const PATH_SEPARATOR = new Uint8Array([47]);
+const VERSION_02_HASH_HEX = '5768b3b6a7db56d21d1abff40d41cebfc83448fed8d7e9b06ec0d3b073f28f7b';
+const VERSION_02_HASH = Binary.hexToUint8Array(VERSION_02_HASH_HEX);
+export class Fork {
+  constructor(prefix, node) {
+    this.prefix = prefix;
+    this.node = node;
+  }
+  static split(a, b) {
+    const commonPart = Binary.commonPrefix(a.prefix, b.prefix);
+    const node = new MantarayNode({
+      path: commonPart
+    });
+    const newAFork = new Fork(a.prefix.slice(commonPart.length), a.node);
+    const newBFork = new Fork(b.prefix.slice(commonPart.length), b.node);
+    a.node.path = a.prefix.slice(commonPart.length);
+    b.node.path = b.prefix.slice(commonPart.length);
+    a.prefix = a.prefix.slice(commonPart.length);
+    b.prefix = b.prefix.slice(commonPart.length);
+    node.forks.set(newAFork.prefix[0], newAFork);
+    node.forks.set(newBFork.prefix[0], newBFork);
+    newAFork.node.parent = node;
+    newBFork.node.parent = node;
+    return new Fork(commonPart, node);
+  }
+  marshal() {
+    if (!this.node.selfAddress) {
+      throw Error('Fork#marshal node.selfAddress is not set');
+    }
+    const data = [];
+    data.push(new Uint8Array([this.node.determineType()]));
+    data.push(Binary.numberToUint8(this.prefix.length));
+    data.push(this.prefix);
+    if (this.prefix.length < 30) {
+      data.push(new Uint8Array(30 - this.prefix.length));
+    }
+    data.push(this.node.selfAddress);
+    if (this.node.metadata) {
+      const metadataBytes = Binary.padEndToMultiple(new Uint8Array([0x00, 0x00, ...ENCODER.encode(JSON.stringify(this.node.metadata))]), 32, 0x0a);
+      const metadataLengthBytes = Binary.numberToUint16(metadataBytes.length - 2, 'BE');
+      metadataBytes.set(metadataLengthBytes, 0);
+      data.push(metadataBytes);
+    }
+    return Binary.concatBytes(...data);
+  }
+  static unmarshal(reader) {
+    const type = Binary.uint8ToNumber(reader.read(1));
+    const prefixLength = Binary.uint8ToNumber(reader.read(1));
+    const prefix = reader.read(prefixLength);
+    reader.read(30 - prefixLength);
+    const targetAddress = reader.read(32);
+    let metadata = undefined;
+    if (isType(type, TYPE_WITH_METADATA)) {
+      const metadataLength = Binary.uint16ToNumber(reader.read(2), 'BE');
+      metadata = JSON.parse(DECODER.decode(reader.read(metadataLength)));
+    }
+    return new Fork(prefix, new MantarayNode({
+      targetAddress,
+      metadata,
+      path: prefix
+    }));
+  }
+}
+export class MantarayNode {
+  constructor(options) {
+    this.obfuscationKey = new Uint8Array(32);
+    this.selfAddress = null;
+    this.targetAddress = new Uint8Array(32);
+    this.metadata = null;
+    this.path = new Uint8Array(0);
+    this.forks = new Map();
+    this.parent = null;
+    if (options?.targetAddress) {
+      this.targetAddress = options.targetAddress;
+    }
+    if (options?.selfAddress) {
+      this.selfAddress = options.selfAddress;
+    }
+    if (options?.metadata) {
+      this.metadata = options.metadata;
+    }
+    if (options?.obfuscationKey) {
+      this.obfuscationKey = options.obfuscationKey;
+    }
+    if (options?.path) {
+      this.path = options.path;
+    }
+    if (options?.parent) {
+      this.parent = options.parent;
+    }
+  }
+  get fullPath() {
+    return Binary.concatBytes(this.parent?.fullPath ?? new Uint8Array(0), this.path);
+  }
+  get fullPathString() {
+    return DECODER.decode(this.fullPath);
+  }
+  /**
+   * Returns the metadata at the `/` path to access idiomatic properties.
+   */
+  getRootMetadata() {
+    const node = this.find('/');
+    if (node && node.metadata) {
+      return Optional.of(node.metadata);
+    }
+    return Optional.empty();
+  }
+  /**
+   * Returns the `swarm-index-document` and `swarm-error-document` metadata values.
+   */
+  getDocsMetadata() {
+    const node = this.find('/');
+    if (!node || !node.metadata) {
+      return {
+        indexDocument: null,
+        errorDocument: null
+      };
+    }
+    return {
+      indexDocument: node.metadata['website-index-document'] ?? null,
+      errorDocument: node.metadata['website-error-document'] ?? null
+    };
+  }
+  /**
+   * Attempts to resolve the manifest as a feed, returning the latest update.
+   */
+  async resolveFeed(bee, requestOptions) {
+    const node = this.find('/');
+    if (!node || !node.metadata) {
+      return Optional.empty();
+    }
+    const owner = node.metadata['swarm-feed-owner'];
+    const topic = node.metadata['swarm-feed-topic'];
+    if (!owner || !topic) {
+      return Optional.empty();
+    }
+    return Optional.of(await bee.fetchLatestFeedUpdate(topic, owner, requestOptions));
+  }
+  /**
+   * Gets the binary representation of the node.
+   */
+  async marshal() {
+    for (const fork of this.forks.values()) {
+      if (!fork.node.selfAddress) {
+        fork.node.selfAddress = (await fork.node.calculateSelfAddress()).toUint8Array();
+      }
+    }
+    const header = new Uint8Array(32);
+    header.set(VERSION_02_HASH, 0);
+    header.set(Binary.equals(this.targetAddress, NULL_ADDRESS) && Binary.equals(this.path, new Uint8Array([47])) ? Binary.numberToUint8(0) : Binary.numberToUint8(this.targetAddress.length), 31);
+    const forkBitmap = new Uint8Array(32);
+    for (const fork of this.forks.keys()) {
+      Binary.setBit(forkBitmap, fork, 1, 'LE');
+    }
+    const forks = [];
+    for (let i = 0; i < 256; i++) {
+      if (Binary.getBit(forkBitmap, i, 'LE')) {
+        forks.push(this.forks.get(i).marshal());
+      }
+    }
+    const data = Binary.xorCypher(Binary.concatBytes(header, Binary.equals(this.targetAddress, NULL_ADDRESS) && Binary.equals(this.path, new Uint8Array([47])) ? new Uint8Array(0) : this.targetAddress, forkBitmap, ...forks), this.obfuscationKey);
+    return Binary.concatBytes(this.obfuscationKey, data);
+  }
+  /**
+   * Downloads and unmarshals a MantarayNode from the given reference.
+   *
+   * Do not forget calling `loadRecursively` on the returned node to load the entire tree.
+   */
+  static async unmarshal(bee, reference, options, requestOptions) {
+    const data = (await bee.downloadData(reference, options, requestOptions)).toUint8Array();
+    return this.unmarshalFromData(data);
+  }
+  /**
+   * Unmarshals a MantarayNode from the given data.
+   *
+   * Do not forget calling `loadRecursively` on the returned node to load the entire tree.
+   */
+  static unmarshalFromData(data) {
+    const obfuscationKey = data.subarray(0, 32);
+    const decrypted = Binary.xorCypher(data.subarray(32), obfuscationKey);
+    const reader = new Uint8ArrayReader(decrypted);
+    const versionHash = reader.read(31);
+    if (!Binary.equals(versionHash, VERSION_02_HASH.slice(0, 31))) {
+      throw new Error('MantarayNode#unmarshal invalid version hash');
+    }
+    const targetAddressLength = Binary.uint8ToNumber(reader.read(1));
+    const targetAddress = targetAddressLength === 0 ? NULL_ADDRESS : reader.read(targetAddressLength);
+    const node = new MantarayNode({
+      targetAddress,
+      obfuscationKey
+    });
+    const forkBitmap = reader.read(32);
+    for (let i = 0; i < 256; i++) {
+      if (Binary.getBit(forkBitmap, i, 'LE')) {
+        const newFork = Fork.unmarshal(reader);
+        node.forks.set(i, newFork);
+        newFork.node.parent = node;
+      }
+    }
+    return node;
+  }
+  /**
+   * Adds a fork to the node.
+   */
+  addFork(path, reference, metadata) {
+    this.selfAddress = null;
+    path = path instanceof Uint8Array ? path : ENCODER.encode(path);
+    // TODO: this should not be ignored
+    // eslint-disable-next-line @typescript-eslint/no-this-alias
+    let tip = this;
+    while (path.length) {
+      const prefix = path.slice(0, 30);
+      path = path.slice(30);
+      const isLast = path.length === 0;
+      const [bestMatch, matchedPath] = tip.findClosest(prefix);
+      const remainingPath = prefix.slice(matchedPath.length);
+      if (matchedPath.length) {
+        tip = bestMatch;
+      }
+      if (!remainingPath.length) {
+        continue;
+      }
+      const newFork = new Fork(remainingPath, new MantarayNode({
+        targetAddress: isLast ? new Reference(reference).toUint8Array() : undefined,
+        metadata: isLast ? metadata : undefined,
+        path: remainingPath
+      }));
+      const existing = bestMatch.forks.get(remainingPath[0]);
+      if (existing) {
+        const fork = Fork.split(newFork, existing);
+        tip.forks.set(remainingPath[0], fork);
+        fork.node.parent = tip;
+        tip.selfAddress = null;
+        tip = newFork.node;
+      } else {
+        tip.forks.set(remainingPath[0], newFork);
+        newFork.node.parent = tip;
+        tip.selfAddress = null;
+        tip = newFork.node;
+      }
+    }
+  }
+  /**
+   * Removes a fork from the node.
+   */
+  removeFork(path) {
+    this.selfAddress = null;
+    path = path instanceof Uint8Array ? path : ENCODER.encode(path);
+    if (path.length === 0) {
+      throw Error('MantarayNode#removeFork [path] parameter cannot be empty');
+    }
+    const match = this.find(path);
+    if (!match) {
+      throw Error('MantarayNode#removeFork fork not found');
+    }
+    const [parent, matchedPath] = this.findClosest(path.slice(0, path.length - 1));
+    parent.forks.delete(path.slice(matchedPath.length)[0]);
+    for (const fork of match.forks.values()) {
+      parent.addFork(Binary.concatBytes(match.path, fork.prefix), fork.node.targetAddress, fork.node.metadata);
+    }
+  }
+  /**
+   * Calculates the self address of the node.
+   */
+  async calculateSelfAddress() {
+    if (this.selfAddress) {
+      return new Reference(this.selfAddress);
+    }
+    return new Reference((await MerkleTree.root(await this.marshal())).hash());
+  }
+  /**
+   * Saves the node and its children recursively.
+   */
+  async saveRecursively(bee, postageBatchId, options, requestOptions) {
+    for (const fork of this.forks.values()) {
+      await fork.node.saveRecursively(bee, postageBatchId, options, requestOptions);
+    }
+    const result = await bee.uploadData(postageBatchId, await this.marshal(), options, requestOptions);
+    this.selfAddress = result.reference.toUint8Array();
+    return result;
+  }
+  /**
+   * Loads the node and its children recursively.
+   */
+  async loadRecursively(bee, options, requestOptions) {
+    for (const fork of this.forks.values()) {
+      const node = await MantarayNode.unmarshal(bee, fork.node.targetAddress, options, requestOptions);
+      fork.node.targetAddress = node.targetAddress;
+      fork.node.forks = node.forks;
+      fork.node.path = fork.prefix;
+      fork.node.parent = this;
+      await fork.node.loadRecursively(bee, options, requestOptions);
+    }
+  }
+  /**
+   * Finds a node in the tree by its path.
+   */
+  find(path) {
+    const [closest, match] = this.findClosest(path);
+    return match.length === path.length ? closest : null;
+  }
+  /**
+   * Finds the closest node in the tree to the given path.
+   */
+  findClosest(path, current = new Uint8Array()) {
+    path = path instanceof Uint8Array ? path : ENCODER.encode(path);
+    if (path.length === 0) {
+      return [this, current];
+    }
+    const fork = this.forks.get(path[0]);
+    if (fork && Binary.commonPrefix(fork.prefix, path).length === fork.prefix.length) {
+      return fork.node.findClosest(path.slice(fork.prefix.length), Binary.concatBytes(current, fork.prefix));
+    }
+    return [this, current];
+  }
+  /**
+   * Returns an array of all nodes in the tree which have a target address set.
+   *
+   * Must be called after `loadRecursively`.
+   */
+  collect(nodes = []) {
+    for (const fork of this.forks.values()) {
+      if (!Binary.equals(fork.node.targetAddress, NULL_ADDRESS)) {
+        nodes.push(fork.node);
+      }
+      fork.node.collect(nodes);
+    }
+    return nodes;
+  }
+  /**
+   * Returns a path:reference map of all nodes in the tree which have a target address set.
+   *
+   * Must be called after `loadRecursively`.
+   */
+  collectAndMap() {
+    const nodes = this.collect();
+    const result = {};
+    for (const node of nodes) {
+      result[node.fullPathString] = new Reference(node.targetAddress).toHex();
+    }
+    return result;
+  }
+  determineType() {
+    let type = 0;
+    if (!Binary.equals(this.targetAddress, NULL_ADDRESS) || Binary.equals(this.path, PATH_SEPARATOR)) {
+      type |= TYPE_VALUE;
+    }
+    if (this.forks.size > 0) {
+      type |= TYPE_EDGE;
+    }
+    if (Binary.indexOf(this.path, PATH_SEPARATOR) !== -1 && !Binary.equals(this.path, PATH_SEPARATOR)) {
+      type |= TYPE_WITH_PATH_SEPARATOR;
+    }
+    if (this.metadata) {
+      type |= TYPE_WITH_METADATA;
+    }
+    return type;
+  }
+}
+function isType(value, type) {
+  return (value & type) === type;
+}

package/dist/mjs/modules/bytes.js

@@ -1,7 +1,9 @@
-import { wrapBytesWithHelpers } from "../utils/bytes.js";
-import { extractDownloadHeaders, extractRedundantUploadHeaders } from "../utils/headers.js";
+import { Optional, Types } from 'cafe-utility';
+import { Bytes } from "../utils/bytes.js";
+import { prepareRequestHeaders } from "../utils/headers.js";
 import { http } from "../utils/http.js";
-import { makeTagUid } from "../utils/type.js";
+import { makeTagUid, prepareDownloadOptions } from "../utils/type.js";
+import { Reference } from "../utils/typed-bytes.js";
 const endpoint = 'bytes';
 /**
  * Upload data to a Bee node
@@ -19,13 +21,16 @@ export async function upload(requestOptions, data, postageBatchId, options) {
     data,
     headers: {
       'content-type': 'application/octet-stream',
-      ...extractRedundantUploadHeaders(postageBatchId, options)
+      ...prepareRequestHeaders(postageBatchId, options)
     }
   });
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
+  });
   return {
-    reference: response.data.reference,
+    reference: new Reference(Types.asHexString(body.reference)),
     tagUid: response.headers['swarm-tag'] ? makeTagUid(response.headers['swarm-tag']) : undefined,
-    historyAddress: response.headers['swarm-act-history-address'] || ''
+    historyAddress: response.headers['swarm-act-history-address'] ? Optional.of(new Reference(response.headers['swarm-act-history-address'])) : Optional.empty()
   };
 }
 /**
@@ -34,9 +39,10 @@ export async function upload(requestOptions, data, postageBatchId, options) {
  * @param requestOptions Options for making requests
  * @param hash Bee content reference
  */
-export async function head(requestOptions, hash) {
+export async function head(requestOptions, reference) {
+  reference = new Reference(reference);
   const response = await http(requestOptions, {
-    url: `${endpoint}/${hash}`,
+    url: `${endpoint}/${reference}`,
     method: 'head',
     responseType: 'json'
   });
@@ -50,13 +56,16 @@ export async function head(requestOptions, hash) {
  * @param requestOptions Options for making requests
  * @param hash Bee content reference
  */
-export async function download(requestOptions, hash, options) {
+export async function download(requestOptions, resource, options) {
+  if (options) {
+    options = prepareDownloadOptions(options);
+  }
   const response = await http(requestOptions, {
     responseType: 'arraybuffer',
-    url: `${endpoint}/${hash}`,
-    headers: extractDownloadHeaders(options)
+    url: `${endpoint}/${resource}`,
+    headers: prepareRequestHeaders(null, options)
   });
-  return wrapBytesWithHelpers(new Uint8Array(response.data));
+  return new Bytes(response.data);
 }
 /**
  * Download data as a readable stream
@@ -64,11 +73,14 @@ export async function download(requestOptions, hash, options) {
  * @param requestOptions Options for making requests
  * @param hash Bee content reference
  */
-export async function downloadReadable(requestOptions, hash, options) {
+export async function downloadReadable(requestOptions, resource, options) {
+  if (options) {
+    options = prepareDownloadOptions(options);
+  }
   const response = await http(requestOptions, {
     responseType: 'stream',
-    url: `${endpoint}/${hash}`,
-    headers: extractDownloadHeaders(options)
+    url: `${endpoint}/${resource}`,
+    headers: prepareRequestHeaders(null, options)
   });
   return response.data;
 }

package/dist/mjs/modules/bzz.js

@@ -1,16 +1,12 @@
-import { wrapBytesWithHelpers } from "../utils/bytes.js";
+import { Optional, Types } from 'cafe-utility';
+import { Bytes } from "../utils/bytes.js";
 import { assertCollection } from "../utils/collection.js";
-import { extractDownloadHeaders, extractRedundantUploadHeaders, readFileHeaders } from "../utils/headers.js";
+import { prepareRequestHeaders, readFileHeaders } from "../utils/headers.js";
 import { http } from "../utils/http.js";
 import { uploadTar } from "../utils/tar-uploader.js";
 import { isReadable, makeTagUid } from "../utils/type.js";
+import { Reference } from "../utils/typed-bytes.js";
 const bzzEndpoint = 'bzz';
-function extractFileUploadHeaders(postageBatchId, options) {
-  const headers = extractRedundantUploadHeaders(postageBatchId, options);
-  if (options?.size) headers['content-length'] = String(options.size);
-  if (options?.contentType) headers['content-type'] = options.contentType;
-  return headers;
-}
 /**
  * Upload single file
  *
@@ -31,18 +27,19 @@ export async function uploadFile(requestOptions, data, postageBatchId, name, opt
     method: 'post',
     url: bzzEndpoint,
     data,
-    headers: {
-      ...extractFileUploadHeaders(postageBatchId, options)
-    },
+    headers: prepareRequestHeaders(postageBatchId, options),
     params: {
       name
     },
     responseType: 'json'
   });
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
+  });
   return {
-    reference: response.data.reference,
+    reference: new Reference(Types.asHexString(body.reference)),
     tagUid: response.headers['swarm-tag'] ? makeTagUid(response.headers['swarm-tag']) : undefined,
-    historyAddress: response.headers['swarm-act-history-address'] || ''
+    historyAddress: response.headers['swarm-act-history-address'] ? Optional.of(new Reference(response.headers['swarm-act-history-address'])) : Optional.empty()
   };
 }
 /**
@@ -52,16 +49,16 @@ export async function uploadFile(requestOptions, data, postageBatchId, name, opt
  * @param hash Bee file or collection hash
  * @param path If hash is collection then this defines path to a single file in the collection
  */
-export async function downloadFile(requestOptions, hash, path = '', options) {
+export async function downloadFile(requestOptions, resource, path = '', options) {
   const response = await http(requestOptions, {
     method: 'GET',
     responseType: 'arraybuffer',
-    url: `${bzzEndpoint}/${hash}/${path}`,
-    headers: extractDownloadHeaders(options)
+    url: `${bzzEndpoint}/${resource}/${path}`,
+    headers: prepareRequestHeaders(null, options)
   });
   const file = {
     ...readFileHeaders(response.headers),
-    data: wrapBytesWithHelpers(new Uint8Array(response.data))
+    data: new Bytes(response.data)
   };
   return file;
 }
@@ -72,12 +69,13 @@ export async function downloadFile(requestOptions, hash, path = '', options) {
  * @param hash Bee file or collection hash
  * @param path If hash is collection then this defines path to a single file in the collection
  */
-export async function downloadFileReadable(requestOptions, hash, path = '', options) {
+export async function downloadFileReadable(requestOptions, reference, path = '', options) {
+  reference = new Reference(reference);
   const response = await http(requestOptions, {
     method: 'GET',
     responseType: 'stream',
-    url: `${bzzEndpoint}/${hash}/${path}`,
-    headers: extractDownloadHeaders(options)
+    url: `${bzzEndpoint}/${reference}/${path}`,
+    headers: prepareRequestHeaders(null, options)
   });
   const file = {
     ...readFileHeaders(response.headers),
@@ -85,16 +83,8 @@ export async function downloadFileReadable(requestOptions, hash, path = '', opti
   };
   return file;
 }
-export function extractCollectionUploadHeaders(postageBatchId, options) {
-  const headers = extractRedundantUploadHeaders(postageBatchId, options);
-  if (options?.indexDocument) {
-    headers['swarm-index-document'] = options.indexDocument;
-  }
-  if (options?.errorDocument) {
-    headers['swarm-error-document'] = options.errorDocument;
-  }
-  return headers;
-}
+/*******************************************************************************************************************/
+// Collections
 /**
  * Upload collection
  * @param requestOptions Options for making requests
@@ -105,9 +95,12 @@ export function extractCollectionUploadHeaders(postageBatchId, options) {
 export async function uploadCollection(requestOptions, collection, postageBatchId, options) {
   assertCollection(collection);
   const response = await uploadTar(requestOptions, collection, postageBatchId, options);
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
+  });
   return {
-    reference: response.data.reference,
+    reference: new Reference(Types.asHexString(body.reference)),
     tagUid: response.headers['swarm-tag'] ? makeTagUid(response.headers['swarm-tag']) : undefined,
-    historyAddress: response.headers['swarm-act-history-address'] || ''
+    historyAddress: response.headers['swarm-act-history-address'] ? Optional.of(new Reference(response.headers['swarm-act-history-address'])) : Optional.empty()
   };
 }

package/dist/mjs/modules/chunk.js

@@ -1,7 +1,8 @@
-import { wrapBytesWithHelpers } from "../utils/bytes.js";
-import { extractUploadHeaders } from "../utils/headers.js";
+import { Optional, Types } from 'cafe-utility';
+import { prepareRequestHeaders } from "../utils/headers.js";
 import { http } from "../utils/http.js";
 import { makeTagUid } from "../utils/type.js";
+import { Reference } from "../utils/typed-bytes.js";
 const endpoint = 'chunks';
 /**
  * Upload chunk to a Bee node
@@ -22,14 +23,19 @@ export async function upload(requestOptions, data, stamp, options) {
     data,
     headers: {
       'content-type': 'application/octet-stream',
-      ...extractUploadHeaders(stamp, options)
+      ...prepareRequestHeaders(stamp, options)
     },
     responseType: 'json'
   });
+  const body = Types.asObject(response.data, {
+    name: 'response.data'
+  });
   return {
-    reference: response.data.reference,
+    reference: new Reference(Types.asString(body.reference, {
+      name: 'reference'
+    })),
     tagUid: response.headers['swarm-tag'] ? makeTagUid(response.headers['swarm-tag']) : undefined,
-    historyAddress: response.headers['swarm-act-history-address'] || ''
+    historyAddress: response.headers['swarm-act-history-address'] ? Optional.of(new Reference(response.headers['swarm-act-history-address'])) : Optional.empty()
   };
 }
 /**
@@ -39,10 +45,12 @@ export async function upload(requestOptions, data, stamp, options) {
  * @param hash Bee content reference
  *
  */
-export async function download(requestOptions, hash) {
+export async function download(requestOptions, reference, options) {
+  reference = new Reference(reference);
   const response = await http(requestOptions, {
     responseType: 'arraybuffer',
-    url: `${endpoint}/${hash}`
+    url: `${endpoint}/${reference}`,
+    headers: prepareRequestHeaders(null, options)
   });
-  return wrapBytesWithHelpers(new Uint8Array(response.data));
+  return new Uint8Array(response.data);
 }