essential-eth 0.5.11-next.1 → 0.5.13-next.1

package/dist/index.module.js

@@ -1,1865 +0,0 @@
-import { Keccak } from 'sha3';
-import unfetch from 'isomorphic-unfetch';
-import Big from 'big.js';
-import { Point } from '@noble/secp256k1';
-import { Buffer as Buffer$1 } from 'buffer';
-
-function _extends() {
-  _extends = Object.assign ? Object.assign.bind() : function (target) {
-    for (var i = 1; i < arguments.length; i++) {
-      var source = arguments[i];
-
-      for (var key in source) {
-        if (Object.prototype.hasOwnProperty.call(source, key)) {
-          target[key] = source[key];
-        }
-      }
-    }
-
-    return target;
-  };
-  return _extends.apply(this, arguments);
-}
-
-function hexToDecimal(hex) {
-  return BigInt(hex).toString();
-}
-
-const hexFalse = '0'.repeat(64);
-const hexTrue = '0'.repeat(63) + '1';
-
-function expandType(type) {
-  if (type === 'uint[]') {
-    return 'uint256[]';
-  } else if (type === 'int[]') {
-    return 'int256[]';
-  }
-
-  return type;
-}
-
-function encodeData(jsonABIArgument, args) {
-  const hash = new Keccak(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('[')) {
-      var _exec;
-
-      const basicType = (_exec = /([^[]*)\[.*$/g.exec(input.type)) == null ? void 0 : _exec[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')) {
-          const argEncoded = rawArg.split('').map(character => character.charCodeAt(0).toString(16)).join('');
-          const paddedEncodedArg = argEncoded.padEnd(64, '0');
-          return paddedEncodedArg;
-        } else if (inputType === 'uint256') {
-          const argEncoded = BigInt(arg).toString(16);
-          const paddedEncodedArg = argEncoded.padStart(64, '0');
-          return paddedEncodedArg;
-        } 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 encodedOutputs = nodeResponse.slice(2).match(/.{1,64}/g);
-  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':
-        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;
-}
-
-function post(url, body) {
-  return unfetch(url, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json'
-    },
-    body: JSON.stringify(body)
-  }).then(async r => {
-    const t = await r.text();
-
-    try {
-      return JSON.parse(t);
-    } catch (_unused) {
-      throw new Error(`Invalid JSON RPC response: "${t}"`);
-    }
-  }).then(response => {
-    const result = response == null ? void 0 : 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',
-    id: 1,
-    method,
-    params
-  };
-}
-
-function estimateGas(txnData) {
-  txnData.split('').reduce((previousValue, currentValue) => {
-    const characterCost = currentValue === '0' ? 4 : 68;
-    return previousValue + characterCost;
-  }, 0);
-}
-
-class BaseContract {
-  constructor(addressOrName, contractInterface, signerOrProvider) {
-    this._address = void 0;
-    this._provider = void 0;
-    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 == null ? void 0 : jsonABIArgument.gas) === 'number' ? estimateGas(data) : null;
-
-          const req = async () => {
-            return await post(this._provider.selectRpcUrl(), buildRPCPostBody('eth_call', [_extends({
-              to: this._address.toLowerCase(),
-              data
-            }, 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: value,
-    writable: false
-  });
-}
-class Contract extends BaseContract {}
-
-const version = '0.5.11-next.1';
-
-class Logger {
-  constructor() {
-    this.packageVersion = void 0;
-    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 >= 0x1fffffffffffff) {
-      this.throwError(message, {
-        operation: 'checkSafeInteger',
-        fault: 'out-of-safe-range',
-        value: value
-      });
-    }
-
-    if (value % 1) {
-      this.throwError(message, {
-        operation: 'checkSafeInteger',
-        fault: 'non-integer',
-        value: value
-      });
-    }
-  }
-
-}
-
-const logger = new Logger();
-
-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)) {
-    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}`;
-  }
-}
-
-class TinyBig extends Big {
-  constructor(value) {
-    if (typeof value === 'string' && value.startsWith('0x')) {
-      value = hexToDecimal(value);
-    }
-
-    super(value);
-
-    this.padAndChop = (str, padChar, length) => {
-      return (Array(length).fill(padChar).join('') + str).slice(length * -1);
-    };
-  }
-
-  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());
-  }
-
-  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);
-}
-
-function cleanTransaction(transaction) {
-  const cleanedTransaction = _extends({}, 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;
-}
-
-function cleanBlock(block, returnTransactionObjects) {
-  const cleanedBlock = _extends({}, 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;
-}
-
-const validateType = (value, allowedTypes) => {
-  if (!allowedTypes.includes(typeof value)) {
-    throw new Error(`${allowedTypes.join(' or ')} required. Received ${typeof value}`);
-  }
-};
-
-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;
-}
-
-function cleanLog(log, receiptLog) {
-  const cleanedLog = _extends({}, 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];
-        }
-
-        break;
-    }
-  });
-  return cleanedLog;
-}
-
-function cleanTransactionReceipt(transactionReceipt) {
-  const cleanedTransaction = cleanTransaction(transactionReceipt);
-
-  const cleanedTransactionReceipt = _extends({}, 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 >= 4370000;
-  return cleanedTransactionReceipt;
-}
-
-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 & 0xff);
-      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;
-}
-const 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 & 0xf] + 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 & 0xf0) >> 4] + HexCharacters[v & 0x0f];
-    }
-
-    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;
-}
-
-function prepareTransaction(transaction) {
-  const preparedTransaction = _extends({}, 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 Big) {
-            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;
-}
-
-var chainsInfo = {
-  "1": ["eth", "0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"],
-  "2": ["exp"],
-  "3": ["rop", "0x112234455c3a32fd11230c42e7bccd4a84e02010"],
-  "4": ["rin", "0xe7410170f87102df0055eb195163a03b7f2bff4a"],
-  "5": ["gor", "0x112234455c3a32fd11230c42e7bccd4a84e02010"],
-  "6": ["kot"],
-  "7": ["tch"],
-  "8": ["ubq"],
-  "9": ["tubq"],
-  "10": ["oeth"],
-  "11": ["meta"],
-  "12": ["kal"],
-  "13": ["dstg"],
-  "14": ["flr"],
-  "15": ["diode"],
-  "16": ["cflr"],
-  "17": ["tfi"],
-  "18": ["TST"],
-  "19": ["sgb"],
-  "20": ["elaeth"],
-  "21": ["elaetht"],
-  "22": ["eladid"],
-  "23": ["eladidt"],
-  "24": ["dthmainnet"],
-  "25": ["cro"],
-  "26": ["L1test"],
-  "27": ["shib"],
-  "28": ["Boba Rinkeby"],
-  "29": ["L1"],
-  "30": ["rsk"],
-  "31": ["trsk"],
-  "32": ["GooDT"],
-  "33": ["GooD"],
-  "34": ["dth"],
-  "35": ["tbwg"],
-  "36": ["dx"],
-  "38": ["val"],
-  "40": ["Telos EVM"],
-  "41": ["Telos EVM Testnet"],
-  "42": ["kov"],
-  "43": ["pangolin"],
-  "44": ["crab"],
-  "45": ["pangoro"],
-  "46": ["darwinia"],
-  "50": ["xdc"],
-  "51": ["TXDC"],
-  "52": ["cet"],
-  "53": ["tcet"],
-  "54": ["OP"],
-  "55": ["ZYX"],
-  "56": ["bnb"],
-  "57": ["sys"],
-  "58": ["Ontology Mainnet"],
-  "59": ["EOS Mainnet"],
-  "60": ["go"],
-  "61": ["etc"],
-  "62": ["tetc"],
-  "63": ["metc"],
-  "64": ["ellaism"],
-  "65": ["tokt"],
-  "66": ["okt"],
-  "67": ["dbm"],
-  "68": ["SO1"],
-  "69": ["okov"],
-  "70": ["hsc"],
-  "71": ["cfxtest"],
-  "72": ["dxc"],
-  "74": ["idchain"],
-  "76": ["mix"],
-  "77": ["spoa"],
-  "78": ["primuschain"],
-  "79": ["zenith"],
-  "80": ["GeneChain"],
-  "81": ["VIL"],
-  "82": ["Meter"],
-  "83": ["MeterTest"],
-  "85": ["gttest"],
-  "86": ["gt"],
-  "87": ["nnw"],
-  "88": ["tomo"],
-  "89": ["tomot"],
-  "90": ["gar-s0"],
-  "91": ["gar-s1"],
-  "92": ["gar-s2"],
-  "93": ["gar-s3"],
-  "95": ["Kylin Testnet"],
-  "96": ["nsc"],
-  "97": ["bnbt"],
-  "99": ["poa"],
-  "100": ["gno"],
-  "101": ["eti"],
-  "102": ["tw3g"],
-  "104": ["tklc"],
-  "105": ["dw3g"],
-  "106": ["vlx"],
-  "107": ["ntn"],
-  "108": ["TT"],
-  "110": ["xpr"],
-  "111": ["ETL"],
-  "122": ["fuse"],
-  "123": ["spark"],
-  "124": ["dwu"],
-  "125": ["oychain testnet"],
-  "126": ["oychain mainnet"],
-  "127": ["feth"],
-  "128": ["heco"],
-  "137": ["MATIC"],
-  "141": ["OPtest"],
-  "142": ["dax"],
-  "162": ["tpht"],
-  "163": ["pht"],
-  "168": ["aioz"],
-  "170": ["hoosmartchain"],
-  "172": ["resil"],
-  "180": ["ame"],
-  "186": ["Seele"],
-  "188": ["BMC"],
-  "189": ["BMCT"],
-  "193": ["cem"],
-  "199": ["BTT"],
-  "200": ["aox"],
-  "211": ["EDI"],
-  "218": ["SO1-old"],
-  "222": ["ASK"],
-  "225": ["LA"],
-  "226": ["TLA"],
-  "246": ["ewt"],
-  "250": ["ftm"],
-  "256": ["hecot"],
-  "258": ["setm"],
-  "262": ["SUR"],
-  "269": ["hpb"],
-  "280": ["zksync-goerli"],
-  "288": ["Boba"],
-  "300": ["ogc"],
-  "321": ["kcs"],
-  "322": ["kcst"],
-  "333": ["w3q"],
-  "335": ["DFKTEST"],
-  "336": ["sdn"],
-  "338": ["tcro"],
-  "361": ["theta-mainnet"],
-  "363": ["theta-sapphire"],
-  "364": ["theta-amber"],
-  "365": ["theta-testnet"],
-  "369": ["pls"],
-  "385": ["lisinski"],
-  "416": ["SX"],
-  "420": ["ogor"],
-  "499": ["rupx"],
-  "512": ["aac"],
-  "513": ["aact"],
-  "520": ["xt"],
-  "530": ["f(x)Core"],
-  "534": ["CNDL"],
-  "555": ["CLASS"],
-  "558": ["tao"],
-  "588": ["metis-stardust"],
-  "592": ["astr"],
-  "595": ["maca"],
-  "596": ["tkar"],
-  "597": ["taca"],
-  "600": ["mesh-chain-testnet"],
-  "647": ["SX-Testnet"],
-  "666": ["pixie-chain-testnet"],
-  "686": ["kar"],
-  "700": ["SNS"],
-  "707": ["bcs"],
-  "708": ["tbcs"],
-  "721": ["tfeth"],
-  "776": ["opc"],
-  "777": ["cth"],
-  "787": ["aca"],
-  "788": ["taero"],
-  "803": ["haic"],
-  "808": ["PFTEST"],
-  "820": ["clo"],
-  "821": ["tclo"],
-  "880": ["ambros"],
-  "888": ["wan"],
-  "900": ["gar-test-s0"],
-  "901": ["gar-test-s1"],
-  "902": ["gar-test-s2"],
-  "903": ["gar-test-s3"],
-  "909": ["PF"],
-  "940": ["tpls"],
-  "941": ["t2bpls"],
-  "942": ["t3pls"],
-  "977": ["yeti"],
-  "980": ["top_evm"],
-  "989": ["top"],
-  "998": ["ln"],
-  "999": ["twan"],
-  "1000": ["gton"],
-  "1001": ["Baobab"],
-  "1007": ["tnew"],
-  "1008": ["eun"],
-  "1010": ["EVC"],
-  "1012": ["new"],
-  "1022": ["sku"],
-  "1023": ["tclv"],
-  "1024": ["clv"],
-  "1028": ["tbtt"],
-  "1030": ["cfx"],
-  "1088": ["metis-andromeda"],
-  "1139": ["MATH"],
-  "1140": ["tMATH"],
-  "1197": ["iora"],
-  "1201": ["avis"],
-  "1202": ["wtt"],
-  "1213": ["popcat"],
-  "1214": ["enter"],
-  "1246": ["om"],
-  "1280": ["HO"],
-  "1284": ["mbeam"],
-  "1285": ["mriver"],
-  "1286": ["mrock-old"],
-  "1287": ["mbase"],
-  "1288": ["mrock"],
-  "1297": ["Bobabase"],
-  "1319": ["aitd"],
-  "1320": ["aitdtestnet"],
-  "1337": ["cennz-old"],
-  "1506": ["Sherpax"],
-  "1507": ["Sherpax Testnet"],
-  "1618": ["cate"],
-  "1620": ["ath"],
-  "1657": ["bta"],
-  "1688": ["LUDAN"],
-  "1818": ["cube"],
-  "1819": ["cubet"],
-  "1856": ["tsf"],
-  "1898": ["boya"],
-  "1984": ["euntest"],
-  "1987": ["egem"],
-  "2001": ["milkAda"],
-  "2008": ["cloudwalk_testnet"],
-  "2009": ["cloudwalk_mainnet"],
-  "2020": ["420"],
-  "2021": ["edg"],
-  "2022": ["edgt"],
-  "2023": ["taycan-testnet"],
-  "2025": ["rpg"],
-  "2100": ["eco"],
-  "2101": ["esp"],
-  "2152": ["fra"],
-  "2153": ["findora-testnet"],
-  "2213": ["evanesco"],
-  "2221": ["tkava"],
-  "2222": ["kava"],
-  "2223": ["VChain"],
-  "2559": ["ktoc"],
-  "2569": ["tpc"],
-  "2612": ["EZChain"],
-  "2613": ["Fuji-EZChain"],
-  "3000": ["cennz-r"],
-  "3001": ["cennz-n"],
-  "3331": ["zcrbeach"],
-  "3333": ["w3q-t"],
-  "3334": ["w3q-g"],
-  "3400": ["prb"],
-  "3500": ["prbtestnet"],
-  "3501": ["jfin"],
-  "3690": ["btx"],
-  "3737": ["csb"],
-  "3966": ["dyno"],
-  "3967": ["tdyno"],
-  "3999": ["ycc"],
-  "4002": ["tftm"],
-  "4051": ["Bobaopera Testnet"],
-  "4102": ["aioz-testnet"],
-  "4181": ["PHI"],
-  "4689": ["iotex-mainnet"],
-  "4690": ["iotex-testnet"],
-  "4918": ["txvm"],
-  "4919": ["xvm"],
-  "5177": ["tlc"],
-  "5197": ["es"],
-  "5315": ["UZMI"],
-  "5551": ["Nahmii"],
-  "5553": ["Nahmii testnet"],
-  "5700": ["tsys"],
-  "5777": ["dgcc"],
-  "5851": ["Ontology Testnet"],
-  "5869": ["rbd"],
-  "6626": ["pixie-chain"],
-  "6969": ["tombchain"],
-  "7027": ["ELLA"],
-  "7341": ["shyft"],
-  "7777": ["Rise of the Warbots Testnet"],
-  "7878": ["tscas"],
-  "8000": ["teleport"],
-  "8001": ["teleport-testnet"],
-  "8029": ["mdgl"],
-  "8080": ["GeneChainAdn"],
-  "8217": ["Cypress"],
-  "8285": ["Kortho"],
-  "8723": ["olo"],
-  "8724": ["tolo"],
-  "8888": ["ambrostestnet"],
-  "8898": ["mmt"],
-  "8995": ["berg"],
-  "9000": ["evmos-testnet"],
-  "9001": ["evmos"],
-  "9012": ["brb"],
-  "9100": ["GENEC"],
-  "9527": ["trpg"],
-  "9999": ["myn"],
-  "10000": ["smartbch"],
-  "10001": ["smartbchtest"],
-  "10101": ["GEN"],
-  "10823": ["CCP"],
-  "10946": ["quadrans"],
-  "10947": ["quadranstestnet"],
-  "11111": ["WAGMI"],
-  "11437": ["shyftt"],
-  "12051": ["tZERO"],
-  "12052": ["ZERO"],
-  "13381": ["Phoenix"],
-  "16000": ["mtt"],
-  "16001": ["mtttest"],
-  "16888": ["tivar"],
-  "19845": ["btcix"],
-  "21337": ["cennz-a"],
-  "21816": ["omc"],
-  "22023": ["SFL"],
-  "24484": ["web"],
-  "24734": ["mintme"],
-  "26863": ["OAC"],
-  "30067": ["Piece"],
-  "31102": ["esn"],
-  "31337": ["got"],
-  "32520": ["Brise"],
-  "32659": ["fsn"],
-  "35441": ["q"],
-  "35443": ["q-testnet"],
-  "39797": ["nrg"],
-  "42069": ["PC"],
-  "42161": ["arb1"],
-  "42170": ["arb-nova"],
-  "42220": ["CELO"],
-  "42261": ["emerald"],
-  "42262": ["oasis"],
-  "43110": ["avaeth"],
-  "43113": ["Fuji"],
-  "43114": ["avax"],
-  "44787": ["ALFA"],
-  "45000": ["Autobahn Network"],
-  "47805": ["REI"],
-  "49797": ["tnrg"],
-  "50021": ["tgton"],
-  "53935": ["DFK"],
-  "55555": ["reichain"],
-  "55556": ["trei"],
-  "60000": ["TKM-test0"],
-  "60001": ["TKM-test1"],
-  "60002": ["TKM-test2"],
-  "60103": ["TKM-test103"],
-  "62320": ["BKLV"],
-  "62621": ["mtv"],
-  "63000": ["ecs"],
-  "63001": ["ecs-testnet"],
-  "69420": ["cndr"],
-  "70000": ["TKM0"],
-  "70001": ["TKM1"],
-  "70002": ["TKM2"],
-  "70103": ["TKM103"],
-  "71393": ["ckb"],
-  "71401": ["gw-testnet-v1"],
-  "71402": ["gw-mainnet-v1"],
-  "73799": ["vt"],
-  "73927": ["mvm"],
-  "75000": ["resin"],
-  "78110": ["firenze"],
-  "80001": ["maticmum"],
-  "88888": ["ivar"],
-  "99998": ["usctest"],
-  "99999": ["usc"],
-  "100000": ["qkc-r"],
-  "100001": ["qkc-s0"],
-  "100002": ["qkc-s1"],
-  "100003": ["qkc-s2"],
-  "100004": ["qkc-s3"],
-  "100005": ["qkc-s4"],
-  "100006": ["qkc-s5"],
-  "100007": ["qkc-s6"],
-  "100008": ["qkc-s7"],
-  "103090": ["CRFI"],
-  "108801": ["bro"],
-  "110000": ["qkc-d-r"],
-  "110001": ["qkc-d-s0"],
-  "110002": ["qkc-d-s1"],
-  "110003": ["qkc-d-s2"],
-  "110004": ["qkc-d-s3"],
-  "110005": ["qkc-d-s4"],
-  "110006": ["qkc-d-s5"],
-  "110007": ["qkc-d-s6"],
-  "110008": ["qkc-d-s7"],
-  "131419": ["ETND"],
-  "200101": ["milkTAda"],
-  "200625": ["aka"],
-  "201018": ["alaya"],
-  "201030": ["alayadev"],
-  "210425": ["platon"],
-  "234666": ["hym"],
-  "246529": ["ats"],
-  "246785": ["atstau"],
-  "281121": ["SoChain"],
-  "333888": ["sparta"],
-  "333999": ["olympus"],
-  "421611": ["arb-rinkeby"],
-  "421613": ["arb-goerli"],
-  "432201": ["Dexalot"],
-  "444900": ["wlkt"],
-  "474142": ["oc"],
-  "512512": ["cmp"],
-  "666666": ["vpioneer"],
-  "846000": ["bloqs4good"],
-  "888888": ["vision"],
-  "955305": ["elv"],
-  "1313114": ["etho"],
-  "1313500": ["xero"],
-  "1337702": ["kintsugi"],
-  "1337802": ["kiln"],
-  "2203181": ["platondev"],
-  "2206132": ["platondev2"],
-  "7762959": ["music"],
-  "11155111": ["sep"],
-  "13371337": ["tpep"],
-  "18289463": ["ilt"],
-  "20180430": ["spectrum"],
-  "20181205": ["qki"],
-  "28945486": ["auxi"],
-  "35855456": ["JOYS"],
-  "61717561": ["aqua"],
-  "99415706": ["TOYS"],
-  "192837465": ["GTH"],
-  "245022926": ["neonevm-devnet"],
-  "245022934": ["neonevm-mainnet"],
-  "245022940": ["neonevm-testnet"],
-  "311752642": ["oneledger"],
-  "356256156": ["tGTH"],
-  "486217935": ["dGTH"],
-  "1122334455": ["ipos"],
-  "1313161554": ["aurora"],
-  "1313161555": ["aurora-testnet"],
-  "1313161556": ["aurora-betanet"],
-  "1666600000": ["hmy-s0"],
-  "1666600001": ["hmy-s1"],
-  "1666600002": ["hmy-s2"],
-  "1666600003": ["hmy-s3"],
-  "1666700000": ["hmy-b-s0"],
-  "1666700001": ["hmy-b-s1"],
-  "1666700002": ["hmy-b-s2"],
-  "1666700003": ["hmy-b-s3"],
-  "2021121117": ["hop"],
-  "3125659152": ["pirl"],
-  "4216137055": ["frankenstein"],
-  "11297108099": ["tpalm"],
-  "11297108109": ["palm"],
-  "197710212030": ["ntt"],
-  "197710212031": ["ntt-haradev"],
-  "6022140761023": ["mole"],
-  "868455272153094": ["gw-testnet-v1-deprecated"]
-};
-
-function prepBlockTag(blockTag) {
-  return typeof blockTag === 'number' ? tinyBig(blockTag).toHexString() : blockTag;
-}
-
-class BaseProvider {
-  constructor(rpcUrls) {
-    this._rpcUrls = [];
-
-    this._post = body => post(this.selectRpcUrl(), body);
-
-    this._rpcUrls = rpcUrls;
-  }
-
-  async getNetwork() {
-    const hexChainId = await this.post(buildRPCPostBody('eth_chainId', []));
-    const chainId = hexToDecimal(hexChainId);
-    const info = chainsInfo[chainId];
-    return {
-      chainId: Number(chainId),
-      name: info[0] || 'unknown',
-      ensAddress: info[1] || null
-    };
-  }
-
-  async getBlockNumber() {
-    const currentBlockNumber = await this.post(buildRPCPostBody('eth_blockNumber', []));
-    return Number(hexToDecimal(currentBlockNumber));
-  }
-
-  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;
-  }
-
-  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;
-  }
-
-  async getTransactionCount(address, blockTag = 'latest') {
-    blockTag = prepBlockTag(blockTag);
-    const transactionCount = await this.post(buildRPCPostBody('eth_getTransactionCount', [address, blockTag]));
-    return Number(hexToDecimal(transactionCount));
-  }
-
-  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);
-  }
-
-  async getGasPrice() {
-    const hexGasPrice = await this.post(buildRPCPostBody('eth_gasPrice', []));
-    return tinyBig(hexToDecimal(hexGasPrice));
-  }
-
-  async getBalance(address, blockTag = 'latest') {
-    blockTag = prepBlockTag(blockTag);
-    const hexBalance = await this.post(buildRPCPostBody('eth_getBalance', [address, blockTag]));
-    return tinyBig(hexToDecimal(hexBalance));
-  }
-
-  async getCode(address, blockTag = 'latest') {
-    blockTag = prepBlockTag(blockTag);
-    const contractCode = await this.post(buildRPCPostBody('eth_getCode', [address, blockTag]));
-    return contractCode;
-  }
-
-  async estimateGas(transaction) {
-    const rpcTransaction = prepareTransaction(transaction);
-    const gasUsed = await this.post(buildRPCPostBody('eth_estimateGas', [rpcTransaction]));
-    return tinyBig(hexToDecimal(gasUsed));
-  }
-
-  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;
-  }
-
-  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;
-  }
-
-}
-
-const promiseTimeout = (prom, time) => Promise.race([prom, new Promise((_r, reject) => setTimeout(() => reject('Promise timed out'), time))]);
-
-const DEFAULT_TIMEOUT_DURATION = 8000;
-class FallthroughProvider extends BaseProvider {
-  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.rpcUrlCounter = 0;
-    this.timeoutDuration = void 0;
-
-    this.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();
-    };
-
-    this.timeoutDuration = options.timeoutDuration || DEFAULT_TIMEOUT_DURATION;
-  }
-
-}
-
-class JsonRpcProvider extends BaseProvider {
-  selectRpcUrl() {
-    return this._rpcUrls[0];
-  }
-
-  post(body) {
-    return this._post(body);
-  }
-
-  constructor(rpcUrl = 'https://free-eth-node.com/api/eth') {
-    super([rpcUrl]);
-  }
-
-}
-function jsonRpcProvider(rpcUrl) {
-  return new JsonRpcProvider(rpcUrl);
-}
-
-function keccak256(data) {
-  let bufferableData;
-
-  if (typeof data === 'string') {
-    bufferableData = Buffer.from(data.replace(/^0x/, ''), 'hex');
-  } else {
-    bufferableData = Buffer.from(data);
-  }
-
-  const keccak = new Keccak(256);
-  const addressHash = '0x' + keccak.update(bufferableData).digest('hex');
-  return addressHash;
-}
-
-function computeAddress(key) {
-  if (!key.startsWith('0x04') && !key.startsWith('0x03') && !key.startsWith('0x02')) {
-    key = computePublicKey(key);
-  }
-
-  return toChecksumAddress(hexDataSlice(keccak256(hexDataSlice(key, 1)), 12));
-}
-
-function computePublicKey(privKey) {
-  privKey = hexlify(privKey).slice(2);
-  return '0x' + Point.fromPrivateKey(privKey).toHex();
-}
-
-function etherToGwei(etherQuantity) {
-  validateType(etherQuantity, ['string', 'number', 'object']);
-  const result = tinyBig(etherQuantity).times('1000000000');
-  return tinyBig(result);
-}
-
-function etherToWei(etherQuantity) {
-  validateType(etherQuantity, ['string', 'number', 'object']);
-  const result = tinyBig(etherQuantity).times('1000000000000000000');
-  return tinyBig(result);
-}
-
-function gweiToEther(gweiQuantity) {
-  validateType(gweiQuantity, ['string', 'number', 'object']);
-  const result = tinyBig(gweiQuantity).div('1000000000');
-  return tinyBig(result);
-}
-
-const messagePrefix = '\x19Ethereum Signed Message:\n';
-function hashMessage(message) {
-  if (typeof message === 'string') {
-    message = toUtf8Bytes(message);
-  }
-
-  return keccak256(concat([toUtf8Bytes(messagePrefix), toUtf8Bytes(String(message.length)), message]));
-}
-
-function isAddress(address) {
-  validateType(address, ['string']);
-
-  try {
-    toChecksumAddress(address);
-    return true;
-  } catch (error) {
-    return false;
-  }
-}
-
-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] &= 0x7f;
-      result.r = hexlify(bytes.slice(0, 32));
-      result.s = hexlify(bytes.slice(32, 64));
-    } else if (bytes.length === 65) {
-      result.r = hexlify(bytes.slice(0, 32));
-      result.s = hexlify(bytes.slice(32, 64));
-      result.v = bytes[64];
-    } else {
-      logger.throwArgumentError('invalid signature string', 'signature', signature);
-    }
-
-    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] |= 0x80;
-    }
-
-    result._vs = hexlify(bytes.slice(32, 64));
-  } else {
-    result.r = signature.r;
-    result.s = signature.s;
-    result.v = signature.v;
-    result.recoveryParam = signature.recoveryParam;
-    result._vs = signature._vs;
-
-    if (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] &= 0x7f;
-      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] |= 0x80;
-    }
-
-    const _vs = hexlify(vs);
-
-    if (result._vs) {
-      if (!isHexString(result._vs)) {
-        logger.throwArgumentError('signature invalid _vs', 'signature', signature);
-      }
-
-      result._vs = hexZeroPad(result._vs, 32);
-    }
-
-    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;
-}
-
-function toUtf8Bytes(data) {
-  return new Uint8Array(Buffer.from(data));
-}
-
-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;
-  }
-}
-
-const regexBytes = new RegExp('^bytes([0-9]+)$');
-const regexNumber = new RegExp('^(u?int)([0-9]*)$');
-const 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 Buffer$1.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 hexValue = hexlify(value);
-    return zeroPad(hexValue, 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 (value) {
-      result.push(_pack(baseType, value, 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));
-}
-
-export { 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 };
-//# sourceMappingURL=index.module.js.map