@layerzerolabs/lz-initia-cli 3.0.23 → 3.0.24

package/dist/cli.mjs

@@ -1,14 +1,14 @@
 import fs3 from 'fs';
 import path4 from 'path';
-import process2 from 'process';
+import process from 'process';
+import { LCDClient, AccAddress, MsgPublish, Wallet, bcs, MsgExecute, MnemonicKey } from '@initia/initia.js';
+import { sha3_256 } from '@noble/hashes/sha3';
+import { networkToChainType, ChainType, InitiaChain, networkToChain, networkToEnv, EndpointVersion } from '@layerzerolabs/lz-definitions';
+import { getLogger, ensure0x } from '@layerzerolabs/lz-utilities';
 import { createOption, Command } from '@commander-js/extra-typings';
 import { sync } from 'find-up';
 import { $ as $$1 } from 'zx/core';
-import { getLogger, ensure0x } from '@layerzerolabs/lz-utilities';
 import * as crypto from 'node:crypto';
-import { LCDClient, AccAddress, MsgPublish, Wallet, bcs, MsgExecute, MnemonicKey } from '@initia/initia.js';
-import { sha3_256 } from '@noble/hashes/sha3';
-import { networkToChainType, ChainType, InitiaChain, networkToChain, networkToEnv, EndpointVersion } from '@layerzerolabs/lz-definitions';
 import { parse } from 'smol-toml';
 import { glob } from 'glob';
 import { $ } from 'zx';
@@ -24,34 +24,6 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-
-// 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;
-  }
-}
-
-// src/subCommands/index.ts
-var subCommands_exports = {};
-__export(subCommands_exports, {
-  build: () => command2,
-  deploy: () => command
-});
 function getInitiaClient(env, config) {
   const url = config.network?.[env];
   if (url === void 0) {
@@ -63,106 +35,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;
-}
 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 path4.join(lzAptosConfig.deploymentPath, network, `${moduleName}.json`);
+function getDeploymentPath(lzInitiaConfig, network, moduleName) {
+  const fullName = getFullName(lzInitiaConfig, moduleName);
+  return path4.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 (!fs3.existsSync(deploymentPath2)) {
     return void 0;
   }
   const deployment = JSON.parse(fs3.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;
@@ -171,9 +93,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();
@@ -183,33 +105,132 @@ 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/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;
+  }
+}
+
+// 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 combineBaseConfigRecursive(config) {
+  if (!config.baseModules || config.baseModules.length === 0) {
+    return config;
+  }
+  const baseConfigs = config.baseModules.map((baseModule) => combineBaseConfigRecursive(loadConfig(baseModule)));
+  const result = baseConfigs.reduce((acc, baseConfig) => {
+    for (const moduleKey in baseConfig.modules) {
+      baseConfig.modules[moduleKey].deployer = baseConfig.modules[moduleKey]?.deployer ?? baseConfig.defaultDeployer;
+      baseConfig.modules[moduleKey].objectDeployer = baseConfig.modules[moduleKey]?.objectDeployer ?? baseConfig.defaultObjectDeployer;
+      baseConfig.modules[moduleKey].deployToObject = baseConfig.modules[moduleKey]?.deployToObject ?? baseConfig.defaultDeployToObject;
+    }
+    return {
+      ...acc,
+      ...baseConfig,
+      modules: {
+        ...acc.modules,
+        ...baseConfig.modules
+      }
+    };
+  }, config);
+  return {
+    ...config,
+    modules: {
+      ...result.modules,
+      ...config.modules
+      // current modules has higher priority
+    }
+  };
+}
+
+// src/subCommands/index.ts
+var subCommands_exports = {};
+__export(subCommands_exports, {
+  build: () => command2,
+  deploy: () => command
+});
 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;
   }
@@ -219,21 +240,21 @@ 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;
@@ -276,40 +297,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 ${moduleName} not found when getting Move context`);
+    throw new Error(`module ${moduleKey} not found in lz-initia.config.ts`);
+  }
+  const tomlPath = path4.join(module.modulePath, "Move.toml");
+  if (!fs3.existsSync(tomlPath)) {
+    throw new Error(`Move.toml not found in ${tomlPath}`);
+  }
+  const toml = parse(fs3.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 ${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()}`
               );
             }
           }
@@ -319,12 +365,12 @@ async function getMoveContext(moduleName, lzInitiaConfig, network) {
   }
   return context;
 }
-function deploymentPath(pkgName, dest, network, variant) {
+function deploymentPath(moduleKey, dest, network, variant) {
   const deploymentPath2 = path4.join(dest, network);
-  return path4.join(deploymentPath2, `${pkgWithVariant(pkgName, variant)}.json`);
+  return path4.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 = path4.dirname(destPath);
   if (!fs3.existsSync(deploymentDir)) {
     fs3.mkdirSync(deploymentDir, { recursive: true });
@@ -335,8 +381,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,
@@ -348,10 +394,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;
@@ -359,10 +405,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 (fs3.existsSync(destPath)) {
       const deployment = JSON.parse(fs3.readFileSync(destPath, "utf-8"));
       if (deployment.bytecodeHash === bytecodeHash) {
@@ -373,8 +419,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");
@@ -396,14 +442,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];
   }
@@ -420,24 +466,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 = path4.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 = path4.join(
+    lzInitiaConfig.artifactsPath,
+    `${moduleKeyWithVariant(pkgName, variant)}/bytecode_modules`
+  );
   const mvNames = glob.sync("*.mv", { cwd: moduleDir });
-  const moduleBuffers = mvNames.map((moduleName2) => fs3.readFileSync(path4.join(moduleDir, moduleName2)));
+  const moduleBuffers = mvNames.map((moduleName) => fs3.readFileSync(path4.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,
@@ -446,7 +495,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 {
@@ -456,7 +505,7 @@ async function deploy(moduleName, lzInitiaConfig, network, variant, deployToObje
       moduleBuffers,
       lzInitiaConfig,
       network,
-      moduleName,
+      moduleKey,
       deployAddress,
       actionType
     ) : await createAccountDeploymentTx(client, deployer, moduleBuffers, lzInitiaConfig, network);
@@ -472,11 +521,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,
@@ -488,7 +537,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;
     }
@@ -541,18 +590,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 (fs3.existsSync(dest)) {
-    console.log(`Removing existing artifacts at ${dest}`);
     fs3.rmSync(dest, { recursive: true });
   }
   fs3.mkdirSync(dest, { recursive: true });
@@ -564,24 +615,22 @@ async function copyArtifacts(src, dest) {
       fs3.mkdirSync(destByteCodePath, { recursive: true });
     }
     await $({
-      verbose: true
+      verbose: false,
+      quiet: true
     })`cp ${path4.join(moduleDir, module)} ${path4.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 = path4.join(modulePath, "build", pkgName);
-  const outputDir = lzInitiaConfig.modules[moduleName]?.alias ?? pkgName;
-  const outputPath = path4.join(
-    lzInitiaConfig.artifactsPath,
-    variant !== void 0 && variant.length > 0 ? `${outputDir}-${variant}` : outputDir
-  );
+  const outputDir = getFullName(lzInitiaConfig, moduleKey);
+  const outputPath = path4.join(lzInitiaConfig.artifactsPath, outputDir);
   let addresses = {};
   for (const key of Object.keys(context)) {
     const toml = context[key];
@@ -590,9 +639,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
     });
@@ -639,7 +688,7 @@ async function checkIfInitiaInstalled() {
   }
 }
 function checkIfInitiaConfigExists() {
-  const packagePath = sync("package.json", { cwd: process2.cwd() });
+  const packagePath = sync("package.json", { cwd: process.cwd() });
   if (packagePath === void 0) {
     throw new Error("package.json not found");
   }
@@ -654,15 +703,15 @@ async function main() {
   const configPath = checkIfInitiaConfigExists();
   const config = loadConfig(configPath);
   Object.values(subCommands_exports).forEach((subCommand) => {
-    subCommand.setOptionValue("__CONTEXT__", config);
+    subCommand.setOptionValue("__CONTEXT__", combineBaseConfigRecursive(config));
     program.addCommand(subCommand);
   });
   await program.parseAsync();
 }
-main().then(() => process2.exit(process2.exitCode)).catch((error) => {
+main().then(() => process.exit(process.exitCode)).catch((error) => {
   logger.error(error);
   console.trace(error);
-  process2.exit(1);
+  process.exit(1);
 });
 //# sourceMappingURL=cli.mjs.map
 //# sourceMappingURL=cli.mjs.map