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

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

@@ -1,30 +1,30 @@
 import { http } from "../../utils/http.js";
 const STAMPS_ENDPOINT = 'stamps';
-export async function getAllPostageBatches(kyOptions) {
-  const response = await http(kyOptions, {
+export async function getAllPostageBatches(requestOptions) {
+  const response = await http(requestOptions, {
     method: 'get',
-    path: `${STAMPS_ENDPOINT}`,
+    url: `${STAMPS_ENDPOINT}`,
     responseType: 'json'
   });
-  return response.parsedData.stamps;
+  return response.data.stamps;
 }
-export async function getPostageBatch(kyOptions, postageBatchId) {
-  const response = await http(kyOptions, {
+export async function getPostageBatch(requestOptions, postageBatchId) {
+  const response = await http(requestOptions, {
     method: 'get',
-    path: `${STAMPS_ENDPOINT}/${postageBatchId}`,
+    url: `${STAMPS_ENDPOINT}/${postageBatchId}`,
     responseType: 'json'
   });
-  return response.parsedData;
+  return response.data;
 }
-export async function getPostageBatchBuckets(kyOptions, postageBatchId) {
-  const response = await http(kyOptions, {
+export async function getPostageBatchBuckets(requestOptions, postageBatchId) {
+  const response = await http(requestOptions, {
     method: 'get',
-    path: `${STAMPS_ENDPOINT}/${postageBatchId}/buckets`,
+    url: `${STAMPS_ENDPOINT}/${postageBatchId}/buckets`,
     responseType: 'json'
   });
-  return response.parsedData;
+  return response.data;
 }
-export async function createPostageBatch(kyOptions, amount, depth, options) {
+export async function createPostageBatch(requestOptions, amount, depth, options) {
   const headers = {};
   if (options?.gasPrice) {
     headers['gas-price'] = options.gasPrice.toString();
@@ -32,30 +32,30 @@ export async function createPostageBatch(kyOptions, amount, depth, options) {
   if (options?.immutableFlag !== undefined) {
     headers.immutable = String(options.immutableFlag);
   }
-  const response = await http(kyOptions, {
+  const response = await http(requestOptions, {
     method: 'post',
-    path: `${STAMPS_ENDPOINT}/${amount}/${depth}`,
+    url: `${STAMPS_ENDPOINT}/${amount}/${depth}`,
     responseType: 'json',
-    searchParams: {
+    params: {
       label: options?.label
     },
     headers
   });
-  return response.parsedData.batchID;
+  return response.data.batchID;
 }
-export async function topUpBatch(kyOptions, id, amount) {
-  const response = await http(kyOptions, {
+export async function topUpBatch(requestOptions, id, amount) {
+  const response = await http(requestOptions, {
     method: 'patch',
-    path: `${STAMPS_ENDPOINT}/topup/${id}/${amount}`,
+    url: `${STAMPS_ENDPOINT}/topup/${id}/${amount}`,
     responseType: 'json'
   });
-  return response.parsedData.batchID;
+  return response.data.batchID;
 }
-export async function diluteBatch(kyOptions, id, depth) {
-  const response = await http(kyOptions, {
+export async function diluteBatch(requestOptions, id, depth) {
+  const response = await http(requestOptions, {
     method: 'patch',
-    path: `${STAMPS_ENDPOINT}/dilute/${id}/${depth}`,
+    url: `${STAMPS_ENDPOINT}/dilute/${id}/${depth}`,
     responseType: 'json'
   });
-  return response.parsedData.batchID;
+  return response.data.batchID;
 }

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

@@ -7,39 +7,39 @@ const CHAIN_STATE_ENDPOINT = 'chainstate';
  *
  * @param kyOptions Ky Options for making requests
  */
-export async function getReserveState(kyOptions) {
-  const response = await http(kyOptions, {
+export async function getReserveState(requestOptions) {
+  const response = await http(requestOptions, {
     method: 'get',
-    path: `${RESERVE_STATE_ENDPOINT}`,
+    url: `${RESERVE_STATE_ENDPOINT}`,
     responseType: 'json'
   });
-  return response.parsedData;
+  return response.data;
 }
 /**
  * Get state of reserve
  *
  * @param kyOptions Ky Options for making requests
  */
-export async function getChainState(kyOptions) {
-  const response = await http(kyOptions, {
+export async function getChainState(requestOptions) {
+  const response = await http(requestOptions, {
     method: 'get',
-    path: `${CHAIN_STATE_ENDPOINT}`,
+    url: `${CHAIN_STATE_ENDPOINT}`,
     responseType: 'json'
   });
-  return response.parsedData;
+  return response.data;
 }
 /**
  * Get wallet balances for xDai and BZZ of the node
  *
  * @param kyOptions Ky Options for making requests
  */
-export async function getWalletBalance(kyOptions) {
-  const response = await http(kyOptions, {
+export async function getWalletBalance(requestOptions) {
+  const response = await http(requestOptions, {
     method: 'get',
-    path: `${WALLET_ENDPOINT}`,
+    url: `${WALLET_ENDPOINT}`,
     responseType: 'json'
   });
-  return mapWalletProperties(response.parsedData);
+  return mapWalletProperties(response.data);
 }
 /**
  * TODO: Remove on next break

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

@@ -1,6 +1,5 @@
-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 { 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.12.0-88c1d236';
 export const SUPPORTED_API_VERSION = '4.0.0';
@@ -14,24 +13,24 @@ const READINESS_URL = 'readiness';
  *
  * @param kyOptions Ky Options for making requests
  */
-export async function getHealth(kyOptions) {
-  const response = await http(kyOptions, {
+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(kyOptions) {
+export async function getReadiness(requestOptions) {
   try {
-    const response = await http(kyOptions, {
+    const response = await http(requestOptions, {
       method: 'get',
-      path: READINESS_URL
+      url: READINESS_URL
     });
     return response.status === 200;
   } catch {
@@ -43,13 +42,13 @@ export async function getReadiness(kyOptions) {
  *
  * @param kyOptions Ky Options for making requests
  */
-export async function getNodeInfo(kyOptions) {
-  const response = await http(kyOptions, {
+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
@@ -60,8 +59,8 @@ export async function getNodeInfo(kyOptions) {
  * @deprecated Use `isSupportedExactVersion` instead
  */
 // TODO: Remove on break
-export async function isSupportedVersion(kyOptions) {
-  return isSupportedExactVersion(kyOptions);
+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.
@@ -73,10 +72,10 @@ export async function isSupportedVersion(kyOptions) {
  *
  * @param ky
  */
-export async function isSupportedExactVersion(kyOptions) {
+export async function isSupportedExactVersion(requestOptions) {
   const {
     version
-  } = await getHealth(kyOptions);
+  } = await getHealth(requestOptions);
   return version === SUPPORTED_BEE_VERSION_EXACT;
 }
 /**
@@ -87,10 +86,10 @@ export async function isSupportedExactVersion(kyOptions) {
  *
  * @param ky
  */
-export async function isSupportedMainApiVersion(kyOptions) {
+export async function isSupportedMainApiVersion(requestOptions) {
   const {
     apiVersion
-  } = await getHealth(kyOptions);
+  } = await getHealth(requestOptions);
   return getMajorSemver(apiVersion) === getMajorSemver(SUPPORTED_API_VERSION);
 }
 /**
@@ -101,10 +100,10 @@ export async function isSupportedMainApiVersion(kyOptions) {
  *
  * @param ky
  */
-export async function isSupportedDebugApiVersion(kyOptions) {
+export async function isSupportedDebugApiVersion(requestOptions) {
   const {
     debugApiVersion
-  } = await getHealth(kyOptions);
+  } = await getHealth(requestOptions);
   return getMajorSemver(debugApiVersion) === getMajorSemver(SUPPORTED_DEBUG_API_VERSION);
 }
 /**
@@ -114,11 +113,11 @@ export async function isSupportedDebugApiVersion(kyOptions) {
  *
  * @param ky
  */
-export async function isSupportedApiVersion(kyOptions) {
+export async function isSupportedApiVersion(requestOptions) {
   const {
     apiVersion,
     debugApiVersion
-  } = await getHealth(kyOptions);
+  } = await getHealth(requestOptions);
   return getMajorSemver(apiVersion) === getMajorSemver(SUPPORTED_API_VERSION) && getMajorSemver(debugApiVersion) === getMajorSemver(SUPPORTED_DEBUG_API_VERSION);
 }
 /**
@@ -127,12 +126,12 @@ export async function isSupportedApiVersion(kyOptions) {
  *
  * @param ky
  */
-export async function getVersions(kyOptions) {
+export async function getVersions(requestOptions) {
   const {
     version,
     apiVersion,
     debugApiVersion
-  } = await getHealth(kyOptions);
+  } = await getHealth(requestOptions);
   return {
     supportedBeeVersion: SUPPORTED_BEE_VERSION_EXACT,
     supportedBeeApiVersion: SUPPORTED_API_VERSION,

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

@@ -6,10 +6,10 @@ const endpoint = 'tags';
  * @param kyOptions Ky Options for making requests
  * @param uid UID of tag to be retrieved
  */
-export async function retrieveExtendedTag(kyOptions, uid) {
-  const response = await http(kyOptions, {
-    path: `${endpoint}/${uid}`,
+export async function retrieveExtendedTag(requestOptions, uid) {
+  const response = await http(requestOptions, {
+    url: `${endpoint}/${uid}`,
     responseType: 'json'
   });
-  return response.parsedData;
+  return response.data;
 }

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

@@ -5,12 +5,12 @@ const transactionsEndpoint = 'transactions';
  *
  * @param ky   Debug Ky instance
  */
-export async function getAllTransactions(kyOptions) {
-  const response = await http(kyOptions, {
-    path: transactionsEndpoint,
+export async function getAllTransactions(requestOptions) {
+  const response = await http(requestOptions, {
+    url: transactionsEndpoint,
     responseType: 'json'
   });
-  return response.parsedData.pendingTransactions;
+  return response.data.pendingTransactions;
 }
 /**
  * Get information for specific pending transactions
@@ -18,12 +18,12 @@ export async function getAllTransactions(kyOptions) {
  * @param ky   Debug Ky instance
  * @param transactionHash Hash of the transaction
  */
-export async function getTransaction(kyOptions, transactionHash) {
-  const response = await http(kyOptions, {
-    path: `${transactionsEndpoint}/${transactionHash}`,
+export async function getTransaction(requestOptions, transactionHash) {
+  const response = await http(requestOptions, {
+    url: `${transactionsEndpoint}/${transactionHash}`,
     responseType: 'json'
   });
-  return response.parsedData;
+  return response.data;
 }
 /**
  * Rebroadcast existing transaction
@@ -31,13 +31,13 @@ export async function getTransaction(kyOptions, transactionHash) {
  * @param ky   Debug Ky instance
  * @param transactionHash Hash of the transaction
  */
-export async function rebroadcastTransaction(kyOptions, transactionHash) {
-  const response = await http(kyOptions, {
+export async function rebroadcastTransaction(requestOptions, transactionHash) {
+  const response = await http(requestOptions, {
     method: 'post',
-    path: `${transactionsEndpoint}/${transactionHash}`,
+    url: `${transactionsEndpoint}/${transactionHash}`,
     responseType: 'json'
   });
-  return response.parsedData.transactionHash;
+  return response.data.transactionHash;
 }
 /**
  * Cancel existing transaction
@@ -46,14 +46,14 @@ export async function rebroadcastTransaction(kyOptions, transactionHash) {
  * @param transactionHash Hash of the transaction
  * @param gasPrice Optional gas price
  */
-export async function cancelTransaction(kyOptions, transactionHash, gasPrice) {
-  const response = await http(kyOptions, {
+export async function cancelTransaction(requestOptions, transactionHash, gasPrice) {
+  const response = await http(requestOptions, {
     method: 'delete',
     headers: {
       'gas-price': gasPrice
     },
-    path: `${transactionsEndpoint}/${transactionHash}`,
+    url: `${transactionsEndpoint}/${transactionHash}`,
     responseType: 'json'
   });
-  return response.parsedData.transactionHash;
+  return response.data.transactionHash;
 }

package/dist/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,19 +11,19 @@ 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(kyOptions, owner, topic, postageBatchId, options) {
-  const response = await http(kyOptions, {
+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!');
   }
@@ -48,14 +48,14 @@ function readFeedUpdateHeaders(headers) {
  * @param topic       Topic in hex
  * @param options     Additional options, like index, at, type
  */
-export async function fetchLatestFeedUpdate(kyOptions, owner, topic, options) {
-  const response = await http(kyOptions, {
+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,
+    ...response.data,
     ...readFeedUpdateHeaders(response.headers)
   };
 }

package/dist/mjs/modules/pinning.js

@@ -6,11 +6,11 @@ const PINNING_ENDPOINT = 'pins';
  * @param kyOptions Ky Options for making requests
  * @param reference Bee data reference
  */
-export async function pin(kyOptions, reference) {
-  await http(kyOptions, {
+export async function pin(requestOptions, reference) {
+  await http(requestOptions, {
     method: 'post',
     responseType: 'json',
-    path: `${PINNING_ENDPOINT}/${reference}`
+    url: `${PINNING_ENDPOINT}/${reference}`
   });
 }
 /**
@@ -19,11 +19,11 @@ export async function pin(kyOptions, reference) {
  * @param kyOptions Ky Options for making requests
  * @param reference Bee data reference
  */
-export async function unpin(kyOptions, reference) {
-  await http(kyOptions, {
+export async function unpin(requestOptions, reference) {
+  await http(requestOptions, {
     method: 'delete',
     responseType: 'json',
-    path: `${PINNING_ENDPOINT}/${reference}`
+    url: `${PINNING_ENDPOINT}/${reference}`
   });
 }
 /**
@@ -33,24 +33,24 @@ export async function unpin(kyOptions, reference) {
  * @param reference
  * @throws Error if given address is not pinned
  */
-export async function getPin(kyOptions, reference) {
-  const response = await http(kyOptions, {
+export async function getPin(requestOptions, reference) {
+  const response = await http(requestOptions, {
     method: 'get',
     responseType: 'json',
-    path: `${PINNING_ENDPOINT}/${reference}`
+    url: `${PINNING_ENDPOINT}/${reference}`
   });
-  return response.parsedData;
+  return response.data;
 }
 /**
  * Get list of all pins
  *
  * @param ky Ky instance
  */
-export async function getAllPins(kyOptions) {
-  const response = await http(kyOptions, {
+export async function getAllPins(requestOptions) {
+  const response = await http(requestOptions, {
     method: 'get',
     responseType: 'json',
-    path: `${PINNING_ENDPOINT}`
+    url: `${PINNING_ENDPOINT}`
   });
-  return response.parsedData.references;
+  return response.data.references;
 }

package/dist/mjs/modules/pss.js

@@ -1,7 +1,7 @@
 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
@@ -14,13 +14,13 @@ const endpoint = 'pss';
  * @param recipient Recipient public key
  *
  */
-export async function send(kyOptions, topic, target, data, postageBatchId, recipient) {
-  await http(kyOptions, {
+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)

package/dist/mjs/modules/soc.js

@@ -12,19 +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(kyOptions, owner, identifier, signature, data, postageBatchId, options) {
-  const response = await http(kyOptions, {
+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

@@ -4,8 +4,8 @@ import { http } from "../utils/http.js";
  *
  * @param kyOptions Ky instance for given Bee class instance
  */
-export async function checkConnection(kyOptions) {
-  await http(kyOptions, {
-    path: ''
+export async function checkConnection(requestOptions) {
+  await http(requestOptions, {
+    url: ''
   });
 }

package/dist/mjs/modules/stewardship.js

@@ -7,17 +7,17 @@ const stewardshipEndpoint = 'stewardship';
  * @param options
  * @throws BeeResponseError if not locally pinned or invalid data
  */
-export async function reupload(kyOptions, reference) {
-  await http(kyOptions, {
+export async function reupload(requestOptions, reference) {
+  await http(requestOptions, {
     method: 'put',
-    path: `${stewardshipEndpoint}/${reference}`
+    url: `${stewardshipEndpoint}/${reference}`
   });
 }
-export async function isRetrievable(kyOptions, reference) {
-  const response = await http(kyOptions, {
+export async function isRetrievable(requestOptions, reference) {
+  const response = await http(requestOptions, {
     method: 'get',
     responseType: 'json',
-    path: `${stewardshipEndpoint}/${reference}`
+    url: `${stewardshipEndpoint}/${reference}`
   });
-  return response.parsedData.isRetrievable;
+  return response.data.isRetrievable;
 }

package/dist/mjs/modules/tag.js

@@ -5,13 +5,13 @@ const endpoint = 'tags';
  *
  * @param url Bee tag URL
  */
-export async function createTag(kyOptions) {
-  const response = await http(kyOptions, {
+export async function createTag(requestOptions) {
+  const response = await http(requestOptions, {
     method: 'post',
-    path: endpoint,
+    url: endpoint,
     responseType: 'json'
   });
-  return response.parsedData;
+  return response.data;
 }
 /**
  * Retrieve tag information from Bee node
@@ -19,12 +19,12 @@ export async function createTag(kyOptions) {
  * @param url Bee tag URL
  * @param uid UID of tag to be retrieved
  */
-export async function retrieveTag(kyOptions, uid) {
-  const response = await http(kyOptions, {
-    path: `${endpoint}/${uid}`,
+export async function retrieveTag(requestOptions, uid) {
+  const response = await http(requestOptions, {
+    url: `${endpoint}/${uid}`,
     responseType: 'json'
   });
-  return response.parsedData;
+  return response.data;
 }
 /**
  * Get limited listing of all tags.
@@ -33,26 +33,26 @@ export async function retrieveTag(kyOptions, uid) {
  * @param offset
  * @param limit
  */
-export async function getAllTags(kyOptions, offset, limit) {
-  const response = await http(kyOptions, {
-    path: `${endpoint}`,
-    searchParams: {
+export async function getAllTags(requestOptions, offset, limit) {
+  const response = await http(requestOptions, {
+    url: endpoint,
+    params: {
       offset,
       limit
     },
     responseType: 'json'
   });
-  return response.parsedData.tags;
+  return response.data.tags;
 }
 /**
  * Removes tag from the Bee node.
  * @param url
  * @param uid
  */
-export async function deleteTag(kyOptions, uid) {
-  await http(kyOptions, {
+export async function deleteTag(requestOptions, uid) {
+  await http(requestOptions, {
     method: 'delete',
-    path: `${endpoint}/${uid}`
+    url: `${endpoint}/${uid}`
   });
 }
 /**
@@ -61,11 +61,11 @@ export async function deleteTag(kyOptions, uid) {
  * @param uid
  * @param reference
  */
-export async function updateTag(kyOptions, uid, reference) {
-  await http(kyOptions, {
+export async function updateTag(requestOptions, uid, reference) {
+  await http(requestOptions, {
     method: 'patch',
-    path: `${endpoint}/${uid}`,
-    json: {
+    url: `${endpoint}/${uid}`,
+    data: {
       reference
     }
   });