essential-eth 0.11.2 → 0.13.0

package/dist/index.js

@@ -1,354 +1,9 @@
-// src/classes/utils/encode-decode-transaction.ts
-import { Keccak as Keccak2 } from "sha3";
-
-// src/shared/tiny-big/tiny-big.ts
-import Big from "big.js";
-
-// src/classes/utils/hex-to-decimal.ts
-function hexToDecimal(hex) {
-  return BigInt(hex).toString();
-}
-
-// src/shared/tiny-big/helpers.ts
-function stripTrailingZeroes(numberString) {
-  const isNegative = numberString.startsWith("-");
-  numberString = numberString.replace("-", "");
-  numberString = numberString.replace(
-    /\.0*$/g,
-    ""
-  );
-  numberString = numberString.replace(/^0+/, "");
-  if (numberString.includes(".")) {
-    numberString = numberString.replace(/0+$/, "");
-  }
-  if (numberString.startsWith(".")) {
-    numberString = `0${numberString}`;
-  }
-  return `${isNegative ? "-" : ""}${numberString}`;
-}
-function scientificStrToDecimalStr(scientificString) {
-  if (!scientificString.match(
-    /e/i
-    /* lowercase and uppercase E */
-  )) {
-    return stripTrailingZeroes(scientificString);
-  }
-  let [base, power] = scientificString.split(
-    /e/i
-  );
-  const isNegative = Number(base) < 0;
-  base = base.replace("-", "");
-  base = stripTrailingZeroes(base);
-  const [wholeNumber, fraction = ""] = base.split(".");
-  if (Number(power) === 0) {
-    return `${isNegative ? "-" : ""}${stripTrailingZeroes(base)}`;
-  } else {
-    const includesDecimal = base.includes(".");
-    if (!includesDecimal) {
-      base = `${base}.`;
-    }
-    base = base.replace(".", "");
-    const baseLength = base.length;
-    let splitPaddedNumber;
-    if (Number(power) < 0) {
-      if (wholeNumber.length < Math.abs(Number(power))) {
-        base = base.padStart(
-          baseLength + Math.abs(Number(power)) - wholeNumber.length,
-          "0"
-        );
-      }
-      splitPaddedNumber = base.split("");
-      if (wholeNumber.length < Math.abs(Number(power))) {
-        splitPaddedNumber = [".", ...splitPaddedNumber];
-      } else {
-        splitPaddedNumber.splice(
-          splitPaddedNumber.length - Math.abs(Number(power)),
-          0,
-          "."
-        );
-      }
-    } else {
-      if (fraction.length < Math.abs(Number(power))) {
-        base = base.padEnd(
-          baseLength + Math.abs(Number(power)) - fraction.length,
-          "0"
-        );
-      }
-      splitPaddedNumber = base.split("");
-      if (fraction.length > Math.abs(Number(power))) {
-        splitPaddedNumber.splice(
-          splitPaddedNumber.length - Math.abs(Number(power)),
-          0,
-          "."
-        );
-      }
-    }
-    const toReturn = stripTrailingZeroes(splitPaddedNumber.join(""));
-    return `${isNegative ? "-" : ""}${toReturn}`;
-  }
-}
-
-// src/shared/tiny-big/tiny-big.ts
-var TinyBig = class extends Big {
-  constructor(value) {
-    if (typeof value === "string" && value.startsWith("0x")) {
-      value = hexToDecimal(value);
-    }
-    super(value);
-  }
-  /**
-   * Used anytime you're passing in "value" to ethers or web3
-   * For now, TypeScript will complain that `TinyBig` is not a `BigNumberish`. You can // @ts-ignore or call this
-   *
-   * @returns the TinyBig represented as a hex string
-   * @example
-   * ```javascript
-   * tinyBig(293).toHexString();
-   * // '0x125'
-   * ```
-   * @example
-   * ```javascript
-   * tinyBig(681365874).toHexString();
-   * // '0x289cd172'
-   */
-  toHexString() {
-    return `0x${BigInt(this.toString()).toString(16)}`;
-  }
-  toNumber() {
-    return Number(scientificStrToDecimalStr(super.toString()));
-  }
-  toString() {
-    if (this.toNumber() === 0) {
-      return "0";
-    }
-    return scientificStrToDecimalStr(super.toString());
-  }
-  /**
-   * Eithers pads or shortens a string to a specified length
-   *
-   * @param str the string to pad or chop
-   * @param padChar the character to pad the string with
-   * @param length the desired length of the given string
-   * @returns a string of the desired length, either padded with the specified padChar or with the beginning of the string chopped off
-   * @example
-   * ```javascript
-   * padAndChop('essential-eth', 'a', 8);
-   * // 'tial-eth'
-   * ```
-   * @example
-   * ```javascript
-   * padAndChop('essential-eth', 'A', 20);
-   * // 'AAAAAAAessential-eth'
-   * ```
-   */
-  padAndChop = (str, padChar, length) => {
-    return (Array(length).fill(padChar).join("") + str).slice(length * -1);
-  };
-  toTwos(bitCount) {
-    let binaryStr;
-    if (this.gte(0)) {
-      const twosComp = this.toNumber().toString(2);
-      binaryStr = this.padAndChop(twosComp, "0", bitCount || twosComp.length);
-    } else {
-      binaryStr = this.plus(Math.pow(2, bitCount)).toNumber().toString(2);
-      if (Number(binaryStr) < 0) {
-        throw new Error("Cannot calculate twos complement");
-      }
-    }
-    const binary = `0b${binaryStr}`;
-    const decimal = Number(binary);
-    return tinyBig(decimal);
-  }
-};
-function tinyBig(value) {
-  return new TinyBig(value);
-}
-
-// src/utils/to-checksum-address.ts
-import { Keccak } from "sha3";
-
-// src/shared/validate-type.ts
-var validateType = (value, allowedTypes) => {
-  if (!allowedTypes.includes(typeof value)) {
-    throw new Error(
-      `${allowedTypes.join(" or ")} required. Received ${typeof value}`
-    );
-  }
-};
-
-// src/utils/to-checksum-address.ts
-function toChecksumAddress(address) {
-  validateType(address, ["string"]);
-  if (!/^(0x)?[0-9a-f]{40}$/i.test(address)) {
-    throw new Error(`Invalid Ethereum address "${address}"`);
-  }
-  const _address = address.toLowerCase().replace(/^0x/i, "");
-  const keccak = new Keccak(256);
-  const addressHash = keccak.update(_address).digest("hex").replace(/^0x/i, "");
-  let checksumAddress = "0x";
-  for (let i = 0; i < _address.length; i++) {
-    if (parseInt(addressHash[i], 16) > 7) {
-      checksumAddress += _address[i].toUpperCase();
-    } else {
-      checksumAddress += _address[i];
-    }
-  }
-  if (address.match(/([A-F].*[a-f])|([a-f].*[A-F])/) && checksumAddress !== address) {
-    throw new Error(`Invalid Checksum address for "${address}"`);
-  }
-  return checksumAddress;
-}
-
-// src/classes/utils/encode-decode-transaction.ts
-var hexFalse = "0".repeat(64);
-var hexTrue = "0".repeat(63) + "1";
-function hexToUtf8(hex) {
-  let str = "";
-  let i = 0;
-  const l = hex.length;
-  if (hex.substring(0, 2) === "0x") {
-    i = 2;
-  }
-  for (; i < l; i += 2) {
-    const code = parseInt(hex.substr(i, 2), 16);
-    if (code === 0) continue;
-    str += String.fromCharCode(code);
-  }
-  try {
-    return decodeURIComponent(escape(str));
-  } catch (e) {
-    return str;
-  }
-}
-function expandType(type) {
-  if (type === "uint[]") {
-    return "uint256[]";
-  }
-  if (type === "int[]") {
-    return "int256[]";
-  }
-  return type;
-}
-function encodeData(jsonABIArgument, args) {
-  const hash = new Keccak2(256);
-  const functionString = `${jsonABIArgument.name}(${jsonABIArgument.inputs.map(
-    (input) => expandType(input.type)
-  )})`;
-  const functionHash = hash.update(functionString).digest("hex");
-  const jsonABIInputsLength = jsonABIArgument.inputs.length;
-  let shouldValidateInputLength = true;
-  if (jsonABIArgument.inputs.find((input) => input.type.includes("["))) {
-    shouldValidateInputLength = false;
-  }
-  if (shouldValidateInputLength && args.length !== jsonABIInputsLength) {
-    throw new Error(
-      `args inputs  of "${args.length}" does not match expected length of "${jsonABIArgument.inputs.length}"`
-    );
-  }
-  const argsWithTypes = (jsonABIArgument.inputs || []).reduce(
-    (acc, input, i) => {
-      if (input.type.includes("[")) {
-        const basicType = /([^[]*)\[.*$/g.exec(input.type)?.[1];
-        args.forEach((arg) => {
-          acc = acc.concat([[arg, basicType]]);
-        });
-        return acc;
-      } else {
-        return acc.concat([[args[i], input.type]]);
-      }
-    },
-    []
-  );
-  const encodedArgs = argsWithTypes.map(([arg, inputType]) => {
-    let rawArg = arg;
-    switch (inputType) {
-      case "bool":
-        return arg ? hexTrue : hexFalse;
-      case "address":
-        rawArg = arg.replace(/^0x/g, "").toLowerCase();
-        break;
-      default:
-        if (inputType.startsWith("bytes")) {
-          if (Array.isArray(arg)) {
-            throw new Error(
-              `essential-eth does not yet support "${inputType}[]" inputs. Make a PR today!"`
-            );
-          }
-          const argEncoded2 = BigInt(arg).toString(16);
-          const paddedEncodedArg2 = argEncoded2.padStart(64, "0");
-          return paddedEncodedArg2;
-        } else if (inputType === "uint256") {
-          const argEncoded2 = BigInt(arg).toString(16);
-          const paddedEncodedArg2 = argEncoded2.padStart(64, "0");
-          return paddedEncodedArg2;
-        } else if (inputType.startsWith("uint")) {
-          break;
-        } else {
-          throw new Error(
-            `essential-eth does not yet support "${inputType}" inputs. Make a PR today!"`
-          );
-        }
-    }
-    const argEncoded = rawArg.toString(16);
-    const paddedEncodedArg = argEncoded.padStart(64, "0");
-    return paddedEncodedArg;
-  });
-  const functionEncoded = functionHash.slice(0, 8);
-  const data = `0x${functionEncoded}${encodedArgs.join("")}`;
-  return data;
-}
-function decodeRPCResponse(jsonABIArgument, nodeResponse) {
-  const rawOutputs = jsonABIArgument.outputs || [];
-  const slicedResponse = nodeResponse.slice(2);
-  if (rawOutputs.length === 1 && rawOutputs[0].type === "string") {
-    const [hexOffset, responseData] = [
-      slicedResponse.slice(0, 64),
-      slicedResponse.slice(64)
-    ];
-    const decimalOffset = Number(hexToDecimal(`0x${hexOffset}`));
-    const hexLength = responseData.slice(0, decimalOffset * 2);
-    const decimalLength = Number(hexToDecimal(`0x${hexLength}`));
-    const hexToDecode = responseData.slice(
-      decimalOffset * 2,
-      decimalOffset * 2 + decimalLength * 2
-    );
-    return hexToUtf8(hexToDecode);
-  }
-  const encodedOutputs = slicedResponse.match(/.{1,64}/g) || [];
-  if (rawOutputs.length === 1 && rawOutputs[0].type === "address[]") {
-    const unformattedAddresses = encodedOutputs.slice(2);
-    return unformattedAddresses.map((unformattedAddress) => {
-      return toChecksumAddress(`0x${unformattedAddress.slice(24)}`);
-    });
-  }
-  if (rawOutputs?.length === 1 && rawOutputs[0].type === "uint256[]") {
-    const outputs2 = encodedOutputs.slice(2);
-    return outputs2.map((output) => {
-      return tinyBig(hexToDecimal(`0x${output}`));
-    });
-  }
-  const outputs = encodedOutputs.map((output, i) => {
-    const outputType = rawOutputs[i].type;
-    switch (outputType) {
-      case "bool":
-        return output === hexTrue;
-      case "address":
-        return toChecksumAddress(`0x${output.slice(24)}`);
-      case "uint256":
-      case "uint120":
-        return tinyBig(hexToDecimal(`0x${output}`));
-      case "bytes32":
-        return `0x${output}`;
-      case "uint8":
-        return Number(hexToDecimal(`0x${output}`));
-      default:
-        throw new Error(
-          `essential-eth does not yet support "${outputType}" outputs. Make a PR today!"`
-        );
-    }
-  });
-  return outputs.length === 1 ? outputs[0] : outputs;
-}
+import { logger, encodeData, decodeRPCResponse, toChecksumAddress, hexlify } from './chunk-C4VOKUKQ.js';
+export { arrayify, computeAddress, computePublicKey, concat, hashMessage, hexConcat, hexDataLength, hexDataSlice, hexStripZeros, hexValue, hexZeroPad, hexlify, isAddress, isBytes, isBytesLike, isHexString, keccak256, pack, solidityKeccak256, splitSignature, stripZeros, toChecksumAddress, toUtf8Bytes, zeroPad } from './chunk-C4VOKUKQ.js';
+import { hexToDecimal, tinyBig, TinyBig } from './chunk-UXC5R4JE.js';
+export { TinyBig, etherToGwei, etherToWei, gweiToEther, tinyBig, weiToEther } from './chunk-UXC5R4JE.js';
+import unfetch from 'isomorphic-unfetch';
+import Big from 'big.js';
 
 // src/classes/Contract.ts
 function estimateGas(txnData) {
@@ -547,9 +202,6 @@ function cleanTransactionReceipt(transactionReceipt) {
   cleanedTransactionReceipt.byzantium = cleanedTransactionReceipt.blockNumber >= 437e4;
   return cleanedTransactionReceipt;
 }
-
-// src/classes/utils/fetchers.ts
-import unfetch from "isomorphic-unfetch";
 function buildFetchInit(body) {
   return {
     method: "POST",
@@ -586,290 +238,6 @@ function buildRPCPostBody(method, params) {
     params
   };
 }
-
-// src/classes/utils/prepare-transaction.ts
-import Big2 from "big.js";
-
-// src/logger/package-version.ts
-var version = "0.11.2";
-
-// src/logger/logger.ts
-var Logger = class {
-  packageVersion;
-  constructor() {
-    this.packageVersion = version;
-  }
-  throwError(message, args) {
-    const argsLength = Object.keys(args).length;
-    throw new Error(
-      `${message} (${Object.entries(args).map(
-        ([key, value], index) => `${key}=${value}${index < argsLength - 1 && ", "}`
-      )}, version=essential-eth@${this.packageVersion})`
-    );
-  }
-  throwArgumentError(message, arg, value) {
-    throw new Error(
-      `${message} (argument="${arg}" value=${value}, version=essential-eth@${this.packageVersion})`
-    );
-  }
-  checkSafeUint53(value, message = "value not safe") {
-    if (typeof value !== "number") {
-      return;
-    }
-    if (value < 0 || value >= 9007199254740991) {
-      this.throwError(message, {
-        operation: "checkSafeInteger",
-        fault: "out-of-safe-range",
-        value
-      });
-    }
-    if (value % 1) {
-      this.throwError(message, {
-        operation: "checkSafeInteger",
-        fault: "non-integer",
-        value
-      });
-    }
-  }
-};
-var logger = new Logger();
-
-// src/utils/bytes.ts
-function isHexable(value) {
-  return !!value.toHexString;
-}
-function isBytesLike(value) {
-  return isHexString(value) && !(value.length % 2) || isBytes(value);
-}
-function isInteger(value) {
-  return typeof value === "number" && value == value && value % 1 === 0;
-}
-function isBytes(value) {
-  if (value == null) {
-    return false;
-  }
-  if (value.constructor === Uint8Array) {
-    return true;
-  }
-  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];
-    if (!isInteger(v) || v < 0 || v >= 256) {
-      return false;
-    }
-  }
-  return true;
-}
-function arrayify(value, options) {
-  if (!options) {
-    options = {};
-  }
-  if (typeof value === "number") {
-    logger.checkSafeUint53(value, "invalid arrayify value");
-    const result = [];
-    while (value) {
-      result.unshift(value & 255);
-      value = parseInt(String(value / 256));
-    }
-    if (result.length === 0) {
-      result.push(0);
-    }
-    return new Uint8Array(result);
-  }
-  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);
-    if (hex.length % 2) {
-      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));
-    }
-    return new Uint8Array(result);
-  }
-  if (isBytes(value)) {
-    return new Uint8Array(value);
-  }
-  return logger.throwArgumentError("invalid arrayify value", "value", value);
-}
-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) => {
-    result.set(object, offset);
-    return offset + object.length;
-  }, 0);
-  return result;
-}
-function stripZeros(value) {
-  let result = arrayify(value);
-  if (result.length === 0) {
-    return result;
-  }
-  let start = 0;
-  while (start < result.length && result[start] === 0) {
-    start++;
-  }
-  if (start) {
-    result = result.slice(start);
-  }
-  return result;
-}
-function zeroPad(value, length) {
-  value = arrayify(value);
-  if (value.length > length) {
-    logger.throwArgumentError("value out of range", "value", value);
-  }
-  const result = new Uint8Array(length);
-  result.set(value, length - value.length);
-  return result;
-}
-function isHexString(value, length) {
-  if (typeof value !== "string" || !value.match(/^0x[0-9A-Fa-f]*$/)) {
-    return false;
-  }
-  if (length && value.length !== 2 + 2 * length) {
-    return false;
-  }
-  return true;
-}
-var HexCharacters = "0123456789abcdef";
-function hexlify(value, options) {
-  if (!options) {
-    options = {};
-  }
-  if (typeof value === "number") {
-    logger.checkSafeUint53(value, "invalid hexlify value");
-    let hex = "";
-    while (value) {
-      hex = HexCharacters[value & 15] + hex;
-      value = Math.floor(value / 16);
-    }
-    if (hex.length) {
-      if (hex.length % 2) {
-        hex = "0" + hex;
-      }
-      return "0x" + hex;
-    }
-    return "0x00";
-  }
-  if (typeof value === "bigint") {
-    value = value.toString(16);
-    if (value.length % 2) {
-      return "0x0" + value;
-    }
-    return "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.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];
-      result += HexCharacters[(v & 240) >> 4] + HexCharacters[v & 15];
-    }
-    return result;
-  }
-  return logger.throwArgumentError("invalid hexlify value", "value", value);
-}
-function hexDataLength(data) {
-  if (typeof data !== "string") {
-    data = hexlify(data);
-  } else if (!isHexString(data) || data.length % 2) {
-    return null;
-  }
-  return (data.length - 2) / 2;
-}
-function hexDataSlice(data, offset, endOffset) {
-  if (typeof data !== "string") {
-    data = hexlify(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);
-}
-function hexConcat(items) {
-  let result = "0x";
-  items.forEach((item) => {
-    result += hexlify(item).substring(2);
-  });
-  return result;
-}
-function hexValue(value) {
-  const trimmed = hexStripZeros(hexlify(value, { hexPad: "left" }));
-  if (trimmed === "0x") {
-    return "0x0";
-  }
-  return trimmed;
-}
-function hexStripZeros(value) {
-  if (typeof value !== "string") {
-    value = hexlify(value);
-  }
-  if (!isHexString(value)) {
-    logger.throwArgumentError("invalid hex string", "value", value);
-  }
-  value = value.substring(2);
-  let offset = 0;
-  while (offset < value.length && value[offset] === "0") {
-    offset++;
-  }
-  return "0x" + value.substring(offset);
-}
-function hexZeroPad(value, length) {
-  if (typeof value !== "string") {
-    value = hexlify(value);
-  } else if (!isHexString(value)) {
-    logger.throwArgumentError("invalid hex string", "value", value);
-  }
-  if (value.length > 2 * length + 2) {
-    logger.throwError("value out of range", { value, length });
-  }
-  while (value.length < 2 * length + 2) {
-    value = "0x0" + value.substring(2);
-  }
-  return value;
-}
-
-// src/classes/utils/prepare-transaction.ts
 function prepareTransaction(transaction) {
   const preparedTransaction = {
     ...transaction
@@ -886,7 +254,7 @@ function prepareTransaction(transaction) {
           const value = transaction[key];
           if (value instanceof TinyBig) {
             preparedTransaction[key] = value.toHexString();
-          } else if (value instanceof Big2) {
+          } else if (value instanceof Big) {
             preparedTransaction[key] = `0x${BigInt(value.toString()).toString(
               16
             )}`;
@@ -1573,380 +941,4 @@ var FallthroughProvider = class extends BaseProvider {
   };
 };
 
-// src/utils/compute-public-key.ts
-import { Point } from "@noble/secp256k1";
-function computePublicKey(privKey) {
-  privKey = hexlify(privKey).slice(2);
-  return "0x" + Point.fromPrivateKey(privKey).toHex();
-}
-
-// src/utils/keccak256.ts
-import { Keccak as Keccak3 } from "sha3";
-function keccak256(data) {
-  let bufferableData;
-  if (typeof data === "string") {
-    bufferableData = Buffer.from(data.replace(/^0x/, ""), "hex");
-  } else {
-    bufferableData = Buffer.from(data);
-  }
-  const keccak = new Keccak3(256);
-  const addressHash = "0x" + keccak.update(bufferableData).digest("hex");
-  return addressHash;
-}
-
-// src/utils/compute-address.ts
-function computeAddress(key) {
-  if (!key.startsWith("0x04") && !key.startsWith("0x03") && !key.startsWith("0x02")) {
-    key = computePublicKey(key);
-  }
-  return toChecksumAddress(hexDataSlice(keccak256(hexDataSlice(key, 1)), 12));
-}
-
-// src/utils/ether-to-gwei.ts
-function etherToGwei(etherQuantity) {
-  validateType(etherQuantity, ["string", "number", "object"]);
-  const result = tinyBig(etherQuantity).times("1000000000");
-  return tinyBig(result);
-}
-
-// src/utils/ether-to-wei.ts
-function etherToWei(etherQuantity) {
-  validateType(etherQuantity, ["string", "number", "object"]);
-  const result = tinyBig(etherQuantity).times("1000000000000000000");
-  return tinyBig(result);
-}
-
-// src/utils/gwei-to-ether.ts
-function gweiToEther(gweiQuantity) {
-  validateType(gweiQuantity, ["string", "number", "object"]);
-  const result = tinyBig(gweiQuantity).div("1000000000");
-  return tinyBig(result);
-}
-
-// src/utils/to-utf8-bytes.ts
-function toUtf8Bytes(data) {
-  return new Uint8Array(Buffer.from(data));
-}
-
-// src/utils/hash-message.ts
-var messagePrefix = "Ethereum Signed Message:\n";
-function hashMessage(message) {
-  if (typeof message === "string") {
-    message = toUtf8Bytes(message);
-  }
-  return keccak256(
-    concat([
-      toUtf8Bytes(messagePrefix),
-      toUtf8Bytes(String(message.length)),
-      message
-    ])
-  );
-}
-
-// src/utils/is-address.ts
-function isAddress(address) {
-  validateType(address, ["string"]);
-  try {
-    toChecksumAddress(address);
-    return true;
-  } catch (error) {
-    return false;
-  }
-}
-
-// src/utils/solidity-keccak256.ts
-import { Buffer as Buffer2 } from "buffer";
-var regexBytes = new RegExp("^bytes([0-9]+)$");
-var regexNumber = new RegExp("^(u?int)([0-9]*)$");
-var regexArray = new RegExp("^(.*)\\[([0-9]*)\\]$");
-function _pack(type, value, isArray) {
-  switch (type) {
-    case "address":
-      if (isArray) {
-        return zeroPad(value, 32);
-      }
-      return arrayify(value);
-    case "string":
-      return Buffer2.from(value);
-    case "bytes":
-      return arrayify(value);
-    case "bool":
-      value = value ? "0x01" : "0x00";
-      if (isArray) {
-        return zeroPad(value, 32);
-      }
-      return arrayify(value);
-  }
-  let match = type.match(regexNumber);
-  if (match) {
-    let 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 = tinyBig(value).toTwos(size).toNumber();
-    const hexValue2 = hexlify(value);
-    return zeroPad(hexValue2, size / 8);
-  }
-  match = type.match(regexBytes);
-  if (match) {
-    const size = parseInt(match[1]);
-    if (String(size) !== match[1] || size === 0 || size > 32) {
-      logger.throwArgumentError("invalid bytes type", "type", type);
-    }
-    if (arrayify(value).byteLength !== size) {
-      logger.throwArgumentError(`invalid value for ${type}`, "value", value);
-    }
-    if (isArray) {
-      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));
-    if (count != value.length) {
-      logger.throwArgumentError(
-        `invalid array length for ${type}`,
-        "value",
-        value
-      );
-    }
-    const result = [];
-    value.forEach(function(value2) {
-      result.push(_pack(baseType, value2, true));
-    });
-    return concat(result);
-  }
-  return logger.throwArgumentError("invalid type", "type", type);
-}
-function pack(types, values) {
-  if (types.length != values.length) {
-    logger.throwArgumentError(
-      "wrong number of values; expected ${ types.length }",
-      "values",
-      values
-    );
-  }
-  const tight = [];
-  types.forEach(function(type, index) {
-    tight.push(_pack(type, values[index]));
-  });
-  return hexlify(concat(tight));
-}
-function solidityKeccak256(types, values) {
-  return keccak256(pack(types, values));
-}
-
-// src/utils/split-signature.ts
-function splitSignature(signature) {
-  const result = {
-    r: "0x",
-    s: "0x",
-    _vs: "0x",
-    recoveryParam: 0,
-    v: 0,
-    yParityAndS: "0x",
-    compact: "0x"
-  };
-  if (isBytesLike(signature)) {
-    const bytes = arrayify(signature);
-    if (bytes.length === 64) {
-      result.v = 27 + (bytes[32] >> 7);
-      bytes[32] &= 127;
-      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
-      );
-    }
-    if (result.v < 27) {
-      if (result.v === 0 || result.v === 1) {
-        result.v += 27;
-      } else {
-        logger.throwArgumentError(
-          "signature invalid v byte",
-          "signature",
-          signature
-        );
-      }
-    }
-    result.recoveryParam = 1 - result.v % 2;
-    if (result.recoveryParam) {
-      bytes[32] |= 128;
-    }
-    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 (result._vs != null) {
-      const vs_1 = zeroPad(arrayify(result._vs), 32);
-      result._vs = hexlify(vs_1);
-      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
-        );
-      }
-      vs_1[0] &= 127;
-      const s = hexlify(vs_1);
-      if (result.s == null) {
-        result.s = s;
-      } else if (result.s !== s) {
-        logger.throwArgumentError(
-          "signature v mismatch _vs",
-          "signature",
-          signature
-        );
-      }
-    }
-    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] |= 128;
-    }
-    const _vs = hexlify(vs);
-    if (result._vs) {
-      if (!isHexString(result._vs)) {
-        logger.throwArgumentError(
-          "signature invalid _vs",
-          "signature",
-          signature
-        );
-      }
-      result._vs = hexZeroPad(result._vs, 32);
-    }
-    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;
-}
-
-// src/utils/wei-to-ether.ts
-function weiToEther(weiQuantity) {
-  validateType(weiQuantity, ["string", "number", "object"]);
-  try {
-    let _weiQuantity = weiQuantity;
-    if (typeof weiQuantity === "string" && weiQuantity.slice(0, 2) === "0x") {
-      _weiQuantity = BigInt(weiQuantity).toString();
-    }
-    const result = tinyBig(_weiQuantity).div("1000000000000000000");
-    return tinyBig(result);
-  } catch (error) {
-    throw error;
-  }
-}
-export {
-  AlchemyProvider,
-  BaseContract,
-  Contract,
-  FallthroughProvider,
-  JsonRpcProvider,
-  TinyBig,
-  arrayify,
-  computeAddress,
-  computePublicKey,
-  concat,
-  etherToGwei,
-  etherToWei,
-  gweiToEther,
-  hashMessage,
-  hexConcat,
-  hexDataLength,
-  hexDataSlice,
-  hexStripZeros,
-  hexValue,
-  hexZeroPad,
-  hexlify,
-  isAddress,
-  isBytes,
-  isBytesLike,
-  isHexString,
-  jsonRpcProvider,
-  keccak256,
-  pack,
-  solidityKeccak256,
-  splitSignature,
-  stripZeros,
-  tinyBig,
-  toChecksumAddress,
-  toUtf8Bytes,
-  weiToEther,
-  zeroPad
-};
+export { AlchemyProvider, BaseContract, Contract, FallthroughProvider, JsonRpcProvider, jsonRpcProvider };