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

package/dist/cjs/utils/eth.js

@@ -0,0 +1,199 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeEthereumWalletSigner = exports.ethToSwarmAddress = exports.fromLittleEndian = exports.toLittleEndian = exports.isHexEthAddress = exports.makeHexEthAddress = exports.makeEthAddress = void 0;
+// For ESM compatibility
+const js_sha3_1 = __importDefault(require("js-sha3"));
+const { keccak256, sha3_256 } = js_sha3_1.default;
+const hex_1 = require("./hex");
+const bytes_1 = require("./bytes");
+const ETH_ADDR_BYTES_LENGTH = 20;
+const ETH_ADDR_HEX_LENGTH = 40;
+function makeEthAddress(address) {
+    if (typeof address === 'string') {
+        const hexAddr = (0, hex_1.makeHexString)(address, ETH_ADDR_HEX_LENGTH);
+        const ownerBytes = (0, hex_1.hexToBytes)(hexAddr);
+        (0, bytes_1.assertBytes)(ownerBytes, ETH_ADDR_BYTES_LENGTH);
+        return ownerBytes;
+    }
+    else if (address instanceof Uint8Array) {
+        (0, bytes_1.assertBytes)(address, ETH_ADDR_BYTES_LENGTH);
+        return address;
+    }
+    throw new TypeError('Invalid EthAddress');
+}
+exports.makeEthAddress = makeEthAddress;
+function makeHexEthAddress(address) {
+    try {
+        return (0, hex_1.makeHexString)(address, ETH_ADDR_HEX_LENGTH);
+    }
+    catch (e) {
+        if (e instanceof TypeError) {
+            e.message = `Invalid HexEthAddress: ${e.message}`;
+        }
+        throw e;
+    }
+}
+exports.makeHexEthAddress = makeHexEthAddress;
+/**
+ * Check if this is all caps or small caps eth address (=address without checksum)
+ *
+ * @param address Ethereum address as hex string
+ */
+function isEthAddrCaseIns(address) {
+    // Check it's string, all small caps or all all caps hex and 40 chars long without the `0x` prefix
+    return (typeof address === 'string' && (/^(0x|0X)?[0-9a-f]{40}$/.test(address) || /^(0x|0X)?[0-9A-F]{40}$/.test(address)));
+}
+/**
+ * Check if this is checksummed ethereum address
+ *
+ * @param address Ethereum address as hex string
+ */
+function isValidChecksummedEthAddress(address) {
+    try {
+        // Check for valid case insensitive hex type string, 40 chars
+        const addr = (0, hex_1.makeHexString)(address, ETH_ADDR_HEX_LENGTH);
+        // Check the checksum
+        const addressHash = keccak256(addr.toLowerCase());
+        for (let i = 0; i < 40; i += 1) {
+            // the nth letter should be uppercase if the nth digit of casemap is 1
+            if ((parseInt(addressHash[i], 16) > 7 && addr[i].toUpperCase() !== addr[i]) ||
+                (parseInt(addressHash[i], 16) <= 7 && addr[i].toLowerCase() !== addr[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    catch (e) {
+        if (e instanceof TypeError) {
+            return false;
+        }
+        throw e;
+    }
+}
+/**
+ * Check if is valid ethereum address
+ *
+ * Pretty much typed version from web3js
+ * https://github.com/ChainSafe/web3.js/blob/1.x/packages/web3-utils/src/utils.js
+ *
+ * @param address  Ethereum address as hex string
+ *
+ * @return True if is valid eth address
+ */
+function isHexEthAddress(address) {
+    return isEthAddrCaseIns(address) || isValidChecksummedEthAddress(address);
+}
+exports.isHexEthAddress = isHexEthAddress;
+/**
+ * Convert big-endian hex or number to little-endian.
+ * Note: Before conversion it is automatically padded to even length hexstring
+ *
+ * @param bigEndian Big-endian hex string or number to convert
+ * @param pad       Length to which the string should be padded before conversion (defaul: 2)
+ *
+ * @return little-endian encoded hexstring
+ */
+function toLittleEndian(bigEndian, pad = 2) {
+    if (!(Number.isInteger(pad) && pad >= 2 && pad % 2 === 0)) {
+        throw new TypeError('minimal padding for conversion needs to be positive even integer');
+    }
+    let hexRep;
+    if (typeof bigEndian === 'string')
+        hexRep = (0, hex_1.makeHexString)(bigEndian);
+    else if (typeof bigEndian === 'number')
+        hexRep = (0, hex_1.intToHex)(bigEndian);
+    else
+        throw new TypeError('incorrect input type');
+    hexRep = hexRep.padStart(pad, '0');
+    // Extend to an even length hexstring
+    if (hexRep.length % 2 !== 0)
+        hexRep = hexRep.padStart(hexRep.length + 1, '0');
+    // Match all two pairs in the hexstring, reverse the pairs and join it again
+    const littleEndian = hexRep.match(/../g)?.reverse().join('');
+    if (littleEndian)
+        return littleEndian;
+    throw new Error('failed to convert');
+}
+exports.toLittleEndian = toLittleEndian;
+/**
+ * Convert little-endian hex or number to big-endian
+ * Note: Before conversion it is automatically padded to even length hexstring
+ *
+ * @param littleEndian Little-endian hex string or number to convert
+ * @param pad          Length to which the string should be padded before conversion (defaul: 2)
+ *
+ * @return big-endian encoded hexstring
+ */
+function fromLittleEndian(littleEndian, pad = 2) {
+    // It's a reversible function
+    return toLittleEndian(littleEndian, pad);
+}
+exports.fromLittleEndian = fromLittleEndian;
+function assertEthAddress(ethAddress) {
+    if (!isHexEthAddress(ethAddress))
+        throw new TypeError('invalid ETH address');
+}
+function assertSwarmNetworkId(networkId) {
+    if (Number.isInteger(networkId && networkId > 0 && networkId < Number.MAX_SAFE_INTEGER)) {
+        throw new TypeError('swarm network id must be positive integer');
+    }
+}
+/**
+ * Get swarm overlay address from public ethereum address and swarm network id
+ *
+ * @param ethAddress  Public ethereum address
+ * @param networkId   Swarm network id
+ *
+ * @return Swarm overlay address
+ */
+function ethToSwarmAddress(ethAddress, networkId = 1) {
+    assertEthAddress(ethAddress);
+    assertSwarmNetworkId(networkId);
+    const hex = `${(0, hex_1.makeHexString)(ethAddress)}${toLittleEndian(networkId, 16)}`;
+    (0, hex_1.assertHexString)(hex);
+    const overlayAddress = sha3_256((0, hex_1.hexToBytes)(hex));
+    return overlayAddress;
+}
+exports.ethToSwarmAddress = ethToSwarmAddress;
+/**
+ * Function that takes Ethereum EIP-1193 compatible provider and create an Signer instance that
+ * uses `personal_sign` method to sign requested data.
+ *
+ * @param provider Injected web3 provider like window.ethereum or other compatible with EIP-1193
+ * @param ethAddress Optional address of the account which the data should be signed with. If not specified `eth_requestAccounts` request is used to get the account address.
+ */
+async function makeEthereumWalletSigner(provider, ethAddress) {
+    let executorFnc;
+    if (typeof provider !== 'object' || provider === null) {
+        throw new TypeError('We need JsonRPC provider object!');
+    }
+    if (provider.request) {
+        executorFnc = provider.request;
+    }
+    else if (provider.sendAsync) {
+        executorFnc = provider.sendAsync;
+    }
+    else {
+        throw new Error('Incompatible interface of given provider!');
+    }
+    if (!ethAddress) {
+        ethAddress = (await executorFnc({ method: 'eth_requestAccounts' }))[0];
+    }
+    const bytesEthAddress = makeEthAddress(ethAddress);
+    const hexEthAddress = makeHexEthAddress(ethAddress);
+    return {
+        address: bytesEthAddress,
+        sign: async (data) => {
+            const result = await executorFnc({
+                jsonrpc: '2.0',
+                method: 'personal_sign',
+                params: ['0x' + data.hex(), '0x' + hexEthAddress],
+            });
+            return result;
+        },
+    };
+}
+exports.makeEthereumWalletSigner = makeEthereumWalletSigner;

package/dist/cjs/utils/expose.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStampUsage = exports.makeMaxTarget = exports.keccak256Hash = exports.isReadable = exports.normalizeToReadableStream = exports.isNodeReadable = exports.isReadableStream = exports.readableNodeToWeb = exports.readableWebToNode = exports.makeEthereumWalletSigner = exports.fromLittleEndian = exports.toLittleEndian = exports.ethToSwarmAddress = exports.isHexEthAddress = exports.makeHexEthAddress = exports.makeEthAddress = exports.assertPrefixedHexString = exports.assertHexString = exports.isHexString = exports.intToHex = exports.bytesToHex = exports.hexToBytes = exports.makeHexString = exports.bytesEqual = exports.flexBytesAtOffset = exports.bytesAtOffset = exports.assertFlexBytes = exports.isFlexBytes = exports.assertBytes = exports.isBytes = exports.getFolderSize = exports.getCollectionSize = void 0;
+var collection_1 = require("./collection");
+Object.defineProperty(exports, "getCollectionSize", { enumerable: true, get: function () { return collection_1.getCollectionSize; } });
+var collection_node_1 = require("./collection.node");
+Object.defineProperty(exports, "getFolderSize", { enumerable: true, get: function () { return collection_node_1.getFolderSize; } });
+var bytes_1 = require("./bytes");
+Object.defineProperty(exports, "isBytes", { enumerable: true, get: function () { return bytes_1.isBytes; } });
+Object.defineProperty(exports, "assertBytes", { enumerable: true, get: function () { return bytes_1.assertBytes; } });
+Object.defineProperty(exports, "isFlexBytes", { enumerable: true, get: function () { return bytes_1.isFlexBytes; } });
+Object.defineProperty(exports, "assertFlexBytes", { enumerable: true, get: function () { return bytes_1.assertFlexBytes; } });
+Object.defineProperty(exports, "bytesAtOffset", { enumerable: true, get: function () { return bytes_1.bytesAtOffset; } });
+Object.defineProperty(exports, "flexBytesAtOffset", { enumerable: true, get: function () { return bytes_1.flexBytesAtOffset; } });
+Object.defineProperty(exports, "bytesEqual", { enumerable: true, get: function () { return bytes_1.bytesEqual; } });
+var hex_1 = require("./hex");
+Object.defineProperty(exports, "makeHexString", { enumerable: true, get: function () { return hex_1.makeHexString; } });
+Object.defineProperty(exports, "hexToBytes", { enumerable: true, get: function () { return hex_1.hexToBytes; } });
+Object.defineProperty(exports, "bytesToHex", { enumerable: true, get: function () { return hex_1.bytesToHex; } });
+Object.defineProperty(exports, "intToHex", { enumerable: true, get: function () { return hex_1.intToHex; } });
+Object.defineProperty(exports, "isHexString", { enumerable: true, get: function () { return hex_1.isHexString; } });
+Object.defineProperty(exports, "assertHexString", { enumerable: true, get: function () { return hex_1.assertHexString; } });
+Object.defineProperty(exports, "assertPrefixedHexString", { enumerable: true, get: function () { return hex_1.assertPrefixedHexString; } });
+var eth_1 = require("./eth");
+Object.defineProperty(exports, "makeEthAddress", { enumerable: true, get: function () { return eth_1.makeEthAddress; } });
+Object.defineProperty(exports, "makeHexEthAddress", { enumerable: true, get: function () { return eth_1.makeHexEthAddress; } });
+Object.defineProperty(exports, "isHexEthAddress", { enumerable: true, get: function () { return eth_1.isHexEthAddress; } });
+Object.defineProperty(exports, "ethToSwarmAddress", { enumerable: true, get: function () { return eth_1.ethToSwarmAddress; } });
+Object.defineProperty(exports, "toLittleEndian", { enumerable: true, get: function () { return eth_1.toLittleEndian; } });
+Object.defineProperty(exports, "fromLittleEndian", { enumerable: true, get: function () { return eth_1.fromLittleEndian; } });
+Object.defineProperty(exports, "makeEthereumWalletSigner", { enumerable: true, get: function () { return eth_1.makeEthereumWalletSigner; } });
+var stream_1 = require("./stream");
+Object.defineProperty(exports, "readableWebToNode", { enumerable: true, get: function () { return stream_1.readableWebToNode; } });
+Object.defineProperty(exports, "readableNodeToWeb", { enumerable: true, get: function () { return stream_1.readableNodeToWeb; } });
+Object.defineProperty(exports, "isReadableStream", { enumerable: true, get: function () { return stream_1.isReadableStream; } });
+Object.defineProperty(exports, "isNodeReadable", { enumerable: true, get: function () { return stream_1.isNodeReadable; } });
+Object.defineProperty(exports, "normalizeToReadableStream", { enumerable: true, get: function () { return stream_1.normalizeToReadableStream; } });
+Object.defineProperty(exports, "isReadable", { enumerable: true, get: function () { return stream_1.isReadable; } });
+var hash_1 = require("./hash");
+Object.defineProperty(exports, "keccak256Hash", { enumerable: true, get: function () { return hash_1.keccak256Hash; } });
+var pss_1 = require("./pss");
+Object.defineProperty(exports, "makeMaxTarget", { enumerable: true, get: function () { return pss_1.makeMaxTarget; } });
+var stamps_1 = require("./stamps");
+Object.defineProperty(exports, "getStampUsage", { enumerable: true, get: function () { return stamps_1.getStampUsage; } });

package/dist/cjs/utils/file.js

@@ -0,0 +1,38 @@
+"use strict";
+/**
+ * Compatibility functions for working with File API objects
+ *
+ * https://developer.mozilla.org/en-US/docs/Web/API/File
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fileArrayBuffer = exports.isFile = void 0;
+function isFile(file) {
+    // browser
+    if (typeof File === 'function') {
+        return file instanceof File;
+    }
+    // node.js
+    const f = file;
+    return (typeof f === 'object' &&
+        typeof f.name === 'string' &&
+        (typeof f.stream === 'function' || typeof f.arrayBuffer === 'function'));
+}
+exports.isFile = isFile;
+/**
+ * Compatibility helper for browsers where the `arrayBuffer function is
+ * missing from `File` objects.
+ *
+ * @param file A File object
+ */
+async function fileArrayBuffer(file) {
+    if (file.arrayBuffer) {
+        return file.arrayBuffer();
+    }
+    // workaround for Safari where arrayBuffer is not supported on Files
+    return new Promise(resolve => {
+        const fr = new FileReader();
+        fr.onload = () => resolve(fr.result);
+        fr.readAsArrayBuffer(file);
+    });
+}
+exports.fileArrayBuffer = fileArrayBuffer;

package/dist/cjs/utils/hash.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keccak256Hash = void 0;
+// For ESM compatibility
+const js_sha3_1 = __importDefault(require("js-sha3"));
+const { keccak256 } = js_sha3_1.default;
+/**
+ * Helper function for calculating the keccak256 hash with
+ * correct types.
+ *
+ * @param messages Any number of messages (strings, byte arrays etc.)
+ */
+function keccak256Hash(...messages) {
+    const hasher = keccak256.create();
+    messages.forEach(bytes => hasher.update(bytes));
+    return Uint8Array.from(hasher.digest());
+}
+exports.keccak256Hash = keccak256Hash;

package/dist/cjs/utils/headers.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractUploadHeaders = exports.readFileHeaders = void 0;
+const error_1 = require("./error");
+/**
+ * Read the filename from the content-disposition header
+ * See https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Disposition
+ *
+ * @param header the content-disposition header value
+ *
+ * @returns the filename
+ */
+function readContentDispositionFilename(header) {
+    if (!header) {
+        throw new error_1.BeeError('missing content-disposition header');
+    }
+    // Regex was found here
+    // https://stackoverflow.com/questions/23054475/javascript-regex-for-extracting-filename-from-content-disposition-header
+    const dispositionMatch = header.match(/filename\*?=['"]?(?:UTF-\d['"]*)?([^;\r\n"']*)['"]?;?/i);
+    if (dispositionMatch && dispositionMatch.length > 0) {
+        return dispositionMatch[1];
+    }
+    throw new error_1.BeeError('invalid content-disposition header');
+}
+function readTagUid(header) {
+    if (!header) {
+        return undefined;
+    }
+    return parseInt(header, 10);
+}
+function readFileHeaders(headers) {
+    const name = readContentDispositionFilename(headers['content-disposition']);
+    const tagUid = readTagUid(headers['swarm-tag-uid']);
+    const contentType = headers['content-type'] || undefined;
+    return {
+        name,
+        tagUid,
+        contentType,
+    };
+}
+exports.readFileHeaders = readFileHeaders;
+function extractUploadHeaders(postageBatchId, options) {
+    if (!postageBatchId) {
+        throw new error_1.BeeError('Postage BatchID has to be specified!');
+    }
+    const headers = {
+        'swarm-postage-batch-id': postageBatchId,
+    };
+    if (options?.pin)
+        headers['swarm-pin'] = String(options.pin);
+    if (options?.encrypt)
+        headers['swarm-encrypt'] = String(options.encrypt);
+    if (options?.tag)
+        headers['swarm-tag'] = String(options.tag);
+    if (typeof options?.deferred === 'boolean')
+        headers['swarm-deferred-upload'] = options.deferred.toString();
+    return headers;
+}
+exports.extractUploadHeaders = extractUploadHeaders;

package/dist/cjs/utils/hex.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertPrefixedHexString = exports.assertHexString = exports.isPrefixedHexString = exports.isHexString = exports.intToHex = exports.bytesToHex = exports.hexToBytes = exports.makeHexString = void 0;
+const bytes_1 = require("./bytes");
+/**
+ * Creates unprefixed hex string from wide range of data.
+ *
+ * TODO: Make Length mandatory: https://github.com/ethersphere/bee-js/issues/208
+ *
+ * @param input
+ * @param len of the resulting HexString WITHOUT prefix!
+ */
+function makeHexString(input, len) {
+    if (typeof input === 'number') {
+        return intToHex(input, len);
+    }
+    if (input instanceof Uint8Array) {
+        return bytesToHex(input, len);
+    }
+    if (typeof input === 'string') {
+        if (isPrefixedHexString(input)) {
+            const hex = input.slice(2);
+            if (len && hex.length !== len) {
+                throw new TypeError(`Length mismatch for valid hex string. Expecting length ${len}: ${hex}`);
+            }
+            return hex;
+        }
+        else {
+            // We use assertHexString() as there might be more reasons why a string is not valid hex string
+            // and usage of isHexString() would not give enough information to the user on what is going
+            // wrong.
+            assertHexString(input, len);
+            return input;
+        }
+    }
+    throw new TypeError('Not HexString compatible type!');
+}
+exports.makeHexString = makeHexString;
+/**
+ * Converts a hex string to Uint8Array
+ *
+ * @param hex string input without 0x prefix!
+ */
+function hexToBytes(hex) {
+    assertHexString(hex);
+    const bytes = (0, bytes_1.makeBytes)(hex.length / 2);
+    for (let i = 0; i < bytes.length; i++) {
+        const hexByte = hex.substr(i * 2, 2);
+        bytes[i] = parseInt(hexByte, 16);
+    }
+    return bytes;
+}
+exports.hexToBytes = hexToBytes;
+/**
+ * Converts array of number or Uint8Array to HexString without prefix.
+ *
+ * @param bytes   The input array
+ * @param len     The length of the non prefixed HexString
+ */
+function bytesToHex(bytes, len) {
+    const hexByte = (n) => n.toString(16).padStart(2, '0');
+    const hex = Array.from(bytes, hexByte).join('');
+    // TODO: Make Length mandatory: https://github.com/ethersphere/bee-js/issues/208
+    if (len && hex.length !== len) {
+        throw new TypeError(`Resulting HexString does not have expected length ${len}: ${hex}`);
+    }
+    return hex;
+}
+exports.bytesToHex = bytesToHex;
+/**
+ * Converts integer number to hex string.
+ *
+ * Optionally provides '0x' prefix or padding
+ *
+ * @param int         The positive integer to be converted
+ * @param len     The length of the non prefixed HexString
+ */
+function intToHex(int, len) {
+    if (!Number.isInteger(int))
+        throw new TypeError('the value provided is not integer');
+    if (int > Number.MAX_SAFE_INTEGER)
+        throw new TypeError('the value provided exceeds safe integer');
+    if (int < 0)
+        throw new TypeError('the value provided is a negative integer');
+    const hex = int.toString(16);
+    // TODO: Make Length mandatory: https://github.com/ethersphere/bee-js/issues/208
+    if (len && hex.length !== len) {
+        throw new TypeError(`Resulting HexString does not have expected length ${len}: ${hex}`);
+    }
+    return hex;
+}
+exports.intToHex = intToHex;
+/**
+ * Type guard for HexStrings.
+ * Requires no 0x prefix!
+ *
+ * TODO: Make Length mandatory: https://github.com/ethersphere/bee-js/issues/208
+ *
+ * @param s string input
+ * @param len expected length of the HexString
+ */
+function isHexString(s, len) {
+    return typeof s === 'string' && /^[0-9a-f]+$/i.test(s) && (!len || s.length === len);
+}
+exports.isHexString = isHexString;
+/**
+ * Type guard for PrefixedHexStrings.
+ * Does enforce presence of 0x prefix!
+ *
+ * @param s string input
+ */
+function isPrefixedHexString(s) {
+    return typeof s === 'string' && /^0x[0-9a-f]+$/i.test(s);
+}
+exports.isPrefixedHexString = isPrefixedHexString;
+/**
+ * Verifies if the provided input is a HexString.
+ *
+ * TODO: Make Length mandatory: https://github.com/ethersphere/bee-js/issues/208
+ *
+ * @param s string input
+ * @param len expected length of the HexString
+ * @param name optional name for the asserted value
+ * @returns HexString or throws error
+ */
+function assertHexString(s, len, name = 'value') {
+    if (!isHexString(s, len)) {
+        if (isPrefixedHexString(s)) {
+            throw new TypeError(`${name} not valid non prefixed hex string (has 0x prefix): ${s}`);
+        }
+        // Don't display length error if no length specified in order not to confuse user
+        const lengthMsg = len ? ` of length ${len}` : '';
+        throw new TypeError(`${name} not valid hex string${lengthMsg}: ${s}`);
+    }
+}
+exports.assertHexString = assertHexString;
+/**
+ * Verifies if the provided input is a PrefixedHexString.
+ *
+ * @param s string input
+ * @param len expected length of the HexString
+ * @param name optional name for the asserted value
+ * @returns HexString or throws error
+ */
+function assertPrefixedHexString(s, name = 'value') {
+    if (!isPrefixedHexString(s)) {
+        throw new TypeError(`${name} not valid prefixed hex string: ${s}`);
+    }
+}
+exports.assertPrefixedHexString = assertPrefixedHexString;

package/dist/cjs/utils/http.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.http = exports.DEFAULT_HTTP_CONFIG = void 0;
+const axios_1 = __importDefault(require("axios"));
+const cafe_utility_1 = require("cafe-utility");
+exports.DEFAULT_HTTP_CONFIG = {
+    headers: {
+        accept: 'application/json, text/plain, */*',
+    },
+};
+/**
+ * Main function to make HTTP requests.
+ * @param options User defined settings
+ * @param config Internal settings and/or Bee settings
+ */
+async function http(options, config) {
+    try {
+        const requestConfig = cafe_utility_1.Objects.deepMerge3(exports.DEFAULT_HTTP_CONFIG, config, options);
+        maybeRunOnRequestHook(options, requestConfig);
+        const response = await (0, axios_1.default)(requestConfig);
+        return response;
+    }
+    catch (e) {
+        throw e;
+    }
+}
+exports.http = http;
+function maybeRunOnRequestHook(options, requestConfig) {
+    if (options.onRequest) {
+        options.onRequest({
+            method: requestConfig.method || 'GET',
+            url: cafe_utility_1.Strings.joinUrl(requestConfig.baseURL, requestConfig.url),
+            headers: { ...requestConfig.headers },
+            params: requestConfig.params,
+        });
+    }
+}

package/dist/cjs/utils/pss.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeMaxTarget = void 0;
+const types_1 = require("../types");
+/**
+ * Utility function that for given strings/reference takes the most specific
+ * target that Bee node will except.
+ *
+ * @param target is a non-prefixed hex string Bee address
+ * @see [Bee docs - PSS](https://docs.ethswarm.org/docs/dapps-on-swarm/pss)
+ */
+function makeMaxTarget(target) {
+    if (typeof target !== 'string') {
+        throw new TypeError('target has to be an string!');
+    }
+    return target.slice(0, types_1.PSS_TARGET_HEX_LENGTH_MAX);
+}
+exports.makeMaxTarget = makeMaxTarget;

package/dist/cjs/utils/reference.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeBytesReference = void 0;
+const types_1 = require("../types");
+const bytes_1 = require("./bytes");
+const hex_1 = require("./hex");
+function makeBytesReference(reference, offset = 0) {
+    if (typeof reference === 'string') {
+        if (offset) {
+            throw new Error('Offset property can be set only for UintArray reference!');
+        }
+        try {
+            // Non-encrypted chunk hex string reference
+            const hexReference = (0, hex_1.makeHexString)(reference, types_1.REFERENCE_HEX_LENGTH);
+            return (0, hex_1.hexToBytes)(hexReference);
+        }
+        catch (e) {
+            if (!(e instanceof TypeError)) {
+                throw e;
+            }
+            // Encrypted chunk hex string reference
+            const hexReference = (0, hex_1.makeHexString)(reference, types_1.ENCRYPTED_REFERENCE_HEX_LENGTH);
+            return (0, hex_1.hexToBytes)(hexReference);
+        }
+    }
+    else if (reference instanceof Uint8Array) {
+        if ((0, bytes_1.hasBytesAtOffset)(reference, offset, types_1.ENCRYPTED_REFERENCE_BYTES_LENGTH)) {
+            return (0, bytes_1.bytesAtOffset)(reference, offset, types_1.ENCRYPTED_REFERENCE_BYTES_LENGTH);
+        }
+        else if ((0, bytes_1.hasBytesAtOffset)(reference, offset, types_1.REFERENCE_BYTES_LENGTH)) {
+            return (0, bytes_1.bytesAtOffset)(reference, offset, types_1.REFERENCE_BYTES_LENGTH);
+        }
+    }
+    throw new TypeError('invalid chunk reference');
+}
+exports.makeBytesReference = makeBytesReference;

package/dist/cjs/utils/stamps.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStampUsage = void 0;
+/**
+ * Utility function that calculates usage of postage batch based on its utilization, depth and bucket depth.
+ *
+ * Be aware for small depths (17, 18) this does not provide that much information as the provided set of distinct values
+ * is small.
+ *
+ * @param utilization
+ * @param depth
+ * @param bucketDepth
+ */
+function getStampUsage({ utilization, depth, bucketDepth }) {
+    return utilization / Math.pow(2, depth - bucketDepth);
+}
+exports.getStampUsage = getStampUsage;