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

package/dist/cjs/feed/retrievable.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.areAllSequentialFeedsUpdateRetrievable = void 0;
+const hex_1 = require("../utils/hex");
+const uint64_1 = require("../utils/uint64");
+const index_1 = require("./index");
+function makeNumericIndex(index) {
+    if (index instanceof Uint8Array) {
+        return (0, uint64_1.readUint64BigEndian)(index);
+    }
+    if (typeof index === 'string') {
+        return parseInt(index);
+    }
+    if (typeof index === 'number') {
+        return index;
+    }
+    throw new TypeError('Unknown type of index!');
+}
+/**
+ * Function that checks if a chunk is retrievable by actually downloading it.
+ * The /stewardship/{reference} endpoint does not support verification of chunks, but only manifest's references.
+ *
+ * @param bee
+ * @param ref
+ * @param options
+ */
+async function isChunkRetrievable(bee, ref, requestOptions) {
+    try {
+        await bee.downloadChunk(ref, requestOptions);
+        return true;
+    }
+    catch (e) {
+        if (e?.response?.status === 404) {
+            return false;
+        }
+        throw e;
+    }
+}
+/**
+ * Creates array of references for all sequence updates chunk up to the given index.
+ *
+ * @param owner
+ * @param topic
+ * @param index
+ */
+function getAllSequenceUpdateReferences(owner, topic, index) {
+    const numIndex = makeNumericIndex(index);
+    const updateReferences = new Array(numIndex + 1);
+    for (let i = 0; i <= numIndex; i++) {
+        updateReferences[i] = (0, hex_1.bytesToHex)((0, index_1.getFeedUpdateChunkReference)(owner, topic, i));
+    }
+    return updateReferences;
+}
+async function areAllSequentialFeedsUpdateRetrievable(bee, owner, topic, index, requestOptions) {
+    const chunkRetrievablePromises = getAllSequenceUpdateReferences(owner, topic, index).map(async (ref) => isChunkRetrievable(bee, ref, requestOptions));
+    return (await Promise.all(chunkRetrievablePromises)).every(result => result);
+}
+exports.areAllSequentialFeedsUpdateRetrievable = areAllSequentialFeedsUpdateRetrievable;

package/dist/cjs/feed/topic.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeTopicFromString = exports.makeTopic = void 0;
+const hash_1 = require("../utils/hash");
+const bytes_1 = require("../utils/bytes");
+const hex_1 = require("../utils/hex");
+const types_1 = require("../types");
+function makeTopic(topic) {
+    if (typeof topic === 'string') {
+        return (0, hex_1.makeHexString)(topic, types_1.TOPIC_HEX_LENGTH);
+    }
+    else if (topic instanceof Uint8Array) {
+        (0, bytes_1.assertBytes)(topic, types_1.TOPIC_BYTES_LENGTH);
+        return (0, hex_1.bytesToHex)(topic, types_1.TOPIC_HEX_LENGTH);
+    }
+    throw new TypeError('invalid topic');
+}
+exports.makeTopic = makeTopic;
+function makeTopicFromString(s) {
+    if (typeof s !== 'string') {
+        throw new TypeError('topic has to be string!');
+    }
+    return (0, hex_1.bytesToHex)((0, hash_1.keccak256Hash)(s), types_1.TOPIC_HEX_LENGTH);
+}
+exports.makeTopicFromString = makeTopicFromString;

package/dist/cjs/feed/type.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertFeedType = exports.isFeedType = exports.DEFAULT_FEED_TYPE = void 0;
+const feedTypes = ['sequence', 'epoch'];
+exports.DEFAULT_FEED_TYPE = 'sequence';
+function isFeedType(type) {
+    return typeof type === 'string' && feedTypes.includes(type);
+}
+exports.isFeedType = isFeedType;
+function assertFeedType(type) {
+    if (!isFeedType(type)) {
+        throw new TypeError('invalid feed type');
+    }
+}
+exports.assertFeedType = assertFeedType;

package/dist/cjs/index.js

@@ -0,0 +1,39 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BeeDebug = exports.Bee = exports.Utils = exports.SUPPORTED_BEE_VERSION_EXACT = exports.SUPPORTED_BEE_VERSION = void 0;
+const bee_1 = require("./bee");
+Object.defineProperty(exports, "Bee", { enumerable: true, get: function () { return bee_1.Bee; } });
+const bee_debug_1 = require("./bee-debug");
+Object.defineProperty(exports, "BeeDebug", { enumerable: true, get: function () { return bee_debug_1.BeeDebug; } });
+var status_1 = require("./modules/debug/status");
+Object.defineProperty(exports, "SUPPORTED_BEE_VERSION", { enumerable: true, get: function () { return status_1.SUPPORTED_BEE_VERSION; } });
+Object.defineProperty(exports, "SUPPORTED_BEE_VERSION_EXACT", { enumerable: true, get: function () { return status_1.SUPPORTED_BEE_VERSION_EXACT; } });
+__exportStar(require("./types"), exports);
+__exportStar(require("./utils/error"), exports);
+exports.Utils = __importStar(require("./utils/expose"));

package/dist/cjs/modules/bytes.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadReadable = exports.download = exports.upload = void 0;
+const bytes_1 = require("../utils/bytes");
+const headers_1 = require("../utils/headers");
+const http_1 = require("../utils/http");
+const type_1 = require("../utils/type");
+const endpoint = 'bytes';
+/**
+ * Upload data to a Bee node
+ *
+ * @param kyOptions Ky Options for making requests
+ * @param data            Data to be uploaded
+ * @param postageBatchId  Postage BatchId that will be assigned to uploaded data
+ * @param options         Additional options like tag, encryption, pinning
+ */
+async function upload(requestOptions, data, postageBatchId, options) {
+    const response = await (0, http_1.http)(requestOptions, {
+        url: endpoint,
+        method: 'post',
+        responseType: 'json',
+        data,
+        headers: {
+            'content-type': 'application/octet-stream',
+            ...(0, headers_1.extractUploadHeaders)(postageBatchId, options),
+        },
+    });
+    return {
+        reference: response.data.reference,
+        tagUid: (0, type_1.makeTagUid)(response.headers['swarm-tag']),
+    };
+}
+exports.upload = upload;
+/**
+ * Download data as a byte array
+ *
+ * @param ky
+ * @param hash Bee content reference
+ */
+async function download(requestOptions, hash) {
+    const response = await (0, http_1.http)(requestOptions, {
+        responseType: 'arraybuffer',
+        url: `${endpoint}/${hash}`,
+    });
+    return (0, bytes_1.wrapBytesWithHelpers)(new Uint8Array(response.data));
+}
+exports.download = download;
+/**
+ * Download data as a readable stream
+ *
+ * @param ky
+ * @param hash Bee content reference
+ */
+async function downloadReadable(requestOptions, hash) {
+    const response = await (0, http_1.http)(requestOptions, {
+        responseType: 'stream',
+        url: `${endpoint}/${hash}`,
+    });
+    return response.data;
+}
+exports.downloadReadable = downloadReadable;

package/dist/cjs/modules/bzz.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadCollection = exports.downloadFileReadable = exports.downloadFile = exports.uploadFile = void 0;
+const bytes_1 = require("../utils/bytes");
+const collection_1 = require("../utils/collection");
+const headers_1 = require("../utils/headers");
+const http_1 = require("../utils/http");
+const stream_1 = require("../utils/stream");
+const tar_1 = require("../utils/tar");
+const type_1 = require("../utils/type");
+const bzzEndpoint = 'bzz';
+function extractFileUploadHeaders(postageBatchId, options) {
+    const headers = (0, headers_1.extractUploadHeaders)(postageBatchId, options);
+    if (options?.size)
+        headers['content-length'] = String(options.size);
+    if (options?.contentType)
+        headers['content-type'] = options.contentType;
+    return headers;
+}
+/**
+ * Upload single file
+ *
+ * @param ky
+ * @param data Files data
+ * @param postageBatchId  Postage BatchId that will be assigned to uploaded data
+ * @param name Name that will be attached to the uploaded file. Wraps the data into manifest with set index document.
+ * @param options
+ */
+async function uploadFile(requestOptions, data, postageBatchId, name, options) {
+    if ((0, stream_1.isReadable)(data) && !options?.contentType) {
+        if (!options)
+            options = {};
+        options.contentType = 'application/octet-stream';
+    }
+    const response = await (0, http_1.http)(requestOptions, {
+        method: 'post',
+        url: bzzEndpoint,
+        data,
+        headers: {
+            ...extractFileUploadHeaders(postageBatchId, options),
+        },
+        params: { name },
+        responseType: 'json',
+    });
+    return {
+        reference: response.data.reference,
+        tagUid: (0, type_1.makeTagUid)(response.headers['swarm-tag']),
+    };
+}
+exports.uploadFile = uploadFile;
+/**
+ * Download single file as a buffer
+ *
+ * @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
+ */
+async function downloadFile(requestOptions, hash, path = '') {
+    const response = await (0, http_1.http)(requestOptions, {
+        method: 'GET',
+        responseType: 'arraybuffer',
+        url: `${bzzEndpoint}/${hash}/${path}`,
+    });
+    const file = {
+        ...(0, headers_1.readFileHeaders)(response.headers),
+        data: (0, bytes_1.wrapBytesWithHelpers)(new Uint8Array(response.data)),
+    };
+    return file;
+}
+exports.downloadFile = downloadFile;
+/**
+ * Download single file as a readable stream
+ *
+ * @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
+ */
+async function downloadFileReadable(requestOptions, hash, path = '') {
+    const response = await (0, http_1.http)(requestOptions, {
+        method: 'GET',
+        responseType: 'stream',
+        url: `${bzzEndpoint}/${hash}/${path}`,
+    });
+    const file = {
+        ...(0, headers_1.readFileHeaders)(response.headers),
+        data: response.data,
+    };
+    return file;
+}
+exports.downloadFileReadable = downloadFileReadable;
+function extractCollectionUploadHeaders(postageBatchId, options) {
+    const headers = (0, headers_1.extractUploadHeaders)(postageBatchId, options);
+    if (options?.indexDocument)
+        headers['swarm-index-document'] = options.indexDocument;
+    if (options?.errorDocument)
+        headers['swarm-error-document'] = options.errorDocument;
+    return headers;
+}
+/**
+ * Upload collection
+ * @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
+ */
+async function uploadCollection(requestOptions, collection, postageBatchId, options) {
+    (0, collection_1.assertCollection)(collection);
+    const tarData = (0, tar_1.makeTar)(collection);
+    const response = await (0, http_1.http)(requestOptions, {
+        method: 'post',
+        url: bzzEndpoint,
+        data: tarData,
+        responseType: 'json',
+        headers: {
+            'content-type': 'application/x-tar',
+            'swarm-collection': 'true',
+            ...extractCollectionUploadHeaders(postageBatchId, options),
+        },
+    });
+    return {
+        reference: response.data.reference,
+        tagUid: (0, type_1.makeTagUid)(response.headers['swarm-tag']),
+    };
+}
+exports.uploadCollection = uploadCollection;

package/dist/cjs/modules/chunk.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.download = exports.upload = void 0;
+const bytes_1 = require("../utils/bytes");
+const headers_1 = require("../utils/headers");
+const http_1 = require("../utils/http");
+const endpoint = 'chunks';
+/**
+ * Upload chunk to a Bee node
+ *
+ * The chunk data consists of 8 byte span and up to 4096 bytes of payload data.
+ * The span stores the length of the payload in uint64 little endian encoding.
+ * Upload expects the chuck data to be set accordingly.
+ *
+ * @param ky Ky instance
+ * @param data    Chunk data to be uploaded
+ * @param postageBatchId  Postage BatchId that will be assigned to uploaded data
+ * @param options Additional options like tag, encryption, pinning
+ */
+async function upload(requestOptions, data, postageBatchId, options) {
+    const response = await (0, http_1.http)(requestOptions, {
+        method: 'post',
+        url: `${endpoint}`,
+        data,
+        headers: {
+            'content-type': 'application/octet-stream',
+            ...(0, headers_1.extractUploadHeaders)(postageBatchId, options),
+        },
+        responseType: 'json',
+    });
+    return response.data.reference;
+}
+exports.upload = upload;
+/**
+ * Download chunk data as a byte array
+ *
+ * @param kyOptions Ky Options for making requests
+ * @param hash Bee content reference
+ *
+ */
+async function download(requestOptions, hash) {
+    const response = await (0, http_1.http)(requestOptions, {
+        responseType: 'arraybuffer',
+        url: `${endpoint}/${hash}`,
+    });
+    return (0, bytes_1.wrapBytesWithHelpers)(new Uint8Array(response.data));
+}
+exports.download = download;

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

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPastDueConsumptionPeerBalance = exports.getPastDueConsumptionBalances = exports.getPeerBalance = exports.getAllBalances = void 0;
+const http_1 = require("../../utils/http");
+const balancesEndpoint = 'balances';
+const consumedEndpoint = 'consumed';
+/**
+ * Get the balances with all known peers including prepaid services
+ *
+ * @param kyOptions Ky Options for making requests
+ */
+async function getAllBalances(requestOptions) {
+    const response = await (0, http_1.http)(requestOptions, {
+        url: balancesEndpoint,
+        responseType: 'json',
+    });
+    return response.data;
+}
+exports.getAllBalances = getAllBalances;
+/**
+ * Get the balances with a specific peer including prepaid services
+ *
+ * @param kyOptions Ky Options for making requests
+ * @param address Swarm address of peer
+ */
+async function getPeerBalance(requestOptions, address) {
+    const response = await (0, http_1.http)(requestOptions, {
+        url: `${balancesEndpoint}/${address}`,
+        responseType: 'json',
+    });
+    return response.data;
+}
+exports.getPeerBalance = getPeerBalance;
+/**
+ * Get the past due consumption balances with all known peers
+ *
+ * @param kyOptions Ky Options for making requests
+ */
+async function getPastDueConsumptionBalances(requestOptions) {
+    const response = await (0, http_1.http)(requestOptions, {
+        url: consumedEndpoint,
+        responseType: 'json',
+    });
+    return response.data;
+}
+exports.getPastDueConsumptionBalances = getPastDueConsumptionBalances;
+/**
+ * Get the past due consumption balance with a specific peer
+ *
+ * @param kyOptions Ky Options for making requests
+ * @param address Swarm address of peer
+ */
+async function getPastDueConsumptionPeerBalance(requestOptions, address) {
+    const response = await (0, http_1.http)(requestOptions, {
+        url: `${consumedEndpoint}/${address}`,
+        responseType: 'json',
+    });
+    return response.data;
+}
+exports.getPastDueConsumptionPeerBalance = getPastDueConsumptionPeerBalance;

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

@@ -0,0 +1,142 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withdrawTokens = exports.depositTokens = exports.getLastCheques = exports.getLastChequesForPeer = exports.cashoutLastCheque = exports.getLastCashoutAction = exports.getChequebookBalance = exports.getChequebookAddress = void 0;
+const http_1 = require("../../utils/http");
+const chequebookEndpoint = 'chequebook';
+/**
+ * Get the address of the chequebook contract used
+ *
+ * @param kyOptions Ky Options for making requests
+ */
+async function getChequebookAddress(requestOptions) {
+    const response = await (0, http_1.http)(requestOptions, {
+        url: chequebookEndpoint + '/address',
+        responseType: 'json',
+    });
+    return response.data;
+}
+exports.getChequebookAddress = getChequebookAddress;
+/**
+ * Get the balance of the chequebook
+ *
+ * @param kyOptions Ky Options for making requests
+ */
+async function getChequebookBalance(requestOptions) {
+    const response = await (0, http_1.http)(requestOptions, {
+        url: chequebookEndpoint + '/balance',
+        responseType: 'json',
+    });
+    return response.data;
+}
+exports.getChequebookBalance = getChequebookBalance;
+/**
+ * Get last cashout action for the peer
+ *
+ * @param kyOptions Ky Options for making requests
+ * @param peer  Swarm address of peer
+ */
+async function getLastCashoutAction(requestOptions, peer) {
+    const response = await (0, http_1.http)(requestOptions, {
+        url: chequebookEndpoint + `/cashout/${peer}`,
+        responseType: 'json',
+    });
+    return response.data;
+}
+exports.getLastCashoutAction = getLastCashoutAction;
+/**
+ * Cashout the last cheque for the peer
+ *
+ * @param kyOptions Ky Options for making requests
+ * @param peer  Swarm address of peer
+ * @param options
+ */
+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 (0, http_1.http)(requestOptions, {
+        method: 'post',
+        url: chequebookEndpoint + `/cashout/${peer}`,
+        responseType: 'json',
+        headers,
+    });
+    return response.data.transactionHash;
+}
+exports.cashoutLastCheque = cashoutLastCheque;
+/**
+ * Get last cheques for the peer
+ *
+ * @param kyOptions Ky Options for making requests
+ * @param peer  Swarm address of peer
+ */
+async function getLastChequesForPeer(requestOptions, peer) {
+    const response = await (0, http_1.http)(requestOptions, {
+        url: chequebookEndpoint + `/cheque/${peer}`,
+        responseType: 'json',
+    });
+    return response.data;
+}
+exports.getLastChequesForPeer = getLastChequesForPeer;
+/**
+ * Get last cheques for all peers
+ *
+ * @param kyOptions Ky Options for making requests
+ */
+async function getLastCheques(requestOptions) {
+    const response = await (0, http_1.http)(requestOptions, {
+        url: chequebookEndpoint + '/cheque',
+        responseType: 'json',
+    });
+    return response.data;
+}
+exports.getLastCheques = getLastCheques;
+/**
+ * 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
+ */
+async function depositTokens(requestOptions, amount, gasPrice) {
+    const headers = {};
+    if (gasPrice) {
+        headers['gas-price'] = gasPrice.toString();
+    }
+    const response = await (0, http_1.http)(requestOptions, {
+        method: 'post',
+        url: chequebookEndpoint + '/deposit',
+        responseType: 'json',
+        params: { amount: amount.toString(10) },
+        headers,
+    });
+    return response.data.transactionHash;
+}
+exports.depositTokens = depositTokens;
+/**
+ * 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
+ */
+async function withdrawTokens(requestOptions, amount, gasPrice) {
+    const headers = {};
+    if (gasPrice) {
+        headers['gas-price'] = gasPrice.toString();
+    }
+    const response = await (0, http_1.http)(requestOptions, {
+        method: 'post',
+        url: chequebookEndpoint + '/withdraw',
+        responseType: 'json',
+        params: { amount: amount.toString(10) },
+        headers,
+    });
+    return response.data.transactionHash;
+}
+exports.withdrawTokens = withdrawTokens;

package/dist/cjs/modules/debug/chunk.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteChunkFromLocalStorage = exports.checkIfChunkExistsLocally = void 0;
+const http_1 = require("../../utils/http");
+const endpoint = 'chunks';
+/**
+ * Check if chunk at address exists locally
+ *
+ * @param kyOptions Ky Options for making requests
+ * @param address  Swarm address of chunk
+ *
+ * @returns BeeGenericResponse if chunk is found or throws an exception
+ */
+async function checkIfChunkExistsLocally(requestOptions, address) {
+    const response = await (0, http_1.http)(requestOptions, {
+        url: `${endpoint}/${address}`,
+        responseType: 'json',
+    });
+    return response.data;
+}
+exports.checkIfChunkExistsLocally = checkIfChunkExistsLocally;
+/**
+ * Delete a chunk from local storage
+ *
+ * @param kyOptions Ky Options for making requests
+ * @param address  Swarm address of chunk
+ *
+ * @returns BeeGenericResponse if chunk was deleted or throws an exception
+ */
+async function deleteChunkFromLocalStorage(requestOptions, address) {
+    const response = await (0, http_1.http)(requestOptions, {
+        method: 'delete',
+        url: `${endpoint}/${address}`,
+        responseType: 'json',
+    });
+    return response.data;
+}
+exports.deleteChunkFromLocalStorage = deleteChunkFromLocalStorage;

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

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pingPeer = exports.getTopology = exports.removePeer = exports.getBlocklist = exports.getPeers = exports.getNodeAddresses = void 0;
+const http_1 = require("../../utils/http");
+async function getNodeAddresses(requestOptions) {
+    const response = await (0, http_1.http)(requestOptions, {
+        url: 'addresses',
+        responseType: 'json',
+    });
+    return response.data;
+}
+exports.getNodeAddresses = getNodeAddresses;
+async function getPeers(requestOptions) {
+    const response = await (0, http_1.http)(requestOptions, {
+        url: 'peers',
+        responseType: 'json',
+    });
+    return response.data.peers;
+}
+exports.getPeers = getPeers;
+async function getBlocklist(requestOptions) {
+    const response = await (0, http_1.http)(requestOptions, {
+        url: 'blocklist',
+        responseType: 'json',
+    });
+    return response.data.peers;
+}
+exports.getBlocklist = getBlocklist;
+async function removePeer(requestOptions, peer) {
+    const response = await (0, http_1.http)(requestOptions, {
+        url: `peers/${peer}`,
+        responseType: 'json',
+        method: 'DELETE',
+    });
+    return response.data;
+}
+exports.removePeer = removePeer;
+async function getTopology(requestOptions) {
+    const response = await (0, http_1.http)(requestOptions, {
+        url: `topology`,
+        responseType: 'json',
+    });
+    return response.data;
+}
+exports.getTopology = getTopology;
+async function pingPeer(requestOptions, peer) {
+    const response = await (0, http_1.http)(requestOptions, {
+        url: `pingpong/${peer}`,
+        responseType: 'json',
+        method: 'POST',
+    });
+    return response.data;
+}
+exports.pingPeer = pingPeer;