essential-eth 0.9.1-next.0 → 0.9.1-next.1

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

@@ -1,7 +1,10 @@
-import { hexDataSlice } from "./bytes";
-import { computePublicKey } from "./compute-public-key";
-import { keccak256 } from "./keccak256";
-import { toChecksumAddress } from "./to-checksum-address";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeAddress = void 0;
+const bytes_1 = require("./bytes");
+const compute_public_key_1 = require("./compute-public-key");
+const keccak256_1 = require("./keccak256");
+const to_checksum_address_1 = require("./to-checksum-address");
 /**
  * Computes the address that corresponds to a specified public or private key
  *
@@ -17,11 +20,15 @@ import { toChecksumAddress } from "./to-checksum-address";
  * computeAddress('0x2f2c419acf4a1da8c1ebea75bb3fcfbd3ec2aa3bf0162901ccdc2f38b8f92427'); // private key
  * // '0xA2902059a7BF992f1450BACD7357CCAa5cC8336a'
  * ```
- */ export function computeAddress(key) {
+ */
+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 = computePublicKey(key);
+    if (!key.startsWith('0x04') &&
+        !key.startsWith('0x03') &&
+        !key.startsWith('0x02')) {
+        key = (0, compute_public_key_1.computePublicKey)(key);
     }
-    return toChecksumAddress(hexDataSlice(keccak256(hexDataSlice(key, 1)), 12));
+    return (0, to_checksum_address_1.toChecksumAddress)((0, bytes_1.hexDataSlice)((0, keccak256_1.keccak256)((0, bytes_1.hexDataSlice)(key, 1)), 12));
 }
+exports.computeAddress = computeAddress;

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

@@ -1,5 +1,8 @@
-import { Point } from "@noble/secp256k1";
-import { hexlify } from "./bytes";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computePublicKey = void 0;
+const secp256k1_1 = require("@noble/secp256k1");
+const bytes_1 = require("./bytes");
 /**
  * Computes the public key from a given private key
  *
@@ -15,7 +18,9 @@ import { hexlify } from "./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'
  * ```
- */ export function computePublicKey(privKey) {
-    privKey = hexlify(privKey).slice(2);
-    return "0x" + Point.fromPrivateKey(privKey).toHex();
+ */
+function computePublicKey(privKey) {
+    privKey = (0, bytes_1.hexlify)(privKey).slice(2);
+    return '0x' + secp256k1_1.Point.fromPrivateKey(privKey).toHex();
 }
+exports.computePublicKey = computePublicKey;

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

@@ -1,5 +1,8 @@
-import { tinyBig } from "../shared/tiny-big/tiny-big";
-import { validateType } from "../shared/validate-type";
+"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");
 /**
  * Convert from Ether to Gwei
  *
@@ -23,12 +26,10 @@ import { validateType } from "../shared/validate-type";
  * etherToGwei(1000).toNumber()
  * // 1000000000000
  * ```
- */ export function etherToGwei(etherQuantity) {
-    validateType(etherQuantity, [
-        "string",
-        "number",
-        "object"
-    ]);
-    var result = tinyBig(etherQuantity).times("1000000000");
-    return tinyBig(result);
+ */
+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);
 }
+exports.etherToGwei = etherToGwei;

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

@@ -1,5 +1,8 @@
-import { tinyBig } from "../shared/tiny-big/tiny-big";
-import { validateType } from "../shared/validate-type";
+"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");
 /**
  * Convert Ether to Wei
  *
@@ -23,12 +26,10 @@ import { validateType } from "../shared/validate-type";
  * etherToWei(1000).toNumber()
  * // 1000000000000000000000
  * ```
- */ export function etherToWei(etherQuantity) {
-    validateType(etherQuantity, [
-        "string",
-        "number",
-        "object"
-    ]);
-    var result = tinyBig(etherQuantity).times("1000000000000000000");
-    return tinyBig(result);
+ */
+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);
 }
+exports.etherToWei = etherToWei;

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

@@ -1,5 +1,8 @@
-import { tinyBig } from "../shared/tiny-big/tiny-big";
-import { validateType } from "../shared/validate-type";
+"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");
 /**
  * Convert from Gwei to Ether
  *
@@ -23,12 +26,10 @@ import { validateType } from "../shared/validate-type";
  * gweiToEther(1000000000000).toNumber()
  * // 1000
  * ```
- */ export function gweiToEther(gweiQuantity) {
-    validateType(gweiQuantity, [
-        "string",
-        "number",
-        "object"
-    ]);
-    var result = tinyBig(gweiQuantity).div("1000000000");
-    return tinyBig(result);
+ */
+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);
 }
+exports.gweiToEther = gweiToEther;

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

@@ -1,7 +1,10 @@
-import { concat } from "./bytes";
-import { keccak256 } from "./keccak256";
-import { toUtf8Bytes } from "./to-utf8-bytes";
-var messagePrefix = "\x19Ethereum Signed Message:\n";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashMessage = void 0;
+const bytes_1 = require("./bytes");
+const keccak256_1 = require("./keccak256");
+const to_utf8_bytes_1 = require("./to-utf8-bytes");
+const 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.
@@ -13,13 +16,15 @@ var messagePrefix = "\x19Ethereum Signed Message:\n";
  * hashMessage("Hello World");
  * // '0xa1de988600a42c4b4ab089b619297c17d53cffae5d5120d82d8a92d0bb3b78f2'
  * ```
- */ export function hashMessage(message) {
-    if (typeof message === "string") {
-        message = toUtf8Bytes(message);
+ */
+function hashMessage(message) {
+    if (typeof message === 'string') {
+        message = (0, to_utf8_bytes_1.toUtf8Bytes)(message);
     }
-    return keccak256(concat([
-        toUtf8Bytes(messagePrefix),
-        toUtf8Bytes(String(message.length)),
-        message
+    return (0, keccak256_1.keccak256)((0, bytes_1.concat)([
+        (0, to_utf8_bytes_1.toUtf8Bytes)(messagePrefix),
+        (0, to_utf8_bytes_1.toUtf8Bytes)(String(message.length)),
+        message,
     ]));
 }
+exports.hashMessage = hashMessage;

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

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

package/dist/cjs/utils/keccak256.js

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

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

@@ -1,12 +1,15 @@
-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]*)\\]$");
+"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]*)\\]$');
 /**
  * Packs a type and value together into a UTF-8 Byte Array
  *
@@ -16,66 +19,70 @@ var 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 zeroPad(value, 32);
+                return (0, bytes_1.zeroPad)(value, 32);
             }
-            return arrayify(value);
-        case "string":
-            return Buffer.from(value);
-        case "bytes":
-            return arrayify(value);
-        case "bool":
-            value = value ? "0x01" : "0x00";
+            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';
             if (isArray) {
-                return zeroPad(value, 32);
+                return (0, bytes_1.zeroPad)(value, 32);
             }
-            return arrayify(value);
+            return (0, bytes_1.arrayify)(value);
     }
-    var match = type.match(regexNumber);
+    let match = type.match(regexNumber);
     if (match) {
         //let signed = (match[1] === "int")
-        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);
+        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);
         }
         if (isArray) {
             size = 256;
         }
-        value = tinyBig(value).toTwos(size).toNumber();
-        var hexValue = hexlify(value);
-        return zeroPad(hexValue, size / 8);
+        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);
     }
     match = type.match(regexBytes);
     if (match) {
-        var size1 = parseInt(match[1]);
-        if (String(size1) !== match[1] || size1 === 0 || size1 > 32) {
-            logger.throwArgumentError("invalid bytes type", "type", type);
+        const size = parseInt(match[1]);
+        if (String(size) !== match[1] || size === 0 || size > 32) {
+            logger_1.logger.throwArgumentError('invalid bytes type', 'type', type);
         }
-        if (arrayify(value).byteLength !== size1) {
-            logger.throwArgumentError("invalid value for ".concat(type), "value", value);
+        if ((0, bytes_1.arrayify)(value).byteLength !== size) {
+            logger_1.logger.throwArgumentError(`invalid value for ${type}`, 'value', value);
         }
         if (isArray) {
-            return arrayify((value + hexFalse).substring(0, 66));
+            return (0, bytes_1.arrayify)((value + encode_decode_transaction_1.hexFalse).substring(0, 66));
         }
         return value;
     }
     match = type.match(regexArray);
     if (match && Array.isArray(value)) {
-        var baseType = match[1];
-        var count = parseInt(match[2] || String(value.length));
+        const baseType = match[1];
+        const count = parseInt(match[2] || String(value.length));
         if (count != value.length) {
-            logger.throwArgumentError("invalid array length for ".concat(type), "value", value);
+            logger_1.logger.throwArgumentError(`invalid array length for ${type}`, 'value', value);
         }
-        var result = [];
-        value.forEach(function(value) {
+        const result = [];
+        value.forEach(function (value) {
             result.push(_pack(baseType, value, true));
         });
-        return concat(result);
+        return (0, bytes_1.concat)(result);
     }
-    return logger.throwArgumentError("invalid type", "type", type);
+    return logger_1.logger.throwArgumentError('invalid type', 'type', type);
 }
 /**
  * Converts arrays with types and values into a hex string that can be hashed
@@ -90,16 +97,18 @@ var regexArray = new RegExp("^(.*)\\[([0-9]*)\\]$");
  * pack(types, values);
  * // '0x0174657874000000000000001e'
  * ```
- */ export function pack(types, values) {
+ */
+function pack(types, values) {
     if (types.length != values.length) {
-        logger.throwArgumentError("wrong number of values; expected ${ types.length }", "values", values);
+        logger_1.logger.throwArgumentError('wrong number of values; expected ${ types.length }', 'values', values);
     }
-    var tight = [];
-    types.forEach(function(type, index) {
+    const tight = [];
+    types.forEach(function (type, index) {
         tight.push(_pack(type, values[index]));
     });
-    return hexlify(concat(tight));
+    return (0, bytes_1.hexlify)((0, bytes_1.concat)(tight));
 }
+exports.pack = pack;
 /**
  * Hashes data from Solidity using the Keccak256 algorithm.
  *
@@ -122,6 +131,8 @@ var regexArray = new RegExp("^(.*)\\[([0-9]*)\\]$");
  * solidityKeccak256(types, values);
  * // '0x038707a887f09355dc545412b058e7ba8f3c74047050c7c5e5e52eec608053d9'
  * ```
- */ export function solidityKeccak256(types, values) {
-    return keccak256(pack(types, values));
+ */
+function solidityKeccak256(types, values) {
+    return (0, keccak256_1.keccak256)(pack(types, values));
 }
+exports.solidityKeccak256 = solidityKeccak256;

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

@@ -1,5 +1,8 @@
-import { logger } from "./../logger/logger";
-import { arrayify, hexlify, hexZeroPad, isBytesLike, isHexString, zeroPad } from "./bytes";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitSignature = void 0;
+const logger_1 = require("./../logger/logger");
+const bytes_1 = require("./bytes");
 /**
  * Expands a signature into the full signature object and fills in missing properties.
  *
@@ -21,48 +24,53 @@ import { arrayify, hexlify, hexZeroPad, isBytesLike, isHexString, zeroPad } from
  *    compact: "0x60bc4ed91f2021aefe7045f3f77bd12f87eb733aee24bd1965343b3c27b3971647252185b7d2abb411b01b5d1ac4ab41ea486df1e9b396758c1aec6c1b6eee33"
  *  }
  * ```
- */ export function splitSignature(signature) {
-    var result = {
-        r: "0x",
-        s: "0x",
-        _vs: "0x",
+ */
+function splitSignature(signature) {
+    const result = {
+        r: '0x',
+        s: '0x',
+        _vs: '0x',
         recoveryParam: 0,
         v: 0,
-        yParityAndS: "0x",
-        compact: "0x"
+        yParityAndS: '0x',
+        compact: '0x',
     };
-    if (isBytesLike(signature)) {
-        var bytes = arrayify(signature);
+    if ((0, bytes_1.isBytesLike)(signature)) {
+        const bytes = (0, bytes_1.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 = 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.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.v = bytes[64];
-        } else {
-            logger.throwArgumentError("invalid signature string", "signature", signature);
+        }
+        else {
+            logger_1.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.throwArgumentError("signature invalid v byte", "signature", signature);
+            }
+            else {
+                logger_1.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 = hexlify(bytes.slice(32, 64));
-    } else {
+        result._vs = (0, bytes_1.hexlify)(bytes.slice(32, 64));
+    }
+    else {
         result.r = signature.r;
         result.s = signature.s;
         result.v = signature.v;
@@ -71,75 +79,85 @@ import { arrayify, hexlify, hexZeroPad, isBytesLike, isHexString, zeroPad } from
         // 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) {
-            var vs_1 = zeroPad(arrayify(result._vs), 32);
-            result._vs = hexlify(vs_1);
+            const vs_1 = (0, bytes_1.zeroPad)((0, bytes_1.arrayify)(result._vs), 32);
+            result._vs = (0, bytes_1.hexlify)(vs_1);
             // Set or check the recid
-            var recoveryParam = vs_1[0] >= 128 ? 1 : 0;
+            const recoveryParam = vs_1[0] >= 128 ? 1 : 0;
             if (result.recoveryParam == null) {
                 result.recoveryParam = recoveryParam;
-            } else if (result.recoveryParam !== recoveryParam) {
-                logger.throwArgumentError("signature recoveryParam mismatch _vs", "signature", signature);
+            }
+            else if (result.recoveryParam !== recoveryParam) {
+                logger_1.logger.throwArgumentError('signature recoveryParam mismatch _vs', 'signature', signature);
             }
             // Set or check the s
             vs_1[0] &= 0x7f;
-            var s = hexlify(vs_1);
+            const s = (0, bytes_1.hexlify)(vs_1);
             if (result.s == null) {
                 result.s = s;
-            } else if (result.s !== s) {
-                logger.throwArgumentError("signature v mismatch _vs", "signature", signature);
+            }
+            else if (result.s !== s) {
+                logger_1.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.throwArgumentError("signature missing v and recoveryParam", "signature", signature);
-            } else if (result.v === 0 || result.v === 1) {
+                logger_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 {
+            else {
+                result.recoveryParam = 1 - (result.v % 2);
+            }
+        }
+        else {
             if (result.v == null) {
                 result.v = 27 + result.recoveryParam;
-            } else {
-                var recId = result.v === 0 || result.v === 1 ? result.v : 1 - result.v % 2;
+            }
+            else {
+                const recId = result.v === 0 || result.v === 1 ? result.v : 1 - (result.v % 2);
                 if (result.recoveryParam !== recId) {
-                    logger.throwArgumentError("signature recoveryParam mismatch v", "signature", signature);
+                    logger_1.logger.throwArgumentError('signature recoveryParam mismatch v', '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);
+        if (result.r == null || !(0, bytes_1.isHexString)(result.r)) {
+            logger_1.logger.throwArgumentError('signature missing or invalid r', 'signature', signature);
         }
-        if (result.s == null || !isHexString(result.s)) {
-            logger.throwArgumentError("signature missing or invalid s", "signature", signature);
-        } else {
-            result.s = hexZeroPad(result.s, 32);
+        else {
+            result.r = (0, bytes_1.hexZeroPad)(result.r, 32);
         }
-        var vs = arrayify(result.s);
+        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);
         if (vs[0] >= 128) {
-            logger.throwArgumentError("signature s out of range", "signature", signature);
+            logger_1.logger.throwArgumentError('signature s out of range', 'signature', signature);
         }
         if (result.recoveryParam) {
             vs[0] |= 0x80;
         }
-        var _vs = hexlify(vs);
+        const _vs = (0, bytes_1.hexlify)(vs);
         if (result._vs) {
-            if (!isHexString(result._vs)) {
-                logger.throwArgumentError("signature invalid _vs", "signature", signature);
+            if (!(0, bytes_1.isHexString)(result._vs)) {
+                logger_1.logger.throwArgumentError('signature invalid _vs', 'signature', signature);
             }
-            result._vs = hexZeroPad(result._vs, 32);
+            result._vs = (0, bytes_1.hexZeroPad)(result._vs, 32);
         }
         // Set or check the _vs
         if (result._vs == null) {
             result._vs = _vs;
-        } else if (result._vs !== _vs) {
-            logger.throwArgumentError("signature _vs mismatch v and s", "signature", signature);
+        }
+        else if (result._vs !== _vs) {
+            logger_1.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;