ethereumjsutility 7.1.5

package/dist.browser/account.js

@@ -0,0 +1,296 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isZeroAddress = exports.zeroAddress = exports.importPublic = exports.privateToAddress = exports.privateToPublic = exports.publicToAddress = exports.pubToAddress = exports.isValidPublic = exports.isValidPrivate = exports.generateAddress2 = exports.generateAddress = exports.isValidChecksumAddress = exports.toChecksumAddress = exports.isValidAddress = exports.Account = void 0;
+var assert_1 = __importDefault(require("assert"));
+var externals_1 = require("./externals");
+var secp256k1_1 = require("ethereum-cryptography/secp256k1");
+var internal_1 = require("./internal");
+var constants_1 = require("./constants");
+var bytes_1 = require("./bytes");
+var hash_1 = require("./hash");
+var helpers_1 = require("./helpers");
+var types_1 = require("./types");
+var Account = /** @class */ (function () {
+    /**
+     * This constructor assigns and validates the values.
+     * Use the static factory methods to assist in creating an Account from varying data types.
+     */
+    function Account(nonce, balance, stateRoot, codeHash) {
+        if (nonce === void 0) { nonce = new externals_1.BN(0); }
+        if (balance === void 0) { balance = new externals_1.BN(0); }
+        if (stateRoot === void 0) { stateRoot = constants_1.KECCAK256_RLP; }
+        if (codeHash === void 0) { codeHash = constants_1.KECCAK256_NULL; }
+        this.nonce = nonce;
+        this.balance = balance;
+        this.stateRoot = stateRoot;
+        this.codeHash = codeHash;
+        this._validate();
+    }
+    Account.fromAccountData = function (accountData) {
+        var nonce = accountData.nonce, balance = accountData.balance, stateRoot = accountData.stateRoot, codeHash = accountData.codeHash;
+        return new Account(nonce ? new externals_1.BN((0, bytes_1.toBuffer)(nonce)) : undefined, balance ? new externals_1.BN((0, bytes_1.toBuffer)(balance)) : undefined, stateRoot ? (0, bytes_1.toBuffer)(stateRoot) : undefined, codeHash ? (0, bytes_1.toBuffer)(codeHash) : undefined);
+    };
+    Account.fromRlpSerializedAccount = function (serialized) {
+        var values = externals_1.rlp.decode(serialized);
+        if (!Array.isArray(values)) {
+            throw new Error('Invalid serialized account input. Must be array');
+        }
+        return this.fromValuesArray(values);
+    };
+    Account.fromValuesArray = function (values) {
+        var _a = __read(values, 4), nonce = _a[0], balance = _a[1], stateRoot = _a[2], codeHash = _a[3];
+        return new Account(new externals_1.BN(nonce), new externals_1.BN(balance), stateRoot, codeHash);
+    };
+    Account.prototype._validate = function () {
+        if (this.nonce.lt(new externals_1.BN(0))) {
+            throw new Error('nonce must be greater than zero');
+        }
+        if (this.balance.lt(new externals_1.BN(0))) {
+            throw new Error('balance must be greater than zero');
+        }
+        if (this.stateRoot.length !== 32) {
+            throw new Error('stateRoot must have a length of 32');
+        }
+        if (this.codeHash.length !== 32) {
+            throw new Error('codeHash must have a length of 32');
+        }
+    };
+    /**
+     * Returns a Buffer Array of the raw Buffers for the account, in order.
+     */
+    Account.prototype.raw = function () {
+        return [
+            (0, types_1.bnToUnpaddedBuffer)(this.nonce),
+            (0, types_1.bnToUnpaddedBuffer)(this.balance),
+            this.stateRoot,
+            this.codeHash,
+        ];
+    };
+    /**
+     * Returns the RLP serialization of the account as a `Buffer`.
+     */
+    Account.prototype.serialize = function () {
+        return externals_1.rlp.encode(this.raw());
+    };
+    /**
+     * Returns a `Boolean` determining if the account is a contract.
+     */
+    Account.prototype.isContract = function () {
+        return !this.codeHash.equals(constants_1.KECCAK256_NULL);
+    };
+    /**
+     * Returns a `Boolean` determining if the account is empty complying to the definition of
+     * account emptiness in [EIP-161](https://eips.ethereum.org/EIPS/eip-161):
+     * "An account is considered empty when it has no code and zero nonce and zero balance."
+     */
+    Account.prototype.isEmpty = function () {
+        return this.balance.isZero() && this.nonce.isZero() && this.codeHash.equals(constants_1.KECCAK256_NULL);
+    };
+    return Account;
+}());
+exports.Account = Account;
+/**
+ * Checks if the address is a valid. Accepts checksummed addresses too.
+ */
+var isValidAddress = function (hexAddress) {
+    try {
+        (0, helpers_1.assertIsString)(hexAddress);
+    }
+    catch (e) {
+        return false;
+    }
+    return /^0x[0-9a-fA-F]{40}$/.test(hexAddress);
+};
+exports.isValidAddress = isValidAddress;
+/**
+ * Returns a checksummed address.
+ *
+ * If an eip1191ChainId is provided, the chainId will be included in the checksum calculation. This
+ * has the effect of checksummed addresses for one chain having invalid checksums for others.
+ * For more details see [EIP-1191](https://eips.ethereum.org/EIPS/eip-1191).
+ *
+ * WARNING: Checksums with and without the chainId will differ and the EIP-1191 checksum is not
+ * backwards compatible to the original widely adopted checksum format standard introduced in
+ * [EIP-55](https://eips.ethereum.org/EIPS/eip-55), so this will break in existing applications.
+ * Usage of this EIP is therefore discouraged unless you have a very targeted use case.
+ */
+var toChecksumAddress = function (hexAddress, eip1191ChainId) {
+    (0, helpers_1.assertIsHexString)(hexAddress);
+    var address = (0, internal_1.stripHexPrefix)(hexAddress).toLowerCase();
+    var prefix = '';
+    if (eip1191ChainId) {
+        var chainId = (0, types_1.toType)(eip1191ChainId, types_1.TypeOutput.BN);
+        prefix = chainId.toString() + '0x';
+    }
+    var hash = (0, hash_1.keccakFromString)(prefix + address).toString('hex');
+    var ret = '0x';
+    for (var i = 0; i < address.length; i++) {
+        if (parseInt(hash[i], 16) >= 8) {
+            ret += address[i].toUpperCase();
+        }
+        else {
+            ret += address[i];
+        }
+    }
+    return ret;
+};
+exports.toChecksumAddress = toChecksumAddress;
+/**
+ * Checks if the address is a valid checksummed address.
+ *
+ * See toChecksumAddress' documentation for details about the eip1191ChainId parameter.
+ */
+var isValidChecksumAddress = function (hexAddress, eip1191ChainId) {
+    return (0, exports.isValidAddress)(hexAddress) && (0, exports.toChecksumAddress)(hexAddress, eip1191ChainId) === hexAddress;
+};
+exports.isValidChecksumAddress = isValidChecksumAddress;
+/**
+ * Generates an address of a newly created contract.
+ * @param from The address which is creating this new address
+ * @param nonce The nonce of the from account
+ */
+var generateAddress = function (from, nonce) {
+    (0, helpers_1.assertIsBuffer)(from);
+    (0, helpers_1.assertIsBuffer)(nonce);
+    var nonceBN = new externals_1.BN(nonce);
+    if (nonceBN.isZero()) {
+        // in RLP we want to encode null in the case of zero nonce
+        // read the RLP documentation for an answer if you dare
+        return (0, hash_1.rlphash)([from, null]).slice(-20);
+    }
+    // Only take the lower 160bits of the hash
+    return (0, hash_1.rlphash)([from, Buffer.from(nonceBN.toArray())]).slice(-20);
+};
+exports.generateAddress = generateAddress;
+/**
+ * Generates an address for a contract created using CREATE2.
+ * @param from The address which is creating this new address
+ * @param salt A salt
+ * @param initCode The init code of the contract being created
+ */
+var generateAddress2 = function (from, salt, initCode) {
+    (0, helpers_1.assertIsBuffer)(from);
+    (0, helpers_1.assertIsBuffer)(salt);
+    (0, helpers_1.assertIsBuffer)(initCode);
+    (0, assert_1.default)(from.length === 20);
+    (0, assert_1.default)(salt.length === 32);
+    var address = (0, hash_1.keccak256)(Buffer.concat([Buffer.from('ff', 'hex'), from, salt, (0, hash_1.keccak256)(initCode)]));
+    return address.slice(-20);
+};
+exports.generateAddress2 = generateAddress2;
+/**
+ * Checks if the private key satisfies the rules of the curve secp256k1.
+ */
+var isValidPrivate = function (privateKey) {
+    return (0, secp256k1_1.privateKeyVerify)(privateKey);
+};
+exports.isValidPrivate = isValidPrivate;
+/**
+ * Checks if the public key satisfies the rules of the curve secp256k1
+ * and the requirements of Ethereum.
+ * @param publicKey The two points of an uncompressed key, unless sanitize is enabled
+ * @param sanitize Accept public keys in other formats
+ */
+var isValidPublic = function (publicKey, sanitize) {
+    if (sanitize === void 0) { sanitize = false; }
+    (0, helpers_1.assertIsBuffer)(publicKey);
+    if (publicKey.length === 64) {
+        // Convert to SEC1 for secp256k1
+        return (0, secp256k1_1.publicKeyVerify)(Buffer.concat([Buffer.from([4]), publicKey]));
+    }
+    if (!sanitize) {
+        return false;
+    }
+    return (0, secp256k1_1.publicKeyVerify)(publicKey);
+};
+exports.isValidPublic = isValidPublic;
+/**
+ * Returns the ethereum address of a given public key.
+ * Accepts "Ethereum public keys" and SEC1 encoded keys.
+ * @param pubKey The two points of an uncompressed key, unless sanitize is enabled
+ * @param sanitize Accept public keys in other formats
+ */
+var pubToAddress = function (pubKey, sanitize) {
+    if (sanitize === void 0) { sanitize = false; }
+    (0, helpers_1.assertIsBuffer)(pubKey);
+    if (sanitize && pubKey.length !== 64) {
+        pubKey = Buffer.from((0, secp256k1_1.publicKeyConvert)(pubKey, false).slice(1));
+    }
+    (0, assert_1.default)(pubKey.length === 64);
+    // Only take the lower 160bits of the hash
+    return (0, hash_1.keccak)(pubKey).slice(-20);
+};
+exports.pubToAddress = pubToAddress;
+exports.publicToAddress = exports.pubToAddress;
+/**
+ * Returns the ethereum public key of a given private key.
+ * @param privateKey A private key must be 256 bits wide
+ */
+var privateToPublic = function (privateKey) {
+    (0, helpers_1.assertIsBuffer)(privateKey);
+    // skip the type flag and use the X, Y points
+    return Buffer.from((0, secp256k1_1.publicKeyCreate)(privateKey, false)).slice(1);
+};
+exports.privateToPublic = privateToPublic;
+/**
+ * Returns the ethereum address of a given private key.
+ * @param privateKey A private key must be 256 bits wide
+ */
+var privateToAddress = function (privateKey) {
+    return (0, exports.publicToAddress)((0, exports.privateToPublic)(privateKey));
+};
+exports.privateToAddress = privateToAddress;
+/**
+ * Converts a public key to the Ethereum format.
+ */
+var importPublic = function (publicKey) {
+    (0, helpers_1.assertIsBuffer)(publicKey);
+    if (publicKey.length !== 64) {
+        publicKey = Buffer.from((0, secp256k1_1.publicKeyConvert)(publicKey, false).slice(1));
+    }
+    return publicKey;
+};
+exports.importPublic = importPublic;
+/**
+ * Returns the zero address.
+ */
+var zeroAddress = function () {
+    var addressLength = 20;
+    var addr = (0, bytes_1.zeros)(addressLength);
+    return (0, bytes_1.bufferToHex)(addr);
+};
+exports.zeroAddress = zeroAddress;
+/**
+ * Checks if a given address is the zero address.
+ */
+var isZeroAddress = function (hexAddress) {
+    try {
+        (0, helpers_1.assertIsString)(hexAddress);
+    }
+    catch (e) {
+        return false;
+    }
+    var zeroAddr = (0, exports.zeroAddress)();
+    return zeroAddr === hexAddress;
+};
+exports.isZeroAddress = isZeroAddress;
+//# sourceMappingURL=account.js.map

package/dist.browser/account.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"account.js","sourceRoot":"","sources":["../src/account.ts"],"names":[],"mappings":"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"}

package/dist.browser/address.d.ts

@@ -0,0 +1,60 @@
+/// <reference types="node" />
+/// <reference types="bn.js" />
+import { BN } from './externals';
+export declare class Address {
+    readonly buf: Buffer;
+    constructor(buf: Buffer);
+    /**
+     * Returns the zero address.
+     */
+    static zero(): Address;
+    /**
+     * Returns an Address object from a hex-encoded string.
+     * @param str - Hex-encoded address
+     */
+    static fromString(str: string): Address;
+    /**
+     * Returns an address for a given public key.
+     * @param pubKey The two points of an uncompressed key
+     */
+    static fromPublicKey(pubKey: Buffer): Address;
+    /**
+     * Returns an address for a given private key.
+     * @param privateKey A private key must be 256 bits wide
+     */
+    static fromPrivateKey(privateKey: Buffer): Address;
+    /**
+     * Generates an address for a newly created contract.
+     * @param from The address which is creating this new address
+     * @param nonce The nonce of the from account
+     */
+    static generate(from: Address, nonce: BN): Address;
+    /**
+     * Generates an address for a contract created using CREATE2.
+     * @param from The address which is creating this new address
+     * @param salt A salt
+     * @param initCode The init code of the contract being created
+     */
+    static generate2(from: Address, salt: Buffer, initCode: Buffer): Address;
+    /**
+     * Is address equal to another.
+     */
+    equals(address: Address): boolean;
+    /**
+     * Is address zero.
+     */
+    isZero(): boolean;
+    /**
+     * True if address is in the address range defined
+     * by EIP-1352
+     */
+    isPrecompileOrSystemAddress(): boolean;
+    /**
+     * Returns hex encoding of address.
+     */
+    toString(): string;
+    /**
+     * Returns Buffer representation of address.
+     */
+    toBuffer(): Buffer;
+}

package/dist.browser/address.js

@@ -0,0 +1,105 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Address = void 0;
+var assert_1 = __importDefault(require("assert"));
+var externals_1 = require("./externals");
+var bytes_1 = require("./bytes");
+var account_1 = require("./account");
+var Address = /** @class */ (function () {
+    function Address(buf) {
+        (0, assert_1.default)(buf.length === 20, 'Invalid address length');
+        this.buf = buf;
+    }
+    /**
+     * Returns the zero address.
+     */
+    Address.zero = function () {
+        return new Address((0, bytes_1.zeros)(20));
+    };
+    /**
+     * Returns an Address object from a hex-encoded string.
+     * @param str - Hex-encoded address
+     */
+    Address.fromString = function (str) {
+        (0, assert_1.default)((0, account_1.isValidAddress)(str), 'Invalid address');
+        return new Address((0, bytes_1.toBuffer)(str));
+    };
+    /**
+     * Returns an address for a given public key.
+     * @param pubKey The two points of an uncompressed key
+     */
+    Address.fromPublicKey = function (pubKey) {
+        (0, assert_1.default)(Buffer.isBuffer(pubKey), 'Public key should be Buffer');
+        var buf = (0, account_1.pubToAddress)(pubKey);
+        return new Address(buf);
+    };
+    /**
+     * Returns an address for a given private key.
+     * @param privateKey A private key must be 256 bits wide
+     */
+    Address.fromPrivateKey = function (privateKey) {
+        (0, assert_1.default)(Buffer.isBuffer(privateKey), 'Private key should be Buffer');
+        var buf = (0, account_1.privateToAddress)(privateKey);
+        return new Address(buf);
+    };
+    /**
+     * Generates an address for a newly created contract.
+     * @param from The address which is creating this new address
+     * @param nonce The nonce of the from account
+     */
+    Address.generate = function (from, nonce) {
+        (0, assert_1.default)(externals_1.BN.isBN(nonce));
+        return new Address((0, account_1.generateAddress)(from.buf, nonce.toArrayLike(Buffer)));
+    };
+    /**
+     * Generates an address for a contract created using CREATE2.
+     * @param from The address which is creating this new address
+     * @param salt A salt
+     * @param initCode The init code of the contract being created
+     */
+    Address.generate2 = function (from, salt, initCode) {
+        (0, assert_1.default)(Buffer.isBuffer(salt));
+        (0, assert_1.default)(Buffer.isBuffer(initCode));
+        return new Address((0, account_1.generateAddress2)(from.buf, salt, initCode));
+    };
+    /**
+     * Is address equal to another.
+     */
+    Address.prototype.equals = function (address) {
+        return this.buf.equals(address.buf);
+    };
+    /**
+     * Is address zero.
+     */
+    Address.prototype.isZero = function () {
+        return this.equals(Address.zero());
+    };
+    /**
+     * True if address is in the address range defined
+     * by EIP-1352
+     */
+    Address.prototype.isPrecompileOrSystemAddress = function () {
+        var addressBN = new externals_1.BN(this.buf);
+        var rangeMin = new externals_1.BN(0);
+        var rangeMax = new externals_1.BN('ffff', 'hex');
+        return addressBN.gte(rangeMin) && addressBN.lte(rangeMax);
+    };
+    /**
+     * Returns hex encoding of address.
+     */
+    Address.prototype.toString = function () {
+        return '0x' + this.buf.toString('hex');
+    };
+    /**
+     * Returns Buffer representation of address.
+     */
+    Address.prototype.toBuffer = function () {
+        return Buffer.from(this.buf);
+    };
+    return Address;
+}());
+exports.Address = Address;
+//# sourceMappingURL=address.js.map

package/dist.browser/address.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"address.js","sourceRoot":"","sources":["../src/address.ts"],"names":[],"mappings":"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"}

package/dist.browser/bytes.d.ts

@@ -0,0 +1,140 @@
+/// <reference types="node" />
+/// <reference types="bn.js" />
+import { BN } from './externals';
+import { PrefixedHexString, TransformableToArray, TransformableToBuffer, NestedBufferArray, NestedUint8Array } from './types';
+/**
+ * Converts a `Number` into a hex `String`
+ * @param {Number} i
+ * @return {String}
+ */
+export declare const intToHex: (i: number) => string;
+/**
+ * Converts an `Number` to a `Buffer`
+ * @param {Number} i
+ * @return {Buffer}
+ */
+export declare const intToBuffer: (i: number) => Buffer;
+/**
+ * Returns a buffer filled with 0s.
+ * @param bytes the number of bytes the buffer should be
+ */
+export declare const zeros: (bytes: number) => Buffer;
+/**
+ * Left Pads a `Buffer` with leading zeros till it has `length` bytes.
+ * Or it truncates the beginning if it exceeds.
+ * @param msg the value to pad (Buffer)
+ * @param length the number of bytes the output should be
+ * @return (Buffer)
+ */
+export declare const setLengthLeft: (msg: Buffer, length: number) => Buffer;
+/**
+ * Right Pads a `Buffer` with trailing zeros till it has `length` bytes.
+ * it truncates the end if it exceeds.
+ * @param msg the value to pad (Buffer)
+ * @param length the number of bytes the output should be
+ * @return (Buffer)
+ */
+export declare const setLengthRight: (msg: Buffer, length: number) => Buffer;
+/**
+ * Trims leading zeros from a `Buffer`.
+ * @param a (Buffer)
+ * @return (Buffer)
+ */
+export declare const unpadBuffer: (a: Buffer) => Buffer;
+/**
+ * Trims leading zeros from an `Array` (of numbers).
+ * @param a (number[])
+ * @return (number[])
+ */
+export declare const unpadArray: (a: number[]) => number[];
+/**
+ * Trims leading zeros from a hex-prefixed `String`.
+ * @param a (String)
+ * @return (String)
+ */
+export declare const unpadHexString: (a: string) => string;
+export declare type ToBufferInputTypes = PrefixedHexString | number | BN | Buffer | Uint8Array | number[] | TransformableToArray | TransformableToBuffer | null | undefined;
+/**
+ * Attempts to turn a value into a `Buffer`.
+ * Inputs supported: `Buffer`, `String` (hex-prefixed), `Number`, null/undefined, `BN` and other objects
+ * with a `toArray()` or `toBuffer()` method.
+ * @param v the value
+ */
+export declare const toBuffer: (v: ToBufferInputTypes) => Buffer;
+/**
+ * Converts a `Buffer` to a `Number`.
+ * @param buf `Buffer` object to convert
+ * @throws If the input number exceeds 53 bits.
+ */
+export declare const bufferToInt: (buf: Buffer) => number;
+/**
+ * Converts a `Buffer` into a `0x`-prefixed hex `String`.
+ * @param buf `Buffer` object to convert
+ */
+export declare const bufferToHex: (buf: Buffer) => string;
+/**
+ * Interprets a `Buffer` as a signed integer and returns a `BN`. Assumes 256-bit numbers.
+ * @param num Signed integer value
+ */
+export declare const fromSigned: (num: Buffer) => BN;
+/**
+ * Converts a `BN` to an unsigned integer and returns it as a `Buffer`. Assumes 256-bit numbers.
+ * @param num
+ */
+export declare const toUnsigned: (num: BN) => Buffer;
+/**
+ * Adds "0x" to a given `String` if it does not already start with "0x".
+ */
+export declare const addHexPrefix: (str: string) => string;
+/**
+ * Returns the utf8 string representation from a hex string.
+ *
+ * Examples:
+ *
+ * Input 1: '657468657265756d000000000000000000000000000000000000000000000000'
+ * Input 2: '657468657265756d'
+ * Input 3: '000000000000000000000000000000000000000000000000657468657265756d'
+ *
+ * Output (all 3 input variants): 'ethereum'
+ *
+ * Note that this method is not intended to be used with hex strings
+ * representing quantities in both big endian or little endian notation.
+ *
+ * @param string Hex string, should be `0x` prefixed
+ * @return Utf8 string
+ */
+export declare const toUtf8: (hex: string) => string;
+/**
+ * Converts a `Buffer` or `Array` to JSON.
+ * @param ba (Buffer|Array)
+ * @return (Array|String|null)
+ */
+export declare const baToJSON: (ba: any) => any;
+/**
+ * Checks provided Buffers for leading zeroes and throws if found.
+ *
+ * Examples:
+ *
+ * Valid values: 0x1, 0x, 0x01, 0x1234
+ * Invalid values: 0x0, 0x00, 0x001, 0x0001
+ *
+ * Note: This method is useful for validating that RLP encoded integers comply with the rule that all
+ * integer values encoded to RLP must be in the most compact form and contain no leading zero bytes
+ * @param values An object containing string keys and Buffer values
+ * @throws if any provided value is found to have leading zero bytes
+ */
+export declare const validateNoLeadingZeroes: (values: {
+    [key: string]: Buffer | undefined;
+}) => void;
+/**
+ * Converts a {@link Uint8Array} or {@link NestedUint8Array} to {@link Buffer} or {@link NestedBufferArray}
+ */
+export declare function arrToBufArr(arr: Uint8Array): Buffer;
+export declare function arrToBufArr(arr: NestedUint8Array): NestedBufferArray;
+export declare function arrToBufArr(arr: Uint8Array | NestedUint8Array): Buffer | NestedBufferArray;
+/**
+ * Converts a {@link Buffer} or {@link NestedBufferArray} to {@link Uint8Array} or {@link NestedUint8Array}
+ */
+export declare function bufArrToArr(arr: Buffer): Uint8Array;
+export declare function bufArrToArr(arr: NestedBufferArray): NestedUint8Array;
+export declare function bufArrToArr(arr: Buffer | NestedBufferArray): Uint8Array | NestedUint8Array;