essential-eth 0.11.2 → 1.0.0

package/dist/chunk-CLIQ4S3P.js

@@ -0,0 +1,780 @@
+import { validateType } from './chunk-GFWRB7PT.js';
+import { keccak_256 } from '@noble/hashes/sha3.js';
+import { bytesToHex } from '@noble/hashes/utils.js';
+import { Point } from '@noble/secp256k1';
+
+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 addressBytes = new TextEncoder().encode(_address);
+  const addressHash = bytesToHex(keccak_256(addressBytes));
+  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/logger/package-version.ts
+var version = "1.0.0";
+
+// 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 (typeof value === "bigint") {
+    const hex = value.toString(16).padStart(2, "0");
+    const padded = hex.length % 2 ? "0" + hex : hex;
+    const result = new Uint8Array(padded.length / 2);
+    for (let i = 0; i < result.length; i++) {
+      result[i] = parseInt(padded.substring(i * 2, i * 2 + 2), 16);
+    }
+    return 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;
+}
+function keccak256(data) {
+  let bytes;
+  if (typeof data === "string") {
+    const hex = data.replace(/^0x/, "");
+    bytes = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < bytes.length; i++) {
+      bytes[i] = parseInt(hex.substr(i * 2, 2), 16);
+    }
+  } else {
+    bytes = new Uint8Array(data);
+  }
+  return "0x" + bytesToHex(keccak_256(bytes));
+}
+
+// src/utils/to-utf8-bytes.ts
+function toUtf8Bytes(data) {
+  return new TextEncoder().encode(data);
+}
+function computePublicKey(privKey) {
+  privKey = hexlify(privKey).slice(2);
+  return "0x" + Point.fromPrivateKey(privKey).toHex();
+}
+
+// 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/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/classes/utils/hex-to-decimal.ts
+function hexToDecimal(hex) {
+  return BigInt(hex).toString();
+}
+
+// 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 functionString = `${jsonABIArgument.name}(${jsonABIArgument.inputs.map(
+    (input) => expandType(input.type)
+  )})`;
+  const functionHash = bytesToHex(
+    keccak_256(new TextEncoder().encode(functionString))
+  );
+  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 BigInt(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 "bytes32":
+        return `0x${output}`;
+      case "uint8":
+        return Number(hexToDecimal(`0x${output}`));
+      default:
+        if (outputType.startsWith("uint")) {
+          return BigInt(hexToDecimal(`0x${output}`));
+        }
+        if (outputType.startsWith("int")) {
+          return BigInt(hexToDecimal(`0x${output}`));
+        }
+        throw new Error(
+          `essential-eth does not yet support "${outputType}" outputs. Make a PR today!"`
+        );
+    }
+  });
+  return outputs.length === 1 ? outputs[0] : outputs;
+}
+
+// src/utils/solidity-keccak256.ts
+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 new TextEncoder().encode(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;
+    }
+    let bigVal = BigInt(value);
+    if (bigVal < 0n) {
+      bigVal = bigVal + (1n << BigInt(size));
+    }
+    value = Number(bigVal);
+    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;
+}
+
+export { arrayify, computeAddress, computePublicKey, concat, decodeRPCResponse, encodeData, hashMessage, hexConcat, hexDataLength, hexDataSlice, hexStripZeros, hexToDecimal, hexValue, hexZeroPad, hexlify, isAddress, isBytes, isBytesLike, isHexString, keccak256, logger, pack, solidityKeccak256, splitSignature, stripZeros, toChecksumAddress, toUtf8Bytes, zeroPad };