@ethersphere/bee-js 3.3.2 → 3.3.4

package/dist/mjs/chunk/signer.js

@@ -1,4 +1,36 @@
-// For ESM compatibility
+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
+
+
 import pkg from 'elliptic';
 const {
   ec
@@ -114,18 +146,20 @@ export function makeSigner(signer) {
   assertSigner(signer);
   return signer;
 }
-export async function sign(signer, data) {
-  const result = await signer.sign(wrapBytesWithHelpers(data));
+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 (typeof result === 'string') {
+      const hexString = makeHexString(result, SIGNATURE_HEX_LENGTH);
+      return hexToBytes(hexString);
+    }
 
-  if (result instanceof Uint8Array) {
-    assertBytes(result, SIGNATURE_BYTES_LENGTH);
-    return result;
-  }
+    if (result instanceof Uint8Array) {
+      assertBytes(result, SIGNATURE_BYTES_LENGTH);
+      return result;
+    }
 
-  throw new TypeError('Invalid output of sign function!');
+    throw new TypeError('Invalid output of sign function!');
+  });
 }

package/dist/mjs/chunk/soc.js

@@ -1,3 +1,35 @@
+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";
@@ -72,22 +104,24 @@ export function makeSOCAddress(identifier, address) {
  * @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
-  };
+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
+    };
+  });
 }
 /**
  * Helper function to upload a chunk.
@@ -100,12 +134,14 @@ export async function makeSingleOwnerChunk(chunk, identifier, signer) {
  * @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);
+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);
+  });
 }
 /**
  * Helper function to create and upload SOC.
@@ -118,11 +154,13 @@ export async function uploadSingleOwnerChunk(ky, chunk, postageBatchId, options)
  * @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);
+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);
+  });
 }
 /**
  * Helper function to download SOC.
@@ -132,8 +170,10 @@ export async function uploadSingleOwnerChunkData(ky, signer, postageBatchId, ide
  * @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);
+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);
+  });
 }

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 = 2 ** 32 - 1;
+const MAX_SPAN_LENGTH = Math.pow(2, 32) - 1;
 /**
  * Create a span for storing the length of the chunk
  *

package/dist/mjs/feed/index.js

@@ -1,3 +1,35 @@
+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 { uploadSingleOwnerChunkData, makeSingleOwnerChunkFromData } from "../chunk/soc.js";
@@ -44,29 +76,37 @@ export function makeFeedIdentifier(topic, index) {
 
   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 function uploadFeedUpdate(ky, signer, topic, index, reference, postageBatchId, options) {
+  var _a;
+
+  return __awaiter(this, void 0, void 0, function* () {
+    const identifier = makeFeedIdentifier(topic, index);
+    const at = (_a = options === null || options === void 0 ? void 0 : options.at) !== null && _a !== void 0 ? _a : Date.now() / 1000.0;
+    const timestamp = 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));
-    }
+export function findNextIndex(ky, owner, topic, options) {
+  return __awaiter(this, void 0, void 0, function* () {
+    try {
+      const feedUpdate = yield 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;
-  }
+      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);
+export function updateFeed(ky, signer, topic, reference, postageBatchId, options) {
+  return __awaiter(this, void 0, void 0, function* () {
+    const ownerHex = makeHexEthAddress(signer.address);
+    const nextIndex = yield findNextIndex(ky, ownerHex, topic, options);
+    return uploadFeedUpdate(ky, signer, topic, nextIndex, reference, postageBatchId, options);
+  });
 }
 
 function verifyChunkReferenceAtOffset(offset, data) {
@@ -80,24 +120,28 @@ function verifyChunkReferenceAtOffset(offset, data) {
 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 downloadFeedUpdate(ky, owner, topic, index) {
+  return __awaiter(this, void 0, void 0, function* () {
+    const identifier = makeFeedIdentifier(topic, index);
+    const address = keccak256Hash(identifier, owner);
+    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 = 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
+  const download = options => __awaiter(this, void 0, void 0, function* () {
+    return fetchFeedUpdate(ky, owner, topic, Object.assign(Object.assign({}, options), {
+      type
+    }));
   });
 
   return {
@@ -131,15 +175,15 @@ function makeChunkReference(reference) {
 }
 
 export function makeFeedWriter(ky, type, topic, signer) {
-  const upload = async (postageBatchId, reference, options) => {
+  const upload = (postageBatchId, reference, options) => __awaiter(this, void 0, void 0, function* () {
     assertAddress(postageBatchId);
     const canonicalReference = makeChunkReference(reference);
-    return updateFeed(ky, signer, topic, canonicalReference, postageBatchId, { ...options,
+    return updateFeed(ky, signer, topic, canonicalReference, postageBatchId, Object.assign(Object.assign({}, options), {
       type
-    });
-  };
+    }));
+  });
 
-  return { ...makeFeedReader(ky, type, topic, makeHexEthAddress(signer.address)),
+  return Object.assign(Object.assign({}, makeFeedReader(ky, type, topic, makeHexEthAddress(signer.address))), {
     upload
-  };
+  });
 }

package/dist/mjs/feed/json.js

@@ -1,3 +1,35 @@
+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 { isError } from "../utils/type.js";
 
 function serializeJson(data) {
@@ -13,15 +45,19 @@ function serializeJson(data) {
   }
 }
 
-export async function getJsonData(bee, reader) {
-  const feedUpdate = await reader.download();
-  const retrievedData = await bee.downloadData(feedUpdate.reference);
-  return retrievedData.json();
+export function getJsonData(bee, reader) {
+  return __awaiter(this, void 0, void 0, function* () {
+    const feedUpdate = yield reader.download();
+    const retrievedData = yield 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);
+export function setJsonData(bee, writer, postageBatchId, data, options) {
+  return __awaiter(this, void 0, void 0, function* () {
+    const serializedData = serializeJson(data);
+    const {
+      reference
+    } = yield bee.uploadData(postageBatchId, serializedData, options);
+    return writer.upload(postageBatchId, reference);
+  });
 }

package/dist/mjs/index.js

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

package/dist/mjs/modules/bytes.js

@@ -1,3 +1,35 @@
+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 { prepareData } from "../utils/data.js";
 import { extractUploadHeaders } from "../utils/headers.js";
 import { http } from "../utils/http.js";
@@ -13,21 +45,22 @@ const endpoint = 'bytes';
  * @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)
-    }
+export function upload(ky, data, postageBatchId, options) {
+  return __awaiter(this, void 0, void 0, function* () {
+    const response = yield http(ky, {
+      path: endpoint,
+      method: 'post',
+      responseType: 'json',
+      body: yield prepareData(data),
+      headers: Object.assign({
+        'content-type': 'application/octet-stream'
+      }, extractUploadHeaders(postageBatchId, options))
+    });
+    return {
+      reference: response.data.reference,
+      tagUid: makeTagUid(response.headers.get('swarm-tag'))
+    };
   });
-  return {
-    reference: response.data.reference,
-    tagUid: makeTagUid(response.headers.get('swarm-tag'))
-  };
 }
 /**
  * Download data as a byte array
@@ -36,12 +69,14 @@ export async function upload(ky, data, postageBatchId, options) {
  * @param hash Bee content reference
  */
 
-export async function download(ky, hash) {
-  const response = await http(ky, {
-    responseType: 'arraybuffer',
-    path: `${endpoint}/${hash}`
+export function download(ky, hash) {
+  return __awaiter(this, void 0, void 0, function* () {
+    const response = yield http(ky, {
+      responseType: 'arraybuffer',
+      path: `${endpoint}/${hash}`
+    });
+    return wrapBytesWithHelpers(new Uint8Array(response.data));
   });
-  return wrapBytesWithHelpers(new Uint8Array(response.data));
 }
 /**
  * Download data as a readable stream
@@ -50,10 +85,12 @@ export async function download(ky, hash) {
  * @param hash Bee content reference
  */
 
-export async function downloadReadable(ky, hash) {
-  const response = await http(ky, {
-    responseType: 'stream',
-    path: `${endpoint}/${hash}`
+export function downloadReadable(ky, hash) {
+  return __awaiter(this, void 0, void 0, function* () {
+    const response = yield http(ky, {
+      responseType: 'stream',
+      path: `${endpoint}/${hash}`
+    });
+    return response.data;
   });
-  return response.data;
 }