@layerzerolabs/lz-initia-cli 2.3.45-initia-oft.5

package/CHANGELOG.md

@@ -0,0 +1,88 @@
+# @layerzerolabs/lz-initia-cli
+
+## 2.3.45-initia-oft.5
+
+### Patch Changes
+
+- Build Initia,aptos,movement,bsc snapshot images with newest images
+- Updated dependencies
+  - @layerzerolabs/lz-definitions@2.3.45-initia-oft.5
+  - @layerzerolabs/lz-config-types@2.3.45-initia-oft.5
+  - @layerzerolabs/lz-utilities@2.3.45-initia-oft.5
+
+## 2.3.45-initia-oft.4
+
+### Patch Changes
+
+- Build initia images with newest contracts
+- Updated dependencies
+  - @layerzerolabs/lz-definitions@2.3.45-initia-oft.4
+  - @layerzerolabs/lz-config-types@2.3.45-initia-oft.4
+  - @layerzerolabs/lz-utilities@2.3.45-initia-oft.4
+
+## 2.3.45-initia-oft.3
+
+### Patch Changes
+
+- Fix Aptos OFT SDK to fit newest contracts
+- Updated dependencies
+  - @layerzerolabs/lz-definitions@2.3.45-initia-oft.3
+  - @layerzerolabs/lz-config-types@2.3.45-initia-oft.3
+  - @layerzerolabs/lz-utilities@2.3.45-initia-oft.3
+
+## 2.3.45-initia-oft.2
+
+### Patch Changes
+
+- Fix bug in Initia OFT sdk
+- Updated dependencies
+  - @layerzerolabs/lz-definitions@2.3.45-initia-oft.2
+  - @layerzerolabs/lz-config-types@2.3.45-initia-oft.2
+  - @layerzerolabs/lz-utilities@2.3.45-initia-oft.2
+
+## 2.3.45-initia-oft.1
+
+### Patch Changes
+
+- Build new initia images with newest contracts
+- Updated dependencies
+  - @layerzerolabs/lz-definitions@2.3.45-initia-oft.1
+  - @layerzerolabs/lz-config-types@2.3.45-initia-oft.1
+  - @layerzerolabs/lz-utilities@2.3.45-initia-oft.1
+
+## 2.3.45-initia-oft.0
+
+### Patch Changes
+
+- Build new initia images with testnet deployments
+- Updated dependencies
+  - @layerzerolabs/lz-definitions@2.3.45-initia-oft.0
+  - @layerzerolabs/lz-config-types@2.3.45-initia-oft.0
+  - @layerzerolabs/lz-utilities@2.3.45-initia-oft.0
+
+## 2.3.43-initia-oft.2
+
+### Patch Changes
+
+- Build new Initia snapshot images with multi tokens
+- Updated dependencies
+  - @layerzerolabs/lz-definitions@2.3.43-initia-oft.2
+  - @layerzerolabs/lz-utilities@2.3.43-initia-oft.2
+
+## 2.3.43-initia-oft.1
+
+### Patch Changes
+
+- Update Initia Snapshot image with newest contracts
+- Updated dependencies
+  - @layerzerolabs/lz-definitions@2.3.43-initia-oft.1
+  - @layerzerolabs/lz-utilities@2.3.43-initia-oft.1
+
+## 2.3.43-initia-oft.0
+
+### Patch Changes
+
+- Building new Initia snapshot image, including OFT TokenOne
+- Updated dependencies
+  - @layerzerolabs/lz-definitions@2.3.43-initia-oft.0
+  - @layerzerolabs/lz-utilities@2.3.43-initia-oft.0

package/README.md

@@ -0,0 +1,122 @@
+Wrap Initia cli to support custom configuration just like Hardhat
+
+#### Install
+
+```bash
+yarn add @layerzerolabs/lz-initia-cli
+```
+
+#### Config
+
+Create a `initia.config.ts` file in the root of your project. A full example is below:
+
+```ts
+import { LzInitiaConfig } from "@layerzerolabs/lz-initia-cli";
+import {
+  Chain,
+  chainAndStageToNetwork,
+  Environment,
+  Stage,
+} from "@layerzerolabs/lz-definitions";
+import path from "path";
+import { Account } from "@initia-labs/ts-sdk";
+
+const INITIA_SANDBOX_LOCAL = chainAndStageToNetwork(
+  Chain.INITIA,
+  Stage.SANDBOX,
+  Environment.LOCAL,
+);
+const INITIA_TESTNET = chainAndStageToNetwork(
+  Chain.INITIA,
+  Stage.TESTNET,
+  Environment.TESTNET,
+);
+const INITIA_MAINNET = chainAndStageToNetwork(
+  Chain.INITIA,
+  Stage.MAINNET,
+  Environment.MAINNET,
+);
+const contractWorkspace = "./contracts";
+
+const config: LzInitiaConfig = {
+  artifactsPath: "./artifacts",
+  deploymentPath: "./deployments",
+  compatibleVersions: ["v1"],
+  network: {
+    [Environment.LOCAL]: "http://127.0.0.1:8080",
+  },
+  defaultDeployer: {
+    [INITIA_SANDBOX_LOCAL]: Account.fromPrivateKey({
+      privateKey: process.env.LOCAL_DEPLOYER,
+    }),
+    [INITIA_TESTNET]: Account.fromPrivateKey({
+      privateKey: process.env.TESTNET_DEPLOYER,
+    }),
+    [INITIA_MAINNET]: Account.fromPrivateKey({
+      privateKey: process.env.MAINNET_DEPLOYER,
+    }),
+  },
+  // alternative way to set defaultDeployer
+  // defaultDeployer: Account.fromPrivateKey({ privateKey: process.env.DEFAULT_DEPLOYER })
+  gasPrice: {
+    [INITIA_SANDBOX_LOCAL]: 1000,
+    [INITIA_TESTNET]: 1000,
+    [INITIA_MAINNET]: 1000,
+  },
+  baseModules: ["PATH_TO_ANOTHER_LZ_INITIA_CONFIG_FILE"],
+  modules: {
+    layerzero_common: {
+      modulePath: path.join(contractWorkspace, "layerzero-common"),
+      deployer: {
+        "initia-sandbox-local": Account.fromPrivateKey({
+          privateKey: process.env.LAYERZERO_DEPLOYER,
+        }),
+      },
+    },
+    executor_v2: {
+      alias: "ExecutorV2",
+      modulePath: path.join(contractWorkspace, "executor/executor-v2"),
+      deployer: Account.fromPrivateKey({
+        privateKey: process.env.EXECUTOR_DEPLOYER,
+      }),
+    },
+    executor_auth: {
+      modulePath: path.join(contractWorkspace, "executor/executor-auth"),
+      variant: process.env.SUFFIX_EXECUTOR,
+    },
+  },
+};
+
+export default config;
+```
+
+Details of the configuration:
+
+- `artifactsPath`: Path to store the artifacts(\*.mv and package-metadata.bcs) generated by the compiler.
+- `deploymentPath`: Path to store the deployment files(\*.json) recording the deployment information.
+- `compatibleVersions`: The compatible endpoint version. If not set, the default value is ['v1', 'v2']
+- `network`: The RPC for each environment.
+- `compileOptions`: The `OPTIONS` for the `initiad move build`. If not set, the default value is `--skip-fetch-latest-git-deps=true`.
+- `defaultDeployer`: The default deployer. Deployer account address is also the address of the contract.
+- `gasPrice`: The gas price for each environment. If not set, the default value is 2 times the current gas price.
+- `baseModules`: The path to another lz-initia config file. The command tool will search the base modules recursively if module name not found in `modules`. If not set, the default value is [].
+- `modules`: The module configuration. The key is the module name used in lz-initia-cli command. The key should be the same with package name in Move.toml.
+  - `alias`: Artifact/Deployment name for the module. If not set, the module name will be used.
+  - `modulePath`: The path to the module's contract directory which contains Move.toml.
+  - `deployer`: The deployer for the module. If not set, the default deployer will be used.
+  - `variant`: The variant for the module. If not set, it means the module has no variant. It will be overridden by the variant in the command line.
+
+#### Usage
+
+```bash
+cd path/to/your/project
+# compile the contracts
+yarn lz-initia-cli build -m layerzero_common -n initia-sandbox-local
+# compile the contracts with a variant
+# for use cases like deploying same contract to different addresses
+yarn lz-initia-cli build -m dvn -n initia-sandbox-local --variant nethermind
+# deploy the contracts
+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
+```

package/dist/cli.cjs

@@ -0,0 +1,469 @@
+'use strict';
+
+var fs2 = require('fs');
+var path3 = require('path');
+var process2 = require('process');
+var extraTypings = require('@commander-js/extra-typings');
+var findUp = require('find-up');
+var core = require('zx/core');
+var lzUtilities = require('@layerzerolabs/lz-utilities');
+var crypto = require('crypto');
+var initia_js = require('@initia/initia.js');
+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 }; }
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var fs2__default = /*#__PURE__*/_interopDefault(fs2);
+var path3__default = /*#__PURE__*/_interopDefault(path3);
+var process2__default = /*#__PURE__*/_interopDefault(process2);
+var crypto__namespace = /*#__PURE__*/_interopNamespace(crypto);
+
+var __defProp = Object.defineProperty;
+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');
+});
+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) {
+    throw new Error(`No network url for ${env} found in lz-initia.config.ts`);
+  }
+  const lcd = new initia_js.LCDClient(url);
+  return lcd;
+}
+function isInitiaAccount(account) {
+  return account !== void 0 && account instanceof initia_js.MnemonicKey;
+}
+function getDeployer(moduleName, lzInitiaConfig, network) {
+  const module = lzInitiaConfig.modules[moduleName];
+  if (!module) {
+    if (lzInitiaConfig.baseModules && lzInitiaConfig.baseModules.length > 0) {
+      for (const baseModule of lzInitiaConfig.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-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 isAxiosError(error) {
+  return error?.response?.data?.message !== void 0;
+}
+function handleDepMissingError(error, moduleName, 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(
+        context
+      ).filter((module) => module !== moduleName).join(",")}]`
+    );
+  }
+}
+function handleAccountNotFoundError(error, moduleName, context, network) {
+  const address = context[moduleName]?.addresses[moduleName];
+  if (address === void 0) {
+    return;
+  }
+  if (error.response.data.message.includes(`account ${initia_js.AccAddress.fromHex(address)} not found`)) {
+    throw new Error(
+      `${error.response.data.message}, make sure you have funded the account ${initia_js.AccAddress.fromHex(address)}(${address}) on ${network}`
+    );
+  }
+}
+function handleSenderNotMatchError(error, moduleName) {
+  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`
+    );
+  }
+}
+function handleOtherAxiosError(error) {
+  throw new Error(error.response.data.message);
+}
+function handleError(error, moduleName, context, network) {
+  if (isAxiosError(error)) {
+    handleDepMissingError(error, moduleName, context);
+    handleAccountNotFoundError(error, moduleName, context, network);
+    handleSenderNotMatchError(error, moduleName);
+    handleOtherAxiosError(error);
+  }
+  throw error;
+}
+function getRawMoveContextByPath(modulePath) {
+  const tomlPath = path3__default.default.join(modulePath, "Move.toml");
+  if (!fs2__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 { dependencies } = toml;
+  let result = { [toml.package.name]: toml };
+  if (dependencies !== void 0) {
+    Object.keys(dependencies).filter((key) => {
+      return dependencies[key]?.local !== void 0;
+    }).forEach((key) => {
+      const dependency = dependencies[key];
+      const dependencyPath = path3__default.default.join(modulePath, dependency.local);
+      result = { ...getRawMoveContextByPath(dependencyPath), ...result };
+    });
+  }
+  return result;
+}
+function parseAddresses(addresses, network) {
+  if (addresses === void 0) {
+    return {};
+  }
+  const result = {};
+  for (const key of Object.keys(addresses)) {
+    const value = addresses[key];
+    if (typeof value === "string") {
+      result[key] = value;
+    } else {
+      const networkAddress = value[network];
+      if (networkAddress === void 0) {
+        throw new Error(`${key} address not found for network ${network}`);
+      }
+      result[key] = networkAddress;
+    }
+  }
+  return result;
+}
+function getMoveContext(moduleName, lzInitiaConfig, network) {
+  const module = lzInitiaConfig.modules[moduleName];
+  if (!module) {
+    throw new Error(`module ${moduleName} not found when getting Move context`);
+  }
+  const context = getRawMoveContextByPath(module.modulePath);
+  for (const key of Object.keys(context)) {
+    const toml = context[key];
+    for (const addressKey of Object.keys(toml.addresses)) {
+      const address = toml.addresses[addressKey];
+      const presetAddresses = parseAddresses(lzInitiaConfig.modules[key]?.addresses, network);
+      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
+            );
+          } catch (e) {
+            if (key === moduleName) {
+              throw new Error(`Fail to generate context for ${key}. ${e.toString()}`);
+            } else {
+              throw new Error(
+                `Fail to generate context for dependent module ${key}. ${e.toString()}`
+              );
+            }
+          }
+        }
+      }
+    }
+  }
+  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`);
+}
+function saveDeployment(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 });
+  }
+  fs2__default.default.writeFileSync(
+    destPath,
+    JSON.stringify(
+      {
+        address,
+        name: pkgWithVariant(pkgName, variant),
+        moduleName,
+        network,
+        compatibleVersions,
+        bytecodeHash,
+        transactionHash: hash
+      },
+      null,
+      2
+    )
+  );
+  console.log(`Deployment saved to ${destPath}`);
+}
+function needDeploy(pkgName, dest, network, bytecodeHash, variant) {
+  if (lzDefinitions.networkToStage(network) === lzDefinitions.Stage.SANDBOX) {
+    return true;
+  }
+  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;
+  }
+  return true;
+}
+function pkgWithVariant(pkgName, variant) {
+  return variant !== void 0 && variant.length > 0 ? `${pkgName}-${variant}` : pkgName;
+}
+function getBytecodesHash(bytecodes) {
+  const hash = crypto__namespace.createHash("sha256");
+  bytecodes.forEach((bytecode) => {
+    hash.update(bytecode);
+  });
+  return hash.digest("hex");
+}
+async function deploy(moduleName, lzInitiaConfig, network, variant) {
+  const module = lzInitiaConfig.modules[moduleName];
+  if (!module) {
+    throw new Error(`module ${moduleName} not found`);
+  }
+  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 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 bytecodeHash = getBytecodesHash(moduleBuffers);
+  if (!needDeploy(pkgName, lzInitiaConfig.deploymentPath, network, bytecodeHash, variant)) {
+    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]}unit`;
+    const signedTx = await wallet.createAndSignTx({ msgs, gasPrices });
+    const tx = await client.tx.broadcast(signedTx);
+    if (tx.code !== 0) {
+      throw new Error(tx.raw_log);
+    }
+    console.log(`Deploy transaction ${tx.txhash} successfully`);
+    saveDeployment(
+      moduleName,
+      pkgName,
+      initia_js.AccAddress.toHex(deployer.accAddress),
+      lzInitiaConfig.deploymentPath,
+      network,
+      bytecodeHash,
+      tx.txhash,
+      variant,
+      lzInitiaConfig.compatibleVersions
+    );
+  } catch (e) {
+    if (e instanceof Error) {
+      handleError(e, moduleName, context, network);
+    } else {
+      throw e;
+    }
+  }
+}
+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);
+  }
+});
+
+// src/options.ts
+function parseOptions(defaultOptions, customOptions) {
+  const options = { ...defaultOptions, ...customOptions };
+  const res = [];
+  for (const key of Object.keys(options)) {
+    if (typeof options[key] === "boolean") {
+      if (options[key] === true) {
+        res.push(key);
+      }
+    } else {
+      res.push(key);
+      res.push(options[key]);
+    }
+  }
+  return res;
+}
+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
+  };
+  const args = parseOptions(defaultOptions, customOptions);
+  return zx.$({
+    cwd: modulePath,
+    stdio: ["inherit", "pipe", process.stderr],
+    verbose: true
+  })`initiad move build ${args}`;
+}
+async function copyArtifacts(src, dest) {
+  if (fs2__default.default.existsSync(dest)) {
+    console.log(`Removing existing artifacts at ${dest}`);
+    fs2__default.default.rmSync(dest, { recursive: true });
+  }
+  fs2__default.default.mkdirSync(dest, { recursive: true });
+  const moduleDir = path3__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 });
+    }
+    await zx.$({
+      verbose: true
+    })`cp ${path3__default.default.join(moduleDir, module)} ${path3__default.default.join(destByteCodePath, module)}`;
+  }
+}
+async function build(moduleName, lzInitiaConfig, network, skipBuild = false, variant) {
+  const module = lzInitiaConfig.modules[moduleName];
+  if (!module) {
+    throw new Error(`module ${moduleName} not found`);
+  }
+  const { modulePath } = module;
+  const context = getMoveContext(moduleName, lzInitiaConfig, network);
+  const pkgName = context[moduleName].package.name;
+  const srcPath = path3__default.default.join(modulePath, "build", pkgName);
+  const outputDir = lzInitiaConfig.modules[moduleName]?.alias ?? pkgName;
+  const outputPath = path3__default.default.join(
+    lzInitiaConfig.artifactsPath,
+    variant !== void 0 && variant.length > 0 ? `${outputDir}-${variant}` : outputDir
+  );
+  let addresses = {};
+  for (const key of Object.keys(context)) {
+    const toml = context[key];
+    if (!(key in toml.addresses)) {
+      throw new Error(`address not found for ${key}`);
+    }
+    addresses = { ...addresses, ...toml.addresses };
+  }
+  addresses = { ...addresses, ...context[moduleName].addresses };
+  if (!skipBuild) {
+    await buildProcess(modulePath, addresses, context[moduleName], {
+      ...lzInitiaConfig.compileOptions,
+      ...module.compileOptions
+    });
+  }
+  await copyArtifacts(srcPath, outputPath);
+}
+var command2 = new extraTypings.Command();
+command2.name("build").description("build Initia program").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("-sb, --skip-build", "skip build").default(false)).action(async (options, cmd) => {
+  const context = cmd.getOptionValue("__CONTEXT__");
+  const { skipBuild, modules, network, variant } = options;
+  for (const module of modules) {
+    await build(module, context, network, skipBuild, variant ?? context.modules[module]?.variant);
+  }
+});
+
+// src/cli.ts
+var program = new extraTypings.Command();
+var logger = lzUtilities.getLogger();
+program.name("lz-initia-cli").description("Wrapper of Initia cli").version("0.1.0").action((_, command3) => {
+  logger.info("Please specify a subcommand");
+  command3.help();
+});
+async function checkIfInitiaInstalled() {
+  try {
+    await core.$`initiad version`;
+  } catch (e) {
+    throw new Error("Initia cli is not installed");
+  }
+}
+function checkIfInitiaConfigExists() {
+  const packagePath = findUp.sync("package.json", { cwd: process2__default.default.cwd() });
+  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)) {
+    throw new Error("lz-initia.config.ts not found, please create one in the same directory as package.json");
+  }
+  return configPath;
+}
+async function main() {
+  await checkIfInitiaInstalled();
+  const configPath = checkIfInitiaConfigExists();
+  const config = loadConfig(configPath);
+  Object.values(subCommands_exports).forEach((subCommand) => {
+    subCommand.setOptionValue("__CONTEXT__", config);
+    program.addCommand(subCommand);
+  });
+  await program.parseAsync();
+}
+main().then(() => process2__default.default.exit(process2__default.default.exitCode)).catch((error) => {
+  logger.error(error);
+  process2__default.default.exit(1);
+});
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=cli.cjs.map