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

package/dist/{src → mjs}/modules/debug/status.js

@@ -1,52 +1,66 @@
-import { http } from "../../utils/http.js";
-import getMajorSemver from 'semver/functions/major.js'; // Following lines bellow are automatically updated with GitHub Action when Bee version is updated
+import getMajorSemver from 'semver/functions/major.js';
+import { http } from "../../utils/http.js"; // Following lines bellow are automatically updated with GitHub Action when Bee version is updated
 // so if you are changing anything about them change the `update_bee` action accordingly!
-
-export const SUPPORTED_BEE_VERSION_EXACT = '1.7.0-bbf13011';
-export const SUPPORTED_API_VERSION = '3.0.2';
-export const SUPPORTED_DEBUG_API_VERSION = '3.0.2';
+export const SUPPORTED_BEE_VERSION_EXACT = '1.12.0-88c1d236';
+export const SUPPORTED_API_VERSION = '4.0.0';
+export const SUPPORTED_DEBUG_API_VERSION = '4.0.0';
 export const SUPPORTED_BEE_VERSION = SUPPORTED_BEE_VERSION_EXACT.substring(0, SUPPORTED_BEE_VERSION_EXACT.indexOf('-'));
 const NODE_INFO_URL = 'node';
 const HEALTH_URL = 'health';
+const READINESS_URL = 'readiness';
 /**
  * Get health of node
  *
- * @param ky Ky debug instance
+ * @param kyOptions Ky Options for making requests
  */
-
-export async function getHealth(ky) {
-  const response = await http(ky, {
+export async function getHealth(requestOptions) {
+  const response = await http(requestOptions, {
     method: 'get',
-    path: HEALTH_URL,
+    url: HEALTH_URL,
     responseType: 'json'
   });
-  return response.parsedData;
+  return response.data;
+}
+/**
+ * Get readiness of node
+ *
+ * @param kyOptions Ky Options for making requests
+ */
+export async function getReadiness(requestOptions) {
+  try {
+    const response = await http(requestOptions, {
+      method: 'get',
+      url: READINESS_URL
+    });
+    return response.status === 200;
+  } catch {
+    return false;
+  }
 }
 /**
  * Get information about Bee node
  *
- * @param ky Ky debug instance
+ * @param kyOptions Ky Options for making requests
  */
-
-export async function getNodeInfo(ky) {
-  const response = await http(ky, {
+export async function getNodeInfo(requestOptions) {
+  const response = await http(requestOptions, {
     method: 'get',
-    path: NODE_INFO_URL,
+    url: NODE_INFO_URL,
     responseType: 'json'
   });
-  return response.parsedData;
+  return response.data;
 }
 /**
  * Connects to a node and checks if it is a supported Bee version by the bee-js
  *
- * @param ky Ky debug instance
+ * @param kyOptions Ky Options for making requests
  *
  * @returns true if the Bee node version is supported
  * @deprecated Use `isSupportedExactVersion` instead
  */
-
-export async function isSupportedVersion(ky) {
-  return isSupportedExactVersion(ky);
+// TODO: Remove on break
+export async function isSupportedVersion(requestOptions) {
+  return isSupportedExactVersion(requestOptions);
 }
 /**
  * Connects to a node and checks if its version matches with the one that bee-js supports.
@@ -58,11 +72,10 @@ export async function isSupportedVersion(ky) {
  *
  * @param ky
  */
-
-export async function isSupportedExactVersion(ky) {
+export async function isSupportedExactVersion(requestOptions) {
   const {
     version
-  } = await getHealth(ky);
+  } = await getHealth(requestOptions);
   return version === SUPPORTED_BEE_VERSION_EXACT;
 }
 /**
@@ -73,11 +86,10 @@ export async function isSupportedExactVersion(ky) {
  *
  * @param ky
  */
-
-export async function isSupportedMainApiVersion(ky) {
+export async function isSupportedMainApiVersion(requestOptions) {
   const {
     apiVersion
-  } = await getHealth(ky);
+  } = await getHealth(requestOptions);
   return getMajorSemver(apiVersion) === getMajorSemver(SUPPORTED_API_VERSION);
 }
 /**
@@ -88,11 +100,10 @@ export async function isSupportedMainApiVersion(ky) {
  *
  * @param ky
  */
-
-export async function isSupportedDebugApiVersion(ky) {
+export async function isSupportedDebugApiVersion(requestOptions) {
   const {
     debugApiVersion
-  } = await getHealth(ky);
+  } = await getHealth(requestOptions);
   return getMajorSemver(debugApiVersion) === getMajorSemver(SUPPORTED_DEBUG_API_VERSION);
 }
 /**
@@ -102,12 +113,11 @@ export async function isSupportedDebugApiVersion(ky) {
  *
  * @param ky
  */
-
-export async function isSupportedApiVersion(ky) {
+export async function isSupportedApiVersion(requestOptions) {
   const {
     apiVersion,
     debugApiVersion
-  } = await getHealth(ky);
+  } = await getHealth(requestOptions);
   return getMajorSemver(apiVersion) === getMajorSemver(SUPPORTED_API_VERSION) && getMajorSemver(debugApiVersion) === getMajorSemver(SUPPORTED_DEBUG_API_VERSION);
 }
 /**
@@ -116,13 +126,12 @@ export async function isSupportedApiVersion(ky) {
  *
  * @param ky
  */
-
-export async function getVersions(ky) {
+export async function getVersions(requestOptions) {
   const {
     version,
     apiVersion,
     debugApiVersion
-  } = await getHealth(ky);
+  } = await getHealth(requestOptions);
   return {
     supportedBeeVersion: SUPPORTED_BEE_VERSION_EXACT,
     supportedBeeApiVersion: SUPPORTED_API_VERSION,

package/dist/mjs/modules/debug/tag.js

@@ -0,0 +1,15 @@
+import { http } from "../../utils/http.js";
+const endpoint = 'tags';
+/**
+ * Retrieve tag with extended information from Bee node
+ *
+ * @param kyOptions Ky Options for making requests
+ * @param uid UID of tag to be retrieved
+ */
+export async function retrieveExtendedTag(requestOptions, uid) {
+  const response = await http(requestOptions, {
+    url: `${endpoint}/${uid}`,
+    responseType: 'json'
+  });
+  return response.data;
+}

package/dist/mjs/modules/debug/transactions.js

@@ -0,0 +1,59 @@
+import { http } from "../../utils/http.js";
+const transactionsEndpoint = 'transactions';
+/**
+ * Get list of all pending transactions
+ *
+ * @param ky   Debug Ky instance
+ */
+export async function getAllTransactions(requestOptions) {
+  const response = await http(requestOptions, {
+    url: transactionsEndpoint,
+    responseType: 'json'
+  });
+  return response.data.pendingTransactions;
+}
+/**
+ * Get information for specific pending transactions
+ *
+ * @param ky   Debug Ky instance
+ * @param transactionHash Hash of the transaction
+ */
+export async function getTransaction(requestOptions, transactionHash) {
+  const response = await http(requestOptions, {
+    url: `${transactionsEndpoint}/${transactionHash}`,
+    responseType: 'json'
+  });
+  return response.data;
+}
+/**
+ * Rebroadcast existing transaction
+ *
+ * @param ky   Debug Ky instance
+ * @param transactionHash Hash of the transaction
+ */
+export async function rebroadcastTransaction(requestOptions, transactionHash) {
+  const response = await http(requestOptions, {
+    method: 'post',
+    url: `${transactionsEndpoint}/${transactionHash}`,
+    responseType: 'json'
+  });
+  return response.data.transactionHash;
+}
+/**
+ * Cancel existing transaction
+ *
+ * @param ky   Debug Ky instance
+ * @param transactionHash Hash of the transaction
+ * @param gasPrice Optional gas price
+ */
+export async function cancelTransaction(requestOptions, transactionHash, gasPrice) {
+  const response = await http(requestOptions, {
+    method: 'delete',
+    headers: {
+      'gas-price': gasPrice
+    },
+    url: `${transactionsEndpoint}/${transactionHash}`,
+    responseType: 'json'
+  });
+  return response.data.transactionHash;
+}

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

@@ -1,6 +1,6 @@
-import { filterHeaders, http } from "../utils/http.js";
-import { extractUploadHeaders } from "../utils/headers.js";
 import { BeeError } from "../utils/error.js";
+import { extractUploadHeaders } from "../utils/headers.js";
+import { http } from "../utils/http.js";
 const feedEndpoint = 'feeds';
 /**
  * Create an initial feed root manifest
@@ -11,30 +11,25 @@ const feedEndpoint = 'feeds';
  * @param postageBatchId  Postage BatchId to be used to create the Feed Manifest
  * @param options         Additional options, like type (default: 'sequence')
  */
-
-export async function createFeedManifest(ky, owner, topic, postageBatchId, options) {
-  const response = await http(ky, {
+export async function createFeedManifest(requestOptions, owner, topic, postageBatchId, options) {
+  const response = await http(requestOptions, {
     method: 'post',
     responseType: 'json',
-    path: `${feedEndpoint}/${owner}/${topic}`,
-    searchParams: filterHeaders(options),
+    url: `${feedEndpoint}/${owner}/${topic}`,
+    params: options,
     headers: extractUploadHeaders(postageBatchId)
   });
-  return response.parsedData.reference;
+  return response.data.reference;
 }
-
 function readFeedUpdateHeaders(headers) {
-  const feedIndex = headers.get('swarm-feed-index');
-  const feedIndexNext = headers.get('swarm-feed-index-next');
-
+  const feedIndex = headers['swarm-feed-index'];
+  const feedIndexNext = headers['swarm-feed-index-next'];
   if (!feedIndex) {
     throw new BeeError('Response did not contain expected swarm-feed-index!');
   }
-
   if (!feedIndexNext) {
     throw new BeeError('Response did not contain expected swarm-feed-index-next!');
   }
-
   return {
     feedIndex,
     feedIndexNext
@@ -53,15 +48,14 @@ function readFeedUpdateHeaders(headers) {
  * @param topic       Topic in hex
  * @param options     Additional options, like index, at, type
  */
-
-
-export async function fetchLatestFeedUpdate(ky, owner, topic, options) {
-  const response = await http(ky, {
+export async function fetchLatestFeedUpdate(requestOptions, owner, topic, options) {
+  const response = await http(requestOptions, {
     responseType: 'json',
-    path: `${feedEndpoint}/${owner}/${topic}`,
-    searchParams: filterHeaders(options)
+    url: `${feedEndpoint}/${owner}/${topic}`,
+    params: options
   });
-  return { ...response.parsedData,
+  return {
+    ...response.data,
     ...readFeedUpdateHeaders(response.headers)
   };
 }

package/dist/mjs/modules/pinning.js

@@ -0,0 +1,56 @@
+import { http } from "../utils/http.js";
+const PINNING_ENDPOINT = 'pins';
+/**
+ * Pin data with given reference
+ *
+ * @param kyOptions Ky Options for making requests
+ * @param reference Bee data reference
+ */
+export async function pin(requestOptions, reference) {
+  await http(requestOptions, {
+    method: 'post',
+    responseType: 'json',
+    url: `${PINNING_ENDPOINT}/${reference}`
+  });
+}
+/**
+ * Unpin data with given reference
+ *
+ * @param kyOptions Ky Options for making requests
+ * @param reference Bee data reference
+ */
+export async function unpin(requestOptions, reference) {
+  await http(requestOptions, {
+    method: 'delete',
+    responseType: 'json',
+    url: `${PINNING_ENDPOINT}/${reference}`
+  });
+}
+/**
+ * Get pin status for specific address.
+ *
+ * @param ky Ky instance
+ * @param reference
+ * @throws Error if given address is not pinned
+ */
+export async function getPin(requestOptions, reference) {
+  const response = await http(requestOptions, {
+    method: 'get',
+    responseType: 'json',
+    url: `${PINNING_ENDPOINT}/${reference}`
+  });
+  return response.data;
+}
+/**
+ * Get list of all pins
+ *
+ * @param ky Ky instance
+ */
+export async function getAllPins(requestOptions) {
+  const response = await http(requestOptions, {
+    method: 'get',
+    responseType: 'json',
+    url: `${PINNING_ENDPOINT}`
+  });
+  return response.data.references;
+}

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

@@ -1,12 +1,12 @@
 import WebSocket from 'isomorphic-ws';
 import { prepareData } from "../utils/data.js";
-import { http } from "../utils/http.js";
 import { extractUploadHeaders } from "../utils/headers.js";
+import { http } from "../utils/http.js";
 const endpoint = 'pss';
 /**
  * Send to recipient or target with Postal Service for Swarm
  *
- * @param ky Ky instance for given Bee class instance
+ * @param kyOptions Ky Options for making requests
  * @param topic Topic name
  * @param target Target message address prefix
  * @param data
@@ -14,14 +14,13 @@ const endpoint = 'pss';
  * @param recipient Recipient public key
  *
  */
-
-export async function send(ky, topic, target, data, postageBatchId, recipient) {
-  await http(ky, {
+export async function send(requestOptions, topic, target, data, postageBatchId, recipient) {
+  await http(requestOptions, {
     method: 'post',
-    path: `${endpoint}/send/${topic}/${target}`,
-    body: await prepareData(data),
+    url: `${endpoint}/send/${topic}/${target}`,
+    data: await prepareData(data),
     responseType: 'json',
-    searchParams: {
+    params: {
       recipient
     },
     headers: extractUploadHeaders(postageBatchId)
@@ -33,7 +32,6 @@ export async function send(ky, topic, target, data, postageBatchId, recipient) {
  * @param url Bee node URL
  * @param topic Topic name
  */
-
 export function subscribe(url, topic) {
   const wsUrl = url.replace(/^http/i, 'ws');
   return new WebSocket(`${wsUrl}/${endpoint}/subscribe/${topic}`);

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

@@ -12,20 +12,19 @@ const socEndpoint = 'soc';
  * @param postageBatchId  Postage BatchId that will be assigned to uploaded data
  * @param options         Additional options like tag, encryption, pinning
  */
-
-export async function upload(ky, owner, identifier, signature, data, postageBatchId, options) {
-  const response = await http(ky, {
+export async function upload(requestOptions, owner, identifier, signature, data, postageBatchId, options) {
+  const response = await http(requestOptions, {
     method: 'post',
-    path: `${socEndpoint}/${owner}/${identifier}`,
-    body: data,
+    url: `${socEndpoint}/${owner}/${identifier}`,
+    data,
     headers: {
       'content-type': 'application/octet-stream',
       ...extractUploadHeaders(postageBatchId, options)
     },
     responseType: 'json',
-    searchParams: {
+    params: {
       sig: signature
     }
   });
-  return response.parsedData.reference;
+  return response.data.reference;
 }

package/dist/mjs/modules/status.js

@@ -0,0 +1,11 @@
+import { http } from "../utils/http.js";
+/**
+ * Ping the base bee URL. If connection was not successful throw error
+ *
+ * @param kyOptions Ky instance for given Bee class instance
+ */
+export async function checkConnection(requestOptions) {
+  await http(requestOptions, {
+    url: ''
+  });
+}

package/dist/mjs/modules/stewardship.js

@@ -0,0 +1,23 @@
+import { http } from "../utils/http.js";
+const stewardshipEndpoint = 'stewardship';
+/**
+ * Reupload locally pinned data
+ * @param ky Ky instance
+ * @param reference
+ * @param options
+ * @throws BeeResponseError if not locally pinned or invalid data
+ */
+export async function reupload(requestOptions, reference) {
+  await http(requestOptions, {
+    method: 'put',
+    url: `${stewardshipEndpoint}/${reference}`
+  });
+}
+export async function isRetrievable(requestOptions, reference) {
+  const response = await http(requestOptions, {
+    method: 'get',
+    responseType: 'json',
+    url: `${stewardshipEndpoint}/${reference}`
+  });
+  return response.data.isRetrievable;
+}

package/dist/mjs/modules/tag.js

@@ -0,0 +1,72 @@
+import { http } from "../utils/http.js";
+const endpoint = 'tags';
+/**
+ * Create new tag on the Bee node
+ *
+ * @param url Bee tag URL
+ */
+export async function createTag(requestOptions) {
+  const response = await http(requestOptions, {
+    method: 'post',
+    url: endpoint,
+    responseType: 'json'
+  });
+  return response.data;
+}
+/**
+ * Retrieve tag information from Bee node
+ *
+ * @param url Bee tag URL
+ * @param uid UID of tag to be retrieved
+ */
+export async function retrieveTag(requestOptions, uid) {
+  const response = await http(requestOptions, {
+    url: `${endpoint}/${uid}`,
+    responseType: 'json'
+  });
+  return response.data;
+}
+/**
+ * Get limited listing of all tags.
+ *
+ * @param url
+ * @param offset
+ * @param limit
+ */
+export async function getAllTags(requestOptions, offset, limit) {
+  const response = await http(requestOptions, {
+    url: endpoint,
+    params: {
+      offset,
+      limit
+    },
+    responseType: 'json'
+  });
+  return response.data.tags;
+}
+/**
+ * Removes tag from the Bee node.
+ * @param url
+ * @param uid
+ */
+export async function deleteTag(requestOptions, uid) {
+  await http(requestOptions, {
+    method: 'delete',
+    url: `${endpoint}/${uid}`
+  });
+}
+/**
+ * Updates tag
+ * @param url
+ * @param uid
+ * @param reference
+ */
+export async function updateTag(requestOptions, uid, reference) {
+  await http(requestOptions, {
+    method: 'patch',
+    url: `${endpoint}/${uid}`,
+    data: {
+      reference
+    }
+  });
+}

package/dist/mjs/package.json

@@ -0,0 +1,8 @@
+{
+    "type": "module",
+    "browser": {
+     "stream": false,
+      "./utils/data.js": "./utils/data.browser.js",
+      "./utils/collection.node.js": "./utils/collection.browser.js"
+    }
+}

package/dist/{src → mjs}/types/debug.js

@@ -1,5 +1,4 @@
 export var BeeModes;
-
 (function (BeeModes) {
   BeeModes["FULL"] = "full";
   BeeModes["LIGHT"] = "light";

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

@@ -14,12 +14,10 @@ export const ENCRYPTED_REFERENCE_BYTES_LENGTH = 64;
 /**
  * Minimal depth that can be used for creation of postage batch
  */
-
 export const STAMPS_DEPTH_MIN = 17;
 /**
  * Maximal depth that can be used for creation of postage batch
  */
-
 export const STAMPS_DEPTH_MAX = 255;
 export const TAGS_LIMIT_MIN = 1;
 export const TAGS_LIMIT_MAX = 1000;
@@ -27,12 +25,10 @@ export const FEED_INDEX_HEX_LENGTH = 16;
 /*********************************************************
  * Writers and Readers interfaces
  */
-
 export const TOPIC_BYTES_LENGTH = 32;
 export const TOPIC_HEX_LENGTH = 64;
 /*********************************************************
  * Ethereum compatible signing interfaces and definitions
  */
-
 export const SIGNATURE_HEX_LENGTH = 130;
 export const SIGNATURE_BYTES_LENGTH = 65;

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

@@ -5,7 +5,6 @@ import { bytesToHex } from "./hex.js";
  * @param b       The byte array
  * @param length  The length of the byte array
  */
-
 export function isBytes(b, length) {
   return b instanceof Uint8Array && b.length === length;
 }
@@ -15,12 +14,10 @@ export function isBytes(b, length) {
  * @param offset
  * @param length
  */
-
 export function hasBytesAtOffset(data, offset, length) {
   if (!(data instanceof Uint8Array)) {
     throw new TypeError('Data has to an Uint8Array!');
   }
-
   const offsetBytes = data.slice(offset, offset + length);
   return isBytes(offsetBytes, length);
 }
@@ -30,7 +27,6 @@ export function hasBytesAtOffset(data, offset, length) {
  * @param b       The byte array
  * @param length  The specified length
  */
-
 export function assertBytes(b, length) {
   if (!isBytes(b, length)) {
     throw new TypeError(`Parameter is not valid Bytes of length: ${length} !== ${b.length}`);
@@ -43,7 +39,6 @@ export function assertBytes(b, length) {
  * @param min     Minimum size of the array
  * @param max     Maximum size of the array
  */
-
 export function isFlexBytes(b, min, max) {
   return b instanceof Uint8Array && b.length >= min && b.length <= max;
 }
@@ -54,7 +49,6 @@ export function isFlexBytes(b, min, max) {
  * @param min     Minimum size of the array
  * @param max     Maximum size of the array
  */
-
 export function assertFlexBytes(b, min, max) {
   if (!isFlexBytes(b, min, max)) {
     throw new TypeError(`Parameter is not valid FlexBytes of  min: ${min}, max: ${max}, length: ${b.length}`);
@@ -67,10 +61,9 @@ export function assertFlexBytes(b, min, max) {
  * @param offset The offset to start from
  * @param length The length of data to be returned
  */
-
 export function bytesAtOffset(data, offset, length) {
-  const offsetBytes = data.slice(offset, offset + length); // We are returning strongly typed Bytes so we have to verify that length is really what we claim
-
+  const offsetBytes = data.slice(offset, offset + length);
+  // We are returning strongly typed Bytes so we have to verify that length is really what we claim
   assertBytes(offsetBytes, length);
   return offsetBytes;
 }
@@ -82,9 +75,10 @@ export function bytesAtOffset(data, offset, length) {
  * @param _min   The minimum size of the data
  * @param _max   The maximum size of the data
  */
-
-export function flexBytesAtOffset(data, offset, // eslint-disable-next-line @typescript-eslint/no-unused-vars
-_min, // eslint-disable-next-line @typescript-eslint/no-unused-vars
+export function flexBytesAtOffset(data, offset,
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+_min,
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
 _max) {
   return data.slice(offset);
 }
@@ -94,7 +88,6 @@ _max) {
  * @param a Byte array to compare
  * @param b Byte array to compare
  */
-
 export function bytesEqual(a, b) {
   return a.length === b.length && a.every((value, index) => value === b[index]);
 }
@@ -103,15 +96,13 @@ export function bytesEqual(a, b) {
  *
  * @param length The length of data to be returned
  */
-
 export function makeBytes(length) {
   return new Uint8Array(length);
 }
 export function wrapBytesWithHelpers(data) {
-  return {
-    bytes: () => data,
+  return Object.assign(data, {
     text: () => new TextDecoder('utf-8').decode(data),
     json: () => JSON.parse(new TextDecoder('utf-8').decode(data)),
     hex: () => bytesToHex(data)
-  };
+  });
 }