essential-eth 0.5.1 → 0.5.5

package/lib/cjs/utils/bytes.d.ts

@@ -9,7 +9,8 @@ export declare type Bytes = ArrayLike<number>;
  * @example
  * '0x123'
  */
-export declare type BytesLike = Bytes | string | number;
+export declare type BytesLike = Bytes | string;
+export declare type BytesLikeWithNumber = BytesLike | number;
 export interface DataOptions {
     allowMissingPrefix?: boolean;
     hexPad?: 'left' | 'right' | null;
@@ -33,12 +34,93 @@ export interface Signature {
     yParityAndS: string;
     compact: string;
 }
+/**
+ * Returns true if and only if value is a valid [Bytes](#bytes) or DataHexString
+ * * Same as [`ethers.utils.isBytesLike`](https://docs.ethers.io/v5/api/utils/bytes/#utils-isBytesLike)
+ *
+ * @example
+ * ```js
+ * isBytesLike([1,2,3]);
+ * // true
+ * ```
+ *
+ * @example
+ * ```js
+ * isBytesLike(false);
+ * // false
+ * ```
+ *
+ * @example
+ * ```js
+ * isBytesLike(new Uint8Array(1));
+ * // true
+ * ```
+ */
 export declare function isBytesLike(value: any): value is BytesLike;
+/**
+ * Returns true if and only if value is a valid [Bytes](#bytes)
+ * * Same as [`ethers.utils.isBytes`](https://docs.ethers.io/v5/api/utils/bytes/#utils-isBytes)
+ *
+ * @example
+ * ```js
+ * isBytes([1,2,3]);
+ * // true
+ * ```
+ *
+ * @example
+ * ```js
+ * isBytes(false);
+ * // false
+ * ```
+ *
+ * @example
+ * ```js
+ * isBytes(new Uint8Array(1));
+ * // true
+ * ```
+ */
 export declare function isBytes(value: any): value is Bytes;
+/**
+ * Converts DataHexStringOrArrayish to a Uint8Array
+ * * Same as [`ethers.utils.arrayify`](https://docs.ethers.io/v5/api/utils/bytes/#utils-arrayify)
+ *
+ * @example
+ * ```js
+ * arrayify(1);
+ * // Uint8Array(1) [ 1 ]
+ * ```
+ *
+ * @example
+ * ```js
+ * arrayify(0x1234);
+ * // Uint8Array(2) [ 18, 52 ]
+ * ```
+ *
+ * @example
+ * ```js
+ * arrayify('0x1', { hexPad: 'right' });
+ * // Uint8Array(1) [ 16 ]
+ * ```
+ */
 export declare function arrayify(value: BytesLike | Hexable | number, options?: DataOptions): Uint8Array;
-export declare function concat(items: ReadonlyArray<BytesLike>): Uint8Array;
+/**
+ * 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)
+ *
+ * @example
+ * ```js
+ * concat([0, 1]);
+ * // Uint8Array(2) [ 0, 1 ]
+ * ```
+ */
+export declare function concat(arrayOfBytesLike: ReadonlyArray<BytesLikeWithNumber>): Uint8Array;
 export declare function stripZeros(value: BytesLike): Uint8Array;
 export declare function zeroPad(value: BytesLike, length: number): Uint8Array;
+/**
+ * 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.
+ * * Same as [`ethers.utils.isHexString`](https://docs.ethers.io/v5/api/utils/bytes/#utils-isHexString)
+ */
 export declare function isHexString(value: any, length?: number): boolean;
 /**
  * @example
@@ -52,7 +134,7 @@ export declare function isHexString(value: any, length?: number): boolean;
  */
 export declare function hexlify(value: BytesLike | Hexable | number | bigint, options?: DataOptions): string;
 export declare function hexDataLength(data: BytesLike): number | null;
-export declare function hexDataSlice(data: BytesLike, offset: number, endOffset?: number): string;
+export declare function hexDataSlice(data: BytesLikeWithNumber, offset: number, endOffset?: number): string;
 export declare function hexConcat(items: ReadonlyArray<BytesLike>): string;
 export declare function hexValue(value: BytesLike | Hexable | number | bigint): string;
 export declare function hexStripZeros(value: BytesLike): string;
@@ -87,4 +169,4 @@ export declare function hexStripZeros(value: BytesLike): string;
  * // Throws
  * ```
  */
-export declare function hexZeroPad(value: BytesLike, length: number): string;
+export declare function hexZeroPad(value: BytesLikeWithNumber, length: number): string;

package/lib/cjs/utils/bytes.js

@@ -3,10 +3,31 @@
 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;
 const logger_1 = require("../logger/logger");
-///////////////////////////////
 function isHexable(value) {
     return !!value.toHexString;
 }
+/**
+ * Returns true if and only if value is a valid [Bytes](#bytes) or DataHexString
+ * * Same as [`ethers.utils.isBytesLike`](https://docs.ethers.io/v5/api/utils/bytes/#utils-isBytesLike)
+ *
+ * @example
+ * ```js
+ * isBytesLike([1,2,3]);
+ * // true
+ * ```
+ *
+ * @example
+ * ```js
+ * isBytesLike(false);
+ * // false
+ * ```
+ *
+ * @example
+ * ```js
+ * isBytesLike(new Uint8Array(1));
+ * // true
+ * ```
+ */
 function isBytesLike(value) {
     return (isHexString(value) && !(value.length % 2)) || isBytes(value);
 }
@@ -14,6 +35,28 @@ exports.isBytesLike = isBytesLike;
 function isInteger(value) {
     return typeof value === 'number' && value == value && value % 1 === 0;
 }
+/**
+ * Returns true if and only if value is a valid [Bytes](#bytes)
+ * * Same as [`ethers.utils.isBytes`](https://docs.ethers.io/v5/api/utils/bytes/#utils-isBytes)
+ *
+ * @example
+ * ```js
+ * isBytes([1,2,3]);
+ * // true
+ * ```
+ *
+ * @example
+ * ```js
+ * isBytes(false);
+ * // false
+ * ```
+ *
+ * @example
+ * ```js
+ * isBytes(new Uint8Array(1));
+ * // true
+ * ```
+ */
 function isBytes(value) {
     if (value == null) {
         return false;
@@ -36,6 +79,28 @@ function isBytes(value) {
     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)
+ *
+ * @example
+ * ```js
+ * arrayify(1);
+ * // Uint8Array(1) [ 1 ]
+ * ```
+ *
+ * @example
+ * ```js
+ * arrayify(0x1234);
+ * // Uint8Array(2) [ 18, 52 ]
+ * ```
+ *
+ * @example
+ * ```js
+ * arrayify('0x1', { hexPad: 'right' });
+ * // Uint8Array(1) [ 16 ]
+ * ```
+ */
 function arrayify(value, options) {
     if (!options) {
         options = {};
@@ -85,8 +150,18 @@ function arrayify(value, options) {
     return logger_1.logger.throwArgumentError('invalid arrayify value', 'value', value);
 }
 exports.arrayify = arrayify;
-function concat(items) {
-    const objects = items.map((item) => arrayify(item));
+/**
+ * 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)
+ *
+ * @example
+ * ```js
+ * 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) => {
@@ -123,6 +198,11 @@ function zeroPad(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.
+ * * Same as [`ethers.utils.isHexString`](https://docs.ethers.io/v5/api/utils/bytes/#utils-isHexString)
+ */
 function isHexString(value, length) {
     if (typeof value !== 'string' || !value.match(/^0x[0-9A-Fa-f]*$/)) {
         return false;

package/lib/cjs/utils/compute-address.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Computes the address that corresponds to a specified public or private key
+ *
+ * @param key the public or private key to find the address related to
+ *
+ * @returns the address that corresponds to the key specified
+ */
+export declare function computeAddress(key: string): string;

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

@@ -0,0 +1,24 @@
+"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");
+/**
+ * Computes the address that corresponds to a specified public or private key
+ *
+ * @param key the public or private key to find the address related to
+ *
+ * @returns the address that corresponds to the key specified
+ */
+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);
+    }
+    return (0, __1.toChecksumAddress)((0, bytes_1.hexDataSlice)((0, keccak256_1.keccak256)((0, bytes_1.hexDataSlice)(key, 1)), 12));
+}
+exports.computeAddress = computeAddress;

package/lib/cjs/utils/compute-public-key.d.ts

@@ -0,0 +1,9 @@
+import { BytesLike } from './bytes';
+/**
+ * Computes the public key from a given private key
+ *
+ * @param key the private key to find a public key from
+ *
+ * @returns the public key
+ */
+export declare function computePublicKey(privKey: BytesLike): string;

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

@@ -0,0 +1,17 @@
+"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
+ *
+ * @param key the private key to find a public key from
+ *
+ * @returns the public key
+ */
+function computePublicKey(privKey) {
+    privKey = (0, bytes_1.hexlify)(privKey).slice(2);
+    return '0x' + secp256k1_1.Point.fromPrivateKey(privKey).toHex();
+}
+exports.computePublicKey = computePublicKey;

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

@@ -0,0 +1,12 @@
+import { Bytes } from '../index';
+/**
+ * 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.
+ *
+ * @example
+ * ```js
+ * hashMessage("Hello World");
+ * // '0xa1de988600a42c4b4ab089b619297c17d53cffae5d5120d82d8a92d0bb3b78f2'
+ * ```
+ */
+export declare function hashMessage(message: Bytes | string): string;

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashMessage = void 0;
+const index_1 = require("../index");
+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.
+ *
+ * @example
+ * ```js
+ * hashMessage("Hello World");
+ * // '0xa1de988600a42c4b4ab089b619297c17d53cffae5d5120d82d8a92d0bb3b78f2'
+ * ```
+ */
+function hashMessage(message) {
+    if (typeof message === 'string') {
+        message = (0, index_1.toUtf8Bytes)(message);
+    }
+    return (0, index_1.keccak256)((0, index_1.concat)([
+        (0, index_1.toUtf8Bytes)(messagePrefix),
+        (0, index_1.toUtf8Bytes)(String(message.length)),
+        message,
+    ]));
+}
+exports.hashMessage = hashMessage;

package/lib/cjs/utils/keccak256.d.ts

@@ -0,0 +1,2 @@
+import { BytesLike } from './bytes';
+export declare const keccak256: (data: BytesLike) => string;

package/lib/cjs/utils/keccak256.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keccak256 = void 0;
+const sha3_1 = require("sha3");
+const keccak256 = (data) => {
+    let 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');
+    return addressHash;
+};
+exports.keccak256 = keccak256;

package/lib/cjs/utils/solidity-keccak256.d.ts

@@ -1,5 +1,4 @@
 export declare function pack(types: ReadonlyArray<string>, values: ReadonlyArray<any>): string;
-export declare const hashKeccak256: (data: string) => string;
 /**
  * Hashes data from Solidity using the Keccak256 algorithm.
  *

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

@@ -1,15 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.solidityKeccak256 = exports.hashKeccak256 = exports.pack = void 0;
+exports.solidityKeccak256 = exports.pack = void 0;
 const buffer_1 = require("buffer");
-const sha3_1 = require("sha3");
+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]*)\\]$');
-const Zeros = '0000000000000000000000000000000000000000000000000000000000000000';
 function _pack(type, value, isArray) {
     switch (type) {
         case 'address':
@@ -55,7 +55,7 @@ function _pack(type, value, isArray) {
             logger_1.logger.throwArgumentError(`invalid value for ${type}`, 'value', value);
         }
         if (isArray) {
-            return (0, bytes_1.arrayify)((value + Zeros).substring(0, 66));
+            return (0, bytes_1.arrayify)((value + encode_decode_transaction_1.hexFalse).substring(0, 66));
         }
         return value;
     }
@@ -85,13 +85,6 @@ function pack(types, values) {
     return (0, bytes_1.hexlify)((0, bytes_1.concat)(tight));
 }
 exports.pack = pack;
-const hashKeccak256 = (data) => {
-    const keccak = new sha3_1.Keccak(256);
-    const bufferableData = buffer_1.Buffer.from(data.replace(/^0x/, ''), 'hex');
-    const addressHash = '0x' + keccak.update(bufferableData).digest('hex');
-    return addressHash;
-};
-exports.hashKeccak256 = hashKeccak256;
 /**
  * Hashes data from Solidity using the Keccak256 algorithm.
  *
@@ -120,6 +113,6 @@ exports.hashKeccak256 = hashKeccak256;
  * ```
  */
 function solidityKeccak256(types, values) {
-    return (0, exports.hashKeccak256)(pack(types, values));
+    return (0, keccak256_1.keccak256)(pack(types, values));
 }
 exports.solidityKeccak256 = solidityKeccak256;

package/lib/cjs/utils/split-signature.d.ts

@@ -0,0 +1,26 @@
+import { Signature, SignatureLike } from './bytes';
+/**
+ * Expands a signature into the full signature object and fills in missing properties.
+ *
+ * * Same as ["splitSignature" in ethers.js](https://docs.ethers.io/v5/api/utils/bytes/#utils-splitSignature)
+ *
+ * @param signature the signature object to split, parse, and compute missing properties from
+ *
+ * @returns a full signature object with all properties filled
+ *
+ * @example
+ * ```javascript
+ * const signature = '0x60bc4ed91f2021aefe7045f3f77bd12f87eb733aee24bd1965343b3c27b3971647252185b7d2abb411b01b5d1ac4ab41ea486df1e9b396758c1aec6c1b6eee331b';
+ * splitSignature(signature);
+ *  {
+ *    r: "0x60bc4ed91f2021aefe7045f3f77bd12f87eb733aee24bd1965343b3c27b39716",
+ *    s: "0x47252185b7d2abb411b01b5d1ac4ab41ea486df1e9b396758c1aec6c1b6eee33",
+ *    _vs: "0x47252185b7d2abb411b01b5d1ac4ab41ea486df1e9b396758c1aec6c1b6eee33",
+ *    recoveryParam: 0,
+ *    v: 27,
+ *    yParityAndS: "0x47252185b7d2abb411b01b5d1ac4ab41ea486df1e9b396758c1aec6c1b6eee33",
+ *    compact: "0x60bc4ed91f2021aefe7045f3f77bd12f87eb733aee24bd1965343b3c27b3971647252185b7d2abb411b01b5d1ac4ab41ea486df1e9b396758c1aec6c1b6eee33"
+ *  }
+ * ```
+ */
+export declare function splitSignature(signature: SignatureLike): Signature;

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

@@ -0,0 +1,165 @@
+"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.
+ *
+ * * Same as ["splitSignature" in ethers.js](https://docs.ethers.io/v5/api/utils/bytes/#utils-splitSignature)
+ *
+ * @param signature the signature object to split, parse, and compute missing properties from
+ *
+ * @returns a full signature object with all properties filled
+ *
+ * @example
+ * ```javascript
+ * const signature = '0x60bc4ed91f2021aefe7045f3f77bd12f87eb733aee24bd1965343b3c27b3971647252185b7d2abb411b01b5d1ac4ab41ea486df1e9b396758c1aec6c1b6eee331b';
+ * splitSignature(signature);
+ *  {
+ *    r: "0x60bc4ed91f2021aefe7045f3f77bd12f87eb733aee24bd1965343b3c27b39716",
+ *    s: "0x47252185b7d2abb411b01b5d1ac4ab41ea486df1e9b396758c1aec6c1b6eee33",
+ *    _vs: "0x47252185b7d2abb411b01b5d1ac4ab41ea486df1e9b396758c1aec6c1b6eee33",
+ *    recoveryParam: 0,
+ *    v: 27,
+ *    yParityAndS: "0x47252185b7d2abb411b01b5d1ac4ab41ea486df1e9b396758c1aec6c1b6eee33",
+ *    compact: "0x60bc4ed91f2021aefe7045f3f77bd12f87eb733aee24bd1965343b3c27b3971647252185b7d2abb411b01b5d1ac4ab41ea486df1e9b396758c1aec6c1b6eee33"
+ *  }
+ * ```
+ */
+function splitSignature(signature) {
+    const result = {
+        r: '0x',
+        s: '0x',
+        _vs: '0x',
+        recoveryParam: 0,
+        v: 0,
+        yParityAndS: '0x',
+        compact: '0x',
+    };
+    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 = (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_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_1.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 = (0, bytes_1.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_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
+            const 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);
+            }
+            // Set or check the s
+            vs_1[0] &= 0x7f;
+            const s = (0, bytes_1.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);
+            }
+        }
+        // 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) {
+                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_1.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);
+        }
+        else {
+            result.r = (0, bytes_1.hexZeroPad)(result.r, 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);
+        if (vs[0] >= 128) {
+            logger_1.logger.throwArgumentError('signature s out of range', 'signature', signature);
+        }
+        if (result.recoveryParam) {
+            vs[0] |= 0x80;
+        }
+        const _vs = (0, bytes_1.hexlify)(vs);
+        if (result._vs) {
+            if (!(0, bytes_1.isHexString)(result._vs)) {
+                logger_1.logger.throwArgumentError('signature invalid _vs', 'signature', signature);
+            }
+            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_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;

package/lib/cjs/utils/to-utf8-bytes.d.ts

@@ -0,0 +1 @@
+export declare function toUtf8Bytes(data: string): Uint8Array;

package/lib/cjs/utils/to-utf8-bytes.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toUtf8Bytes = void 0;
+function toUtf8Bytes(data) {
+    return new Uint8Array(Buffer.from(data));
+}
+exports.toUtf8Bytes = toUtf8Bytes;

package/lib/esm/classes/Contract.js

@@ -40,7 +40,7 @@ export class BaseContract {
                             ? estimateGas(data)
                             : null;
                     const req = () => __awaiter(this, void 0, void 0, function* () {
-                        return yield post(this._provider._rpcUrl, buildRPCPostBody('eth_call', [
+                        return yield post(this._provider.selectRpcUrl(), buildRPCPostBody('eth_call', [
                             Object.assign({ to: this._address.toLowerCase(), data }, (decimalGas
                                 ? { gas: `0x${decimalGas.toString(16)}` }
                                 : {})),

package/lib/esm/classes/utils/clean-transaction-receipt.d.ts

@@ -0,0 +1,2 @@
+import { RPCTransactionReceipt, TransactionReceipt } from '../../types/Transaction.types';
+export declare function cleanTransactionReceipt(transactionReceipt: RPCTransactionReceipt): TransactionReceipt;