@layerzerolabs/lz-initia-cli 3.0.19 → 3.0.20

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @layerzerolabs/lz-initia-cli
 
+## 3.0.20
+
+### Patch Changes
+
+- b1b6506: endpoints
+- Updated dependencies [b1b6506]
+  - @layerzerolabs/lz-definitions@3.0.20
+  - @layerzerolabs/lz-config-types@3.0.20
+  - @layerzerolabs/lz-utilities@3.0.20
+
 ## 3.0.19
 
 ### Patch Changes

package/README.md

@@ -121,4 +121,6 @@ yarn lz-initia-cli build -m layerzero_common -n initia-sandbox-local -p path/to/
 yarn lz-initia-cli deploy -m layerzero_common -n initia-sandbox-local
 # deploy the contracts with a variant
 yarn lz-initia-cli deploy -m layerzero_common -n initia-sandbox-local --variant nethermind
+# deploy the contracts to Object
+yarn lz-initia-cli deploy -m layerzero_common -n initia-sandbox-local -dto
 ```

package/dist/cli.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
-var fs2 = require('fs');
-var path3 = require('path');
+var fs3 = require('fs');
+var path4 = require('path');
 var process2 = require('process');
 var extraTypings = require('@commander-js/extra-typings');
 var findUp = require('find-up');
@@ -9,9 +9,10 @@ var core = require('zx/core');
 var lzUtilities = require('@layerzerolabs/lz-utilities');
 var crypto = require('crypto');
 var initia_js = require('@initia/initia.js');
+var sha3 = require('@noble/hashes/sha3');
+var lzDefinitions = require('@layerzerolabs/lz-definitions');
 var smolToml = require('smol-toml');
 var glob = require('glob');
-var lzDefinitions = require('@layerzerolabs/lz-definitions');
 var zx = require('zx');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
@@ -34,8 +35,8 @@ function _interopNamespace(e) {
   return Object.freeze(n);
 }
 
-var fs2__default = /*#__PURE__*/_interopDefault(fs2);
-var path3__default = /*#__PURE__*/_interopDefault(path3);
+var fs3__default = /*#__PURE__*/_interopDefault(fs3);
+var path4__default = /*#__PURE__*/_interopDefault(path4);
 var process2__default = /*#__PURE__*/_interopDefault(process2);
 var crypto__namespace = /*#__PURE__*/_interopNamespace(crypto);
 
@@ -86,14 +87,44 @@ function getInitiaClient(env, config) {
   const lcd = new initia_js.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 initia_js.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);
@@ -102,17 +133,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__default.default.join(lzAptosConfig.deploymentPath, network, `${moduleName}.json`);
+}
+async function checkIfObjectAddressExists(lzAptosConfig, network, address) {
+  try {
+    const client = getInitiaClient(lzDefinitions.networkToEnv(network, lzDefinitions.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__default.default.existsSync(deploymentPath2)) {
+    return void 0;
+  }
+  const deployment = JSON.parse(fs3__default.default.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 initia_js.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 = initia_js.AccAddress.validate(creatorAddress) ? initia_js.AccAddress.toHex(creatorAddress) : creatorAddress;
+  const creatorBytes = initia_js.bcs.address().serialize(hexAddress).toBytes();
+  const seedBytes = typeof seed === "string" ? Buffer.from(seed, "utf8") : seed;
+  const bytes = new Uint8Array([...creatorBytes, ...seedBytes, 254]);
+  return lzUtilities.ensure0x(Buffer.from(sha3.sha3_256(bytes)).toString("hex"));
+};
+async function genObjectAddressForOfficial(network, lzAptosConfig, moduleName) {
+  const client = getInitiaClient(lzDefinitions.networkToEnv(network, lzDefinitions.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 = initia_js.bcs.string().serialize(OBJECT_CODE_DEPLOYMENT_DOMAIN_SEPARATOR);
+  const secondPart = initia_js.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;
 }
@@ -156,11 +266,11 @@ function handleError(error, moduleName, context, network) {
   throw error;
 }
 function getRawMoveContextByPath(modulePath) {
-  const tomlPath = path3__default.default.join(modulePath, "Move.toml");
-  if (!fs2__default.default.existsSync(tomlPath)) {
+  const tomlPath = path4__default.default.join(modulePath, "Move.toml");
+  if (!fs3__default.default.existsSync(tomlPath)) {
     throw new Error(`Move.toml not found in ${tomlPath}`);
   }
-  const toml = smolToml.parse(fs2__default.default.readFileSync(tomlPath, "utf-8"));
+  const toml = smolToml.parse(fs3__default.default.readFileSync(tomlPath, "utf-8"));
   const { dependencies } = toml;
   let result = { [toml.package.name]: toml };
   if (dependencies !== void 0) {
@@ -168,7 +278,7 @@ function getRawMoveContextByPath(modulePath) {
       return dependencies[key]?.local !== void 0;
     }).forEach((key) => {
       const dependency = dependencies[key];
-      const dependencyPath = path3__default.default.join(modulePath, dependency.local);
+      const dependencyPath = path4__default.default.join(modulePath, dependency.local);
       result = { ...getRawMoveContextByPath(dependencyPath), ...result };
     });
   }
@@ -193,7 +303,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`);
@@ -205,15 +315,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] = initia_js.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) {
@@ -231,20 +347,21 @@ function getMoveContext(moduleName, lzInitiaConfig, network) {
   return context;
 }
 function deploymentPath(pkgName, dest, network, variant) {
-  const deploymentPath2 = path3__default.default.join(dest, network);
-  return path3__default.default.join(deploymentPath2, `${pkgWithVariant(pkgName, variant)}.json`);
+  const deploymentPath2 = path4__default.default.join(dest, network);
+  return path4__default.default.join(deploymentPath2, `${pkgWithVariant(pkgName, variant)}.json`);
 }
-function saveDeployment(moduleName, pkgName, address, dest, network, bytecodeHash, hash, variant, compatibleVersions = [lzDefinitions.EndpointVersion.V1, lzDefinitions.EndpointVersion.V2]) {
+function saveDeployment(deployer, moduleName, pkgName, address, dest, network, bytecodeHash, hash, variant, compatibleVersions = [lzDefinitions.EndpointVersion.V1, lzDefinitions.EndpointVersion.V2]) {
   const destPath = deploymentPath(pkgName, dest, network, variant);
-  const deploymentDir = path3__default.default.dirname(destPath);
-  if (!fs2__default.default.existsSync(deploymentDir)) {
-    fs2__default.default.mkdirSync(deploymentDir, { recursive: true });
+  const deploymentDir = path4__default.default.dirname(destPath);
+  if (!fs3__default.default.existsSync(deploymentDir)) {
+    fs3__default.default.mkdirSync(deploymentDir, { recursive: true });
   }
-  fs2__default.default.writeFileSync(
+  fs3__default.default.writeFileSync(
     destPath,
     JSON.stringify(
       {
         address,
+        deployer: initia_js.AccAddress.toHex(deployer.accAddress),
         name: pkgWithVariant(pkgName, variant),
         moduleName,
         network,
@@ -258,16 +375,35 @@ function saveDeployment(moduleName, pkgName, address, dest, network, bytecodeHas
   );
   console.log(`Deployment saved to ${destPath}`);
 }
-function needDeploy(pkgName, dest, network, bytecodeHash, variant) {
-  if (lzDefinitions.networkToStage(network) === lzDefinitions.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__default.default.existsSync(destPath)) {
-    const deployment = JSON.parse(fs2__default.default.readFileSync(destPath, "utf-8"));
-    return deployment.bytecodeHash !== bytecodeHash;
+  if (fs3__default.default.existsSync(destPath)) {
+    const deployment = JSON.parse(fs3__default.default.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;
@@ -279,7 +415,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 initia_js.MsgPublish(
+      deployer.accAddress,
+      modules.map((codeBytes) => codeBytes.toString("base64")),
+      initia_js.MsgPublish.Policy.COMPATIBLE
+    )
+  ];
+  const wallet = new initia_js.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 = initia_js.bcs.vector(initia_js.bcs.u8()).serialize(Uint8Array.from([])).toBase64();
+  const modulesArg = initia_js.bcs.vector(initia_js.bcs.vector(initia_js.bcs.u8())).serialize(modules).toBase64();
+  const objectAddressArg = objectAddress === void 0 ? void 0 : initia_js.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 = initia_js.bcs.vector(initia_js.bcs.u8()).serialize(Uint8Array.from(Buffer.from(seed))).toBase64();
+    functionArguments = objectAddressArg === void 0 ? [seedArg, metadataArg, modulesArg] : [metadataArg, modulesArg, objectAddressArg];
+  }
+  const msg = new initia_js.MsgExecute(
+    deployer.accAddress,
+    initia_js.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 initia_js.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`);
@@ -287,36 +460,52 @@ async function deploy(moduleName, lzInitiaConfig, network, variant) {
   const env = lzDefinitions.networkToEnv(network, lzDefinitions.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__default.default.join(lzInitiaConfig.artifactsPath, `${pkgWithVariant(pkgName, variant)}/bytecode_modules`);
-  const moduleNames = glob.glob.sync("*.mv", { cwd: moduleDir });
-  const moduleBuffers = moduleNames.map((moduleName2) => fs2__default.default.readFileSync(path3__default.default.join(moduleDir, moduleName2)));
+  const moduleDir = path4__default.default.join(lzInitiaConfig.artifactsPath, `${pkgWithVariant(pkgName, variant)}/bytecode_modules`);
+  const mvNames = glob.glob.sync("*.mv", { cwd: moduleDir });
+  const moduleBuffers = mvNames.map((moduleName2) => fs3__default.default.readFileSync(path4__default.default.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 initia_js.MsgPublish(
-        deployer.accAddress,
-        moduleBuffers.map((codeBytes) => codeBytes.toString("base64")),
-        initia_js.MsgPublish.Policy.COMPATIBLE
-      )
-    ];
-    const wallet = new initia_js.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,
-      initia_js.AccAddress.toHex(deployer.accAddress),
+      codeAddress,
       lzInitiaConfig.deploymentPath,
       network,
       bytecodeHash,
@@ -333,13 +522,24 @@ async function deploy(moduleName, lzInitiaConfig, network, variant) {
   }
 }
 var command = new extraTypings.Command();
-command.name("deploy").description("deploy Initia modules").addOption(extraTypings.createOption("-m, --modules <modules...>", "modules").makeOptionMandatory(true)).addOption(extraTypings.createOption("-n, --network <network>", "network").makeOptionMandatory(true)).addOption(extraTypings.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(extraTypings.createOption("-m, --modules <modules...>", "modules").makeOptionMandatory(true)).addOption(extraTypings.createOption("-n, --network <network>", "network").makeOptionMandatory(true)).addOption(extraTypings.createOption("-v, --variant <variant>", "variant").makeOptionMandatory(false)).addOption(
+  extraTypings.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) {
@@ -371,21 +571,21 @@ function buildProcess(modulePath, addresses, toml, customOptions = {}) {
   })`initiad move build ${args}`;
 }
 async function copyArtifacts(src, dest) {
-  if (fs2__default.default.existsSync(dest)) {
+  if (fs3__default.default.existsSync(dest)) {
     console.log(`Removing existing artifacts at ${dest}`);
-    fs2__default.default.rmSync(dest, { recursive: true });
+    fs3__default.default.rmSync(dest, { recursive: true });
   }
-  fs2__default.default.mkdirSync(dest, { recursive: true });
-  const moduleDir = path3__default.default.join(src, "bytecode_modules");
+  fs3__default.default.mkdirSync(dest, { recursive: true });
+  const moduleDir = path4__default.default.join(src, "bytecode_modules");
   const modules = glob.glob.sync("*.mv", { cwd: moduleDir });
   for (const module of modules) {
-    const destByteCodePath = path3__default.default.join(dest, "bytecode_modules");
-    if (!fs2__default.default.existsSync(destByteCodePath)) {
-      fs2__default.default.mkdirSync(destByteCodePath, { recursive: true });
+    const destByteCodePath = path4__default.default.join(dest, "bytecode_modules");
+    if (!fs3__default.default.existsSync(destByteCodePath)) {
+      fs3__default.default.mkdirSync(destByteCodePath, { recursive: true });
     }
     await zx.$({
       verbose: true
-    })`cp ${path3__default.default.join(moduleDir, module)} ${path3__default.default.join(destByteCodePath, module)}`;
+    })`cp ${path4__default.default.join(moduleDir, module)} ${path4__default.default.join(destByteCodePath, module)}`;
   }
 }
 async function build(moduleName, lzInitiaConfig, network, skipBuild = false, variant) {
@@ -394,11 +594,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__default.default.join(modulePath, "build", pkgName);
+  const srcPath = path4__default.default.join(modulePath, "build", pkgName);
   const outputDir = lzInitiaConfig.modules[moduleName]?.alias ?? pkgName;
-  const outputPath = path3__default.default.join(
+  const outputPath = path4__default.default.join(
     lzInitiaConfig.artifactsPath,
     variant !== void 0 && variant.length > 0 ? `${outputDir}-${variant}` : outputDir
   );
@@ -463,8 +663,8 @@ function checkIfInitiaConfigExists() {
   if (packagePath === void 0) {
     throw new Error("package.json not found");
   }
-  const configPath = path3__default.default.join(path3__default.default.dirname(packagePath), "lz-initia.config.ts");
-  if (!fs2__default.default.existsSync(configPath)) {
+  const configPath = path4__default.default.join(path4__default.default.dirname(packagePath), "lz-initia.config.ts");
+  if (!fs3__default.default.existsSync(configPath)) {
     throw new Error("lz-initia.config.ts not found, please create one in the same directory as package.json");
   }
   return configPath;
@@ -481,6 +681,7 @@ async function main() {
 }
 main().then(() => process2__default.default.exit(process2__default.default.exitCode)).catch((error) => {
   logger.error(error);
+  console.trace(error);
   process2__default.default.exit(1);
 });
 //# sourceMappingURL=cli.cjs.map