essential-eth 0.10.3 → 0.11.1

package/dist/index.js

@@ -0,0 +1,1952 @@
+// 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;
+}
+
+// src/classes/Contract.ts
+function estimateGas(txnData) {
+  txnData.split("").reduce((previousValue, currentValue) => {
+    const characterCost = currentValue === "0" ? 4 : 68;
+    return previousValue + characterCost;
+  }, 0);
+}
+var BaseContract = class {
+  /**
+   * The URL to your Eth node. Consider POKT or Infura
+   */
+  _address;
+  _provider;
+  /**
+   * @param addressOrName The ethereum address of the smart-contract
+   * @param contractInterface The JSON ABI of the smart-contract (like http://api.etherscan.io/api?module=contract&action=getabi&address=0x090d4613473dee047c3f2706764f49e0821d256e&format=raw)
+   * @param signerOrProvider An instantiated essential-eth provider
+   * @example
+   */
+  constructor(addressOrName, contractInterface, signerOrProvider) {
+    this._address = addressOrName;
+    this._provider = signerOrProvider;
+    contractInterface.filter((jsonABIArgument) => jsonABIArgument.type === "function").forEach((jsonABIArgument) => {
+      if ("name" in jsonABIArgument && typeof jsonABIArgument.name === "string") {
+        defineReadOnly(
+          this,
+          jsonABIArgument.name,
+          async (..._args) => {
+            let functionArguments = _args;
+            let options = {};
+            const lastArg = _args[_args.length - 1];
+            if (!Array.isArray(lastArg) && typeof lastArg === "object") {
+              options = lastArg;
+              functionArguments = _args.slice(0, _args.length - 1);
+            }
+            const data = encodeData(jsonABIArgument, functionArguments);
+            const decimalGas = typeof options.gasLimit === "number" ? options.gasLimit : typeof jsonABIArgument?.gas === "number" ? estimateGas(data) : null;
+            const req = async () => {
+              return await this._provider.call(
+                {
+                  to: this._address.toLowerCase(),
+                  data,
+                  // sometimes gas is defined in the ABI
+                  ...decimalGas ? { gas: `0x${decimalGas.toString(16)}` } : {}
+                },
+                "latest"
+              );
+            };
+            const nodeResponse = await req();
+            return decodeRPCResponse(jsonABIArgument, nodeResponse);
+          }
+        );
+      }
+    });
+  }
+};
+function defineReadOnly(object, name, value) {
+  Object.defineProperty(object, name, {
+    enumerable: true,
+    value,
+    writable: false
+  });
+}
+var Contract = class extends BaseContract {
+  // readonly [key: string]: ContractFunction | any;
+};
+
+// src/classes/utils/clean-transaction.ts
+function cleanTransaction(transaction) {
+  const cleanedTransaction = {
+    ...transaction
+  };
+  Object.keys(transaction).forEach((key) => {
+    if (!transaction[key]) return;
+    switch (key) {
+      case "blockNumber":
+      case "chainId":
+      case "transactionIndex":
+      case "type":
+      case "v":
+        cleanedTransaction[key] = Number(hexToDecimal(transaction[key]));
+        break;
+      case "from":
+      case "to":
+        if (transaction[key]) {
+          cleanedTransaction[key] = toChecksumAddress(transaction[key]);
+        }
+        break;
+      case "value":
+      case "gas":
+      case "gasPrice":
+      case "maxFeePerGas":
+      case "maxPriorityFeePerGas":
+      case "nonce":
+        cleanedTransaction[key] = tinyBig(hexToDecimal(transaction[key]));
+        break;
+    }
+  });
+  return cleanedTransaction;
+}
+
+// src/classes/utils/clean-block.ts
+function cleanBlock(block, returnTransactionObjects) {
+  const cleanedBlock = { ...block };
+  Object.keys(block).forEach((key) => {
+    if (!block[key]) return;
+    switch (key) {
+      case "difficulty":
+      case "totalDifficulty":
+      case "gasLimit":
+      case "gasUsed":
+      case "size":
+      case "timestamp":
+      case "baseFeePerGas":
+        cleanedBlock[key] = tinyBig(hexToDecimal(block[key]));
+        break;
+      case "number":
+        cleanedBlock[key] = Number(hexToDecimal(block[key]));
+        break;
+      case "miner":
+        cleanedBlock[key] = toChecksumAddress(block[key]);
+        break;
+    }
+  });
+  if (returnTransactionObjects) {
+    const txns = block.transactions;
+    txns.forEach((transaction, index) => {
+      cleanedBlock.transactions[index] = cleanTransaction(transaction);
+    });
+  }
+  return cleanedBlock;
+}
+
+// src/classes/utils/clean-log.ts
+function cleanLog(log, receiptLog) {
+  const cleanedLog = {
+    ...log
+  };
+  Object.keys(log).forEach((key) => {
+    switch (key) {
+      case "address":
+        cleanedLog[key] = toChecksumAddress(log[key]);
+        break;
+      case "blockNumber":
+      case "logIndex":
+      case "transactionIndex":
+        cleanedLog[key] = Number(hexToDecimal(log[key]));
+        break;
+      case "removed":
+        if (receiptLog) {
+          delete cleanedLog[key];
+        } else if (log[key] == null) {
+          cleanedLog[key] === false;
+        }
+        break;
+    }
+  });
+  return cleanedLog;
+}
+
+// src/classes/utils/clean-transaction-receipt.ts
+function cleanTransactionReceipt(transactionReceipt) {
+  const cleanedTransaction = cleanTransaction(transactionReceipt);
+  const cleanedTransactionReceipt = {
+    ...cleanedTransaction
+  };
+  Object.keys(transactionReceipt).forEach((key) => {
+    if (!transactionReceipt[key]) return;
+    switch (key) {
+      case "status":
+        cleanedTransactionReceipt[key] = Number(
+          hexToDecimal(transactionReceipt[key])
+        );
+        break;
+      case "contractAddress":
+        if (transactionReceipt[key]) {
+          cleanedTransactionReceipt[key] = toChecksumAddress(
+            transactionReceipt[key]
+          );
+        }
+        break;
+      case "cumulativeGasUsed":
+      case "effectiveGasPrice":
+      case "gasUsed":
+        cleanedTransactionReceipt[key] = tinyBig(
+          hexToDecimal(transactionReceipt[key])
+        );
+        break;
+      case "logs":
+        transactionReceipt[key].forEach((log, index) => {
+          cleanedTransactionReceipt[key][index] = cleanLog(log, true);
+        });
+    }
+  });
+  cleanedTransactionReceipt.byzantium = cleanedTransactionReceipt.blockNumber >= 437e4;
+  return cleanedTransactionReceipt;
+}
+
+// src/classes/utils/fetchers.ts
+import unfetch from "isomorphic-unfetch";
+function buildFetchInit(body) {
+  return {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(body)
+  };
+}
+function post(url, body) {
+  return unfetch(url, buildFetchInit(body)).then(async (r) => {
+    const t = await r.text();
+    try {
+      return JSON.parse(t);
+    } catch {
+      throw new Error(`Invalid JSON RPC response: "${t}"`);
+    }
+  }).then((response) => {
+    const result = response?.result;
+    if (!result) {
+      throw new Error(
+        `Invalid JSON RPC response: ${JSON.stringify(response)}`
+      );
+    }
+    return response.result;
+  });
+}
+function buildRPCPostBody(method, params) {
+  return {
+    jsonrpc: "2.0",
+    // TODO: Increment ID will be needed when websocket support is added
+    id: 1,
+    method,
+    params
+  };
+}
+
+// src/classes/utils/prepare-transaction.ts
+import Big2 from "big.js";
+
+// src/logger/package-version.ts
+var version = "0.11.1";
+
+// 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
+  };
+  Object.keys(transaction).forEach(
+    (key) => {
+      switch (key) {
+        case "gas":
+        case "gasPrice":
+        case "nonce":
+        case "maxFeePerGas":
+        case "maxPriorityFeePerGas":
+        case "value": {
+          const value = transaction[key];
+          if (value instanceof TinyBig) {
+            preparedTransaction[key] = value.toHexString();
+          } else if (value instanceof Big2) {
+            preparedTransaction[key] = `0x${BigInt(value.toString()).toString(
+              16
+            )}`;
+          } else if (typeof transaction[key] === "number")
+            preparedTransaction[key] = "0x" + transaction[key].toString(16);
+          else preparedTransaction[key] = transaction[key].toString();
+          break;
+        }
+        case "data":
+          preparedTransaction[key] = hexlify(transaction[key]);
+          break;
+      }
+    }
+  );
+  return preparedTransaction;
+}
+
+// src/providers/utils/chains-info.ts
+var chains_info_default = {
+  "1": [
+    "eth",
+    "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"
+  ],
+  "5": [
+    "gor",
+    "0x112234455c3a32fd11230c42e7bccd4a84e02010"
+  ],
+  "10": [
+    "oeth"
+  ],
+  "50": [
+    "xdc"
+  ],
+  "56": [
+    "bnb"
+  ],
+  "100": [
+    "gno"
+  ],
+  "137": [
+    "pol"
+  ],
+  "250": [
+    "ftm"
+  ],
+  "324": [
+    "zksync"
+  ],
+  "1101": [
+    "zkevm"
+  ],
+  "1337": [
+    "geth"
+  ],
+  "7700": [
+    "canto"
+  ],
+  "9001": [
+    "evmos"
+  ],
+  "42161": [
+    "arb1"
+  ],
+  "42220": [
+    "celo"
+  ],
+  "43114": [
+    "avax"
+  ],
+  "59140": [
+    "linea-goerli"
+  ],
+  "80001": [
+    "maticmum"
+  ],
+  "421613": [
+    "arb-goerli"
+  ],
+  "534352": [
+    "scr"
+  ],
+  "11155111": [
+    "sep"
+  ]
+};
+
+// src/providers/BaseProvider.ts
+function prepBlockTag(blockTag) {
+  return typeof blockTag === "number" ? tinyBig(blockTag).toHexString() : blockTag;
+}
+var BaseProvider = class {
+  /**
+   * @ignore
+   */
+  _rpcUrls = [];
+  /**
+   * @ignore
+   */
+  _post = (body) => post(this.selectRpcUrl(), body);
+  /**
+   * @param rpcUrls The URL(s) to your Eth node(s). Consider POKT or Infura
+   * @example
+   * `https://free-eth-node.com/api/eth`
+   * @example
+   * `https://mainnet.infura.io/v3/YOUR-PROJECT-ID`
+   */
+  constructor(rpcUrls) {
+    this._rpcUrls = rpcUrls;
+  }
+  /**
+   * Gets information (name, chainId, and ensAddress when applicable) about the network the provider is connected to.
+   *
+   * * [Identical](/docs/api#isd) to [`ethers.provider.getNetwork`](https://docs.ethers.io/v5/api/providers/provider/#Provider-getNetwork) in ethers.js
+   * * [Similar](/docs/api#isd) to [`web3.eth.getChainId`](https://web3js.readthedocs.io/en/v1.7.3/web3-eth.html#getchainid) in web3.js, returns more than just the `chainId`
+   *
+   * @returns information about the network this provider is currently connected to
+   * @example
+   * ```javascript
+   * jsonRpcProvider('https://free-eth-node.com/api/eth').getNetwork();
+   * // { chainId: 1, name: 'eth', ensAddress: '0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e' }
+   * ```
+   * @example
+   * ```javascript
+   * jsonRpcProvider('https://free-eth-node.com/api/MATIC').getNetwork();
+   * // { chainId: 137, name: 'MATIC', ensAddress: null }
+   * ```
+   */
+  async getNetwork() {
+    const hexChainId = await this.post(
+      buildRPCPostBody("eth_chainId", [])
+    );
+    const chainId = hexToDecimal(hexChainId);
+    const info = chains_info_default[chainId];
+    return {
+      chainId: Number(chainId),
+      name: info[0] || "unknown",
+      ensAddress: info[1] || null
+      // only send ensAddress if it exists
+    };
+  }
+  /**
+   * Gets the number of the most recently mined block on the network the provider is connected to.
+   *
+   * * [Identical](/docs/api#isd) to [`ethers.provider.getBlockNumber`](https://docs.ethers.io/v5/api/providers/provider/#Provider-getBlockNumber) in ethers.js
+   * * [Identical](/docs/api#isd) to [`web3.eth.getBlockNumber`](https://web3js.readthedocs.io/en/v1.7.3/web3-eth.html#getblocknumber) in web3.js
+   *
+   * @returns the number of the most recently mined block
+   * @example
+   * ```javascript
+   * await provider.getBlockNumber();
+   * // 1053312
+   * ```
+   */
+  async getBlockNumber() {
+    const currentBlockNumber = await this.post(
+      buildRPCPostBody("eth_blockNumber", [])
+    );
+    return Number(hexToDecimal(currentBlockNumber));
+  }
+  /**
+   * Gets information about a specified transaction, even if it hasn't been mined yet.
+   *
+   * * [Similar](/docs/api#isd) to [`ethers.provider.getTransaction`](https://docs.ethers.io/v5/api/providers/provider/#Provider-getTransaction) in ethers.js, does not have `wait` method that waits until the transaction has been mined
+   * * [Similar](/docs/api#isd) to [`web3.eth.getTransaction`](https://web3js.readthedocs.io/en/v1.7.3/web3-eth.html#gettransaction) in web3.js, some information returned using different types
+   *
+   * @param transactionHash the hash of the transaction to get information about
+   * @returns information about the specified transaction
+   * @example
+   * ```javascript
+   * await provider.getTransaction('0x9014ae6ef92464338355a79e5150e542ff9a83e2323318b21f40d6a3e65b4789');
+   * // {
+   * //   accessList: [],
+   * //   blockHash: "0x876810a013dbcd140f6fd6048c1dc33abbb901f1f96b394c2fa63aef3cb40b5d",
+   * //   blockNumber: 14578286,
+   * //   chainId: 1,
+   * //   from: "0xdfD9dE5f6FA60BD70636c0900752E93a6144AEd4",
+   * //   gas: { TinyBig: 112163 },
+   * //   gasPrice: { TinyBig: 48592426858 },
+   * //   hash: "0x9014ae6ef92464338355a79e5150e542ff9a83e2323318b21f40d6a3e65b4789",
+   * //   input: "0x83259f17000000000000000000000000000000000000000000...",
+   * //   maxFeePerGas: { TinyBig: 67681261618 },
+   * //   maxPriorityFeePerGas: { TinyBig: 1500000000 },
+   * //   nonce: { TinyBig: 129 },
+   * //   r: "0x59a7c15b12c18cd68d6c440963d959bff3e73831ffc938e75ecad07f7ee43fbc",
+   * //   s: "0x1ebaf05f0d9273b16c2a7748b150a79d22533a8cd74552611cbe620fee3dcf1c",
+   * //   to: "0x39B72d136ba3e4ceF35F48CD09587ffaB754DD8B",
+   * //   transactionIndex: 29,
+   * //   type: 2,
+   * //   v: 0,
+   * //   value: { TinyBig: 0 },
+   * //   confirmations: 298140,
+   * // }
+   * ```
+   */
+  async getTransaction(transactionHash) {
+    const [rpcTransaction, blockNumber] = await Promise.all([
+      this.post(
+        buildRPCPostBody("eth_getTransactionByHash", [transactionHash])
+      ),
+      this.getBlock("latest")
+    ]);
+    const cleanedTransaction = cleanTransaction(rpcTransaction);
+    cleanedTransaction.confirmations = blockNumber.number - cleanedTransaction.blockNumber + 1;
+    return cleanedTransaction;
+  }
+  /**
+   * Gives information about a transaction that has already been mined. Includes additional information beyond what's provided by [`getTransaction`](/docs/api/modules#gettransaction).
+   *
+   * * [Identical](/docs/api#isd) to [`ethers.provider.getTransactionReceipt`](https://docs.ethers.io/v5/api/providers/provider/#Provider-getTransactionReceipt) in ethers.js
+   * * [Similar](/docs/api#isd) to [`web3.eth.getTransactionReceipt`](https://web3js.readthedocs.io/en/v1.7.3/web3-eth.html#gettransactionreceipt) in web3.js, some information returned using different types
+   *
+   * @param transactionHash the hash of the transaction to get information about
+   * @returns information about the specified transaction that has already been mined
+   * @example
+   * ```javascript
+   * await provider.getTransactionReceipt('0x9014ae6ef92464338355a79e5150e542ff9a83e2323318b21f40d6a3e65b4789');
+   * // {
+   * //   blockHash: "0x876810a013dbcd140f6fd6048c1dc33abbb901f1f96b394c2fa63aef3cb40b5d",
+   * //   blockNumber: 14578286,
+   * //   contractAddress: null,
+   * //   cumulativeGasUsed: { TinyBig: 3067973 },
+   * //   effectiveGasPrice: { TinyBig: 48592426858 },
+   * //   from: "0xdfD9dE5f6FA60BD70636c0900752E93a6144AEd4",
+   * //   gasUsed: { TinyBig: 112163 },
+   * //   logs: [
+   * //     {
+   * //       address: "0x0eDF9bc41Bbc1354c70e2107F80C42caE7FBBcA8",
+   * //       blockHash: "0x876810a013dbcd140f6fd6048c1dc33abbb901f1f96b394c2fa63aef3cb40b5d",
+   * //       blockNumber: 14578286,
+   * //       data: "0x0000000000000000000000000000000000000000000003a12ec797b5484968c1",
+   * //       logIndex: 42,
+   * //       topics: [
+   * //         "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
+   * //         "0x00000000000000000000000039b72d136ba3e4cef35f48cd09587ffab754dd8b",
+   * //         "0x000000000000000000000000dfd9de5f6fa60bd70636c0900752e93a6144aed4",
+   * //       ],
+   * //       transactionHash: "0x9014ae6ef92464338355a79e5150e542ff9a83e2323318b21f40d6a3e65b4789",
+   * //       transactionIndex: 29,
+   * //     },
+   * //     {
+   * //       address: "0x39B72d136ba3e4ceF35F48CD09587ffaB754DD8B",
+   * //       blockHash: "0x876810a013dbcd140f6fd6048c1dc33abbb901f1f96b394c2fa63aef3cb40b5d",
+   * //       blockNumber: 14578286,
+   * //       data: "0x0000000000000000000000000000000000000000000003a12ec797b5484968c1",
+   * //       logIndex: 43,
+   * //       topics: [
+   * //         "0x34fcbac0073d7c3d388e51312faf357774904998eeb8fca628b9e6f65ee1cbf7",
+   * //         "0x000000000000000000000000dfd9de5f6fa60bd70636c0900752e93a6144aed4",
+   * //         "0x0000000000000000000000000000000000000000000000000000000000000003",
+   * //       ],
+   * //       transactionHash: "0x9014ae6ef92464338355a79e5150e542ff9a83e2323318b21f40d6a3e65b4789",
+   * //       transactionIndex: 29,
+   * //     },
+   * //   ],
+   * //   logsBloom: "0x00000000000000000000000000000...",
+   * //   status: 1,
+   * //   to: "0x39B72d136ba3e4ceF35F48CD09587ffaB754DD8B",
+   * //   transactionHash: "0x9014ae6ef92464338355a79e5150e542ff9a83e2323318b21f40d6a3e65b4789",
+   * //   transactionIndex: 29,
+   * //   type: 2,
+   * //   byzantium: true,
+   * //   confirmations: 298171,
+   * // }
+   * ```
+   */
+  async getTransactionReceipt(transactionHash) {
+    const [rpcTransaction, blockNumber] = await Promise.all([
+      this.post(
+        buildRPCPostBody("eth_getTransactionReceipt", [transactionHash])
+      ),
+      this.getBlock("latest")
+    ]);
+    const cleanedTransactionReceipt = cleanTransactionReceipt(rpcTransaction);
+    cleanedTransactionReceipt.confirmations = blockNumber.number - cleanedTransactionReceipt.blockNumber + 1;
+    return cleanedTransactionReceipt;
+  }
+  /**
+   * Returns the number of sent transactions by an address, from genesis (or as far back as a provider looks) up to specified block.
+   *
+   * * [Identical](/docs/api#isd) to [`ethers.provider.getTransactionCount`](https://docs.ethers.io/v5/api/providers/provider/#Provider-getTransactionCount) in ethers.js
+   * * [Identical](/docs/api#isd) to [`web3.eth.getTransactionCount`](https://web3js.readthedocs.io/en/v1.7.3/web3-eth.html#gettransactioncount) in web3.js
+   *
+   * @param address the address to count number of sent transactions
+   * @param blockTag the block to count transactions up to, inclusive
+   * @returns the number of transactions sent by the specified address
+   * @example
+   * ```javascript
+   * await provider.getTransactionCount('0x71660c4005ba85c37ccec55d0c4493e66fe775d3');
+   * // 1060000
+   * ```
+   * @example
+   * ```javascript
+   * await provider.getTransactionCount('0x71660c4005ba85c37ccec55d0c4493e66fe775d3', 'latest');
+   * // 1060000
+   * ```
+   * @example
+   * ```javascript
+   * await provider.getTransactionCount('0x71660c4005ba85c37ccec55d0c4493e66fe775d3', 14649390);
+   * // 1053312
+   * ```
+   */
+  async getTransactionCount(address, blockTag = "latest") {
+    blockTag = prepBlockTag(blockTag);
+    const transactionCount = await this.post(
+      buildRPCPostBody("eth_getTransactionCount", [address, blockTag])
+    );
+    return Number(hexToDecimal(transactionCount));
+  }
+  /**
+   * Gets information about a certain block, optionally with full transaction objects.
+   *
+   * * [Similar](/docs/api#isd) to [`ethers.provider.getBlock`](https://docs.ethers.io/v5/api/providers/provider/#Provider-getLogs) in ethers.js, includes some additional information. Can also return block with full transaction objects, similar to [`ethers.providers.getBlockWithTransactions`]
+   * * [Identical](/docs/api#isd) to [`web3.eth.getBlock`](https://web3js.readthedocs.io/en/v1.7.3/web3-eth.html#getpastlogs) in web3.js
+   *
+   * @param timeFrame The number, hash, or text-based description ('latest', 'earliest', or 'pending') of the block to collect information on.
+   * @param returnTransactionObjects Whether to also return data about the transactions on the block.
+   * @returns A BlockResponse object with information about the specified block
+   * @example
+   * ```javascript
+   * await provider.getBlock(14879862);
+   * // {
+   * //   baseFeePerGas: { TinyBig: 39095728776 },
+   * //   difficulty: { TinyBig: 14321294455359973 },
+   * //   extraData: "0x486976656f6e2073672d6865617679",
+   * //   gasLimit: { TinyBig: 29970620 },
+   * //   gasUsed: { TinyBig: 20951384 },
+   * //   hash: "0x563b458ec3c4f87393b53f70bdddc0058497109b784d8cacd9247ddf267049ab",
+   * //   logsBloom:
+   * //     "0x9f38794fe80b521794df6efad8b0d2e9582f9ec3959a3f9384bda0fa371cfa5fac5af9d515c6bdf1ec325f5b5f7ebdd6a3a9fae17b38a86d4dc4b0971afc68d8086640550f4c156e6f923f4a1bb94fb0bed6cdcc474c5c64bfeff7a4a906f72b9a7b94004ee58efc53d63ac66961acd3a431b2d896cc9fd75f6072960bced45f770587caf130f57504decfcb63c6ca8fbc5bdbd749edd5a99a7375d2b81872289adb775fb3c928259f4be39c6d3f4d5b6217822979bb88c1f1fb62429b1b6d41cf4e3f77f9e1db3f5723108f1e5b1255dd734ad8cdb11e7ea22487c788e67c83777b6f395e504ca59c64f52245ee6de3804cf809e5caa4f0ea6a9aa9eb6ed801",
+   * //   miner: "0x1aD91ee08f21bE3dE0BA2ba6918E714dA6B45836",
+   * //   mixHash: "0x73cc9419bfb89c9d41c3a8c34ce56b5ebe468bdcf870258d2e77262275d580ec",
+   * //   nonce: "0x976f3f5d596ffb08",
+   * //   number: 14879862,
+   * //   parentHash: "0x95986ae14a71face8d9a6a379edd875b2e8bc73e4de0d9d460e7752bddb0f579",
+   * //   receiptsRoot: "0x8e6ba2fd9bee602b653dae6e3132f16538c2c5df24f1df8c000392053f73defa",
+   * //   sha3Uncles: "0x1dcc4de8dec75d7aab85b567b6ccd41ad312451b948a7413f0a142fd40d49347",
+   * //   size: { TinyBig: 134483 },
+   * //   stateRoot: "0xbf2bb67bd1c741f3d00904b8451d7c2cf4e3a2726f5a5884792ede2074747b85",
+   * //   timestamp: { TinyBig: 1654016186 },
+   * //   totalDifficulty: { TinyBig: 50478104614257705213748 },
+   * //   transactions: [
+   * //     "0xb3326a9149809603a2c28545e50e4f7d16e194bf5ee9764e0544603854c4a8d2",
+   * //     "0x8b42095f8d335404a4896b2817b8e5e3d86a5a87cb434a8eec295d5280a7f48e",
+   * //     "0x882f78fcb73f0f7ad0700bb0424a8b4beb366aaa93b88a3562c49a8d0ce4dcff",
+   * //     ...
+   * //   ],
+   * //   transactionsRoot: "0x5934902f3dcc263ec34f24318179bf6301f53f4834685792066026f3a4849d72",
+   * //   uncles: [],
+   * // }
+   * ```
+   */
+  async getBlock(timeFrame = "latest", returnTransactionObjects = false) {
+    let type = "Number";
+    if (typeof timeFrame === "string" && timeFrame.length === 66) {
+      type = "Hash";
+    } else {
+      timeFrame = prepBlockTag(timeFrame);
+    }
+    const rpcBlock = await this.post(
+      buildRPCPostBody(`eth_getBlockBy${type}`, [
+        timeFrame,
+        returnTransactionObjects
+      ])
+    );
+    return cleanBlock(rpcBlock, returnTransactionObjects);
+  }
+  /**
+   * Gives an estimate of the current gas price in wei.
+   *
+   * * [Similar](/docs/api#isd) to [`ethers.provider.getGasPrice`](https://docs.ethers.io/v5/api/providers/provider/#Provider-getGasPrice) in ethers.js, does not have a parameter specifying what unit you'd like to return. See also [`weiToEther`](/docs/api/modules#weitoether) and [`etherToGwei`](/docs/api/modules#ethertogwei)
+   * * [Identical](/docs/api#isd) to [`web3.eth.getGasPrice`](https://web3js.readthedocs.io/en/v1.7.3/web3-eth.html#getgasprice) in web3.js, returns a number (TinyBig) instead of a string
+   *
+   * @returns an estimate of the current gas price in wei
+   * @example
+   * ```javascript
+   * await provider.getGasPrice();
+   * // 52493941856
+   * ```
+   */
+  async getGasPrice() {
+    const hexGasPrice = await this.post(
+      buildRPCPostBody("eth_gasPrice", [])
+    );
+    return tinyBig(hexToDecimal(hexGasPrice));
+  }
+  /**
+   * Returns the balance of the account in wei.
+   *
+   * * [Identical](/docs/api#isd) to [`ethers.provider.getBalance`](https://docs.ethers.io/v5/api/providers/provider/#Provider-getBalance) in ethers.js
+   * * [Identical](/docs/api#isd) to [`web3.eth.getBalance`](https://web3js.readthedocs.io/en/v1.7.3/web3-eth.html#getbalance) in web3.js, returns a number (TinyBig) instead of a string
+   *
+   * @param address the address to check the balance of
+   * @param blockTag the block to check the specified address' balance on
+   * @returns the balance of the network's native token for the specified address on the specified block
+   * @example
+   * ```javascript
+   *  await provider.getBalance('0x7cB57B5A97eAbe94205C07890BE4c1aD31E486A8');
+   * // 28798127851528138
+   * ```
+   */
+  async getBalance(address, blockTag = "latest") {
+    blockTag = prepBlockTag(blockTag);
+    const hexBalance = await this.post(
+      buildRPCPostBody("eth_getBalance", [address, blockTag])
+    );
+    return tinyBig(hexToDecimal(hexBalance));
+  }
+  /**
+   * Gets the code of a contract on a specified block.
+   *
+   * * [Identical](/docs/api#isd) to [`ethers.provider.getCode`](https://docs.ethers.io/v5/api/providers/provider/#Provider-getCode) in ethers.js
+   * * [Identical](/docs/api#isd) to [`web3.eth.getCode`](https://web3js.readthedocs.io/en/v1.7.3/web3-eth.html#getcode) in web3.js
+   *
+   * @param address the contract address to get the contract code from
+   * @param blockTag the block height to search for the contract code from. Contract code can change, so this allows for checking a specific block
+   * @returns the contract creation code for the specified address at the specified block height
+   * @example
+   * ```javascript
+   * await jsonRpcProvider().getCode('0xaC6095720221C79C6E7C638d260A2eFBC5D8d880', 'latest');
+   * // '0x608060405234801561001057600080fd5b506004361061...'
+   * ```
+   */
+  async getCode(address, blockTag = "latest") {
+    blockTag = prepBlockTag(blockTag);
+    const contractCode = await this.post(
+      buildRPCPostBody("eth_getCode", [address, blockTag])
+    );
+    return contractCode;
+  }
+  /**
+   * Returns an estimate of the amount of gas that would be required to submit transaction to the network.
+   * An estimate may not be accurate since there could be another transaction on the network that was not accounted for.
+   *
+   * * [Identical](/docs/api#isd) to [`ethers.provider.estimateGas`](https://docs.ethers.io/v5/api/providers/provider/#Provider-estimateGas) in ethers.js
+   * * [Identical](/docs/api#isd) to [`web3.eth.estimateGas`](https://web3js.readthedocs.io/en/v1.7.3/web3-eth.html#estimateGas) in web3.js
+   *
+   * @param transaction the transaction to check the estimated gas cost for
+   * @returns the estimated amount of gas charged for submitting the specified transaction to the blockchain
+   * @example
+   * ```javascript
+   * await provider.estimateGas({
+   *   // Wrapped ETH address
+   *   to: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+   *   data: "0xd0e30db0",
+   *   value: etherToWei('1.0').toHexString(),
+   * });
+   * // { TinyBig: "27938" }
+   * ```
+   */
+  async estimateGas(transaction) {
+    const rpcTransaction = prepareTransaction(transaction);
+    const gasUsed = await this.post(
+      buildRPCPostBody("eth_estimateGas", [rpcTransaction])
+    );
+    return tinyBig(hexToDecimal(gasUsed));
+  }
+  /**
+   * Returns the current recommended FeeData to use in a transaction.
+   * For an EIP-1559 transaction, the maxFeePerGas and maxPriorityFeePerGas should be used.
+   * For legacy transactions and networks which do not support EIP-1559, the gasPrice should be used.Returns an estimate of the amount of gas that would be required to submit transaction to the network.
+   *
+   * * [Identical](/docs/api#isd) to [`ethers.provider.getFeeData`](https://docs.ethers.org/v5/api/providers/provider/#Provider-getFeeData) in ethers.js
+   *
+   * @returns an object with gas estimates for the network currently
+   * @example
+   * ```javascript
+   * await provider.getFeeData();
+   * // {
+   * //   gasPrice: { TinyBig: "14184772639" },
+   * //   lastBaseFeePerGas: { TinyBig: "14038523098" },
+   * //   maxFeePerGas: { TinyBig: "29577046196" },
+   * //   maxPriorityFeePerGas: { TinyBig: "1500000000" }
+   * // }
+   * ```
+   */
+  async getFeeData() {
+    const [block, gasPrice] = await Promise.all([
+      this.getBlock("latest"),
+      this.getGasPrice()
+    ]);
+    let lastBaseFeePerGas = null, maxFeePerGas = null, maxPriorityFeePerGas = null;
+    if (block && block.baseFeePerGas) {
+      lastBaseFeePerGas = block.baseFeePerGas;
+      maxPriorityFeePerGas = tinyBig("1500000000");
+      maxFeePerGas = tinyBig(
+        block.baseFeePerGas.mul(2).add(maxPriorityFeePerGas)
+      );
+    }
+    return { lastBaseFeePerGas, maxFeePerGas, maxPriorityFeePerGas, gasPrice };
+  }
+  /**
+   * Returns transaction receipt event logs that match a specified filter.
+   * May return `[]` if parameters are too broad, even if logs exist.
+   *
+   * * [Identical](/docs/api#isd) to [`ethers.provider.getLogs`](https://docs.ethers.io/v5/api/providers/provider/#Provider-getLogs) in ethers.js
+   * * [Identical](/docs/api#isd) to [`web3.eth.getPastLogs`](https://web3js.readthedocs.io/en/v1.7.3/web3-eth.html#getpastlogs) in web3.js
+   *
+   * @param filter parameters to filter the logs by
+   * @returns an array of logs matching the specified filter
+   * @example
+   * ```javascript
+   * provider.getLogs({
+   *   address: "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2",
+   *   topics: [
+   *     "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef",
+   *     "0x00000000000000000000000021b8065d10f73ee2e260e5b47d3344d3ced7596e",
+   *   ],
+   *   fromBlock: 14825027,
+   *   toBlock: 14825039,
+   * });
+   *
+   * [
+   *   {
+   *     address: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
+   *     blockHash: '0x8e0dfac2f704851960f866c8708b3bef2f66c0fee0329cf25ff0261b264ca6bc',
+   *     blockNumber: 14825029,
+   *     data: '0x000000000000000000000000000000000000000000000000005f862ee352a38a',
+   *     logIndex: 384,
+   *     removed: false,
+   *     topics: [
+   *       '0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef',
+   *       '0x00000000000000000000000021b8065d10f73ee2e260e5b47d3344d3ced7596e',
+   *       '0x00000000000000000000000068b3465833fb72a70ecdf485e0e4c7bd8665fc45'
+   *     ],
+   *     transactionHash: '0xbd49031be16f8fd1775f4e0fe79b408ffd8ae9c65b2827ee47e3238e3f51f4c0',
+   *     transactionIndex: 226
+   *   }
+   * ]
+   * ```
+   */
+  async getLogs(filter) {
+    const filterByRange = filter;
+    if (filterByRange.fromBlock)
+      filterByRange.fromBlock = prepBlockTag(filterByRange.fromBlock);
+    if (filterByRange.toBlock)
+      filterByRange.toBlock = prepBlockTag(filterByRange.toBlock);
+    const rpcLogs = await this.post(
+      buildRPCPostBody("eth_getLogs", [filter])
+    );
+    const logs = rpcLogs.map((log) => cleanLog(log, false));
+    return logs;
+  }
+  /**
+   * Returns the result of adding a transaction to the blockchain without actually adding that transaction to the blockchain.
+   * Does not require any ether as gas.
+   *
+   * * [Identical](/docs/api#isd) to [`ethers.provider.call`](https://docs.ethers.io/v5/api/providers/provider/#Provider-call) in ethers.js
+   * * [Identical](/docs/api#isd) to [`web3.eth.call`](https://web3js.readthedocs.io/en/v1.7.3/web3-eth.html#call) in web3.js
+   *
+   * @param transaction the transaction object to, in theory, execute. Doesn't actually get added to the blockchain.
+   * @param blockTag the block to execute this transaction on
+   * @returns the result of executing the transaction on the specified block
+   * @example
+   * ```javascript
+   * await provider.call({ to: "0x6b175474e89094c44da98b954eedeac495271d0f", data: "0x70a082310000000000000000000000006E0d01A76C3Cf4288372a29124A26D4353EE51BE" });
+   * // '0x0000000000000000000000000000000000000000000000000858898f93629000'
+   * ```
+   */
+  async call(transaction, blockTag = "latest") {
+    if (transaction.gasPrice && (transaction.maxPriorityFeePerGas || transaction.maxFeePerGas)) {
+      logger.throwError(
+        'Cannot specify both "gasPrice" and ("maxPriorityFeePerGas" or "maxFeePerGas")',
+        {
+          gasPrice: transaction.gasPrice,
+          maxFeePerGas: transaction.maxFeePerGas,
+          maxPriorityFeePerGas: transaction.maxPriorityFeePerGas
+        }
+      );
+    }
+    if (transaction.maxFeePerGas && transaction.maxPriorityFeePerGas) {
+      logger.throwError(
+        'Cannot specify both "maxFeePerGas" and "maxPriorityFeePerGas"',
+        {
+          maxFeePerGas: transaction.maxFeePerGas,
+          maxPriorityFeePerGas: transaction.maxPriorityFeePerGas
+        }
+      );
+    }
+    blockTag = prepBlockTag(blockTag);
+    const rpcTransaction = prepareTransaction(transaction);
+    const transactionRes = await this.post(
+      buildRPCPostBody("eth_call", [rpcTransaction, blockTag])
+    );
+    return transactionRes;
+  }
+};
+
+// src/providers/JsonRpcProvider.ts
+var JsonRpcProvider = class extends BaseProvider {
+  /**
+   * @ignore
+   */
+  selectRpcUrl() {
+    return this._rpcUrls[0];
+  }
+  /**
+   * @ignore
+   */
+  post(body) {
+    return this._post(body);
+  }
+  /**
+   * @param rpcUrl The URL to your Eth node. Consider POKT or Infura
+   * @example
+   * `https://free-eth-node.com/api/eth`
+   * @example
+   * `https://mainnet.infura.io/v3/YOUR-PROJECT-ID`
+   */
+  constructor(rpcUrl = "https://free-eth-node.com/api/eth") {
+    super([rpcUrl]);
+  }
+};
+function jsonRpcProvider(rpcUrl) {
+  return new JsonRpcProvider(rpcUrl);
+}
+
+// src/providers/AlchemyProvider.ts
+var AlchemyProvider = class extends JsonRpcProvider {
+  constructor(apiKey, network = "mainnet") {
+    const alchemyUrl = `https://eth-${network}.alchemyapi.io/v2/${apiKey}`;
+    super(alchemyUrl);
+  }
+};
+
+// src/providers/FallthroughProvider.ts
+var promiseTimeout = (prom, time) => new Promise((resolve, reject) => {
+  const timeout = setTimeout(
+    () => reject(new Error("Promise timed out")),
+    time
+  );
+  prom.then((result) => {
+    clearTimeout(timeout);
+    resolve(result);
+  }).catch((error) => {
+    clearTimeout(timeout);
+    reject(error);
+  });
+});
+var DEFAULT_TIMEOUT_DURATION = 8e3;
+var FallthroughProvider = class extends BaseProvider {
+  // index of current trusted rpc url
+  /**
+   * @ignore
+   */
+  rpcUrlCounter = 0;
+  timeoutDuration;
+  /**
+   * @ignore
+   */
+  selectRpcUrl() {
+    return this._rpcUrls[this.rpcUrlCounter];
+  }
+  constructor(rpcUrls, options = {}) {
+    if (!Array.isArray(rpcUrls)) {
+      logger.throwError("Array required", { rpcUrls });
+    }
+    if (rpcUrls.length <= 1) {
+      logger.throwError("More than one rpcUrl is required", { rpcUrls });
+    }
+    super(rpcUrls);
+    this.timeoutDuration = options.timeoutDuration || DEFAULT_TIMEOUT_DURATION;
+  }
+  /**
+   * @ignore
+   */
+  post = (body) => {
+    const genesisCount = this.rpcUrlCounter;
+    const recursivePostRetry = () => {
+      const genesisRpcUrl = this.selectRpcUrl();
+      const res = promiseTimeout(this._post(body), this.timeoutDuration).catch(
+        (e) => {
+          if (genesisRpcUrl === this.selectRpcUrl()) {
+            this.rpcUrlCounter = (this.rpcUrlCounter + 1) % this._rpcUrls.length;
+          }
+          if (this.rpcUrlCounter === genesisCount) {
+            throw e;
+          }
+          return recursivePostRetry();
+        }
+      );
+      return res;
+    };
+    return recursivePostRetry();
+  };
+};
+
+// 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
+};