@ethersphere/bee-js 3.0.0 → 3.3.1

package/dist/cjs/utils/collection.node.js

@@ -0,0 +1,115 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFolderSize = exports.makeCollectionFromFS = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/**
+ * Creates array in the format of Collection with data loaded from directory on filesystem.
+ * The function loads all the data into memory!
+ *
+ * @param dir path to the directory
+ */
+function makeCollectionFromFS(dir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (typeof dir !== 'string') {
+            throw new TypeError('dir has to be string!');
+        }
+        if (dir === '') {
+            throw new TypeError('dir must not be empty string!');
+        }
+        return buildCollectionRelative(dir, '');
+    });
+}
+exports.makeCollectionFromFS = makeCollectionFromFS;
+function buildCollectionRelative(dir, relativePath) {
+    var e_1, _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        // Handles case when the dir is not existing or it is a file ==> throws an error
+        const dirname = path_1.default.join(dir, relativePath);
+        const entries = yield fs_1.default.promises.opendir(dirname);
+        let collection = [];
+        try {
+            for (var entries_1 = __asyncValues(entries), entries_1_1; entries_1_1 = yield entries_1.next(), !entries_1_1.done;) {
+                const entry = entries_1_1.value;
+                const fullPath = path_1.default.join(dir, relativePath, entry.name);
+                const entryPath = path_1.default.join(relativePath, entry.name);
+                if (entry.isFile()) {
+                    collection.push({
+                        path: entryPath,
+                        data: new Uint8Array(yield fs_1.default.promises.readFile(fullPath)),
+                    });
+                }
+                else if (entry.isDirectory()) {
+                    collection = [...(yield buildCollectionRelative(dir, entryPath)), ...collection];
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (entries_1_1 && !entries_1_1.done && (_a = entries_1.return)) yield _a.call(entries_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return collection;
+    });
+}
+/**
+ * Calculate folder size recursively
+ *
+ * @param dir the path to the folder to check
+ * @returns size in bytes
+ */
+function getFolderSize(dir) {
+    var e_2, _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        if (typeof dir !== 'string') {
+            throw new TypeError('dir has to be string!');
+        }
+        if (dir === '') {
+            throw new TypeError('dir must not be empty string!');
+        }
+        const entries = yield fs_1.default.promises.opendir(dir);
+        let size = 0;
+        try {
+            for (var entries_2 = __asyncValues(entries), entries_2_1; entries_2_1 = yield entries_2.next(), !entries_2_1.done;) {
+                const entry = entries_2_1.value;
+                if (entry.isFile()) {
+                    const stats = yield fs_1.default.promises.stat(path_1.default.join(dir, entry.name));
+                    size += stats.size;
+                }
+                else if (entry.isDirectory()) {
+                    size += yield getFolderSize(path_1.default.join(dir, entry.name));
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (entries_2_1 && !entries_2_1.done && (_a = entries_2.return)) yield _a.call(entries_2);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return size;
+    });
+}
+exports.getFolderSize = getFolderSize;

package/dist/cjs/utils/data.browser.js

@@ -0,0 +1,78 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareWebsocketData = exports.prepareData = void 0;
+const stream_1 = require("./stream");
+const cross_blob_1 = __importDefault(require("cross-blob"));
+/**
+ * Validates input and converts to Uint8Array
+ *
+ * @param data any string, ArrayBuffer or Uint8Array
+ */
+function prepareData(data) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (typeof data === 'string')
+            return new cross_blob_1.default([data], { type: 'text/plain' });
+        if (data instanceof Uint8Array || data instanceof ArrayBuffer) {
+            return new cross_blob_1.default([data], { type: 'application/octet-stream' });
+        }
+        if (data instanceof cross_blob_1.default) {
+            return data;
+        }
+        // Currently it is not possible to stream requests from browsers
+        // there are already first experiments on this field (Chromium)
+        // but till it is fully implemented across browsers-land we have to
+        // buffer the data before sending the requests.
+        if ((0, stream_1.isNodeReadable)(data)) {
+            return new Promise(resolve => {
+                const buffers = [];
+                data.on('data', d => {
+                    buffers.push(d);
+                });
+                data.on('end', () => {
+                    resolve(new cross_blob_1.default(buffers, { type: 'application/octet-stream' }));
+                });
+            });
+        }
+        if ((0, stream_1.isReadableStream)(data)) {
+            return new Promise((resolve) => __awaiter(this, void 0, void 0, function* () {
+                const reader = data.getReader();
+                const buffers = [];
+                let done, value;
+                do {
+                    ;
+                    ({ done, value } = yield reader.read());
+                    if (!done) {
+                        buffers.push(value);
+                    }
+                } while (!done);
+                resolve(new cross_blob_1.default(buffers, { type: 'application/octet-stream' }));
+            }));
+        }
+        throw new TypeError('unknown data type');
+    });
+}
+exports.prepareData = prepareData;
+function prepareWebsocketData(data) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (typeof data === 'string')
+            return new TextEncoder().encode(data);
+        if (data instanceof ArrayBuffer)
+            return new Uint8Array(data);
+        if (data instanceof cross_blob_1.default)
+            return new Uint8Array(yield new Response(data).arrayBuffer());
+        throw new TypeError('unknown websocket data type');
+    });
+}
+exports.prepareWebsocketData = prepareWebsocketData;

package/dist/cjs/utils/data.js

@@ -0,0 +1,60 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareWebsocketData = exports.prepareData = void 0;
+const cross_blob_1 = __importDefault(require("cross-blob"));
+const stream_1 = require("./stream");
+/**
+ * Prepare data for valid input for node-fetch.
+ *
+ * node-fetch is not using WHATWG ReadableStream but NodeJS Readable so we need to convert in case of ReadableStream,
+ * but the typings are set to use ReadableStream so hence why type conversion here.
+ *
+ * @param data any string, ArrayBuffer, Uint8Array or Readable
+ */
+function prepareData(data) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (typeof data === 'string')
+            return new cross_blob_1.default([data], { type: 'text/plain' });
+        if (data instanceof Uint8Array || data instanceof ArrayBuffer) {
+            return new cross_blob_1.default([data], { type: 'application/octet-stream' });
+        }
+        if (data instanceof cross_blob_1.default || (0, stream_1.isNodeReadable)(data))
+            return data;
+        if ((0, stream_1.isReadableStream)(data)) {
+            return (0, stream_1.readableWebToNode)(data);
+        }
+        throw new TypeError('unknown data type');
+    });
+}
+exports.prepareData = prepareData;
+function isBufferArray(buffer) {
+    return Array.isArray(buffer) && buffer.length > 0 && buffer.every(data => data instanceof Buffer);
+}
+function prepareWebsocketData(data) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (typeof data === 'string')
+            return new TextEncoder().encode(data);
+        if (data instanceof Buffer)
+            return new Uint8Array(data);
+        if (data instanceof ArrayBuffer)
+            return new Uint8Array(data);
+        if (data instanceof cross_blob_1.default)
+            return new Uint8Array(yield new Response(data).arrayBuffer());
+        if (isBufferArray(data))
+            return new Uint8Array(Buffer.concat(data));
+        throw new TypeError('unknown websocket data type');
+    });
+}
+exports.prepareWebsocketData = prepareWebsocketData;

package/dist/cjs/utils/error.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BeeNotAJsonError = exports.BeeResponseError = exports.BeeRequestError = exports.BeeArgumentError = exports.BeeError = void 0;
+class BeeError extends Error {
+    constructor(message) {
+        super(message);
+    }
+}
+exports.BeeError = BeeError;
+class BeeArgumentError extends BeeError {
+    constructor(message, value) {
+        super(message);
+        this.value = value;
+    }
+}
+exports.BeeArgumentError = BeeArgumentError;
+class BeeRequestError extends BeeError {
+    /**
+     * @param message
+     * @param requestOptions KyOptions that were used to assemble the request. THIS MIGHT NOT BE COMPLETE! If custom Ky instance was used that has set defaults then these defaults are not visible in this object!
+     */
+    constructor(message, requestOptions) {
+        super(message);
+        this.requestOptions = requestOptions;
+    }
+}
+exports.BeeRequestError = BeeRequestError;
+class BeeResponseError extends BeeError {
+    /**
+     * @param status HTTP status code number
+     * @param response Response returned from the server
+     * @param responseBody Response body as string which is returned from response.text() call
+     * @param requestOptions KyOptions that were used to assemble the request. THIS MIGHT NOT BE COMPLETE! If custom Ky instance was used that has set defaults then these defaults are not visible in this object!
+     * @param message
+     */
+    constructor(status, response, responseBody, requestOptions, message) {
+        super(message);
+        this.status = status;
+        this.response = response;
+        this.responseBody = responseBody;
+        this.requestOptions = requestOptions;
+    }
+}
+exports.BeeResponseError = BeeResponseError;
+class BeeNotAJsonError extends BeeError {
+    constructor() {
+        super(`Received response is not valid JSON.`);
+    }
+}
+exports.BeeNotAJsonError = BeeNotAJsonError;

package/dist/cjs/utils/eth.js

@@ -0,0 +1,211 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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) {
+    var _a;
+    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 = (_a = hexRep.match(/../g)) === null || _a === void 0 ? void 0 : _a.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.
+ */
+function makeEthereumWalletSigner(provider, ethAddress) {
+    return __awaiter(this, void 0, void 0, function* () {
+        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 = (yield executorFnc({ method: 'eth_requestAccounts' }))[0];
+        }
+        const bytesEthAddress = makeEthAddress(ethAddress);
+        const hexEthAddress = makeHexEthAddress(ethAddress);
+        return {
+            address: bytesEthAddress,
+            sign: (data) => __awaiter(this, void 0, void 0, function* () {
+                const result = yield 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,49 @@
+"use strict";
+/**
+ * Compatibility functions for working with File API objects
+ *
+ * https://developer.mozilla.org/en-US/docs/Web/API/File
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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
+ */
+function fileArrayBuffer(file) {
+    return __awaiter(this, void 0, void 0, function* () {
+        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;