essential-eth 0.6.2 → 0.8.0

package/dist/cjs/utils/bytes.js

@@ -1,8 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.hexZeroPad = exports.hexStripZeros = exports.hexValue = exports.hexConcat = exports.hexDataSlice = exports.hexDataLength = exports.hexlify = exports.isHexString = exports.zeroPad = exports.stripZeros = exports.concat = exports.arrayify = exports.isBytes = exports.isBytesLike = void 0;
 // primarily duplicate code from https://github.com/ethers-io/ethers.js/blob/f599d6f23dad0d0acaa3828d6b7acaab2d5e455b/packages/bytes/src.ts/index.ts
-const logger_1 = require("../logger/logger");
+var _typeof = function(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+};
+import { logger } from "../logger/logger";
 /**
  * Check if a value can be converted to a hex string
  *
@@ -14,8 +15,7 @@ const logger_1 = require("../logger/logger");
  * isHexable(val);
  * // true
  * ```
- */
-function isHexable(value) {
+ */ function isHexable(value) {
     return !!value.toHexString;
 }
 /**
@@ -39,11 +39,9 @@ function isHexable(value) {
  * isBytesLike(new Uint8Array(1));
  * // true
  * ```
- */
-function isBytesLike(value) {
-    return (isHexString(value) && !(value.length % 2)) || isBytes(value);
+ */ export function isBytesLike(value) {
+    return isHexString(value) && !(value.length % 2) || isBytes(value);
 }
-exports.isBytesLike = isBytesLike;
 /**
  * Checks if a value is an integer
  *
@@ -59,9 +57,8 @@ exports.isBytesLike = isBytesLike;
  * isInteger(6.2)
  * // false
  * ```
- */
-function isInteger(value) {
-    return typeof value === 'number' && value == value && value % 1 === 0;
+ */ function isInteger(value) {
+    return typeof value === "number" && value == value && value % 1 === 0;
 }
 /**
  * Returns true if and only if value is a valid [Bytes](#bytes)
@@ -84,29 +81,27 @@ function isInteger(value) {
  * isBytes(new Uint8Array(1));
  * // true
  * ```
- */
-function isBytes(value) {
+ */ export function isBytes(value) {
     if (value == null) {
         return false;
     }
     if (value.constructor === Uint8Array) {
         return true;
     }
-    if (typeof value === 'string') {
+    if (typeof value === "string") {
         return false;
     }
     if (!isInteger(value.length) || value.length < 0) {
         return false;
     }
-    for (let i = 0; i < value.length; i++) {
-        const v = value[i];
+    for(var i = 0; i < value.length; i++){
+        var v = value[i];
         if (!isInteger(v) || v < 0 || v >= 256) {
             return false;
         }
     }
     return true;
 }
-exports.isBytes = isBytes;
 /**
  * Converts DataHexStringOrArrayish to a Uint8Array
  * Same as [`ethers.utils.arrayify`](https://docs.ethers.io/v5/api/utils/bytes/#utils-arrayify)
@@ -129,15 +124,14 @@ exports.isBytes = isBytes;
  * arrayify('0x1', { hexPad: 'right' });
  * // Uint8Array(1) [ 16 ]
  * ```
- */
-function arrayify(value, options) {
+ */ export function arrayify(value, options) {
     if (!options) {
         options = {};
     }
-    if (typeof value === 'number') {
-        logger_1.logger.checkSafeUint53(value, 'invalid arrayify value');
-        const result = [];
-        while (value) {
+    if (typeof value === "number") {
+        logger.checkSafeUint53(value, "invalid arrayify value");
+        var result = [];
+        while(value){
             result.unshift(value & 0xff);
             value = parseInt(String(value / 256));
         }
@@ -146,39 +140,34 @@ function arrayify(value, options) {
         }
         return new Uint8Array(result);
     }
-    if (options.allowMissingPrefix &&
-        typeof value === 'string' &&
-        value.substring(0, 2) !== '0x') {
-        value = '0x' + value;
+    if (options.allowMissingPrefix && typeof value === "string" && value.substring(0, 2) !== "0x") {
+        value = "0x" + value;
     }
     if (isHexable(value)) {
         value = value.toHexString();
     }
     if (isHexString(value)) {
-        let hex = value.substring(2);
+        var hex = value.substring(2);
         if (hex.length % 2) {
-            if (options.hexPad === 'left') {
-                hex = '0' + hex;
-            }
-            else if (options.hexPad === 'right') {
-                hex += '0';
-            }
-            else {
-                logger_1.logger.throwArgumentError('hex data is odd-length', 'value', value);
+            if (options.hexPad === "left") {
+                hex = "0" + hex;
+            } else if (options.hexPad === "right") {
+                hex += "0";
+            } else {
+                logger.throwArgumentError("hex data is odd-length", "value", value);
             }
         }
-        const result = [];
-        for (let i = 0; i < hex.length; i += 2) {
-            result.push(parseInt(hex.substring(i, i + 2), 16));
+        var result1 = [];
+        for(var i = 0; i < hex.length; i += 2){
+            result1.push(parseInt(hex.substring(i, i + 2), 16));
         }
-        return new Uint8Array(result);
+        return new Uint8Array(result1);
     }
     if (isBytes(value)) {
         return new Uint8Array(value);
     }
-    return logger_1.logger.throwArgumentError('invalid arrayify value', 'value', value);
+    return logger.throwArgumentError("invalid arrayify value", "value", value);
 }
-exports.arrayify = arrayify;
 /**
  * Concatenates all the BytesLike in arrayOfBytesLike into a single Uint8Array.
  * Same as [`ethers.utils.concat`](https://docs.ethers.io/v5/api/utils/bytes/#utils-concat)
@@ -190,18 +179,20 @@ exports.arrayify = arrayify;
  * concat([0, 1]);
  * // Uint8Array(2) [ 0, 1 ]
  * ```
- */
-function concat(arrayOfBytesLike) {
-    const objects = arrayOfBytesLike.map((item) => arrayify(item));
-    const length = objects.reduce((accum, item) => accum + item.length, 0);
-    const result = new Uint8Array(length);
-    objects.reduce((offset, object) => {
+ */ export function concat(arrayOfBytesLike) {
+    var objects = arrayOfBytesLike.map(function(item) {
+        return arrayify(item);
+    });
+    var length = objects.reduce(function(accum, item) {
+        return accum + item.length;
+    }, 0);
+    var result = new Uint8Array(length);
+    objects.reduce(function(offset, object) {
         result.set(object, offset);
         return offset + object.length;
     }, 0);
     return result;
 }
-exports.concat = concat;
 /**
  * Strips leading zeros from a BytesLike object
  *
@@ -213,15 +204,14 @@ exports.concat = concat;
  * // Uint8Array { [Iterator]  0: 40, 1: 52 }
  * // Equivalent to '0x2834'
  * ```
- */
-function stripZeros(value) {
-    let result = arrayify(value);
+ */ export function stripZeros(value) {
+    var result = arrayify(value);
     if (result.length === 0) {
         return result;
     }
     // Find the first non-zero entry
-    let start = 0;
-    while (start < result.length && result[start] === 0) {
+    var start = 0;
+    while(start < result.length && result[start] === 0){
         start++;
     }
     // If we started with zeros, strip them
@@ -230,7 +220,6 @@ function stripZeros(value) {
     }
     return result;
 }
-exports.stripZeros = stripZeros;
 /**
  * Pads the beginning of a {@link BytesLike} with zeros so it's the specified length as a Uint8Array
  *
@@ -248,17 +237,15 @@ exports.stripZeros = stripZeros;
  * zeroPad([39, 25, 103, 45], 5);
  * // Uint8Array { [Iterator]  0: 0, 1: 39, 2: 25, 3: 103, 4: 45 }
  * ```
- */
-function zeroPad(value, length) {
+ */ export function zeroPad(value, length) {
     value = arrayify(value);
     if (value.length > length) {
-        logger_1.logger.throwArgumentError('value out of range', 'value', value);
+        logger.throwArgumentError("value out of range", "value", value);
     }
-    const result = new Uint8Array(length);
+    var result = new Uint8Array(length);
     result.set(value, length - value.length);
     return result;
 }
-exports.zeroPad = zeroPad;
 /**
  * Returns true if and only if object is a valid hex string.
  * If length is specified and object is not a valid DataHexString of length bytes, an InvalidArgument error is thrown.
@@ -278,9 +265,8 @@ exports.zeroPad = zeroPad;
  * // false
  * // length of 4 in bytes would mean a hex string with 8 characters
  * ```
- */
-function isHexString(value, length) {
-    if (typeof value !== 'string' || !value.match(/^0x[0-9A-Fa-f]*$/)) {
+ */ export function isHexString(value, length) {
+    if (typeof value !== "string" || !value.match(/^0x[0-9A-Fa-f]*$/)) {
         return false;
     }
     if (length && value.length !== 2 + 2 * length) {
@@ -288,8 +274,7 @@ function isHexString(value, length) {
     }
     return true;
 }
-exports.isHexString = isHexString;
-const HexCharacters = '0123456789abcdef';
+var HexCharacters = "0123456789abcdef";
 /**
  * Converts a value into a hex string
  *
@@ -306,66 +291,60 @@ const HexCharacters = '0123456789abcdef';
  * hexlify(14);
  * // '0x0e'
  * ```
- */
-function hexlify(value, options) {
+ */ export function hexlify(value, options) {
     if (!options) {
         options = {};
     }
-    if (typeof value === 'number') {
-        logger_1.logger.checkSafeUint53(value, 'invalid hexlify value');
-        let hex = '';
-        while (value) {
+    if (typeof value === "number") {
+        logger.checkSafeUint53(value, "invalid hexlify value");
+        var hex = "";
+        while(value){
             hex = HexCharacters[value & 0xf] + hex;
             value = Math.floor(value / 16);
         }
         if (hex.length) {
             if (hex.length % 2) {
-                hex = '0' + hex;
+                hex = "0" + hex;
             }
-            return '0x' + hex;
+            return "0x" + hex;
         }
-        return '0x00';
+        return "0x00";
     }
-    if (typeof value === 'bigint') {
+    if ((typeof value === "undefined" ? "undefined" : _typeof(value)) === "bigint") {
         value = value.toString(16);
         if (value.length % 2) {
-            return '0x0' + value;
+            return "0x0" + value;
         }
-        return '0x' + value;
+        return "0x" + value;
     }
-    if (options.allowMissingPrefix &&
-        typeof value === 'string' &&
-        value.substring(0, 2) !== '0x') {
-        value = '0x' + value;
+    if (options.allowMissingPrefix && typeof value === "string" && value.substring(0, 2) !== "0x") {
+        value = "0x" + value;
     }
     if (isHexable(value)) {
         return value.toHexString();
     }
     if (isHexString(value)) {
         if (value.length % 2) {
-            if (options.hexPad === 'left') {
-                value = '0x0' + value.substring(2);
-            }
-            else if (options.hexPad === 'right') {
-                value += '0';
-            }
-            else {
-                logger_1.logger.throwArgumentError('hex data is odd-length', 'value', value);
+            if (options.hexPad === "left") {
+                value = "0x0" + value.substring(2);
+            } else if (options.hexPad === "right") {
+                value += "0";
+            } else {
+                logger.throwArgumentError("hex data is odd-length", "value", value);
             }
         }
         return value.toLowerCase();
     }
     if (isBytes(value)) {
-        let result = '0x';
-        for (let i = 0; i < value.length; i++) {
-            const v = value[i];
+        var result = "0x";
+        for(var i = 0; i < value.length; i++){
+            var v = value[i];
             result += HexCharacters[(v & 0xf0) >> 4] + HexCharacters[v & 0x0f];
         }
         return result;
     }
-    return logger_1.logger.throwArgumentError('invalid hexlify value', 'value', value);
+    return logger.throwArgumentError("invalid hexlify value", "value", value);
 }
-exports.hexlify = hexlify;
 /**
  * Gets the length of data represented as a hex string
  *
@@ -381,17 +360,14 @@ exports.hexlify = hexlify;
  * hexDataLength('0x3925');
  * // 2
  * ```
- */
-function hexDataLength(data) {
-    if (typeof data !== 'string') {
+ */ export function hexDataLength(data) {
+    if (typeof data !== "string") {
         data = hexlify(data);
-    }
-    else if (!isHexString(data) || data.length % 2) {
+    } else if (!isHexString(data) || data.length % 2) {
         return null;
     }
     return (data.length - 2) / 2;
 }
-exports.hexDataLength = hexDataLength;
 /**
  * Slices a {@link BytesLike} to extract a certain part of the input
  *
@@ -404,21 +380,18 @@ exports.hexDataLength = hexDataLength;
  * hexDataSlice([20, 6, 48], 0, 2);
  * // '0x1406'
  * ```
- */
-function hexDataSlice(data, offset, endOffset) {
-    if (typeof data !== 'string') {
+ */ export function hexDataSlice(data, offset, endOffset) {
+    if (typeof data !== "string") {
         data = hexlify(data);
-    }
-    else if (!isHexString(data) || data.length % 2) {
-        logger_1.logger.throwArgumentError('invalid hexData', 'value', data);
+    } else if (!isHexString(data) || data.length % 2) {
+        logger.throwArgumentError("invalid hexData", "value", data);
     }
     offset = 2 + 2 * offset;
     if (endOffset != null) {
-        return '0x' + data.substring(offset, 2 + 2 * endOffset);
+        return "0x" + data.substring(offset, 2 + 2 * endOffset);
     }
-    return '0x' + data.substring(offset);
+    return "0x" + data.substring(offset);
 }
-exports.hexDataSlice = hexDataSlice;
 /**
  * Concatenates values together into one hex string
  *
@@ -429,15 +402,13 @@ exports.hexDataSlice = hexDataSlice;
  * hexConcat([[2, 4, 0, 1], 9, '0x2934', '0x3947']);
  * // '0x020400010929343947'
  * ```
- */
-function hexConcat(items) {
-    let result = '0x';
-    items.forEach((item) => {
+ */ export function hexConcat(items) {
+    var result = "0x";
+    items.forEach(function(item) {
         result += hexlify(item).substring(2);
     });
     return result;
 }
-exports.hexConcat = hexConcat;
 /**
  * Converts a number of different types into a hex string
  *
@@ -453,15 +424,15 @@ exports.hexConcat = hexConcat;
  * hexValue([9, 4, 19, 4]);
  * // '0x9041304'
  * ```
- */
-function hexValue(value) {
-    const trimmed = hexStripZeros(hexlify(value, { hexPad: 'left' }));
-    if (trimmed === '0x') {
-        return '0x0';
+ */ export function hexValue(value) {
+    var trimmed = hexStripZeros(hexlify(value, {
+        hexPad: "left"
+    }));
+    if (trimmed === "0x") {
+        return "0x0";
     }
     return trimmed;
 }
-exports.hexValue = hexValue;
 /**
  * Strips the leading zeros from a value and returns it as a hex string
  *
@@ -472,22 +443,20 @@ exports.hexValue = hexValue;
  * hexStripZeros([0,0,0,48]);
  * // '0x30'
  * ```
- */
-function hexStripZeros(value) {
-    if (typeof value !== 'string') {
+ */ export function hexStripZeros(value) {
+    if (typeof value !== "string") {
         value = hexlify(value);
     }
     if (!isHexString(value)) {
-        logger_1.logger.throwArgumentError('invalid hex string', 'value', value);
+        logger.throwArgumentError("invalid hex string", "value", value);
     }
     value = value.substring(2);
-    let offset = 0;
-    while (offset < value.length && value[offset] === '0') {
+    var offset = 0;
+    while(offset < value.length && value[offset] === "0"){
         offset++;
     }
-    return '0x' + value.substring(offset);
+    return "0x" + value.substring(offset);
 }
-exports.hexStripZeros = hexStripZeros;
 /**
  * Returns a hex string padded to a specified length of bytes.
  *
@@ -515,197 +484,196 @@ exports.hexStripZeros = hexStripZeros;
  * hexZeroPad('12345', 1);
  * // Throws
  * ```
- */
-function hexZeroPad(value, length) {
-    if (typeof value !== 'string') {
+ */ export function hexZeroPad(value, length) {
+    if (typeof value !== "string") {
         value = hexlify(value);
-    }
-    else if (!isHexString(value)) {
-        logger_1.logger.throwArgumentError('invalid hex string', 'value', value);
+    } else if (!isHexString(value)) {
+        logger.throwArgumentError("invalid hex string", "value", value);
     }
     if (value.length > 2 * length + 2) {
-        logger_1.logger.throwError('value out of range', { value, length });
+        logger.throwError("value out of range", {
+            value: value,
+            length: length
+        });
     }
-    while (value.length < 2 * length + 2) {
-        value = '0x0' + value.substring(2);
+    while(value.length < 2 * length + 2){
+        value = "0x0" + value.substring(2);
     }
     return value;
-}
-exports.hexZeroPad = hexZeroPad;
-// export function splitSignature(signature: SignatureLike): Signature {
-//   const result: Signature = {
-//     r: '0x',
-//     s: '0x',
-//     _vs: '0x',
-//     recoveryParam: 0,
-//     v: 0,
-//     yParityAndS: '0x',
-//     compact: '0x',
-//   };
-//   if (isBytesLike(signature)) {
-//     const bytes: Uint8Array = 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.v = bytes[64];
-//     } 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.throwArgumentError(
-//           'signature invalid v byte',
-//           'signature',
-//           signature,
-//         );
-//       }
-//     }
-//     // Compute recoveryParam from v
-//     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.r = signature.r;
-//     result.s = signature.s;
-//     result.v = signature.v;
-//     result.recoveryParam = signature.recoveryParam;
-//     result._vs = signature._vs;
-//     // 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 = zeroPad(arrayify(result._vs), 32);
-//       result._vs = hexlify(vs);
-//       // Set or check the recid
-//       const recoveryParam = vs[0] >= 128 ? 1 : 0;
-//       if (result.recoveryParam == null) {
-//         result.recoveryParam = recoveryParam;
-//       } else if (result.recoveryParam !== recoveryParam) {
-//         logger.throwArgumentError(
-//           'signature recoveryParam mismatch _vs',
-//           'signature',
-//           signature,
-//         );
-//       }
-//       // Set or check the s
-//       vs[0] &= 0x7f;
-//       const s = hexlify(vs);
-//       if (result.s == null) {
-//         result.s = s;
-//       } 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.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 {
-//       if (result.v == null) {
-//         result.v = 27 + result.recoveryParam;
-//       } 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,
-//           );
-//         }
-//       }
-//     }
-//     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.s == null || !isHexString(result.s)) {
-//       logger.throwArgumentError(
-//         'signature missing or invalid s',
-//         'signature',
-//         signature,
-//       );
-//     } else {
-//       result.s = hexZeroPad(result.s, 32);
-//     }
-//     const vs = arrayify(result.s);
-//     if (vs[0] >= 128) {
-//       logger.throwArgumentError(
-//         'signature s out of range',
-//         'signature',
-//         signature,
-//       );
-//     }
-//     if (result.recoveryParam) {
-//       vs[0] |= 0x80;
-//     }
-//     const _vs = hexlify(vs);
-//     if (result._vs) {
-//       if (!isHexString(result._vs)) {
-//         logger.throwArgumentError(
-//           'signature invalid _vs',
-//           'signature',
-//           signature,
-//         );
-//       }
-//       result._vs = 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,
-//       );
-//     }
-//   }
-//   result.yParityAndS = result._vs;
-//   result.compact = result.r + result.yParityAndS.substring(2);
-//   return result;
-// }
-// export function joinSignature(signature: SignatureLike): string {
-//   signature = splitSignature(signature);
-//   return hexlify(
-//     concat([
-//       signature.r,
-//       signature.s,
-//       signature.recoveryParam ? '0x1c' : '0x1b',
-//     ]),
-//   );
-// }
+} // export function splitSignature(signature: SignatureLike): Signature {
+ //   const result: Signature = {
+ //     r: '0x',
+ //     s: '0x',
+ //     _vs: '0x',
+ //     recoveryParam: 0,
+ //     v: 0,
+ //     yParityAndS: '0x',
+ //     compact: '0x',
+ //   };
+ //   if (isBytesLike(signature)) {
+ //     const bytes: Uint8Array = 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.v = bytes[64];
+ //     } 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.throwArgumentError(
+ //           'signature invalid v byte',
+ //           'signature',
+ //           signature,
+ //         );
+ //       }
+ //     }
+ //     // Compute recoveryParam from v
+ //     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.r = signature.r;
+ //     result.s = signature.s;
+ //     result.v = signature.v;
+ //     result.recoveryParam = signature.recoveryParam;
+ //     result._vs = signature._vs;
+ //     // 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 = zeroPad(arrayify(result._vs), 32);
+ //       result._vs = hexlify(vs);
+ //       // Set or check the recid
+ //       const recoveryParam = vs[0] >= 128 ? 1 : 0;
+ //       if (result.recoveryParam == null) {
+ //         result.recoveryParam = recoveryParam;
+ //       } else if (result.recoveryParam !== recoveryParam) {
+ //         logger.throwArgumentError(
+ //           'signature recoveryParam mismatch _vs',
+ //           'signature',
+ //           signature,
+ //         );
+ //       }
+ //       // Set or check the s
+ //       vs[0] &= 0x7f;
+ //       const s = hexlify(vs);
+ //       if (result.s == null) {
+ //         result.s = s;
+ //       } 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.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 {
+ //       if (result.v == null) {
+ //         result.v = 27 + result.recoveryParam;
+ //       } 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,
+ //           );
+ //         }
+ //       }
+ //     }
+ //     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.s == null || !isHexString(result.s)) {
+ //       logger.throwArgumentError(
+ //         'signature missing or invalid s',
+ //         'signature',
+ //         signature,
+ //       );
+ //     } else {
+ //       result.s = hexZeroPad(result.s, 32);
+ //     }
+ //     const vs = arrayify(result.s);
+ //     if (vs[0] >= 128) {
+ //       logger.throwArgumentError(
+ //         'signature s out of range',
+ //         'signature',
+ //         signature,
+ //       );
+ //     }
+ //     if (result.recoveryParam) {
+ //       vs[0] |= 0x80;
+ //     }
+ //     const _vs = hexlify(vs);
+ //     if (result._vs) {
+ //       if (!isHexString(result._vs)) {
+ //         logger.throwArgumentError(
+ //           'signature invalid _vs',
+ //           'signature',
+ //           signature,
+ //         );
+ //       }
+ //       result._vs = 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,
+ //       );
+ //     }
+ //   }
+ //   result.yParityAndS = result._vs;
+ //   result.compact = result.r + result.yParityAndS.substring(2);
+ //   return result;
+ // }
+ // export function joinSignature(signature: SignatureLike): string {
+ //   signature = splitSignature(signature);
+ //   return hexlify(
+ //     concat([
+ //       signature.r,
+ //       signature.s,
+ //       signature.recoveryParam ? '0x1c' : '0x1b',
+ //     ]),
+ //   );
+ // }