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

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

@@ -1,13 +1,11 @@
+import { wrapBytesWithHelpers } from "../utils/bytes.js";
+import { assertCollection } from "../utils/collection.js";
 import { extractUploadHeaders, readFileHeaders } from "../utils/headers.js";
 import { http } from "../utils/http.js";
-import { prepareData } from "../utils/data.js";
-import { makeTar } from "../utils/tar.js";
-import { assertCollection } from "../utils/collection.js";
-import { wrapBytesWithHelpers } from "../utils/bytes.js";
 import { isReadable } from "../utils/stream.js";
+import { makeTar } from "../utils/tar.js";
 import { makeTagUid } from "../utils/type.js";
 const bzzEndpoint = 'bzz';
-
 function extractFileUploadHeaders(postageBatchId, options) {
   const headers = extractUploadHeaders(postageBatchId, options);
   if (options?.size) headers['content-length'] = String(options.size);
@@ -23,69 +21,66 @@ function extractFileUploadHeaders(postageBatchId, options) {
  * @param name Name that will be attached to the uploaded file. Wraps the data into manifest with set index document.
  * @param options
  */
-
-
-export async function uploadFile(ky, data, postageBatchId, name, options) {
+export async function uploadFile(requestOptions, data, postageBatchId, name, options) {
   if (isReadable(data) && !options?.contentType) {
     if (!options) options = {};
     options.contentType = 'application/octet-stream';
   }
-
-  const response = await http(ky, {
+  const response = await http(requestOptions, {
     method: 'post',
-    path: bzzEndpoint,
-    body: await prepareData(data),
-    headers: { ...extractFileUploadHeaders(postageBatchId, options)
+    url: bzzEndpoint,
+    data,
+    headers: {
+      ...extractFileUploadHeaders(postageBatchId, options)
     },
-    searchParams: {
+    params: {
       name
     },
     responseType: 'json'
   });
   return {
-    reference: response.parsedData.reference,
-    tagUid: makeTagUid(response.headers.get('swarm-tag'))
+    reference: response.data.reference,
+    tagUid: makeTagUid(response.headers['swarm-tag'])
   };
 }
 /**
  * Download single file as a buffer
  *
- * @param ky Ky instance for given Bee class instance
+ * @param kyOptions Ky Options for making requests
  * @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(ky, hash, path = '') {
-  const response = await http(ky, {
+export async function downloadFile(requestOptions, hash, path = '') {
+  const response = await http(requestOptions, {
     method: 'GET',
     responseType: 'arraybuffer',
-    path: `${bzzEndpoint}/${hash}/${path}`
+    url: `${bzzEndpoint}/${hash}/${path}`
   });
-  const file = { ...readFileHeaders(response.headers),
-    data: wrapBytesWithHelpers(new Uint8Array(response.parsedData))
+  const file = {
+    ...readFileHeaders(response.headers),
+    data: wrapBytesWithHelpers(new Uint8Array(response.data))
   };
   return file;
 }
 /**
  * Download single file as a readable stream
  *
- * @param ky Ky instance for given Bee class instance
+ * @param kyOptions Ky Options for making requests
  * @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(ky, hash, path = '') {
-  const response = await http(ky, {
+export async function downloadFileReadable(requestOptions, hash, path = '') {
+  const response = await http(requestOptions, {
     method: 'GET',
     responseType: 'stream',
-    path: `${bzzEndpoint}/${hash}/${path}`
+    url: `${bzzEndpoint}/${hash}/${path}`
   });
-  const file = { ...readFileHeaders(response.headers),
-    data: response.parsedData
+  const file = {
+    ...readFileHeaders(response.headers),
+    data: response.data
   };
   return file;
 }
-
 function extractCollectionUploadHeaders(postageBatchId, options) {
   const headers = extractUploadHeaders(postageBatchId, options);
   if (options?.indexDocument) headers['swarm-index-document'] = options.indexDocument;
@@ -94,20 +89,18 @@ function extractCollectionUploadHeaders(postageBatchId, options) {
 }
 /**
  * Upload collection
- * @param ky Ky instance for given Bee class instance
+ * @param kyOptions Ky Options for making requests
  * @param collection Collection of Uint8Array buffers to upload
  * @param postageBatchId  Postage BatchId that will be assigned to uploaded data
  * @param options
  */
-
-
-export async function uploadCollection(ky, collection, postageBatchId, options) {
+export async function uploadCollection(requestOptions, collection, postageBatchId, options) {
   assertCollection(collection);
   const tarData = makeTar(collection);
-  const response = await http(ky, {
+  const response = await http(requestOptions, {
     method: 'post',
-    path: bzzEndpoint,
-    body: tarData,
+    url: bzzEndpoint,
+    data: tarData,
     responseType: 'json',
     headers: {
       'content-type': 'application/x-tar',
@@ -116,7 +109,7 @@ export async function uploadCollection(ky, collection, postageBatchId, options)
     }
   });
   return {
-    reference: response.parsedData.reference,
-    tagUid: makeTagUid(response.headers.get('swarm-tag'))
+    reference: response.data.reference,
+    tagUid: makeTagUid(response.headers['swarm-tag'])
   };
 }

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

@@ -1,6 +1,6 @@
+import { wrapBytesWithHelpers } from "../utils/bytes.js";
 import { extractUploadHeaders } from "../utils/headers.js";
 import { http } from "../utils/http.js";
-import { wrapBytesWithHelpers } from "../utils/bytes.js";
 const endpoint = 'chunks';
 /**
  * Upload chunk to a Bee node
@@ -14,32 +14,30 @@ const endpoint = 'chunks';
  * @param postageBatchId  Postage BatchId that will be assigned to uploaded data
  * @param options Additional options like tag, encryption, pinning
  */
-
-export async function upload(ky, data, postageBatchId, options) {
-  const response = await http(ky, {
+export async function upload(requestOptions, data, postageBatchId, options) {
+  const response = await http(requestOptions, {
     method: 'post',
-    path: `${endpoint}`,
-    body: data,
+    url: `${endpoint}`,
+    data,
     headers: {
       'content-type': 'application/octet-stream',
       ...extractUploadHeaders(postageBatchId, options)
     },
     responseType: 'json'
   });
-  return response.parsedData.reference;
+  return response.data.reference;
 }
 /**
  * Download chunk data as a byte array
  *
- * @param ky Ky instance for given Bee class instance
+ * @param kyOptions Ky Options for making requests
  * @param hash Bee content reference
  *
  */
-
-export async function download(ky, hash) {
-  const response = await http(ky, {
+export async function download(requestOptions, hash) {
+  const response = await http(requestOptions, {
     responseType: 'arraybuffer',
-    path: `${endpoint}/${hash}`
+    url: `${endpoint}/${hash}`
   });
-  return wrapBytesWithHelpers(new Uint8Array(response.parsedData));
+  return wrapBytesWithHelpers(new Uint8Array(response.data));
 }

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

@@ -0,0 +1,53 @@
+import { http } from "../../utils/http.js";
+const balancesEndpoint = 'balances';
+const consumedEndpoint = 'consumed';
+/**
+ * Get the balances with all known peers including prepaid services
+ *
+ * @param kyOptions Ky Options for making requests
+ */
+export async function getAllBalances(requestOptions) {
+  const response = await http(requestOptions, {
+    url: balancesEndpoint,
+    responseType: 'json'
+  });
+  return response.data;
+}
+/**
+ * Get the balances with a specific peer including prepaid services
+ *
+ * @param kyOptions Ky Options for making requests
+ * @param address Swarm address of peer
+ */
+export async function getPeerBalance(requestOptions, address) {
+  const response = await http(requestOptions, {
+    url: `${balancesEndpoint}/${address}`,
+    responseType: 'json'
+  });
+  return response.data;
+}
+/**
+ * Get the past due consumption balances with all known peers
+ *
+ * @param kyOptions Ky Options for making requests
+ */
+export async function getPastDueConsumptionBalances(requestOptions) {
+  const response = await http(requestOptions, {
+    url: consumedEndpoint,
+    responseType: 'json'
+  });
+  return response.data;
+}
+/**
+ * Get the past due consumption balance with a specific peer
+ *
+ * @param kyOptions Ky Options for making requests
+ * @param address Swarm address of peer
+ */
+export async function getPastDueConsumptionPeerBalance(requestOptions, address) {
+  const response = await http(requestOptions, {
+    url: `${consumedEndpoint}/${address}`,
+    responseType: 'json'
+  });
+  return response.data;
+}

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

@@ -0,0 +1,135 @@
+import { http } from "../../utils/http.js";
+const chequebookEndpoint = 'chequebook';
+/**
+ * Get the address of the chequebook contract used
+ *
+ * @param kyOptions Ky Options for making requests
+ */
+export async function getChequebookAddress(requestOptions) {
+  const response = await http(requestOptions, {
+    url: chequebookEndpoint + '/address',
+    responseType: 'json'
+  });
+  return response.data;
+}
+/**
+ * Get the balance of the chequebook
+ *
+ * @param kyOptions Ky Options for making requests
+ */
+export async function getChequebookBalance(requestOptions) {
+  const response = await http(requestOptions, {
+    url: chequebookEndpoint + '/balance',
+    responseType: 'json'
+  });
+  return response.data;
+}
+/**
+ * Get last cashout action for the peer
+ *
+ * @param kyOptions Ky Options for making requests
+ * @param peer  Swarm address of peer
+ */
+export async function getLastCashoutAction(requestOptions, peer) {
+  const response = await http(requestOptions, {
+    url: chequebookEndpoint + `/cashout/${peer}`,
+    responseType: 'json'
+  });
+  return response.data;
+}
+/**
+ * Cashout the last cheque for the peer
+ *
+ * @param kyOptions Ky Options for making requests
+ * @param peer  Swarm address of peer
+ * @param options
+ */
+export async function cashoutLastCheque(requestOptions, peer, options) {
+  const headers = {};
+  if (options?.gasPrice) {
+    headers['gas-price'] = options.gasPrice.toString();
+  }
+  if (options?.gasLimit) {
+    headers['gas-limit'] = options.gasLimit.toString();
+  }
+  const response = await http(requestOptions, {
+    method: 'post',
+    url: chequebookEndpoint + `/cashout/${peer}`,
+    responseType: 'json',
+    headers
+  });
+  return response.data.transactionHash;
+}
+/**
+ * Get last cheques for the peer
+ *
+ * @param kyOptions Ky Options for making requests
+ * @param peer  Swarm address of peer
+ */
+export async function getLastChequesForPeer(requestOptions, peer) {
+  const response = await http(requestOptions, {
+    url: chequebookEndpoint + `/cheque/${peer}`,
+    responseType: 'json'
+  });
+  return response.data;
+}
+/**
+ * Get last cheques for all peers
+ *
+ * @param kyOptions Ky Options for making requests
+ */
+export async function getLastCheques(requestOptions) {
+  const response = await http(requestOptions, {
+    url: chequebookEndpoint + '/cheque',
+    responseType: 'json'
+  });
+  return response.data;
+}
+/**
+ * Deposit tokens from overlay address into chequebook
+ *
+ * @param kyOptions Ky Options for making requests
+ * @param amount   Amount of tokens to deposit
+ * @param gasPrice Gas Price in WEI for the transaction call
+ * @return string  Hash of the transaction
+ */
+export async function depositTokens(requestOptions, amount, gasPrice) {
+  const headers = {};
+  if (gasPrice) {
+    headers['gas-price'] = gasPrice.toString();
+  }
+  const response = await http(requestOptions, {
+    method: 'post',
+    url: chequebookEndpoint + '/deposit',
+    responseType: 'json',
+    params: {
+      amount: amount.toString(10)
+    },
+    headers
+  });
+  return response.data.transactionHash;
+}
+/**
+ * Withdraw tokens from the chequebook to the overlay address
+ *
+ * @param kyOptions Ky Options for making requests
+ * @param amount   Amount of tokens to withdraw
+ * @param gasPrice Gas Price in WEI for the transaction call
+ * @return string  Hash of the transaction
+ */
+export async function withdrawTokens(requestOptions, amount, gasPrice) {
+  const headers = {};
+  if (gasPrice) {
+    headers['gas-price'] = gasPrice.toString();
+  }
+  const response = await http(requestOptions, {
+    method: 'post',
+    url: chequebookEndpoint + '/withdraw',
+    responseType: 'json',
+    params: {
+      amount: amount.toString(10)
+    },
+    headers
+  });
+  return response.data.transactionHash;
+}

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

@@ -3,33 +3,31 @@ const endpoint = 'chunks';
 /**
  * Check if chunk at address exists locally
  *
- * @param ky Ky debug instance
+ * @param kyOptions Ky Options for making requests
  * @param address  Swarm address of chunk
  *
  * @returns BeeGenericResponse if chunk is found or throws an exception
  */
-
-export async function checkIfChunkExistsLocally(ky, address) {
-  const response = await http(ky, {
-    path: endpoint + `/${address}`,
+export async function checkIfChunkExistsLocally(requestOptions, address) {
+  const response = await http(requestOptions, {
+    url: `${endpoint}/${address}`,
     responseType: 'json'
   });
-  return response.parsedData;
+  return response.data;
 }
 /**
  * Delete a chunk from local storage
  *
- * @param ky Ky debug instance
+ * @param kyOptions Ky Options for making requests
  * @param address  Swarm address of chunk
  *
  * @returns BeeGenericResponse if chunk was deleted or throws an exception
  */
-
-export async function deleteChunkFromLocalStorage(ky, address) {
-  const response = await http(ky, {
+export async function deleteChunkFromLocalStorage(requestOptions, address) {
+  const response = await http(requestOptions, {
     method: 'delete',
-    path: endpoint + `/${address}`,
+    url: `${endpoint}/${address}`,
     responseType: 'json'
   });
-  return response.parsedData;
+  return response.data;
 }

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

@@ -0,0 +1,45 @@
+import { http } from "../../utils/http.js";
+export async function getNodeAddresses(requestOptions) {
+  const response = await http(requestOptions, {
+    url: 'addresses',
+    responseType: 'json'
+  });
+  return response.data;
+}
+export async function getPeers(requestOptions) {
+  const response = await http(requestOptions, {
+    url: 'peers',
+    responseType: 'json'
+  });
+  return response.data.peers;
+}
+export async function getBlocklist(requestOptions) {
+  const response = await http(requestOptions, {
+    url: 'blocklist',
+    responseType: 'json'
+  });
+  return response.data.peers;
+}
+export async function removePeer(requestOptions, peer) {
+  const response = await http(requestOptions, {
+    url: `peers/${peer}`,
+    responseType: 'json',
+    method: 'DELETE'
+  });
+  return response.data;
+}
+export async function getTopology(requestOptions) {
+  const response = await http(requestOptions, {
+    url: `topology`,
+    responseType: 'json'
+  });
+  return response.data;
+}
+export async function pingPeer(requestOptions, peer) {
+  const response = await http(requestOptions, {
+    url: `pingpong/${peer}`,
+    responseType: 'json',
+    method: 'POST'
+  });
+  return response.data;
+}

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

@@ -0,0 +1,27 @@
+import { http } from "../../utils/http.js";
+const settlementsEndpoint = 'settlements';
+/**
+ * Get amount of sent and received from settlements with a peer
+ *
+ * @param kyOptions Ky Options for making requests
+ * @param peer  Swarm address of peer
+ */
+export async function getSettlements(requestOptions, peer) {
+  const response = await http(requestOptions, {
+    url: `${settlementsEndpoint}/${peer}`,
+    responseType: 'json'
+  });
+  return response.data;
+}
+/**
+ * Get settlements with all known peers and total amount sent or received
+ *
+ * @param kyOptions Ky Options for making requests
+ */
+export async function getAllSettlements(requestOptions) {
+  const response = await http(requestOptions, {
+    url: settlementsEndpoint,
+    responseType: 'json'
+  });
+  return response.data;
+}

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

@@ -0,0 +1,51 @@
+import { http } from "../../utils/http.js";
+const STAKE_ENDPOINT = 'stake';
+const REDISTRIBUTION_ENDPOINT = 'redistributionstate';
+/**
+ * Gets the staked amount
+ *
+ * @param kyOptions Ky Options for making requests
+ */
+export async function getStake(requestOptions) {
+  const response = await http(requestOptions, {
+    method: 'get',
+    responseType: 'json',
+    url: `${STAKE_ENDPOINT}`
+  });
+  return response.data.stakedAmount.toString();
+}
+/**
+ * Stake given amount of tokens.
+ *
+ * @param ky
+ * @param amount
+ * @param options
+ */
+export async function stake(requestOptions, amount, options) {
+  const headers = {};
+  if (options?.gasPrice) {
+    headers['gas-price'] = options.gasPrice.toString();
+  }
+  if (options?.gasLimit) {
+    headers['gas-limit'] = options.gasLimit.toString();
+  }
+  await http(requestOptions, {
+    method: 'post',
+    responseType: 'json',
+    url: `${STAKE_ENDPOINT}/${amount}`,
+    headers
+  });
+}
+/**
+ * Get current status of node in redistribution game
+ *
+ * @param kyOptions Ky Options for making requests
+ */
+export async function getRedistributionState(requestOptions) {
+  const response = await http(requestOptions, {
+    method: 'get',
+    responseType: 'json',
+    url: REDISTRIBUTION_ENDPOINT
+  });
+  return response.data;
+}

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

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

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

@@ -0,0 +1,58 @@
+import { http } from "../../utils/http.js";
+const RESERVE_STATE_ENDPOINT = 'reservestate';
+const WALLET_ENDPOINT = 'wallet';
+const CHAIN_STATE_ENDPOINT = 'chainstate';
+/**
+ * Get state of reserve
+ *
+ * @param kyOptions Ky Options for making requests
+ */
+export async function getReserveState(requestOptions) {
+  const response = await http(requestOptions, {
+    method: 'get',
+    url: `${RESERVE_STATE_ENDPOINT}`,
+    responseType: 'json'
+  });
+  return response.data;
+}
+/**
+ * Get state of reserve
+ *
+ * @param kyOptions Ky Options for making requests
+ */
+export async function getChainState(requestOptions) {
+  const response = await http(requestOptions, {
+    method: 'get',
+    url: `${CHAIN_STATE_ENDPOINT}`,
+    responseType: 'json'
+  });
+  return response.data;
+}
+/**
+ * Get wallet balances for xDai and BZZ of the node
+ *
+ * @param kyOptions Ky Options for making requests
+ */
+export async function getWalletBalance(requestOptions) {
+  const response = await http(requestOptions, {
+    method: 'get',
+    url: `${WALLET_ENDPOINT}`,
+    responseType: 'json'
+  });
+  return mapWalletProperties(response.data);
+}
+/**
+ * TODO: Remove on next break
+ * @param data
+ */
+function mapWalletProperties(data) {
+  return {
+    // @ts-ignore: Needed for backward compatibility mapping
+    bzz: data.bzzBalance,
+    // @ts-ignore: Needed for backward compatibility mapping
+    xDai: data.nativeTokenBalance,
+    // @ts-ignore: Needed for backward compatibility mapping
+    contractAddress: data.chequebookContractAddress,
+    ...data
+  };
+}