@layerzerolabs/lz-initia-cli 3.0.19 → 3.0.20

package/dist/cli.mjs

@@ -1,15 +1,16 @@
-import fs2 from 'fs';
-import path3 from 'path';
+import fs3 from 'fs';
+import path4 from 'path';
 import process2 from 'process';
 import { Command, createOption } from '@commander-js/extra-typings';
 import { sync } from 'find-up';
 import { $ as $$1 } from 'zx/core';
-import { getLogger } from '@layerzerolabs/lz-utilities';
+import { getLogger, ensure0x } from '@layerzerolabs/lz-utilities';
 import * as crypto from 'node:crypto';
-import { MsgPublish, Wallet, AccAddress, LCDClient, MnemonicKey } from '@initia/initia.js';
+import { LCDClient, AccAddress, MsgPublish, Wallet, bcs, MsgExecute, MnemonicKey } from '@initia/initia.js';
+import { sha3_256 } from '@noble/hashes/sha3';
+import { networkToEnv, EndpointVersion } from '@layerzerolabs/lz-definitions';
 import { parse } from 'smol-toml';
 import { glob } from 'glob';
-import { networkToEnv, EndpointVersion, networkToStage, Stage } from '@layerzerolabs/lz-definitions';
 import { $ } from 'zx';
 
 var __defProp = Object.defineProperty;
@@ -59,14 +60,44 @@ function getInitiaClient(env, config) {
   const lcd = new LCDClient(url);
   return lcd;
 }
+
+// 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, lzInitiaConfig, network) {
-  const module = lzInitiaConfig.modules[moduleName];
+function getDeployer(moduleName, lzAptosConfig, network) {
+  const module = lzAptosConfig.modules[moduleName];
   if (!module) {
-    if (lzInitiaConfig.baseModules && lzInitiaConfig.baseModules.length > 0) {
-      for (const baseModule of lzInitiaConfig.baseModules) {
+    if (lzAptosConfig.baseModules && lzAptosConfig.baseModules.length > 0) {
+      for (const baseModule of lzAptosConfig.baseModules) {
         const baseConfig = loadConfig(baseModule);
         try {
           return getDeployer(moduleName, baseConfig, network);
@@ -75,17 +106,96 @@ function getDeployer(moduleName, lzInitiaConfig, network) {
       }
     }
     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.`
+      `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(lzInitiaConfig.defaultDeployer) ? lzInitiaConfig.defaultDeployer : lzInitiaConfig.defaultDeployer?.[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`);
+}
+async function checkIfObjectAddressExists(lzAptosConfig, network, address) {
+  try {
+    const client = getInitiaClient(networkToEnv(network, EndpointVersion.V2), lzAptosConfig);
+    const object = await client.auth.accountInfo(address);
+    return object !== void 0;
+  } catch (e) {
+    return false;
+  }
+}
+function getObjectAddressFromDeployment(lzAptosConfig, network, moduleName) {
+  const deploymentPath2 = getDeploymentPath(lzAptosConfig, 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;
+  if (!deployToObject) {
+    const deployer = getDeployer(moduleName, lzAptosConfig, network);
+    return AccAddress.toHex(deployer.accAddress);
+  }
+  const objectDeployer = getObjectDeployerFromConfig(lzAptosConfig, network, moduleName);
+  if (objectDeployer !== InitiaObjectDeployerAddress) {
+    return genObjectAddressForLayerzero(network, lzAptosConfig, moduleName);
+  }
+  const objectAddress = getObjectAddressFromDeployment(lzAptosConfig, network, moduleName);
+  if (objectAddress !== void 0) {
+    if (await checkIfObjectAddressExists(lzAptosConfig, 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.`
+      );
+    }
+  } else if (!isOngoingModule) {
+    throw new Error(
+      `Deployment file not found at: ${getDeploymentPath(lzAptosConfig, network, moduleName)}. Make sure ${moduleName} is deployed.`
+    );
+  }
+  return genObjectAddress(moduleName, lzAptosConfig, network);
+}
+var createObjectAddress = (creatorAddress, seed) => {
+  const hexAddress = AccAddress.validate(creatorAddress) ? AccAddress.toHex(creatorAddress) : creatorAddress;
+  const creatorBytes = bcs.address().serialize(hexAddress).toBytes();
+  const seedBytes = typeof seed === "string" ? Buffer.from(seed, "utf8") : 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);
+  const OBJECT_CODE_DEPLOYMENT_DOMAIN_SEPARATOR = "aptos_framework::object_code_deployment";
+  const account = await client.auth.accountInfo(deployer.accAddress);
+  const sequenceNumber = account.getSequenceNumber();
+  const firstPart = bcs.string().serialize(OBJECT_CODE_DEPLOYMENT_DOMAIN_SEPARATOR);
+  const secondPart = bcs.u64().serialize(BigInt(sequenceNumber) + BigInt(1));
+  const seed = new Uint8Array([...firstPart.toBytes(), ...secondPart.toBytes()]);
+  const objectAddress = createObjectAddress(deployer.accAddress, seed);
+  return objectAddress;
+}
+function genObjectAddressForLayerzero(network, lzAptosConfig, moduleName) {
+  const deployer = getDeployer(moduleName, lzAptosConfig, network);
+  const seed = getFullName(lzAptosConfig, moduleName);
+  const objectAddress = createObjectAddress(deployer.accAddress, new Uint8Array(Buffer.from(seed, "utf8")));
+  return objectAddress.toString();
+}
+async function genObjectAddress(moduleName, lzAptosConfig, network) {
+  const objectDeployer = getObjectDeployerFromConfig(lzAptosConfig, network, moduleName);
+  if (objectDeployer === InitiaObjectDeployerAddress) {
+    return genObjectAddressForOfficial(network, lzAptosConfig, moduleName);
+  }
+  return genObjectAddressForLayerzero(network, lzAptosConfig, moduleName);
+}
 function isAxiosError(error) {
   return error?.response?.data?.message !== void 0;
 }
@@ -129,11 +239,11 @@ function handleError(error, moduleName, context, network) {
   throw error;
 }
 function getRawMoveContextByPath(modulePath) {
-  const tomlPath = path3.join(modulePath, "Move.toml");
-  if (!fs2.existsSync(tomlPath)) {
+  const tomlPath = path4.join(modulePath, "Move.toml");
+  if (!fs3.existsSync(tomlPath)) {
     throw new Error(`Move.toml not found in ${tomlPath}`);
   }
-  const toml = parse(fs2.readFileSync(tomlPath, "utf-8"));
+  const toml = parse(fs3.readFileSync(tomlPath, "utf-8"));
   const { dependencies } = toml;
   let result = { [toml.package.name]: toml };
   if (dependencies !== void 0) {
@@ -141,7 +251,7 @@ function getRawMoveContextByPath(modulePath) {
       return dependencies[key]?.local !== void 0;
     }).forEach((key) => {
       const dependency = dependencies[key];
-      const dependencyPath = path3.join(modulePath, dependency.local);
+      const dependencyPath = path4.join(modulePath, dependency.local);
       result = { ...getRawMoveContextByPath(dependencyPath), ...result };
     });
   }
@@ -166,7 +276,7 @@ function parseAddresses(addresses, network) {
   }
   return result;
 }
-function getMoveContext(moduleName, lzInitiaConfig, network) {
+async function getMoveContext(moduleName, lzInitiaConfig, network) {
   const module = lzInitiaConfig.modules[moduleName];
   if (!module) {
     throw new Error(`module ${moduleName} not found when getting Move context`);
@@ -178,15 +288,21 @@ function getMoveContext(moduleName, lzInitiaConfig, network) {
       const address = toml.addresses[addressKey];
       const presetAddresses = {
         ...parseAddresses(lzInitiaConfig.modules[key]?.addresses, network),
+        // dependency or current module config address
         ...parseAddresses(lzInitiaConfig.modules[moduleName]?.addresses, network)
+        // current module config address
       };
       if (address === "_") {
         if (presetAddresses[addressKey] !== void 0 && presetAddresses[addressKey] !== "") {
           toml.addresses[addressKey] = presetAddresses[addressKey];
         } else {
           try {
-            toml.addresses[addressKey] = AccAddress.toHex(
-              getDeployer(addressKey, lzInitiaConfig, network).accAddress
+            const isOnGoingModule = moduleName === addressKey;
+            toml.addresses[addressKey] = await resolveAddress(
+              addressKey,
+              lzInitiaConfig,
+              network,
+              isOnGoingModule
             );
           } catch (e) {
             if (key === moduleName) {
@@ -204,20 +320,21 @@ function getMoveContext(moduleName, lzInitiaConfig, network) {
   return context;
 }
 function deploymentPath(pkgName, dest, network, variant) {
-  const deploymentPath2 = path3.join(dest, network);
-  return path3.join(deploymentPath2, `${pkgWithVariant(pkgName, variant)}.json`);
+  const deploymentPath2 = path4.join(dest, network);
+  return path4.join(deploymentPath2, `${pkgWithVariant(pkgName, variant)}.json`);
 }
-function saveDeployment(moduleName, pkgName, address, dest, network, bytecodeHash, hash, variant, compatibleVersions = [EndpointVersion.V1, EndpointVersion.V2]) {
+function saveDeployment(deployer, moduleName, pkgName, address, dest, network, bytecodeHash, hash, variant, compatibleVersions = [EndpointVersion.V1, EndpointVersion.V2]) {
   const destPath = deploymentPath(pkgName, dest, network, variant);
-  const deploymentDir = path3.dirname(destPath);
-  if (!fs2.existsSync(deploymentDir)) {
-    fs2.mkdirSync(deploymentDir, { recursive: true });
+  const deploymentDir = path4.dirname(destPath);
+  if (!fs3.existsSync(deploymentDir)) {
+    fs3.mkdirSync(deploymentDir, { recursive: true });
   }
-  fs2.writeFileSync(
+  fs3.writeFileSync(
     destPath,
     JSON.stringify(
       {
         address,
+        deployer: AccAddress.toHex(deployer.accAddress),
         name: pkgWithVariant(pkgName, variant),
         moduleName,
         network,
@@ -231,16 +348,35 @@ function saveDeployment(moduleName, pkgName, address, dest, network, bytecodeHas
   );
   console.log(`Deployment saved to ${destPath}`);
 }
-function needDeploy(pkgName, dest, network, bytecodeHash, variant) {
-  if (networkToStage(network) === Stage.SANDBOX) {
-    return true;
+async function checkIfModuleExistedOnChain(client, moduleNames, address) {
+  try {
+    const modules = (await client.move.modules(address))[0];
+    return moduleNames.some(
+      (moduleName) => modules.map((module) => module.module_name).includes(moduleName.replace(".mv", ""))
+    );
+  } catch (e) {
+    try {
+      const object = await client.auth.accountInfo(address);
+      return object !== void 0;
+    } catch (e2) {
+      return false;
+    }
   }
+}
+async function getDeployActionType(client, pkgName, moduleNames, dest, network, bytecodeHash, variant) {
   const destPath = deploymentPath(pkgName, dest, network, variant);
-  if (fs2.existsSync(destPath)) {
-    const deployment = JSON.parse(fs2.readFileSync(destPath, "utf-8"));
-    return deployment.bytecodeHash !== bytecodeHash;
+  if (fs3.existsSync(destPath)) {
+    const deployment = JSON.parse(fs3.readFileSync(destPath, "utf-8"));
+    const moduleExisted = await checkIfModuleExistedOnChain(client, moduleNames, deployment.address);
+    if (moduleExisted) {
+      if (deployment.bytecodeHash !== bytecodeHash || network.includes("local")) {
+        return { actionType: "Upgrade" /* Upgrade */, address: deployment.address };
+      } else {
+        return { actionType: "Skip" /* Skip */, address: deployment.address };
+      }
+    }
   }
-  return true;
+  return { actionType: "Deploy" /* Deploy */, address: void 0 };
 }
 function pkgWithVariant(pkgName, variant) {
   return variant !== void 0 && variant.length > 0 ? `${pkgName}-${variant}` : pkgName;
@@ -252,7 +388,44 @@ function getBytecodesHash(bytecodes) {
   });
   return hash.digest("hex");
 }
-async function deploy(moduleName, lzInitiaConfig, network, variant) {
+async function createAccountDeploymentTx(client, deployer, modules, lzInitiaConfig, network) {
+  const msgs = [
+    new MsgPublish(
+      deployer.accAddress,
+      modules.map((codeBytes) => codeBytes.toString("base64")),
+      MsgPublish.Policy.COMPATIBLE
+    )
+  ];
+  const wallet = new Wallet(client, deployer);
+  const gasPrices = lzInitiaConfig.gasPrice?.[network] === void 0 ? void 0 : `${lzInitiaConfig.gasPrice[network]}uinit`;
+  const signedTx = await wallet.createAndSignTx({ msgs, gasPrices });
+  return signedTx;
+}
+async function createObjectDeploymentTx(client, deployer, modules, lzInitiaConfig, network, moduleName, objectAddress) {
+  const objectDeployer = getObjectDeployerFromConfig(lzInitiaConfig, network, moduleName);
+  const metadataArg = bcs.vector(bcs.u8()).serialize(Uint8Array.from([])).toBase64();
+  const modulesArg = bcs.vector(bcs.vector(bcs.u8())).serialize(modules).toBase64();
+  const objectAddressArg = objectAddress === void 0 ? void 0 : bcs.address().serialize(objectAddress).toBase64();
+  let functionArguments = objectAddressArg === void 0 ? [metadataArg, modulesArg] : [metadataArg, modulesArg, objectAddressArg];
+  if (objectDeployer !== InitiaObjectDeployerAddress) {
+    const seed = getFullName(lzInitiaConfig, moduleName);
+    const seedArg = bcs.vector(bcs.u8()).serialize(Uint8Array.from(Buffer.from(seed))).toBase64();
+    functionArguments = objectAddressArg === void 0 ? [seedArg, metadataArg, modulesArg] : [metadataArg, modulesArg, objectAddressArg];
+  }
+  const msg = new MsgExecute(
+    deployer.accAddress,
+    AccAddress.fromHex(objectDeployer),
+    "object_code_deployment",
+    objectAddress === void 0 ? `publish` : `upgrade`,
+    [],
+    functionArguments
+  );
+  const gasPrices = lzInitiaConfig.gasPrice?.[network] === void 0 ? void 0 : `${lzInitiaConfig.gasPrice[network]}uinit`;
+  const wallet = new Wallet(client, deployer);
+  const signedTx = await wallet.createAndSignTx({ msgs: [msg], gasPrices });
+  return signedTx;
+}
+async function deploy(moduleName, lzInitiaConfig, network, variant, deployToObject = false) {
   const module = lzInitiaConfig.modules[moduleName];
   if (!module) {
     throw new Error(`module ${moduleName} not found`);
@@ -260,36 +433,52 @@ async function deploy(moduleName, lzInitiaConfig, network, variant) {
   const env = networkToEnv(network, EndpointVersion.V2);
   const client = getInitiaClient(env, lzInitiaConfig);
   const deployer = getDeployer(moduleName, lzInitiaConfig, network);
-  const context = getMoveContext(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 moduleNames = glob.sync("*.mv", { cwd: moduleDir });
-  const moduleBuffers = moduleNames.map((moduleName2) => fs2.readFileSync(path3.join(moduleDir, moduleName2)));
+  const moduleDir = path4.join(lzInitiaConfig.artifactsPath, `${pkgWithVariant(pkgName, variant)}/bytecode_modules`);
+  const mvNames = glob.sync("*.mv", { cwd: moduleDir });
+  const moduleBuffers = mvNames.map((moduleName2) => fs3.readFileSync(path4.join(moduleDir, moduleName2)));
   const bytecodeHash = getBytecodesHash(moduleBuffers);
-  if (!needDeploy(pkgName, lzInitiaConfig.deploymentPath, network, bytecodeHash, variant)) {
+  const { actionType, address: deployedAddress } = await getDeployActionType(
+    client,
+    moduleName,
+    mvNames,
+    lzInitiaConfig.deploymentPath,
+    network,
+    bytecodeHash,
+    variant
+  );
+  if (actionType === "Skip" /* Skip */) {
     console.warn(`Code of ${moduleName} has not changed, skipping deploy`);
     return;
   }
   try {
-    const msgs = [
-      new MsgPublish(
-        deployer.accAddress,
-        moduleBuffers.map((codeBytes) => codeBytes.toString("base64")),
-        MsgPublish.Policy.COMPATIBLE
-      )
-    ];
-    const wallet = new Wallet(client, deployer);
-    const gasPrices = lzInitiaConfig.gasPrice?.[network] === void 0 ? void 0 : `${lzInitiaConfig.gasPrice[network]}uinit`;
-    const signedTx = await wallet.createAndSignTx({ msgs, gasPrices });
+    const signedTx = deployToObject ? await createObjectDeploymentTx(
+      client,
+      deployer,
+      moduleBuffers,
+      lzInitiaConfig,
+      network,
+      moduleName,
+      deployedAddress
+    ) : await createAccountDeploymentTx(client, deployer, moduleBuffers, lzInitiaConfig, network);
     const tx = await client.tx.broadcast(signedTx);
+    const info = await client.tx.txInfo(tx.txhash);
+    const publishedEvent = info.events.find(
+      (event) => event.type === "move" && event.attributes.find((attr) => attr.key === "type_tag")?.value === "0x1::code::ModulePublishedEvent"
+    );
+    const publishModuleAttr = publishedEvent?.attributes.find((attr) => attr.key === "data");
+    const { module_id } = JSON.parse(publishModuleAttr.value);
+    const codeAddress = module_id.split("::")[0];
     if (tx.code !== 0) {
       throw new Error(tx.raw_log);
     }
     console.log(`Deploy transaction ${tx.txhash} successfully`);
     saveDeployment(
+      deployer,
       moduleName,
       pkgName,
-      AccAddress.toHex(deployer.accAddress),
+      codeAddress,
       lzInitiaConfig.deploymentPath,
       network,
       bytecodeHash,
@@ -306,13 +495,24 @@ async function deploy(moduleName, lzInitiaConfig, network, variant) {
   }
 }
 var command = new Command();
-command.name("deploy").description("deploy Initia modules").addOption(createOption("-m, --modules <modules...>", "modules").makeOptionMandatory(true)).addOption(createOption("-n, --network <network>", "network").makeOptionMandatory(true)).addOption(createOption("-v, --variant <variant>", "variant").makeOptionMandatory(false)).action(async (options, cmd) => {
-  const context = cmd.getOptionValue("__CONTEXT__");
-  const { modules, variant, network } = options;
-  for (const module of modules) {
-    await deploy(module, context, network, variant ?? context.modules[module]?.variant);
+command.name("deploy").description("deploy Initia modules").addOption(createOption("-m, --modules <modules...>", "modules").makeOptionMandatory(true)).addOption(createOption("-n, --network <network>", "network").makeOptionMandatory(true)).addOption(createOption("-v, --variant <variant>", "variant").makeOptionMandatory(false)).addOption(
+  createOption("-dto, --deploy-to-object", "Deploy to Move Object. Default to false").makeOptionMandatory(false)
+).action(
+  async (options, cmd) => {
+    const context = cmd.getOptionValue("__CONTEXT__");
+    const { modules, variant, network, deployToObject: deployToObjectOpt } = options;
+    for (const module of modules) {
+      const deployToObject = deployToObjectOpt ?? context.modules[module]?.deployToObject ?? context.defaultDeployToObject ?? false;
+      await deploy(
+        module,
+        context,
+        network,
+        variant ?? context.modules[module]?.variant,
+        deployToObject
+      );
+    }
   }
-});
+);
 
 // src/options.ts
 function parseOptions(defaultOptions, customOptions) {
@@ -344,21 +544,21 @@ function buildProcess(modulePath, addresses, toml, customOptions = {}) {
   })`initiad move build ${args}`;
 }
 async function copyArtifacts(src, dest) {
-  if (fs2.existsSync(dest)) {
+  if (fs3.existsSync(dest)) {
     console.log(`Removing existing artifacts at ${dest}`);
-    fs2.rmSync(dest, { recursive: true });
+    fs3.rmSync(dest, { recursive: true });
   }
-  fs2.mkdirSync(dest, { recursive: true });
-  const moduleDir = path3.join(src, "bytecode_modules");
+  fs3.mkdirSync(dest, { recursive: true });
+  const moduleDir = path4.join(src, "bytecode_modules");
   const modules = glob.sync("*.mv", { cwd: moduleDir });
   for (const module of modules) {
-    const destByteCodePath = path3.join(dest, "bytecode_modules");
-    if (!fs2.existsSync(destByteCodePath)) {
-      fs2.mkdirSync(destByteCodePath, { recursive: true });
+    const destByteCodePath = path4.join(dest, "bytecode_modules");
+    if (!fs3.existsSync(destByteCodePath)) {
+      fs3.mkdirSync(destByteCodePath, { recursive: true });
     }
     await $({
       verbose: true
-    })`cp ${path3.join(moduleDir, module)} ${path3.join(destByteCodePath, module)}`;
+    })`cp ${path4.join(moduleDir, module)} ${path4.join(destByteCodePath, module)}`;
   }
 }
 async function build(moduleName, lzInitiaConfig, network, skipBuild = false, variant) {
@@ -367,11 +567,11 @@ async function build(moduleName, lzInitiaConfig, network, skipBuild = false, var
     throw new Error(`module ${moduleName} not found`);
   }
   const { modulePath } = module;
-  const context = getMoveContext(moduleName, lzInitiaConfig, network);
+  const context = await getMoveContext(moduleName, lzInitiaConfig, network);
   const pkgName = context[moduleName].package.name;
-  const srcPath = path3.join(modulePath, "build", pkgName);
+  const srcPath = path4.join(modulePath, "build", pkgName);
   const outputDir = lzInitiaConfig.modules[moduleName]?.alias ?? pkgName;
-  const outputPath = path3.join(
+  const outputPath = path4.join(
     lzInitiaConfig.artifactsPath,
     variant !== void 0 && variant.length > 0 ? `${outputDir}-${variant}` : outputDir
   );
@@ -436,8 +636,8 @@ function checkIfInitiaConfigExists() {
   if (packagePath === void 0) {
     throw new Error("package.json not found");
   }
-  const configPath = path3.join(path3.dirname(packagePath), "lz-initia.config.ts");
-  if (!fs2.existsSync(configPath)) {
+  const configPath = path4.join(path4.dirname(packagePath), "lz-initia.config.ts");
+  if (!fs3.existsSync(configPath)) {
     throw new Error("lz-initia.config.ts not found, please create one in the same directory as package.json");
   }
   return configPath;
@@ -454,6 +654,7 @@ async function main() {
 }
 main().then(() => process2.exit(process2.exitCode)).catch((error) => {
   logger.error(error);
+  console.trace(error);
   process2.exit(1);
 });
 //# sourceMappingURL=cli.mjs.map