@layerzerolabs/lz-initia-cli 3.0.23 → 3.0.24

package/dist/index.mjs

@@ -10,12 +10,7 @@ import { glob } from 'glob';
 import { $ } from 'zx';
 import * as crypto from 'node:crypto';
 
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
+// src/build.ts
 function getInitiaClient(env, config) {
   const url = config.network?.[env];
   if (url === void 0) {
@@ -27,127 +22,56 @@ function getInitiaClient(env, config) {
 
 // src/constant.ts
 var InitiaObjectDeployerAddress = "0x1";
-
-// src/config-parser.ts
-function getConfigByNetwork(config, network) {
-  if (config === null) {
-    throw new Error("Config is null");
-  }
-  if (typeof config === "object") {
-    return config[network];
-  }
-  return config;
-}
-function getObjectDeployer(configValue, network) {
-  return getConfigByNetwork(configValue, network);
-}
-function getObjectDeployerFromConfig(config, network, moduleName) {
-  const module = config.modules[moduleName];
-  if (!module) {
-    throw new Error(`module ${moduleName} not found when getting object deployer`);
-  }
-  const moduleObjectDeployer = getObjectDeployer(module.objectDeployer, network);
-  const defaultObjectDeployer = getObjectDeployer(config.defaultObjectDeployer, network);
-  return moduleObjectDeployer ?? defaultObjectDeployer ?? InitiaObjectDeployerAddress;
-}
-function getFullName(config, moduleName) {
-  const variant = config.modules[moduleName]?.variant;
-  return variant !== void 0 && variant.length > 0 ? `${moduleName}-${variant}` : moduleName;
-}
-
-// src/loader.ts
-function loadConfig(configPath) {
-  const moduleName = "ts-node";
-  const tsnode = __require(moduleName);
-  tsnode.register({
-    transpileOnly: true,
-    typeCheck: false
-  });
-  try {
-    const imported = __require(configPath);
-    return "default" in imported ? imported.default : imported;
-  } catch (e) {
-    if (e !== null && typeof e === "object" && "code" in e && e.code === "ERR_REQUIRE_ESM") {
-      throw new Error(
-        `Your project is an ESM project (you have "type": "module" set in your package.json) but your LayerZero config file uses the .js extension.`
-      );
-    }
-    throw e;
-  }
-}
 function isInitiaAccount(account) {
   return account !== void 0 && account instanceof MnemonicKey;
 }
-function getDeployer(moduleName, lzAptosConfig, network) {
-  const module = lzAptosConfig.modules[moduleName];
-  if (!module) {
-    if (lzAptosConfig.baseModules && lzAptosConfig.baseModules.length > 0) {
-      for (const baseModule of lzAptosConfig.baseModules) {
-        const baseConfig = loadConfig(baseModule);
-        try {
-          return getDeployer(moduleName, baseConfig, network);
-        } catch (e) {
-        }
-      }
-    }
-    throw new Error(
-      `Module ${moduleName} not found. Make sure it is defined in lz-aptos.config.ts and double check the key is the package name in Move.toml.`
-    );
-  }
-  const moduleDeployer = isInitiaAccount(module.deployer) ? module.deployer : module.deployer?.[network];
-  const defaultDeployer = isInitiaAccount(lzAptosConfig.defaultDeployer) ? lzAptosConfig.defaultDeployer : lzAptosConfig.defaultDeployer?.[network];
-  const deployer = moduleDeployer ?? defaultDeployer;
-  if (!deployer) {
-    throw new Error(`deployer for module ${moduleName} not found`);
-  }
-  return deployer;
-}
-function getDeploymentPath(lzAptosConfig, network, moduleName) {
-  return path3.join(lzAptosConfig.deploymentPath, network, `${moduleName}.json`);
+function getDeploymentPath(lzInitiaConfig, network, moduleName) {
+  const fullName = getFullName(lzInitiaConfig, moduleName);
+  return path3.join(lzInitiaConfig.deploymentPath, network, `${fullName}.json`);
 }
-async function checkIfObjectAddressExists(lzAptosConfig, network, address) {
+async function checkIfObjectAddressExists(lzInitiaConfig, network, address) {
   try {
-    const client = getInitiaClient(networkToEnv(network, EndpointVersion.V2), lzAptosConfig);
+    const client = getInitiaClient(networkToEnv(network, EndpointVersion.V2), lzInitiaConfig);
     const module = (await client.move.modules(address))[0];
     return module !== void 0;
   } catch (e) {
     return false;
   }
 }
-function getObjectAddressFromDeployment(lzAptosConfig, network, moduleName) {
-  const deploymentPath2 = getDeploymentPath(lzAptosConfig, network, moduleName);
+function getObjectAddressFromDeployment(lzInitiaConfig, network, moduleName) {
+  const deploymentPath2 = getDeploymentPath(lzInitiaConfig, network, moduleName);
   if (!fs4.existsSync(deploymentPath2)) {
     return void 0;
   }
   const deployment = JSON.parse(fs4.readFileSync(deploymentPath2, "utf-8"));
   return deployment.address;
 }
-async function resolveAddress(moduleName, lzAptosConfig, network, isOngoingModule) {
-  const deployToObject = lzAptosConfig.modules[moduleName]?.deployToObject ?? lzAptosConfig.defaultDeployToObject ?? false;
+async function resolveAddress(moduleKey, lzInitiaConfig, network, isOngoingModule) {
+  const deployToObject = lzInitiaConfig.modules[moduleKey]?.deployToObject ?? lzInitiaConfig.defaultDeployToObject ?? false;
   if (!deployToObject) {
-    const deployer = getDeployer(moduleName, lzAptosConfig, network);
+    const deployer = getDeployerAccount(moduleKey, lzInitiaConfig, network);
     return AccAddress.toHex(deployer.accAddress);
   }
-  const objectDeployer = getObjectDeployerFromConfig(lzAptosConfig, network, moduleName);
+  const objectDeployer = getObjectDeployerFromConfig(lzInitiaConfig, network, moduleKey);
   if (objectDeployer !== InitiaObjectDeployerAddress) {
-    return genObjectAddressForLayerzero(network, lzAptosConfig, moduleName);
+    return genObjectAddressForLayerzero(network, lzInitiaConfig, moduleKey);
   }
-  const objectAddress = getObjectAddressFromDeployment(lzAptosConfig, network, moduleName);
+  const objectAddress = getObjectAddressFromDeployment(lzInitiaConfig, network, moduleKey);
   if (objectAddress !== void 0) {
-    if (await checkIfObjectAddressExists(lzAptosConfig, network, objectAddress)) {
+    if (await checkIfObjectAddressExists(lzInitiaConfig, network, objectAddress)) {
       return objectAddress;
     }
     if (!isOngoingModule) {
       throw new Error(
-        `Deployment file found at: ${getDeploymentPath(lzAptosConfig, network, moduleName)} but object address ${objectAddress} does not exist. Dependent module ${moduleName} should be deployed if using ${InitiaObjectDeployerAddress}::object_code_deployment.`
+        `Deployment file found at: ${getDeploymentPath(lzInitiaConfig, network, moduleKey)} but object address ${objectAddress} does not exist. Dependent module ${moduleKey} should be deployed if using ${InitiaObjectDeployerAddress}::object_code_deployment.`
       );
     }
   } else if (!isOngoingModule) {
     throw new Error(
-      `Deployment file not found at: ${getDeploymentPath(lzAptosConfig, network, moduleName)}. Make sure ${moduleName} is deployed.`
+      `Deployment file not found at: ${getDeploymentPath(lzInitiaConfig, network, moduleKey)}. Make sure ${moduleKey} is deployed.`
     );
   }
-  return genObjectAddress(moduleName, lzAptosConfig, network);
+  return genObjectAddress(moduleKey, lzInitiaConfig, network);
 }
 var createObjectAddress = (creatorAddress, seed) => {
   const hexAddress = AccAddress.validate(creatorAddress) ? AccAddress.toHex(creatorAddress) : creatorAddress;
@@ -156,9 +80,9 @@ var createObjectAddress = (creatorAddress, seed) => {
   const bytes = new Uint8Array([...creatorBytes, ...seedBytes, 254]);
   return ensure0x(Buffer.from(sha3_256(bytes)).toString("hex"));
 };
-async function genObjectAddressForOfficial(network, lzAptosConfig, moduleName) {
-  const client = getInitiaClient(networkToEnv(network, EndpointVersion.V2), lzAptosConfig);
-  const deployer = getDeployer(moduleName, lzAptosConfig, network);
+async function genObjectAddressForOfficial(network, lzInitiaConfig, moduleKey) {
+  const client = getInitiaClient(networkToEnv(network, EndpointVersion.V2), lzInitiaConfig);
+  const deployer = getDeployerAccount(moduleKey, lzInitiaConfig, network);
   const OBJECT_CODE_DEPLOYMENT_DOMAIN_SEPARATOR = "initia_std::object_code_deployment";
   const account = await client.auth.accountInfo(deployer.accAddress);
   const sequenceNumber = account.getSequenceNumber();
@@ -168,18 +92,60 @@ async function genObjectAddressForOfficial(network, lzAptosConfig, moduleName) {
   const objectAddress = createObjectAddress(deployer.accAddress, seed);
   return objectAddress;
 }
-function genObjectAddressForLayerzero(network, lzAptosConfig, moduleName) {
-  const deployer = getDeployer(moduleName, lzAptosConfig, network);
-  const seed = getFullName(lzAptosConfig, moduleName);
+function genObjectAddressForLayerzero(network, lzInitiaConfig, moduleName) {
+  const deployer = getDeployerAccount(moduleName, lzInitiaConfig, network);
+  const seed = getFullName(lzInitiaConfig, moduleName);
   const objectAddress = createObjectAddress(deployer.accAddress, new Uint8Array(Buffer.from(seed, "utf8")));
   return objectAddress;
 }
-async function genObjectAddress(moduleName, lzAptosConfig, network) {
-  const objectDeployer = getObjectDeployerFromConfig(lzAptosConfig, network, moduleName);
+async function genObjectAddress(moduleKey, lzInitiaConfig, network) {
+  const objectDeployer = getObjectDeployerFromConfig(lzInitiaConfig, network, moduleKey);
   if (objectDeployer === InitiaObjectDeployerAddress) {
-    return genObjectAddressForOfficial(network, lzAptosConfig, moduleName);
+    return genObjectAddressForOfficial(network, lzInitiaConfig, moduleKey);
   }
-  return genObjectAddressForLayerzero(network, lzAptosConfig, moduleName);
+  return genObjectAddressForLayerzero(network, lzInitiaConfig, moduleKey);
+}
+
+// src/config-parser.ts
+function getConfigByNetwork(config, network) {
+  if (config === null) {
+    throw new Error("Config is null");
+  }
+  if (typeof config === "object") {
+    return config[network];
+  }
+  return config;
+}
+function getObjectDeployer(configValue, network) {
+  return getConfigByNetwork(configValue, network);
+}
+function getObjectDeployerFromConfig(config, network, moduleName) {
+  const module = config.modules[moduleName];
+  if (!module) {
+    throw new Error(`module ${moduleName} not found when getting object deployer`);
+  }
+  const moduleObjectDeployer = getObjectDeployer(module.objectDeployer, network);
+  const defaultObjectDeployer = getObjectDeployer(config.defaultObjectDeployer, network);
+  return moduleObjectDeployer ?? defaultObjectDeployer ?? InitiaObjectDeployerAddress;
+}
+function getDeployerAccount(moduleName, lzInitiaConfig, network) {
+  const module = lzInitiaConfig.modules[moduleName];
+  if (!module) {
+    throw new Error(
+      `Module ${moduleName} not found. Make sure it is defined in lz-initia.config.ts and double check the key is the package name in Move.toml.`
+    );
+  }
+  const moduleDeployer = isInitiaAccount(module.deployer) ? module.deployer : module.deployer?.[network];
+  const defaultDeployer = isInitiaAccount(lzInitiaConfig.defaultDeployer) ? lzInitiaConfig.defaultDeployer : lzInitiaConfig.defaultDeployer?.[network];
+  const deployer = moduleDeployer ?? defaultDeployer;
+  if (!deployer) {
+    throw new Error(`deployer for module ${moduleName} not found`);
+  }
+  return deployer;
+}
+function getFullName(config, moduleName) {
+  const variant = config.modules[moduleName]?.variant;
+  return variant !== void 0 && variant.length > 0 ? `${moduleName}-${variant}` : moduleName;
 }
 function getRawMoveContextByPath(modulePath) {
   const tomlPath = path3.join(modulePath, "Move.toml");
@@ -219,40 +185,65 @@ function parseAddresses(addresses, network) {
   }
   return result;
 }
-async function getMoveContext(moduleName, lzInitiaConfig, network) {
-  const module = lzInitiaConfig.modules[moduleName];
+function getPkgName(moduleKey, lzInitiaConfig) {
+  const module = lzInitiaConfig.modules[moduleKey];
+  if (!module) {
+    throw new Error(`module ${moduleKey} not found in lz-initia.config.ts`);
+  }
+  const tomlPath = path3.join(module.modulePath, "Move.toml");
+  if (!fs4.existsSync(tomlPath)) {
+    throw new Error(`Move.toml not found in ${tomlPath}`);
+  }
+  const toml = parse(fs4.readFileSync(tomlPath, "utf-8"));
+  return toml.package.name;
+}
+function genModuleKeyToPkgNameMap(lzInitiaConfig) {
+  const result = {};
+  for (const moduleKey of Object.keys(lzInitiaConfig.modules)) {
+    result[getPkgName(moduleKey, lzInitiaConfig)] = moduleKey;
+  }
+  return result;
+}
+async function getMoveContext(moduleKey, lzInitiaConfig, network) {
+  const module = lzInitiaConfig.modules[moduleKey];
   if (!module) {
-    throw new Error(`module ${moduleName} not found when getting Move context`);
+    throw new Error(`module ${moduleKey} not found when getting Move context`);
   }
   const context = getRawMoveContextByPath(module.modulePath);
-  for (const key of Object.keys(context)) {
-    const toml = context[key];
+  const pkgNameToModuleKey = genModuleKeyToPkgNameMap(lzInitiaConfig);
+  for (const pkgName of Object.keys(context)) {
+    const toml = context[pkgName];
     for (const addressKey of Object.keys(toml.addresses)) {
       const address = toml.addresses[addressKey];
       const presetAddresses = {
-        ...parseAddresses(lzInitiaConfig.modules[key]?.addresses, network),
+        ...parseAddresses(lzInitiaConfig.modules[pkgNameToModuleKey[pkgName]]?.addresses, network),
         // dependency or current module config address
-        ...parseAddresses(lzInitiaConfig.modules[moduleName]?.addresses, network)
+        ...parseAddresses(lzInitiaConfig.modules[moduleKey]?.addresses, network)
         // current module config address
       };
       if (address === "_") {
         if (presetAddresses[addressKey] !== void 0 && presetAddresses[addressKey] !== "") {
           toml.addresses[addressKey] = presetAddresses[addressKey];
         } else {
+          const isOnGoingModule = moduleKey === pkgNameToModuleKey[addressKey];
           try {
-            const isOnGoingModule = moduleName === addressKey;
+            if (pkgNameToModuleKey[addressKey] === void 0) {
+              throw new Error(
+                `Module ${addressKey} not found. Make sure it is defined in lz-initia.config.ts and double check the key is the package name in Move.toml.`
+              );
+            }
             toml.addresses[addressKey] = await resolveAddress(
-              addressKey,
+              pkgNameToModuleKey[addressKey],
               lzInitiaConfig,
               network,
               isOnGoingModule
             );
           } catch (e) {
-            if (key === moduleName) {
-              throw new Error(`Fail to generate context for ${key}. ${e.toString()}`);
+            if (isOnGoingModule) {
+              throw new Error(`Fail to generate context for ${pkgName}. ${e.toString()}`);
             } else {
               throw new Error(
-                `Fail to generate context for dependent module ${key}. ${e.toString()}`
+                `Fail to generate context for dependent module ${pkgName}. ${e.toString()}`
               );
             }
           }
@@ -290,18 +281,20 @@ function buildProcess(modulePath, addresses, toml, customOptions = {}) {
   const addressesParam = Object.keys(addresses).map((key) => `${key}=${addresses[key]}`).join(",");
   const defaultOptions = {
     "--skip-fetch-latest-git-deps": true,
-    "--named-addresses": addressesParam
+    "--named-addresses": addressesParam,
+    "--verbose": true
   };
   const args = parseOptions(defaultOptions, customOptions);
+  console.log(`initiad move build ${args.join(" ")}`);
   return $({
     cwd: modulePath,
-    stdio: ["inherit", "pipe", process.stderr],
-    verbose: true
+    // pipe std error to avoid printing the compiling message which is not useful
+    stdio: ["inherit", "inherit", "pipe"],
+    quiet: true
   })`initiad move build ${args}`;
 }
 async function copyArtifacts(src, dest) {
   if (fs4.existsSync(dest)) {
-    console.log(`Removing existing artifacts at ${dest}`);
     fs4.rmSync(dest, { recursive: true });
   }
   fs4.mkdirSync(dest, { recursive: true });
@@ -313,24 +306,22 @@ async function copyArtifacts(src, dest) {
       fs4.mkdirSync(destByteCodePath, { recursive: true });
     }
     await $({
-      verbose: true
+      verbose: false,
+      quiet: true
     })`cp ${path3.join(moduleDir, module)} ${path3.join(destByteCodePath, module)}`;
   }
 }
-async function build(moduleName, lzInitiaConfig, network, skipBuild = false, variant) {
-  const module = lzInitiaConfig.modules[moduleName];
+async function build(moduleKey, lzInitiaConfig, network, skipBuild = false, variant) {
+  const module = lzInitiaConfig.modules[moduleKey];
   if (!module) {
-    throw new Error(`module ${moduleName} not found in lz-initia.config.ts`);
+    throw new Error(`module ${moduleKey} not found in lz-initia.config.ts`);
   }
   const { modulePath } = module;
-  const context = await getMoveContext(moduleName, lzInitiaConfig, network);
-  const pkgName = context[moduleName].package.name;
+  const context = await getMoveContext(moduleKey, lzInitiaConfig, network);
+  const pkgName = context[moduleKey].package.name;
   const srcPath = path3.join(modulePath, "build", pkgName);
-  const outputDir = lzInitiaConfig.modules[moduleName]?.alias ?? pkgName;
-  const outputPath = path3.join(
-    lzInitiaConfig.artifactsPath,
-    variant !== void 0 && variant.length > 0 ? `${outputDir}-${variant}` : outputDir
-  );
+  const outputDir = getFullName(lzInitiaConfig, moduleKey);
+  const outputPath = path3.join(lzInitiaConfig.artifactsPath, outputDir);
   let addresses = {};
   for (const key of Object.keys(context)) {
     const toml = context[key];
@@ -339,9 +330,9 @@ async function build(moduleName, lzInitiaConfig, network, skipBuild = false, var
     }
     addresses = { ...addresses, ...toml.addresses };
   }
-  addresses = { ...addresses, ...context[moduleName].addresses };
+  addresses = { ...addresses, ...context[pkgName].addresses };
   if (!skipBuild) {
-    await buildProcess(modulePath, addresses, context[moduleName], {
+    await buildProcess(modulePath, addresses, context[pkgName], {
       ...lzInitiaConfig.compileOptions,
       ...module.compileOptions
     });
@@ -351,17 +342,17 @@ async function build(moduleName, lzInitiaConfig, network, skipBuild = false, var
 function isAxiosError(error) {
   return error?.response?.data?.message !== void 0;
 }
-function handleDepMissingError(error, moduleName, context) {
+function handleDepMissingError(error, pkgName, context) {
   if (error.response.data.message.includes("EPACKAGE_DEP_MISSING")) {
     throw new Error(
-      `Deploy ${moduleName} failed with EPACKAGE_DEP_MISSING, make sure you have deployed the dependent module [${Object.keys(
+      `Deploy ${pkgName} failed with EPACKAGE_DEP_MISSING, make sure you have deployed the dependent module [${Object.keys(
         context
-      ).filter((module) => module !== moduleName).join(",")}]`
+      ).filter((module) => module !== pkgName).join(",")}]`
     );
   }
 }
-function handleAccountNotFoundError(error, moduleName, context, network) {
-  const address = context[moduleName]?.addresses[moduleName];
+function handleAccountNotFoundError(error, pkgName, context, network) {
+  const address = context[pkgName]?.addresses[pkgName];
   if (address === void 0) {
     return;
   }
@@ -371,31 +362,31 @@ function handleAccountNotFoundError(error, moduleName, context, network) {
     );
   }
 }
-function handleSenderNotMatchError(error, moduleName) {
+function handleSenderNotMatchError(error, pkgName) {
   if (error.response.data.message.includes("MODULE_ADDRESS_DOES_NOT_MATCH_SENDER")) {
     throw new Error(
-      `Deploy ${moduleName} failed with MODULE_ADDRESS_DOES_NOT_MATCH_SENDER, make sure you compile ${moduleName} with the deployer account address`
+      `Deploy ${pkgName} failed with MODULE_ADDRESS_DOES_NOT_MATCH_SENDER, make sure you compile ${pkgName} with the deployer account address`
     );
   }
 }
 function handleOtherAxiosError(error) {
   throw new Error(error.response.data.message);
 }
-function handleError(error, moduleName, context, network) {
+function handleError(error, pkgName, context, network) {
   if (isAxiosError(error)) {
-    handleDepMissingError(error, moduleName, context);
-    handleAccountNotFoundError(error, moduleName, context, network);
-    handleSenderNotMatchError(error, moduleName);
+    handleDepMissingError(error, pkgName, context);
+    handleAccountNotFoundError(error, pkgName, context, network);
+    handleSenderNotMatchError(error, pkgName);
     handleOtherAxiosError(error);
   }
   throw error;
 }
-function deploymentPath(pkgName, dest, network, variant) {
+function deploymentPath(moduleKey, dest, network, variant) {
   const deploymentPath2 = path3.join(dest, network);
-  return path3.join(deploymentPath2, `${pkgWithVariant(pkgName, variant)}.json`);
+  return path3.join(deploymentPath2, `${moduleKeyWithVariant(moduleKey, variant)}.json`);
 }
-function saveDeployment(deployer, moduleName, pkgName, address, dest, network, bytecodeHash, hash, variant, compatibleVersions = [EndpointVersion.V1, EndpointVersion.V2]) {
-  const destPath = deploymentPath(pkgName, dest, network, variant);
+function saveDeployment(deployer, moduleKey, pkgName, address, dest, network, bytecodeHash, hash, variant, compatibleVersions = [EndpointVersion.V1, EndpointVersion.V2]) {
+  const destPath = deploymentPath(moduleKey, dest, network, variant);
   const deploymentDir = path3.dirname(destPath);
   if (!fs4.existsSync(deploymentDir)) {
     fs4.mkdirSync(deploymentDir, { recursive: true });
@@ -406,8 +397,8 @@ function saveDeployment(deployer, moduleName, pkgName, address, dest, network, b
       {
         address,
         deployer: AccAddress.toHex(deployer.accAddress),
-        name: pkgWithVariant(pkgName, variant),
-        moduleName,
+        name: moduleKeyWithVariant(moduleKey, variant),
+        moduleName: pkgName,
         network,
         compatibleVersions,
         bytecodeHash,
@@ -419,10 +410,10 @@ function saveDeployment(deployer, moduleName, pkgName, address, dest, network, b
   );
   console.log(`Deployment saved to ${destPath}`);
 }
-async function checkIfModuleExistedOnAddress(client, moduleNames, address) {
+async function checkIfModuleExistedOnAddress(client, mvNames, address) {
   try {
     const modules = (await client.move.modules(address))[0];
-    const isExisted = moduleNames.some(
+    const isExisted = mvNames.some(
       (moduleName) => modules.map((module) => module.module_name).includes(moduleName.replace(".mv", ""))
     );
     return isExisted;
@@ -430,10 +421,10 @@ async function checkIfModuleExistedOnAddress(client, moduleNames, address) {
     return false;
   }
 }
-async function getDeployActionType(client, pkgName, moduleNames, dest, network, bytecodeHash, deployAddress, variant) {
-  const moduleExisted = await checkIfModuleExistedOnAddress(client, moduleNames, deployAddress);
+async function getDeployActionType(client, moduleKey, mvNames, dest, network, bytecodeHash, deployAddress, variant) {
+  const moduleExisted = await checkIfModuleExistedOnAddress(client, mvNames, deployAddress);
   if (moduleExisted) {
-    const destPath = deploymentPath(pkgName, dest, network, variant);
+    const destPath = deploymentPath(moduleKey, dest, network, variant);
     if (fs4.existsSync(destPath)) {
       const deployment = JSON.parse(fs4.readFileSync(destPath, "utf-8"));
       if (deployment.bytecodeHash === bytecodeHash) {
@@ -444,8 +435,8 @@ async function getDeployActionType(client, pkgName, moduleNames, dest, network,
   }
   return "Deploy" /* Deploy */;
 }
-function pkgWithVariant(pkgName, variant) {
-  return variant !== void 0 && variant.length > 0 ? `${pkgName}-${variant}` : pkgName;
+function moduleKeyWithVariant(moduleKey, variant) {
+  return variant !== void 0 && variant.length > 0 ? `${moduleKey}-${variant}` : moduleKey;
 }
 function getBytecodesHash(bytecodes) {
   const hash = crypto.createHash("sha256");
@@ -467,14 +458,14 @@ async function createAccountDeploymentTx(client, deployer, modules, lzInitiaConf
   const signedTx = await wallet.createAndSignTx({ msgs, gasPrices });
   return signedTx;
 }
-async function createObjectDeploymentTx(client, deployer, modules, lzInitiaConfig, network, moduleName, deployedAddress, actionType) {
-  const objectDeployer = getObjectDeployerFromConfig(lzInitiaConfig, network, moduleName);
+async function createObjectDeploymentTx(client, deployer, modules, lzInitiaConfig, network, moduleKey, deployedAddress, actionType) {
+  const objectDeployer = getObjectDeployerFromConfig(lzInitiaConfig, network, moduleKey);
   const metadataArg = bcs.vector(bcs.u8()).serialize(Uint8Array.from([])).toBase64();
   const modulesArg = bcs.vector(bcs.vector(bcs.u8())).serialize(modules).toBase64();
   const objectAddressArg = bcs.address().serialize(deployedAddress).toBase64();
   let functionArguments = actionType === "Deploy" /* Deploy */ ? [metadataArg, modulesArg] : [metadataArg, modulesArg, objectAddressArg];
   if (objectDeployer !== InitiaObjectDeployerAddress) {
-    const seed = getFullName(lzInitiaConfig, moduleName);
+    const seed = getFullName(lzInitiaConfig, moduleKey);
     const seedArg = bcs.vector(bcs.u8()).serialize(Uint8Array.from(Buffer.from(seed))).toBase64();
     functionArguments = actionType === "Deploy" /* Deploy */ ? [seedArg, metadataArg, modulesArg] : [metadataArg, modulesArg, objectAddressArg];
   }
@@ -491,24 +482,27 @@ async function createObjectDeploymentTx(client, deployer, modules, lzInitiaConfi
   const signedTx = await wallet.createAndSignTx({ msgs: [msg], gasPrices });
   return signedTx;
 }
-async function deploy(moduleName, lzInitiaConfig, network, variant, deployToObject = false) {
-  const module = lzInitiaConfig.modules[moduleName];
+async function deploy(moduleKey, lzInitiaConfig, network, variant, deployToObject = false) {
+  const module = lzInitiaConfig.modules[moduleKey];
   if (!module) {
-    throw new Error(`module ${moduleName} not found in lz-initia.config.ts`);
+    throw new Error(`module ${moduleKey} not found in lz-initia.config.ts`);
   }
   const env = networkToEnv(network, EndpointVersion.V2);
   const client = getInitiaClient(env, lzInitiaConfig);
-  const deployer = getDeployer(moduleName, lzInitiaConfig, network);
-  const context = await getMoveContext(moduleName, lzInitiaConfig, network);
-  const pkgName = lzInitiaConfig.modules[moduleName]?.alias ?? context[moduleName].package.name;
-  const moduleDir = path3.join(lzInitiaConfig.artifactsPath, `${pkgWithVariant(pkgName, variant)}/bytecode_modules`);
+  const deployer = getDeployerAccount(moduleKey, lzInitiaConfig, network);
+  const context = await getMoveContext(moduleKey, lzInitiaConfig, network);
+  const pkgName = getPkgName(moduleKey, lzInitiaConfig);
+  const moduleDir = path3.join(
+    lzInitiaConfig.artifactsPath,
+    `${moduleKeyWithVariant(pkgName, variant)}/bytecode_modules`
+  );
   const mvNames = glob.sync("*.mv", { cwd: moduleDir });
-  const moduleBuffers = mvNames.map((moduleName2) => fs4.readFileSync(path3.join(moduleDir, moduleName2)));
+  const moduleBuffers = mvNames.map((moduleName) => fs4.readFileSync(path3.join(moduleDir, moduleName)));
   const bytecodeHash = getBytecodesHash(moduleBuffers);
-  const deployAddress = await resolveAddress(moduleName, lzInitiaConfig, network, true);
+  const deployAddress = await resolveAddress(moduleKey, lzInitiaConfig, network, true);
   const actionType = await getDeployActionType(
     client,
-    moduleName,
+    moduleKey,
     mvNames,
     lzInitiaConfig.deploymentPath,
     network,
@@ -517,7 +511,7 @@ async function deploy(moduleName, lzInitiaConfig, network, variant, deployToObje
     variant
   );
   if (actionType === "Skip" /* Skip */) {
-    console.warn(`Code of ${moduleName} has not changed, skipping deploy`);
+    console.warn(`Code of ${moduleKey} has not changed, skipping deploy`);
     return;
   }
   try {
@@ -527,7 +521,7 @@ async function deploy(moduleName, lzInitiaConfig, network, variant, deployToObje
       moduleBuffers,
       lzInitiaConfig,
       network,
-      moduleName,
+      moduleKey,
       deployAddress,
       actionType
     ) : await createAccountDeploymentTx(client, deployer, moduleBuffers, lzInitiaConfig, network);
@@ -543,11 +537,11 @@ async function deploy(moduleName, lzInitiaConfig, network, variant, deployToObje
       throw new Error(tx.raw_log);
     }
     console.log(
-      `${actionType} ${moduleName} to ${deployToObject ? "Object" : "Account"}(${codeAddress}) succeeded on ${network}`
+      `${actionType} ${moduleKey} to ${deployToObject ? "Object" : "Account"}(${codeAddress}) succeeded on ${network}`
     );
     saveDeployment(
       deployer,
-      moduleName,
+      moduleKey,
       pkgName,
       codeAddress,
       lzInitiaConfig.deploymentPath,
@@ -559,7 +553,7 @@ async function deploy(moduleName, lzInitiaConfig, network, variant, deployToObje
     );
   } catch (e) {
     if (e instanceof Error) {
-      handleError(e, moduleName, context, network);
+      handleError(e, moduleKey, context, network);
     } else {
       throw e;
     }