ethereumjsutility 7.1.5

package/dist/bytes.js

@@ -0,0 +1,295 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bufArrToArr = exports.arrToBufArr = exports.validateNoLeadingZeroes = exports.baToJSON = exports.toUtf8 = exports.addHexPrefix = exports.toUnsigned = exports.fromSigned = exports.bufferToHex = exports.bufferToInt = exports.toBuffer = exports.unpadHexString = exports.unpadArray = exports.unpadBuffer = exports.setLengthRight = exports.setLengthLeft = exports.zeros = exports.intToBuffer = exports.intToHex = void 0;
+const externals_1 = require("./externals");
+const internal_1 = require("./internal");
+const helpers_1 = require("./helpers");
+/**
+ * Converts a `Number` into a hex `String`
+ * @param {Number} i
+ * @return {String}
+ */
+const intToHex = function (i) {
+    if (!Number.isSafeInteger(i) || i < 0) {
+        throw new Error(`Received an invalid integer type: ${i}`);
+    }
+    return `0x${i.toString(16)}`;
+};
+exports.intToHex = intToHex;
+/**
+ * Converts an `Number` to a `Buffer`
+ * @param {Number} i
+ * @return {Buffer}
+ */
+const intToBuffer = function (i) {
+    const hex = (0, exports.intToHex)(i);
+    return Buffer.from((0, internal_1.padToEven)(hex.slice(2)), 'hex');
+};
+exports.intToBuffer = intToBuffer;
+/**
+ * Returns a buffer filled with 0s.
+ * @param bytes the number of bytes the buffer should be
+ */
+const zeros = function (bytes) {
+    return Buffer.allocUnsafe(bytes).fill(0);
+};
+exports.zeros = zeros;
+/**
+ * Pads a `Buffer` with zeros till it has `length` bytes.
+ * Truncates the beginning or end of input if its length exceeds `length`.
+ * @param msg the value to pad (Buffer)
+ * @param length the number of bytes the output should be
+ * @param right whether to start padding form the left or right
+ * @return (Buffer)
+ */
+const setLength = function (msg, length, right) {
+    const buf = (0, exports.zeros)(length);
+    if (right) {
+        if (msg.length < length) {
+            msg.copy(buf);
+            return buf;
+        }
+        return msg.slice(0, length);
+    }
+    else {
+        if (msg.length < length) {
+            msg.copy(buf, length - msg.length);
+            return buf;
+        }
+        return msg.slice(-length);
+    }
+};
+/**
+ * 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)
+ */
+const setLengthLeft = function (msg, length) {
+    (0, helpers_1.assertIsBuffer)(msg);
+    return setLength(msg, length, false);
+};
+exports.setLengthLeft = setLengthLeft;
+/**
+ * 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)
+ */
+const setLengthRight = function (msg, length) {
+    (0, helpers_1.assertIsBuffer)(msg);
+    return setLength(msg, length, true);
+};
+exports.setLengthRight = setLengthRight;
+/**
+ * Trims leading zeros from a `Buffer`, `String` or `Number[]`.
+ * @param a (Buffer|Array|String)
+ * @return (Buffer|Array|String)
+ */
+const stripZeros = function (a) {
+    let first = a[0];
+    while (a.length > 0 && first.toString() === '0') {
+        a = a.slice(1);
+        first = a[0];
+    }
+    return a;
+};
+/**
+ * Trims leading zeros from a `Buffer`.
+ * @param a (Buffer)
+ * @return (Buffer)
+ */
+const unpadBuffer = function (a) {
+    (0, helpers_1.assertIsBuffer)(a);
+    return stripZeros(a);
+};
+exports.unpadBuffer = unpadBuffer;
+/**
+ * Trims leading zeros from an `Array` (of numbers).
+ * @param a (number[])
+ * @return (number[])
+ */
+const unpadArray = function (a) {
+    (0, helpers_1.assertIsArray)(a);
+    return stripZeros(a);
+};
+exports.unpadArray = unpadArray;
+/**
+ * Trims leading zeros from a hex-prefixed `String`.
+ * @param a (String)
+ * @return (String)
+ */
+const unpadHexString = function (a) {
+    (0, helpers_1.assertIsHexString)(a);
+    a = (0, internal_1.stripHexPrefix)(a);
+    return stripZeros(a);
+};
+exports.unpadHexString = unpadHexString;
+/**
+ * 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
+ */
+const toBuffer = function (v) {
+    if (v === null || v === undefined) {
+        return Buffer.allocUnsafe(0);
+    }
+    if (Buffer.isBuffer(v)) {
+        return Buffer.from(v);
+    }
+    if (Array.isArray(v) || v instanceof Uint8Array) {
+        return Buffer.from(v);
+    }
+    if (typeof v === 'string') {
+        if (!(0, internal_1.isHexString)(v)) {
+            throw new Error(`Cannot convert string to buffer. toBuffer only supports 0x-prefixed hex strings and this string was given: ${v}`);
+        }
+        return Buffer.from((0, internal_1.padToEven)((0, internal_1.stripHexPrefix)(v)), 'hex');
+    }
+    if (typeof v === 'number') {
+        return (0, exports.intToBuffer)(v);
+    }
+    if (externals_1.BN.isBN(v)) {
+        if (v.isNeg()) {
+            throw new Error(`Cannot convert negative BN to buffer. Given: ${v}`);
+        }
+        return v.toArrayLike(Buffer);
+    }
+    if (v.toArray) {
+        // converts a BN to a Buffer
+        return Buffer.from(v.toArray());
+    }
+    if (v.toBuffer) {
+        return Buffer.from(v.toBuffer());
+    }
+    throw new Error('invalid type');
+};
+exports.toBuffer = toBuffer;
+/**
+ * Converts a `Buffer` to a `Number`.
+ * @param buf `Buffer` object to convert
+ * @throws If the input number exceeds 53 bits.
+ */
+const bufferToInt = function (buf) {
+    return new externals_1.BN((0, exports.toBuffer)(buf)).toNumber();
+};
+exports.bufferToInt = bufferToInt;
+/**
+ * Converts a `Buffer` into a `0x`-prefixed hex `String`.
+ * @param buf `Buffer` object to convert
+ */
+const bufferToHex = function (buf) {
+    buf = (0, exports.toBuffer)(buf);
+    return '0x' + buf.toString('hex');
+};
+exports.bufferToHex = bufferToHex;
+/**
+ * Interprets a `Buffer` as a signed integer and returns a `BN`. Assumes 256-bit numbers.
+ * @param num Signed integer value
+ */
+const fromSigned = function (num) {
+    return new externals_1.BN(num).fromTwos(256);
+};
+exports.fromSigned = fromSigned;
+/**
+ * Converts a `BN` to an unsigned integer and returns it as a `Buffer`. Assumes 256-bit numbers.
+ * @param num
+ */
+const toUnsigned = function (num) {
+    return Buffer.from(num.toTwos(256).toArray());
+};
+exports.toUnsigned = toUnsigned;
+/**
+ * Adds "0x" to a given `String` if it does not already start with "0x".
+ */
+const addHexPrefix = function (str) {
+    if (typeof str !== 'string') {
+        return str;
+    }
+    return (0, internal_1.isHexPrefixed)(str) ? str : '0x' + str;
+};
+exports.addHexPrefix = addHexPrefix;
+/**
+ * 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
+ */
+const toUtf8 = function (hex) {
+    const zerosRegexp = /^(00)+|(00)+$/g;
+    hex = (0, internal_1.stripHexPrefix)(hex);
+    if (hex.length % 2 !== 0) {
+        throw new Error('Invalid non-even hex string input for toUtf8() provided');
+    }
+    const bufferVal = Buffer.from(hex.replace(zerosRegexp, ''), 'hex');
+    return bufferVal.toString('utf8');
+};
+exports.toUtf8 = toUtf8;
+/**
+ * Converts a `Buffer` or `Array` to JSON.
+ * @param ba (Buffer|Array)
+ * @return (Array|String|null)
+ */
+const baToJSON = function (ba) {
+    if (Buffer.isBuffer(ba)) {
+        return `0x${ba.toString('hex')}`;
+    }
+    else if (ba instanceof Array) {
+        const array = [];
+        for (let i = 0; i < ba.length; i++) {
+            array.push((0, exports.baToJSON)(ba[i]));
+        }
+        return array;
+    }
+};
+exports.baToJSON = baToJSON;
+/**
+ * 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
+ */
+const validateNoLeadingZeroes = function (values) {
+    for (const [k, v] of Object.entries(values)) {
+        if (v !== undefined && v.length > 0 && v[0] === 0) {
+            throw new Error(`${k} cannot have leading zeroes, received: ${v.toString('hex')}`);
+        }
+    }
+};
+exports.validateNoLeadingZeroes = validateNoLeadingZeroes;
+function arrToBufArr(arr) {
+    if (!Array.isArray(arr)) {
+        return Buffer.from(arr);
+    }
+    return arr.map((a) => arrToBufArr(a));
+}
+exports.arrToBufArr = arrToBufArr;
+function bufArrToArr(arr) {
+    if (!Array.isArray(arr)) {
+        return Uint8Array.from(arr !== null && arr !== void 0 ? arr : []);
+    }
+    return arr.map((a) => bufArrToArr(a));
+}
+exports.bufArrToArr = bufArrToArr;
+//# sourceMappingURL=bytes.js.map

package/dist/bytes.js.map

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

package/dist/constants.d.ts

@@ -0,0 +1,40 @@
+/// <reference types="bn.js" />
+/// <reference types="node" />
+import { Buffer } from 'buffer';
+import { BN } from './externals';
+/**
+ * 2^64-1
+ */
+export declare const MAX_UINT64: BN;
+/**
+ * The max integer that the evm can handle (2^256-1)
+ */
+export declare const MAX_INTEGER: BN;
+/**
+ * 2^256
+ */
+export declare const TWO_POW256: BN;
+/**
+ * Keccak-256 hash of null
+ */
+export declare const KECCAK256_NULL_S = "c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470";
+/**
+ * Keccak-256 hash of null
+ */
+export declare const KECCAK256_NULL: Buffer;
+/**
+ * Keccak-256 of an RLP of an empty array
+ */
+export declare const KECCAK256_RLP_ARRAY_S = "1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347";
+/**
+ * Keccak-256 of an RLP of an empty array
+ */
+export declare const KECCAK256_RLP_ARRAY: Buffer;
+/**
+ * Keccak-256 hash of the RLP of null
+ */
+export declare const KECCAK256_RLP_S = "56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421";
+/**
+ * Keccak-256 hash of the RLP of null
+ */
+export declare const KECCAK256_RLP: Buffer;

package/dist/constants.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KECCAK256_RLP = exports.KECCAK256_RLP_S = exports.KECCAK256_RLP_ARRAY = exports.KECCAK256_RLP_ARRAY_S = exports.KECCAK256_NULL = exports.KECCAK256_NULL_S = exports.TWO_POW256 = exports.MAX_INTEGER = exports.MAX_UINT64 = void 0;
+const buffer_1 = require("buffer");
+const externals_1 = require("./externals");
+/**
+ * 2^64-1
+ */
+exports.MAX_UINT64 = new externals_1.BN('ffffffffffffffff', 16);
+/**
+ * The max integer that the evm can handle (2^256-1)
+ */
+exports.MAX_INTEGER = new externals_1.BN('ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff', 16);
+/**
+ * 2^256
+ */
+exports.TWO_POW256 = new externals_1.BN('10000000000000000000000000000000000000000000000000000000000000000', 16);
+/**
+ * Keccak-256 hash of null
+ */
+exports.KECCAK256_NULL_S = 'c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470';
+/**
+ * Keccak-256 hash of null
+ */
+exports.KECCAK256_NULL = buffer_1.Buffer.from(exports.KECCAK256_NULL_S, 'hex');
+/**
+ * Keccak-256 of an RLP of an empty array
+ */
+exports.KECCAK256_RLP_ARRAY_S = '1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347';
+/**
+ * Keccak-256 of an RLP of an empty array
+ */
+exports.KECCAK256_RLP_ARRAY = buffer_1.Buffer.from(exports.KECCAK256_RLP_ARRAY_S, 'hex');
+/**
+ * Keccak-256 hash of the RLP of null
+ */
+exports.KECCAK256_RLP_S = '56e81f171bcc55a6ff8345e692c0f86e5b48e01b996cadc001622fb5e363b421';
+/**
+ * Keccak-256 hash of the RLP of null
+ */
+exports.KECCAK256_RLP = buffer_1.Buffer.from(exports.KECCAK256_RLP_S, 'hex');
+//# sourceMappingURL=constants.js.map

package/dist/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":";;;AAAA,mCAA+B;AAC/B,2CAAgC;AAEhC;;GAEG;AACU,QAAA,UAAU,GAAG,IAAI,cAAE,CAAC,kBAAkB,EAAE,EAAE,CAAC,CAAA;AAExD;;GAEG;AACU,QAAA,WAAW,GAAG,IAAI,cAAE,CAC/B,kEAAkE,EAClE,EAAE,CACH,CAAA;AAED;;GAEG;AACU,QAAA,UAAU,GAAG,IAAI,cAAE,CAC9B,mEAAmE,EACnE,EAAE,CACH,CAAA;AAED;;GAEG;AACU,QAAA,gBAAgB,GAAG,kEAAkE,CAAA;AAElG;;GAEG;AACU,QAAA,cAAc,GAAG,eAAM,CAAC,IAAI,CAAC,wBAAgB,EAAE,KAAK,CAAC,CAAA;AAElE;;GAEG;AACU,QAAA,qBAAqB,GAChC,kEAAkE,CAAA;AAEpE;;GAEG;AACU,QAAA,mBAAmB,GAAG,eAAM,CAAC,IAAI,CAAC,6BAAqB,EAAE,KAAK,CAAC,CAAA;AAE5E;;GAEG;AACU,QAAA,eAAe,GAAG,kEAAkE,CAAA;AAEjG;;GAEG;AACU,QAAA,aAAa,GAAG,eAAM,CAAC,IAAI,CAAC,uBAAe,EAAE,KAAK,CAAC,CAAA"}

package/dist/externals.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Re-exports commonly used modules:
+ * * Exports [`BN`](https://github.com/indutny/bn.js), [`rlp`](https://github.com/ethereumjs/rlp).
+ * @packageDocumentation
+ */
+import BN from 'bn.js';
+import * as rlp from 'rlp';
+/**
+ * [`BN`](https://github.com/indutny/bn.js)
+ */
+export { BN };
+/**
+ * [`rlp`](https://github.com/ethereumjs/rlp)
+ */
+export { rlp };

package/dist/externals.js

@@ -0,0 +1,39 @@
+"use strict";
+/**
+ * Re-exports commonly used modules:
+ * * Exports [`BN`](https://github.com/indutny/bn.js), [`rlp`](https://github.com/ethereumjs/rlp).
+ * @packageDocumentation
+ */
+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 __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;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rlp = exports.BN = void 0;
+const bn_js_1 = __importDefault(require("bn.js"));
+exports.BN = bn_js_1.default;
+const rlp = __importStar(require("rlp"));
+exports.rlp = rlp;
+//# sourceMappingURL=externals.js.map

package/dist/externals.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"externals.js","sourceRoot":"","sources":["../src/externals.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,kDAAsB;AAMb,aANF,eAAE,CAME;AALX,yCAA0B;AAUjB,kBAAG"}

package/dist/hash.d.ts

@@ -0,0 +1,69 @@
+/// <reference types="node" />
+import { rlp } from './externals';
+/**
+ * Creates Keccak hash of a Buffer input
+ * @param a The input data (Buffer)
+ * @param bits (number = 256) The Keccak width
+ */
+export declare const keccak: (a: Buffer, bits?: number) => Buffer;
+/**
+ * Creates Keccak-256 hash of the input, alias for keccak(a, 256).
+ * @param a The input data (Buffer)
+ */
+export declare const keccak256: (a: Buffer) => Buffer;
+/**
+ * Creates Keccak hash of a utf-8 string input
+ * @param a The input data (String)
+ * @param bits (number = 256) The Keccak width
+ */
+export declare const keccakFromString: (a: string, bits?: number) => Buffer;
+/**
+ * Creates Keccak hash of an 0x-prefixed string input
+ * @param a The input data (String)
+ * @param bits (number = 256) The Keccak width
+ */
+export declare const keccakFromHexString: (a: string, bits?: number) => Buffer;
+/**
+ * Creates Keccak hash of a number array input
+ * @param a The input data (number[])
+ * @param bits (number = 256) The Keccak width
+ */
+export declare const keccakFromArray: (a: number[], bits?: number) => Buffer;
+/**
+ * Creates SHA256 hash of a Buffer input.
+ * @param a The input data (Buffer)
+ */
+export declare const sha256: (a: Buffer) => Buffer;
+/**
+ * Creates SHA256 hash of a string input.
+ * @param a The input data (string)
+ */
+export declare const sha256FromString: (a: string) => Buffer;
+/**
+ * Creates SHA256 hash of a number[] input.
+ * @param a The input data (number[])
+ */
+export declare const sha256FromArray: (a: number[]) => Buffer;
+/**
+ * Creates RIPEMD160 hash of a Buffer input.
+ * @param a The input data (Buffer)
+ * @param padded Whether it should be padded to 256 bits or not
+ */
+export declare const ripemd160: (a: Buffer, padded: boolean) => Buffer;
+/**
+ * Creates RIPEMD160 hash of a string input.
+ * @param a The input data (String)
+ * @param padded Whether it should be padded to 256 bits or not
+ */
+export declare const ripemd160FromString: (a: string, padded: boolean) => Buffer;
+/**
+ * Creates RIPEMD160 hash of a number[] input.
+ * @param a The input data (number[])
+ * @param padded Whether it should be padded to 256 bits or not
+ */
+export declare const ripemd160FromArray: (a: number[], padded: boolean) => Buffer;
+/**
+ * Creates SHA-3 hash of the RLP encoded version of the input.
+ * @param a The input data
+ */
+export declare const rlphash: (a: rlp.Input) => Buffer;

package/dist/hash.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rlphash = exports.ripemd160FromArray = exports.ripemd160FromString = exports.ripemd160 = exports.sha256FromArray = exports.sha256FromString = exports.sha256 = exports.keccakFromArray = exports.keccakFromHexString = exports.keccakFromString = exports.keccak256 = exports.keccak = void 0;
+const keccak_1 = require("ethereum-cryptography/keccak");
+const createHash = require('create-hash');
+const externals_1 = require("./externals");
+const bytes_1 = require("./bytes");
+const helpers_1 = require("./helpers");
+/**
+ * Creates Keccak hash of a Buffer input
+ * @param a The input data (Buffer)
+ * @param bits (number = 256) The Keccak width
+ */
+const keccak = function (a, bits = 256) {
+    (0, helpers_1.assertIsBuffer)(a);
+    switch (bits) {
+        case 224: {
+            return (0, keccak_1.keccak224)(a);
+        }
+        case 256: {
+            return (0, keccak_1.keccak256)(a);
+        }
+        case 384: {
+            return (0, keccak_1.keccak384)(a);
+        }
+        case 512: {
+            return (0, keccak_1.keccak512)(a);
+        }
+        default: {
+            throw new Error(`Invald algorithm: keccak${bits}`);
+        }
+    }
+};
+exports.keccak = keccak;
+/**
+ * Creates Keccak-256 hash of the input, alias for keccak(a, 256).
+ * @param a The input data (Buffer)
+ */
+const keccak256 = function (a) {
+    return (0, exports.keccak)(a);
+};
+exports.keccak256 = keccak256;
+/**
+ * Creates Keccak hash of a utf-8 string input
+ * @param a The input data (String)
+ * @param bits (number = 256) The Keccak width
+ */
+const keccakFromString = function (a, bits = 256) {
+    (0, helpers_1.assertIsString)(a);
+    const buf = Buffer.from(a, 'utf8');
+    return (0, exports.keccak)(buf, bits);
+};
+exports.keccakFromString = keccakFromString;
+/**
+ * Creates Keccak hash of an 0x-prefixed string input
+ * @param a The input data (String)
+ * @param bits (number = 256) The Keccak width
+ */
+const keccakFromHexString = function (a, bits = 256) {
+    (0, helpers_1.assertIsHexString)(a);
+    return (0, exports.keccak)((0, bytes_1.toBuffer)(a), bits);
+};
+exports.keccakFromHexString = keccakFromHexString;
+/**
+ * Creates Keccak hash of a number array input
+ * @param a The input data (number[])
+ * @param bits (number = 256) The Keccak width
+ */
+const keccakFromArray = function (a, bits = 256) {
+    (0, helpers_1.assertIsArray)(a);
+    return (0, exports.keccak)((0, bytes_1.toBuffer)(a), bits);
+};
+exports.keccakFromArray = keccakFromArray;
+/**
+ * Creates SHA256 hash of an input.
+ * @param  a The input data (Buffer|Array|String)
+ */
+const _sha256 = function (a) {
+    a = (0, bytes_1.toBuffer)(a);
+    return createHash('sha256').update(a).digest();
+};
+/**
+ * Creates SHA256 hash of a Buffer input.
+ * @param a The input data (Buffer)
+ */
+const sha256 = function (a) {
+    (0, helpers_1.assertIsBuffer)(a);
+    return _sha256(a);
+};
+exports.sha256 = sha256;
+/**
+ * Creates SHA256 hash of a string input.
+ * @param a The input data (string)
+ */
+const sha256FromString = function (a) {
+    (0, helpers_1.assertIsString)(a);
+    return _sha256(a);
+};
+exports.sha256FromString = sha256FromString;
+/**
+ * Creates SHA256 hash of a number[] input.
+ * @param a The input data (number[])
+ */
+const sha256FromArray = function (a) {
+    (0, helpers_1.assertIsArray)(a);
+    return _sha256(a);
+};
+exports.sha256FromArray = sha256FromArray;
+/**
+ * Creates RIPEMD160 hash of the input.
+ * @param a The input data (Buffer|Array|String|Number)
+ * @param padded Whether it should be padded to 256 bits or not
+ */
+const _ripemd160 = function (a, padded) {
+    a = (0, bytes_1.toBuffer)(a);
+    const hash = createHash('rmd160').update(a).digest();
+    if (padded === true) {
+        return (0, bytes_1.setLengthLeft)(hash, 32);
+    }
+    else {
+        return hash;
+    }
+};
+/**
+ * Creates RIPEMD160 hash of a Buffer input.
+ * @param a The input data (Buffer)
+ * @param padded Whether it should be padded to 256 bits or not
+ */
+const ripemd160 = function (a, padded) {
+    (0, helpers_1.assertIsBuffer)(a);
+    return _ripemd160(a, padded);
+};
+exports.ripemd160 = ripemd160;
+/**
+ * Creates RIPEMD160 hash of a string input.
+ * @param a The input data (String)
+ * @param padded Whether it should be padded to 256 bits or not
+ */
+const ripemd160FromString = function (a, padded) {
+    (0, helpers_1.assertIsString)(a);
+    return _ripemd160(a, padded);
+};
+exports.ripemd160FromString = ripemd160FromString;
+/**
+ * Creates RIPEMD160 hash of a number[] input.
+ * @param a The input data (number[])
+ * @param padded Whether it should be padded to 256 bits or not
+ */
+const ripemd160FromArray = function (a, padded) {
+    (0, helpers_1.assertIsArray)(a);
+    return _ripemd160(a, padded);
+};
+exports.ripemd160FromArray = ripemd160FromArray;
+/**
+ * Creates SHA-3 hash of the RLP encoded version of the input.
+ * @param a The input data
+ */
+const rlphash = function (a) {
+    return (0, exports.keccak)(externals_1.rlp.encode(a));
+};
+exports.rlphash = rlphash;
+//# sourceMappingURL=hash.js.map