essential-eth 0.6.2 → 0.8.0

package/dist/cjs/utils/compute-address.js

@@ -1,9 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.computeAddress = void 0;
-const __1 = require("..");
-const bytes_1 = require("./bytes");
-const keccak256_1 = require("./keccak256");
+import { hexDataSlice } from "./bytes";
+import { computePublicKey } from "./compute-public-key";
+import { keccak256 } from "./keccak256";
+import { toChecksumAddress } from "./to-checksum-address";
 /**
  * Computes the address that corresponds to a specified public or private key
  *
@@ -19,15 +17,11 @@ const keccak256_1 = require("./keccak256");
  * computeAddress('0x2f2c419acf4a1da8c1ebea75bb3fcfbd3ec2aa3bf0162901ccdc2f38b8f92427'); // private key
  * // '0xA2902059a7BF992f1450BACD7357CCAa5cC8336a'
  * ```
- */
-function computeAddress(key) {
+ */ export function computeAddress(key) {
     // compressed public keys start with 0x04
     // uncompressed public keys start with 0x03 or 0x02
-    if (!key.startsWith('0x04') &&
-        !key.startsWith('0x03') &&
-        !key.startsWith('0x02')) {
-        key = (0, __1.computePublicKey)(key);
+    if (!key.startsWith("0x04") && !key.startsWith("0x03") && !key.startsWith("0x02")) {
+        key = computePublicKey(key);
     }
-    return (0, __1.toChecksumAddress)((0, bytes_1.hexDataSlice)((0, keccak256_1.keccak256)((0, bytes_1.hexDataSlice)(key, 1)), 12));
+    return toChecksumAddress(hexDataSlice(keccak256(hexDataSlice(key, 1)), 12));
 }
-exports.computeAddress = computeAddress;

package/dist/cjs/utils/compute-public-key.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.computePublicKey = void 0;
-const secp256k1_1 = require("@noble/secp256k1");
-const bytes_1 = require("./bytes");
+import { Point } from "@noble/secp256k1";
+import { hexlify } from "./bytes";
 /**
  * Computes the public key from a given private key
  *
@@ -18,9 +15,7 @@ const bytes_1 = require("./bytes");
  * computePublicKey([50,102,50,99,52,49,57,97,99,102,52,97,49,100,97,56,99,49,101,98,101,97,55,53,98,98,51,102,99,102,98,100]);
  * // '0x04a9cea77eca949df84f661cee153426fb51f2294b9364b4fac240df57360b9b0ac9c99e4d7966491ab4c81f8c82e0cd24ec5759832ad4ab736d22c7d90b806ee8'
  * ```
- */
-function computePublicKey(privKey) {
-    privKey = (0, bytes_1.hexlify)(privKey).slice(2);
-    return '0x' + secp256k1_1.Point.fromPrivateKey(privKey).toHex();
+ */ export function computePublicKey(privKey) {
+    privKey = hexlify(privKey).slice(2);
+    return "0x" + Point.fromPrivateKey(privKey).toHex();
 }
-exports.computePublicKey = computePublicKey;

package/dist/cjs/utils/ether-to-gwei.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.etherToGwei = void 0;
-const tiny_big_1 = require("../shared/tiny-big/tiny-big");
-const validate_type_1 = require("../shared/validate-type");
+import { tinyBig } from "../shared/tiny-big/tiny-big";
+import { validateType } from "../shared/validate-type";
 /**
  * Convert from Ether to Gwei
  *
@@ -26,10 +23,12 @@ const validate_type_1 = require("../shared/validate-type");
  * etherToGwei(1000).toNumber()
  * // 1000000000000
  * ```
- */
-function etherToGwei(etherQuantity) {
-    (0, validate_type_1.validateType)(etherQuantity, ['string', 'number', 'object']);
-    const result = (0, tiny_big_1.tinyBig)(etherQuantity).times('1000000000');
-    return (0, tiny_big_1.tinyBig)(result);
+ */ export function etherToGwei(etherQuantity) {
+    validateType(etherQuantity, [
+        "string",
+        "number",
+        "object"
+    ]);
+    var result = tinyBig(etherQuantity).times("1000000000");
+    return tinyBig(result);
 }
-exports.etherToGwei = etherToGwei;

package/dist/cjs/utils/ether-to-wei.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.etherToWei = void 0;
-const tiny_big_1 = require("../shared/tiny-big/tiny-big");
-const validate_type_1 = require("../shared/validate-type");
+import { tinyBig } from "../shared/tiny-big/tiny-big";
+import { validateType } from "../shared/validate-type";
 /**
  * Convert Ether to Wei
  *
@@ -26,10 +23,12 @@ const validate_type_1 = require("../shared/validate-type");
  * etherToWei(1000).toNumber()
  * // 1000000000000000000000
  * ```
- */
-function etherToWei(etherQuantity) {
-    (0, validate_type_1.validateType)(etherQuantity, ['string', 'number', 'object']);
-    const result = (0, tiny_big_1.tinyBig)(etherQuantity).times('1000000000000000000');
-    return (0, tiny_big_1.tinyBig)(result);
+ */ export function etherToWei(etherQuantity) {
+    validateType(etherQuantity, [
+        "string",
+        "number",
+        "object"
+    ]);
+    var result = tinyBig(etherQuantity).times("1000000000000000000");
+    return tinyBig(result);
 }
-exports.etherToWei = etherToWei;

package/dist/cjs/utils/gwei-to-ether.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.gweiToEther = void 0;
-const tiny_big_1 = require("../shared/tiny-big/tiny-big");
-const validate_type_1 = require("../shared/validate-type");
+import { tinyBig } from "../shared/tiny-big/tiny-big";
+import { validateType } from "../shared/validate-type";
 /**
  * Convert from Gwei to Ether
  *
@@ -26,10 +23,12 @@ const validate_type_1 = require("../shared/validate-type");
  * gweiToEther(1000000000000).toNumber()
  * // 1000
  * ```
- */
-function gweiToEther(gweiQuantity) {
-    (0, validate_type_1.validateType)(gweiQuantity, ['string', 'number', 'object']);
-    const result = (0, tiny_big_1.tinyBig)(gweiQuantity).div('1000000000');
-    return (0, tiny_big_1.tinyBig)(result);
+ */ export function gweiToEther(gweiQuantity) {
+    validateType(gweiQuantity, [
+        "string",
+        "number",
+        "object"
+    ]);
+    var result = tinyBig(gweiQuantity).div("1000000000");
+    return tinyBig(result);
 }
-exports.gweiToEther = gweiToEther;

package/dist/cjs/utils/hash-message.d.ts

@@ -1,2 +1,2 @@
-import type { Bytes } from '../index';
+import type { Bytes } from './bytes';
 export declare function hashMessage(message: Bytes | string): string;

package/dist/cjs/utils/hash-message.js

@@ -1,8 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hashMessage = void 0;
-const index_1 = require("../index");
-const messagePrefix = '\x19Ethereum Signed Message:\n';
+import { concat } from "./bytes";
+import { keccak256 } from "./keccak256";
+import { toUtf8Bytes } from "./to-utf8-bytes";
+var messagePrefix = "\x19Ethereum Signed Message:\n";
 /**
  * Computes the EIP-191 personal message digest of message.
  * Personal messages are converted to UTF-8 bytes and prefixed with \x19Ethereum Signed Message: and the length of message.
@@ -14,15 +13,13 @@ const messagePrefix = '\x19Ethereum Signed Message:\n';
  * hashMessage("Hello World");
  * // '0xa1de988600a42c4b4ab089b619297c17d53cffae5d5120d82d8a92d0bb3b78f2'
  * ```
- */
-function hashMessage(message) {
-    if (typeof message === 'string') {
-        message = (0, index_1.toUtf8Bytes)(message);
+ */ export function hashMessage(message) {
+    if (typeof message === "string") {
+        message = toUtf8Bytes(message);
     }
-    return (0, index_1.keccak256)((0, index_1.concat)([
-        (0, index_1.toUtf8Bytes)(messagePrefix),
-        (0, index_1.toUtf8Bytes)(String(message.length)),
-        message,
+    return keccak256(concat([
+        toUtf8Bytes(messagePrefix),
+        toUtf8Bytes(String(message.length)),
+        message
     ]));
 }
-exports.hashMessage = hashMessage;

package/dist/cjs/utils/is-address.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isAddress = void 0;
-const __1 = require("..");
-const validate_type_1 = require("../shared/validate-type");
+import { validateType } from "../shared/validate-type";
+import { toChecksumAddress } from "./to-checksum-address";
 /**
  * Returns a boolean as to whether the input is a valid address.
  * Does NOT support ICAP addresses
@@ -25,15 +22,14 @@ const validate_type_1 = require("../shared/validate-type");
  * isAddress('vitalik.eth');
  * // false
  * ```
- */
-function isAddress(address) {
-    (0, validate_type_1.validateType)(address, ['string']);
+ */ export function isAddress(address) {
+    validateType(address, [
+        "string"
+    ]);
     try {
-        (0, __1.toChecksumAddress)(address);
+        toChecksumAddress(address);
         return true;
-    }
-    catch (error) {
+    } catch (error) {
         return false;
     }
 }
-exports.isAddress = isAddress;

package/dist/cjs/utils/keccak256.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.keccak256 = void 0;
-const sha3_1 = require("sha3");
+import { Keccak } from "sha3";
 /**
  * Hashes data into a Keccak256 hex string
  *
@@ -15,17 +12,14 @@ const sha3_1 = require("sha3");
  * keccak256('0x123');
  * // '0x5fa2358263196dbbf23d1ca7a509451f7a2f64c15837bfbb81298b1e3e24e4fa'
  * ```
- */
-function keccak256(data) {
-    let bufferableData;
-    if (typeof data === 'string') {
-        bufferableData = Buffer.from(data.replace(/^0x/, ''), 'hex');
-    }
-    else {
+ */ export function keccak256(data) {
+    var bufferableData;
+    if (typeof data === "string") {
+        bufferableData = Buffer.from(data.replace(/^0x/, ""), "hex");
+    } else {
         bufferableData = Buffer.from(data);
     }
-    const keccak = new sha3_1.Keccak(256);
-    const addressHash = '0x' + keccak.update(bufferableData).digest('hex');
+    var keccak = new Keccak(256);
+    var addressHash = "0x" + keccak.update(bufferableData).digest("hex");
     return addressHash;
 }
-exports.keccak256 = keccak256;

package/dist/cjs/utils/solidity-keccak256.js

@@ -1,15 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.solidityKeccak256 = exports.pack = void 0;
-const buffer_1 = require("buffer");
-const encode_decode_transaction_1 = require("../classes/utils/encode-decode-transaction");
-const logger_1 = require("../logger/logger");
-const tiny_big_1 = require("../shared/tiny-big/tiny-big");
-const bytes_1 = require("./bytes");
-const keccak256_1 = require("./keccak256");
-const regexBytes = new RegExp('^bytes([0-9]+)$');
-const regexNumber = new RegExp('^(u?int)([0-9]*)$');
-const regexArray = new RegExp('^(.*)\\[([0-9]*)\\]$');
+import { Buffer } from "buffer";
+import { hexFalse } from "../classes/utils/encode-decode-transaction";
+import { logger } from "../logger/logger";
+import { tinyBig } from "../shared/tiny-big/tiny-big";
+import { arrayify, concat, hexlify, zeroPad } from "./bytes";
+import { keccak256 } from "./keccak256";
+var regexBytes = new RegExp("^bytes([0-9]+)$");
+var regexNumber = new RegExp("^(u?int)([0-9]*)$");
+var regexArray = new RegExp("^(.*)\\[([0-9]*)\\]$");
 /**
  * Packs a type and value together into a UTF-8 Byte Array
  *
@@ -19,70 +16,66 @@ const regexArray = new RegExp('^(.*)\\[([0-9]*)\\]$');
  * @param isArray whether the specified data is in an array
  * @returns packed data consisting of the type and value
  * @example N/A - internal function
- */
-function _pack(type, value, isArray) {
-    switch (type) {
-        case 'address':
+ */ function _pack(type, value, isArray) {
+    switch(type){
+        case "address":
             if (isArray) {
-                return (0, bytes_1.zeroPad)(value, 32);
+                return zeroPad(value, 32);
             }
-            return (0, bytes_1.arrayify)(value);
-        case 'string':
-            return buffer_1.Buffer.from(value);
-        case 'bytes':
-            return (0, bytes_1.arrayify)(value);
-        case 'bool':
-            value = value ? '0x01' : '0x00';
+            return arrayify(value);
+        case "string":
+            return Buffer.from(value);
+        case "bytes":
+            return arrayify(value);
+        case "bool":
+            value = value ? "0x01" : "0x00";
             if (isArray) {
-                return (0, bytes_1.zeroPad)(value, 32);
+                return zeroPad(value, 32);
             }
-            return (0, bytes_1.arrayify)(value);
+            return arrayify(value);
     }
-    let match = type.match(regexNumber);
+    var match = type.match(regexNumber);
     if (match) {
         //let signed = (match[1] === "int")
-        let size = parseInt(match[2] || '256');
-        if ((match[2] && String(size) !== match[2]) ||
-            size % 8 !== 0 ||
-            size === 0 ||
-            size > 256) {
-            logger_1.logger.throwArgumentError('invalid number type', 'type', type);
+        var size = parseInt(match[2] || "256");
+        if (match[2] && String(size) !== match[2] || size % 8 !== 0 || size === 0 || size > 256) {
+            logger.throwArgumentError("invalid number type", "type", type);
         }
         if (isArray) {
             size = 256;
         }
-        value = (0, tiny_big_1.tinyBig)(value).toTwos(size).toNumber();
-        const hexValue = (0, bytes_1.hexlify)(value);
-        return (0, bytes_1.zeroPad)(hexValue, size / 8);
+        value = tinyBig(value).toTwos(size).toNumber();
+        var hexValue = hexlify(value);
+        return zeroPad(hexValue, size / 8);
     }
     match = type.match(regexBytes);
     if (match) {
-        const size = parseInt(match[1]);
-        if (String(size) !== match[1] || size === 0 || size > 32) {
-            logger_1.logger.throwArgumentError('invalid bytes type', 'type', type);
+        var size1 = parseInt(match[1]);
+        if (String(size1) !== match[1] || size1 === 0 || size1 > 32) {
+            logger.throwArgumentError("invalid bytes type", "type", type);
         }
-        if ((0, bytes_1.arrayify)(value).byteLength !== size) {
-            logger_1.logger.throwArgumentError(`invalid value for ${type}`, 'value', value);
+        if (arrayify(value).byteLength !== size1) {
+            logger.throwArgumentError("invalid value for ".concat(type), "value", value);
         }
         if (isArray) {
-            return (0, bytes_1.arrayify)((value + encode_decode_transaction_1.hexFalse).substring(0, 66));
+            return arrayify((value + hexFalse).substring(0, 66));
         }
         return value;
     }
     match = type.match(regexArray);
     if (match && Array.isArray(value)) {
-        const baseType = match[1];
-        const count = parseInt(match[2] || String(value.length));
+        var baseType = match[1];
+        var count = parseInt(match[2] || String(value.length));
         if (count != value.length) {
-            logger_1.logger.throwArgumentError(`invalid array length for ${type}`, 'value', value);
+            logger.throwArgumentError("invalid array length for ".concat(type), "value", value);
         }
-        const result = [];
-        value.forEach(function (value) {
+        var result = [];
+        value.forEach(function(value) {
             result.push(_pack(baseType, value, true));
         });
-        return (0, bytes_1.concat)(result);
+        return concat(result);
     }
-    return logger_1.logger.throwArgumentError('invalid type', 'type', type);
+    return logger.throwArgumentError("invalid type", "type", type);
 }
 /**
  * Converts arrays with types and values into a hex string that can be hashed
@@ -97,18 +90,16 @@ function _pack(type, value, isArray) {
  * pack(types, values);
  * // '0x0174657874000000000000001e'
  * ```
- */
-function pack(types, values) {
+ */ export function pack(types, values) {
     if (types.length != values.length) {
-        logger_1.logger.throwArgumentError('wrong number of values; expected ${ types.length }', 'values', values);
+        logger.throwArgumentError("wrong number of values; expected ${ types.length }", "values", values);
     }
-    const tight = [];
-    types.forEach(function (type, index) {
+    var tight = [];
+    types.forEach(function(type, index) {
         tight.push(_pack(type, values[index]));
     });
-    return (0, bytes_1.hexlify)((0, bytes_1.concat)(tight));
+    return hexlify(concat(tight));
 }
-exports.pack = pack;
 /**
  * Hashes data from Solidity using the Keccak256 algorithm.
  *
@@ -131,8 +122,6 @@ exports.pack = pack;
  * solidityKeccak256(types, values);
  * // '0x038707a887f09355dc545412b058e7ba8f3c74047050c7c5e5e52eec608053d9'
  * ```
- */
-function solidityKeccak256(types, values) {
-    return (0, keccak256_1.keccak256)(pack(types, values));
+ */ export function solidityKeccak256(types, values) {
+    return keccak256(pack(types, values));
 }
-exports.solidityKeccak256 = solidityKeccak256;

package/dist/cjs/utils/split-signature.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.splitSignature = void 0;
-const logger_1 = require("./../logger/logger");
-const bytes_1 = require("./bytes");
+import { logger } from "./../logger/logger";
+import { arrayify, hexlify, hexZeroPad, isBytesLike, isHexString, zeroPad } from "./bytes";
 /**
  * Expands a signature into the full signature object and fills in missing properties.
  *
@@ -24,53 +21,48 @@ const bytes_1 = require("./bytes");
  *    compact: "0x60bc4ed91f2021aefe7045f3f77bd12f87eb733aee24bd1965343b3c27b3971647252185b7d2abb411b01b5d1ac4ab41ea486df1e9b396758c1aec6c1b6eee33"
  *  }
  * ```
- */
-function splitSignature(signature) {
-    const result = {
-        r: '0x',
-        s: '0x',
-        _vs: '0x',
+ */ export function splitSignature(signature) {
+    var result = {
+        r: "0x",
+        s: "0x",
+        _vs: "0x",
         recoveryParam: 0,
         v: 0,
-        yParityAndS: '0x',
-        compact: '0x',
+        yParityAndS: "0x",
+        compact: "0x"
     };
-    if ((0, bytes_1.isBytesLike)(signature)) {
-        const bytes = (0, bytes_1.arrayify)(signature);
+    if (isBytesLike(signature)) {
+        var bytes = arrayify(signature);
         // Get the r, s and v
         if (bytes.length === 64) {
             // EIP-2098; pull the v from the top bit of s and clear it
             result.v = 27 + (bytes[32] >> 7);
             bytes[32] &= 0x7f;
-            result.r = (0, bytes_1.hexlify)(bytes.slice(0, 32));
-            result.s = (0, bytes_1.hexlify)(bytes.slice(32, 64));
-        }
-        else if (bytes.length === 65) {
-            result.r = (0, bytes_1.hexlify)(bytes.slice(0, 32));
-            result.s = (0, bytes_1.hexlify)(bytes.slice(32, 64));
+            result.r = hexlify(bytes.slice(0, 32));
+            result.s = hexlify(bytes.slice(32, 64));
+        } else if (bytes.length === 65) {
+            result.r = hexlify(bytes.slice(0, 32));
+            result.s = hexlify(bytes.slice(32, 64));
             result.v = bytes[64];
-        }
-        else {
-            logger_1.logger.throwArgumentError('invalid signature string', 'signature', signature);
+        } else {
+            logger.throwArgumentError("invalid signature string", "signature", signature);
         }
         // Allow a recid to be used as the v
         if (result.v < 27) {
             if (result.v === 0 || result.v === 1) {
                 result.v += 27;
-            }
-            else {
-                logger_1.logger.throwArgumentError('signature invalid v byte', 'signature', signature);
+            } else {
+                logger.throwArgumentError("signature invalid v byte", "signature", signature);
             }
         }
         // Compute recoveryParam from v
-        result.recoveryParam = 1 - (result.v % 2);
+        result.recoveryParam = 1 - result.v % 2;
         // Compute _vs from recoveryParam and s
         if (result.recoveryParam) {
             bytes[32] |= 0x80;
         }
-        result._vs = (0, bytes_1.hexlify)(bytes.slice(32, 64));
-    }
-    else {
+        result._vs = hexlify(bytes.slice(32, 64));
+    } else {
         result.r = signature.r;
         result.s = signature.s;
         result.v = signature.v;
@@ -79,85 +71,75 @@ function splitSignature(signature) {
         // If the _vs is available, use it to populate missing s, v and recoveryParam
         // and verify non-missing s, v and recoveryParam
         if (result._vs != null) {
-            const vs_1 = (0, bytes_1.zeroPad)((0, bytes_1.arrayify)(result._vs), 32);
-            result._vs = (0, bytes_1.hexlify)(vs_1);
+            var vs_1 = zeroPad(arrayify(result._vs), 32);
+            result._vs = hexlify(vs_1);
             // Set or check the recid
-            const recoveryParam = vs_1[0] >= 128 ? 1 : 0;
+            var recoveryParam = vs_1[0] >= 128 ? 1 : 0;
             if (result.recoveryParam == null) {
                 result.recoveryParam = recoveryParam;
-            }
-            else if (result.recoveryParam !== recoveryParam) {
-                logger_1.logger.throwArgumentError('signature recoveryParam mismatch _vs', 'signature', signature);
+            } else if (result.recoveryParam !== recoveryParam) {
+                logger.throwArgumentError("signature recoveryParam mismatch _vs", "signature", signature);
             }
             // Set or check the s
             vs_1[0] &= 0x7f;
-            const s = (0, bytes_1.hexlify)(vs_1);
+            var s = hexlify(vs_1);
             if (result.s == null) {
                 result.s = s;
-            }
-            else if (result.s !== s) {
-                logger_1.logger.throwArgumentError('signature v mismatch _vs', 'signature', signature);
+            } else if (result.s !== s) {
+                logger.throwArgumentError("signature v mismatch _vs", "signature", signature);
             }
         }
         // Use recid and v to populate each other
         if (result.recoveryParam == null) {
             if (result.v == null) {
-                logger_1.logger.throwArgumentError('signature missing v and recoveryParam', 'signature', signature);
-            }
-            else if (result.v === 0 || result.v === 1) {
+                logger.throwArgumentError("signature missing v and recoveryParam", "signature", signature);
+            } else if (result.v === 0 || result.v === 1) {
                 result.recoveryParam = result.v;
+            } else {
+                result.recoveryParam = 1 - result.v % 2;
             }
-            else {
-                result.recoveryParam = 1 - (result.v % 2);
-            }
-        }
-        else {
+        } else {
             if (result.v == null) {
                 result.v = 27 + result.recoveryParam;
-            }
-            else {
-                const recId = result.v === 0 || result.v === 1 ? result.v : 1 - (result.v % 2);
+            } else {
+                var recId = result.v === 0 || result.v === 1 ? result.v : 1 - result.v % 2;
                 if (result.recoveryParam !== recId) {
-                    logger_1.logger.throwArgumentError('signature recoveryParam mismatch v', 'signature', signature);
+                    logger.throwArgumentError("signature recoveryParam mismatch v", "signature", signature);
                 }
             }
         }
-        if (result.r == null || !(0, bytes_1.isHexString)(result.r)) {
-            logger_1.logger.throwArgumentError('signature missing or invalid r', 'signature', signature);
+        if (result.r == null || !isHexString(result.r)) {
+            logger.throwArgumentError("signature missing or invalid r", "signature", signature);
+        } else {
+            result.r = hexZeroPad(result.r, 32);
         }
-        else {
-            result.r = (0, bytes_1.hexZeroPad)(result.r, 32);
+        if (result.s == null || !isHexString(result.s)) {
+            logger.throwArgumentError("signature missing or invalid s", "signature", signature);
+        } else {
+            result.s = hexZeroPad(result.s, 32);
         }
-        if (result.s == null || !(0, bytes_1.isHexString)(result.s)) {
-            logger_1.logger.throwArgumentError('signature missing or invalid s', 'signature', signature);
-        }
-        else {
-            result.s = (0, bytes_1.hexZeroPad)(result.s, 32);
-        }
-        const vs = (0, bytes_1.arrayify)(result.s);
+        var vs = arrayify(result.s);
         if (vs[0] >= 128) {
-            logger_1.logger.throwArgumentError('signature s out of range', 'signature', signature);
+            logger.throwArgumentError("signature s out of range", "signature", signature);
         }
         if (result.recoveryParam) {
             vs[0] |= 0x80;
         }
-        const _vs = (0, bytes_1.hexlify)(vs);
+        var _vs = hexlify(vs);
         if (result._vs) {
-            if (!(0, bytes_1.isHexString)(result._vs)) {
-                logger_1.logger.throwArgumentError('signature invalid _vs', 'signature', signature);
+            if (!isHexString(result._vs)) {
+                logger.throwArgumentError("signature invalid _vs", "signature", signature);
             }
-            result._vs = (0, bytes_1.hexZeroPad)(result._vs, 32);
+            result._vs = hexZeroPad(result._vs, 32);
         }
         // Set or check the _vs
         if (result._vs == null) {
             result._vs = _vs;
-        }
-        else if (result._vs !== _vs) {
-            logger_1.logger.throwArgumentError('signature _vs mismatch v and s', 'signature', signature);
+        } else if (result._vs !== _vs) {
+            logger.throwArgumentError("signature _vs mismatch v and s", "signature", signature);
         }
     }
     result.yParityAndS = result._vs;
     result.compact = result.r + result.yParityAndS.substring(2);
     return result;
 }
-exports.splitSignature = splitSignature;