@layerzerolabs/lz-utilities 2.3.41 → 2.3.43

package/dist/index.cjs

@@ -1,8 +1,7 @@
 'use strict';
 
 var http = require('http');
-var path = require('path');
-var utils = require('@noble/hashes/utils');
+var path2 = require('path');
 var web3_js = require('@solana/web3.js');
 var aptos = require('aptos');
 var bip39 = require('bip39');
@@ -11,8 +10,8 @@ var ethers = require('ethers');
 var lzDefinitions = require('@layerzerolabs/lz-definitions');
 var winston = require('winston');
 var module$1 = require('module');
-var assert = require('assert');
-var findUp = require('find-up');
+var fs = require('fs');
+var findUp$1 = require('find-up');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -35,14 +34,138 @@ function _interopNamespace(e) {
 }
 
 var http__default = /*#__PURE__*/_interopDefault(http);
-var path__default = /*#__PURE__*/_interopDefault(path);
+var path2__namespace = /*#__PURE__*/_interopNamespace(path2);
 var aptos__namespace = /*#__PURE__*/_interopNamespace(aptos);
 var bip39__namespace = /*#__PURE__*/_interopNamespace(bip39);
 var ed25519HdKey__namespace = /*#__PURE__*/_interopNamespace(ed25519HdKey);
 var winston__namespace = /*#__PURE__*/_interopNamespace(winston);
-var assert__default = /*#__PURE__*/_interopDefault(assert);
+var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
 
 // src/index.ts
+
+// src/pad.ts
+var SizeExceedsPaddingSizeError = class extends Error {
+  constructor({ size, targetSize, type }) {
+    super(
+      `${type.charAt(0).toUpperCase()}${type.slice(1).toLowerCase()} size (${size}) exceeds padding size (${targetSize})`
+    );
+    this.name = "SizeExceedsPaddingSizeError";
+  }
+};
+function padify(hexOrBytes, { dir, size = 32 } = {}) {
+  if (typeof hexOrBytes === "string") {
+    return padHex(hexOrBytes, { dir, size });
+  }
+  return padBytes(hexOrBytes, { dir, size });
+}
+function padHex(hex, { dir, size = 32 } = {}) {
+  if (size === null)
+    return hex;
+  const value = hex.replace("0x", "");
+  if (value.length > size * 2)
+    throw new SizeExceedsPaddingSizeError({
+      size: Math.ceil(value.length / 2),
+      targetSize: size,
+      type: "hex"
+    });
+  return `0x${value[dir === "right" ? "padEnd" : "padStart"](size * 2, "0")}`;
+}
+function padBytes(bytes, { dir, size = 32 } = {}) {
+  if (size === null)
+    return bytes;
+  if (bytes.length > size)
+    throw new SizeExceedsPaddingSizeError({
+      size: bytes.length,
+      targetSize: size,
+      type: "bytes"
+    });
+  const paddedBytes = new Uint8Array(size);
+  for (let i = 0; i < size; i++) {
+    const padEnd = dir === "right";
+    paddedBytes[padEnd ? i : size - i - 1] = bytes[padEnd ? i : bytes.length - i - 1];
+  }
+  return paddedBytes;
+}
+
+// src/types.ts
+function isHex(value) {
+  return /^(0x)?[0-9A-F]+/i.test(value);
+}
+function isHash(value) {
+  return /^(0x)?[0-9A-F]+/i.test(value);
+}
+
+// src/format.ts
+function bytesToHex(bytes) {
+  return trim0x(hexlify(bytes)).replace(/^0x/i, "");
+}
+function hexToBytes(hex) {
+  return arrayify(hex);
+}
+function trim0x(hex) {
+  return hex.replace(/^0x/i, "");
+}
+function ensure0x(hex) {
+  if (!isHex(hex)) {
+    throw new Error("invalid hex string");
+  }
+  const value = trim0x(hex);
+  const retval = `0x${value}`;
+  return retval;
+}
+function isHexString(value) {
+  return isHex(value);
+}
+function _arrayify(value) {
+  if (value instanceof Uint8Array) {
+    return value;
+  }
+  if (typeof value === "string") {
+    if (value.match(/^(0x)?[0-9A-F]*$/i)) {
+      const hex = value.replace(/^0x/i, "");
+      const len = hex.length + 1 - (hex.length + 1) % 2;
+      return Uint8Array.from(Buffer.from(hex.padStart(len, "0"), "hex"));
+    }
+    throw new Error("Invalid hex string");
+  }
+  if (typeof value === "number") {
+    if (value < 0) {
+      throw new Error("Number must be non-negative");
+    }
+    const byteArray = [];
+    while (value > 0) {
+      byteArray.push(value & 255);
+      value >>= 8;
+    }
+    return new Uint8Array(byteArray.reverse());
+  }
+  if (typeof Buffer !== "undefined" && Buffer.isBuffer(value)) {
+    return new Uint8Array(value);
+  }
+  if (typeof value === "bigint") {
+    const hex = value.toString(16);
+    return _arrayify(hex);
+  }
+  throw new Error("unsupported type");
+}
+function arrayify(value, size) {
+  const bytes = _arrayify(value);
+  if (size === void 0) {
+    return bytes;
+  }
+  return padify(bytes, { size });
+}
+function hexlify(value) {
+  if (typeof value === "string" && /^(0x)?[0-9A-F]*$/i.test(value)) {
+    const retval = "0x" + trim0x(value);
+    return retval;
+  }
+  const bytes = arrayify(value);
+  const hex = Buffer.from(bytes).toString("hex");
+  return ensure0x(hex);
+}
+
+// src/account.ts
 function getBIP044Path(chainType, account, change, index) {
   switch (chainType) {
     case lzDefinitions.ChainType.EVM:
@@ -55,49 +178,49 @@ function getBIP044Path(chainType, account, change, index) {
       throw new Error(`Unsupported chain: ${chainType}`);
   }
 }
-function getEvmAccountFromMnemonic(mnemonic, path2 = "m/44'/60'/0'/0/0") {
-  const wallet = ethers.ethers.Wallet.fromMnemonic(mnemonic, path2);
+function getEvmAccountFromMnemonic(mnemonic, path3 = "m/44'/60'/0'/0/0") {
+  const wallet = ethers.ethers.Wallet.fromMnemonic(mnemonic, path3);
   return {
     mnemonic,
-    path: path2,
+    path: path3,
     privateKey: wallet.privateKey,
     address: wallet.address
   };
 }
-function getAptosAccountFromMnemonic(mnemonic, path2 = "m/44'/637'/0'/0'/0'") {
-  if (!aptos__namespace.AptosAccount.isValidPath(path2)) {
-    throw new Error(`Invalid derivation path: ${path2}`);
+function getAptosAccountFromMnemonic(mnemonic, path3 = "m/44'/637'/0'/0'/0'") {
+  if (!aptos__namespace.AptosAccount.isValidPath(path3)) {
+    throw new Error(`Invalid derivation path: ${path3}`);
   }
   const normalizeMnemonics = mnemonic.trim().split(/\s+/).map((part) => part.toLowerCase()).join(" ");
   {
-    const { key } = aptos__namespace.derivePath(path2, utils.bytesToHex(bip39__namespace.mnemonicToSeedSync(normalizeMnemonics)));
+    const { key } = aptos__namespace.derivePath(path3, trim0x(hexlify(bip39__namespace.mnemonicToSeedSync(normalizeMnemonics))));
     const account = new aptos__namespace.AptosAccount(new Uint8Array(key)).toPrivateKeyObject();
     return {
       mnemonic,
-      path: path2,
+      path: path3,
       privateKey: account.privateKeyHex,
       address: account.address
     };
   }
 }
-function getSolanaAccountFromMnemonic(mnemonic, path2 = "m/44'/501'/0'/0'") {
+function getSolanaAccountFromMnemonic(mnemonic, path3 = "m/44'/501'/0'/0'") {
   const seed = bip39__namespace.mnemonicToSeedSync(mnemonic, "");
-  const keyPair = web3_js.Keypair.fromSeed(ed25519HdKey__namespace.derivePath(path2, seed.toString("hex")).key);
+  const keyPair = web3_js.Keypair.fromSeed(ed25519HdKey__namespace.derivePath(path3, seed.toString("hex")).key);
   return {
     mnemonic,
-    path: path2,
+    path: path3,
     privateKey: ethers.ethers.utils.hexlify(keyPair.secretKey),
     address: keyPair.publicKey.toBase58()
   };
 }
-function getKeypairFromMnemonic(chainType, mnemonic, path2) {
+function getKeypairFromMnemonic(chainType, mnemonic, path3) {
   switch (chainType) {
     case lzDefinitions.ChainType.EVM:
-      return getEvmAccountFromMnemonic(mnemonic, path2);
+      return getEvmAccountFromMnemonic(mnemonic, path3);
     case lzDefinitions.ChainType.APTOS:
-      return getAptosAccountFromMnemonic(mnemonic, path2);
+      return getAptosAccountFromMnemonic(mnemonic, path3);
     case lzDefinitions.ChainType.SOLANA:
-      return getSolanaAccountFromMnemonic(mnemonic, path2);
+      return getSolanaAccountFromMnemonic(mnemonic, path3);
     default:
       throw new Error(`Unsupported chain: ${chainType}`);
   }
@@ -194,7 +317,7 @@ function getLogger() {
 }
 if (process.env.NODE_ENV === "test") ;
 function findDeployment(deployments, nameOrAddress, options) {
-  return deployments.find((deployment) => {
+  const retval = deployments.find((deployment) => {
     let hasMatchingNameOrAddress = deployment.name === nameOrAddress;
     if (!hasMatchingNameOrAddress && ethers.ethers.utils.isAddress(nameOrAddress)) {
       hasMatchingNameOrAddress = ethers.ethers.utils.getAddress(deployment.address) === ethers.ethers.utils.getAddress(nameOrAddress);
@@ -214,6 +337,10 @@ function findDeployment(deployments, nameOrAddress, options) {
     }
     return hasMatchingNameOrAddress && hasMatchingChain && hasMatchingNetwork && hasMatchingEndpoint && hasMatchingSource;
   });
+  if (retval === void 0) {
+    throw new Error(`Deployment not found: ${nameOrAddress}`);
+  }
+  return retval;
 }
 var contractCache = {};
 function deploymentToEvmContract(deployment, provider) {
@@ -230,11 +357,16 @@ function deploymentToEvmContract(deployment, provider) {
   }
   return contractCache[key].connect(provider);
 }
-function dirname(path2) {
-  const match = path2.match(/(.*)([\\/][^\\/]+)[/\\]?$/);
+function findContract(provider, deployments, nameOrAddress, options) {
+  const deployment = findDeployment(deployments, nameOrAddress, options);
+  const retval = deploymentToEvmContract(deployment, provider);
+  return retval;
+}
+function dirname(path3) {
+  const match = path3.match(/(.*)([\\/][^\\/]+)[/\\]?$/);
   const [, basePath] = match ?? [];
-  const dirname2 = typeof basePath !== "undefined" ? basePath : path2;
-  return dirname2;
+  const dirname3 = typeof basePath !== "undefined" ? basePath : path3;
+  return dirname3;
 }
 function getStackTrace2(stackTraceLimit = Infinity) {
   const oldLimit = Error.stackTraceLimit;
@@ -265,6 +397,33 @@ function pkgroot(packageName, relativeToPath) {
   const packagePath = dirname(filepath);
   return packagePath.replace(/.yarn\/([^/]*\/)?(__virtual__|\$\$virtual)\/[^/]*\/\d*\//, "");
 }
+
+// src/assert.ts
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(`Assertion Error:  ${message ?? "condition is false"}`);
+  }
+}
+function assertType(value, fn, message) {
+  if (!fn(value)) {
+    throw new Error(`Expected value to be ${message ?? "of correct type"}`);
+  }
+}
+function assertDefined(value, message) {
+  if (value === void 0 || value === null) {
+    throw new Error(message ?? "Value is undefined or null");
+  }
+}
+function asType(value, fn, message) {
+  if (!fn(value)) {
+    throw new Error(`Expected value to be ${message ?? "of correct type"}`);
+  }
+  return value;
+}
+function assumeType(value) {
+}
+
+// src/promise.ts
 var sequence = async (tasks) => {
   const collector = [];
   for (const task of tasks) {
@@ -274,7 +433,7 @@ var sequence = async (tasks) => {
 };
 var parallel = async (tasks) => Promise.all(tasks.map(async (task) => task()));
 var first = async (tasks) => {
-  assert__default.default(tasks.length !== 0, `Must have at least one task for first()`);
+  assert(tasks.length !== 0, `Must have at least one task for first()`);
   let lastError;
   for (const task of tasks) {
     try {
@@ -301,59 +460,96 @@ function safeMap(elements, callbackfn) {
   }
 }
 
-// src/format.ts
-function bytesToHex2(bytes) {
-  return Buffer.from(bytes).toString("hex");
+// src/enum.ts
+function asEnum(enumType, value) {
+  const enumValues = Object.values(enumType);
+  if (enumValues.includes(value)) {
+    return value;
+  } else {
+    throw new Error(`Invalid enum value: ${value}`);
+  }
 }
-function hexToBytes(hex) {
-  const value = hex.replace(/^0x/i, "");
-  const len = value.length + 1 - (value.length + 1) % 2;
-  return Uint8Array.from(Buffer.from(value.padStart(len, "0"), "hex"));
+
+// src/generic.ts
+function hasRequiredProperties(obj, paths) {
+  return paths.every((path3) => {
+    const keys = path3.split(".");
+    let current = obj;
+    for (const key of keys) {
+      if (current !== void 0 && key in current) {
+        current = current[key];
+      } else {
+        return false;
+      }
+    }
+    return true;
+  });
 }
-function trim0x(hex) {
-  return hex.replace(/^0[xX]/, "");
+function findUp(cwd, expectations) {
+  let currentDir = cwd;
+  while (currentDir !== "/") {
+    const dirFiles = fs__namespace.readdirSync(currentDir);
+    const foundFiles = dirFiles.filter((file) => expectations.includes(file));
+    if (foundFiles.length > 0) {
+      return foundFiles.map((file) => path2__namespace.join(currentDir, file));
+    }
+    currentDir = path2__namespace.dirname(currentDir);
+  }
+  return [];
 }
-function ensure0x(hex) {
-  return hex.startsWith("0x") || hex.startsWith("0X") ? hex : `0x${hex}`;
+function enableTS(relativeToPath) {
+  const moduleName = "ts-node";
+  const require2 = module$1.createRequire(relativeToPath);
+  const modulePath = require2.resolve(moduleName);
+  const tsnode = require2(modulePath);
+  tsnode.register({
+    transpileOnly: true,
+    typeCheck: false
+  });
 }
-function isHexString(value) {
-  return /^(0x)?[0-9a-fA-F]+$/.test(value);
+function loadJSorTS(fileName, relativeToPath) {
+  if (fileName.endsWith(".ts")) {
+    enableTS(relativeToPath);
+  }
+  const require2 = module$1.createRequire(relativeToPath);
+  const modulePath = require2.resolve(fileName);
+  return require2(modulePath);
 }
 var logger2 = getLogger();
 async function sleep(timeout) {
   await new Promise((resolve) => setTimeout(resolve, timeout));
 }
 function getProjectPackageManager(cwd) {
-  const yarn = findUp.sync("yarn.lock", { cwd });
+  const yarn = findUp$1.sync("yarn.lock", { cwd });
   if (yarn !== void 0)
     return "yarn";
-  const npm = findUp.sync("package-lock.json", { cwd });
+  const npm = findUp$1.sync("package-lock.json", { cwd });
   if (npm !== void 0)
     return "npm";
-  const pnpm = findUp.sync("pnpm-lock.yaml", { cwd });
+  const pnpm = findUp$1.sync("pnpm-lock.yaml", { cwd });
   if (pnpm !== void 0)
     return "pnpm";
   throw new Error("Cannot find package.json or yarn.lock");
 }
 function getProjectRootDir(cwd) {
-  const yarn = findUp.sync("yarn.lock", { cwd });
+  const yarn = findUp$1.sync("yarn.lock", { cwd });
   if (yarn !== void 0)
-    return path__default.default.dirname(yarn);
-  const npm = findUp.sync("package-lock.json", { cwd });
+    return path2__namespace.default.dirname(yarn);
+  const npm = findUp$1.sync("package-lock.json", { cwd });
   if (npm !== void 0)
-    return path__default.default.dirname(npm);
-  const pnpm = findUp.sync("pnpm-lock.yaml", { cwd });
+    return path2__namespace.default.dirname(npm);
+  const pnpm = findUp$1.sync("pnpm-lock.yaml", { cwd });
   if (pnpm !== void 0)
-    return path__default.default.dirname(pnpm);
+    return path2__namespace.default.dirname(pnpm);
   throw new Error("Cannot find yarn.lock or package-lock.json or pnpm-lock.yaml");
 }
-async function isHttpServiceReachable(host, port, timeout, path2) {
+async function isHttpServiceReachable(host, port, timeout, path3) {
   return new Promise((resolve, _reject) => {
     const options = {
       host,
       port,
       timeout,
-      path: path2,
+      path: path3,
       method: "HEAD"
     };
     const request = http__default.default.request(options, (_response) => {
@@ -381,13 +577,24 @@ Object.defineProperty(exports, "Logger", {
   enumerable: true,
   get: function () { return winston.Logger; }
 });
-exports.bytesToHex = bytesToHex2;
+exports.SizeExceedsPaddingSizeError = SizeExceedsPaddingSizeError;
+exports.arrayify = arrayify;
+exports.asEnum = asEnum;
+exports.asType = asType;
+exports.assert = assert;
+exports.assertDefined = assertDefined;
+exports.assertType = assertType;
+exports.assumeType = assumeType;
+exports.bytesToHex = bytesToHex;
 exports.createLogger = createLogger2;
 exports.deploymentToEvmContract = deploymentToEvmContract;
 exports.dirname = dirname;
+exports.enableTS = enableTS;
 exports.ensure0x = ensure0x;
 exports.extractUrlInfo = extractUrlInfo;
+exports.findContract = findContract;
 exports.findDeployment = findDeployment;
+exports.findUp = findUp;
 exports.first = first;
 exports.firstFactory = firstFactory;
 exports.getAptosAccountFromMnemonic = getAptosAccountFromMnemonic;
@@ -399,11 +606,17 @@ exports.getLogger = getLogger;
 exports.getProjectPackageManager = getProjectPackageManager;
 exports.getProjectRootDir = getProjectRootDir;
 exports.getSolanaAccountFromMnemonic = getSolanaAccountFromMnemonic;
+exports.hasRequiredProperties = hasRequiredProperties;
 exports.hexToBytes = hexToBytes;
+exports.hexlify = hexlify;
 exports.initLogger = initLogger;
+exports.isHash = isHash;
+exports.isHex = isHex;
 exports.isHexString = isHexString;
 exports.isHttpServiceReachable = isHttpServiceReachable;
+exports.loadJSorTS = loadJSorTS;
 exports.logger = logger2;
+exports.padify = padify;
 exports.parallel = parallel;
 exports.pkgroot = pkgroot;
 exports.safeMap = safeMap;