@twin.org/move-to-json 0.0.2-next.6 → 0.0.2-next.8

package/dist/cjs/index.cjs

@@ -67,33 +67,31 @@ function buildCommandBuild(program) {
         .command("build")
         .description(core.I18n.formatMessage("commands.build.description"))
         .argument("<inputGlob>", core.I18n.formatMessage("commands.build.options.inputGlob.description"))
-        .option(core.I18n.formatMessage("commands.build.options.network.param"), core.I18n.formatMessage("commands.build.options.network.description"))
+        .option(core.I18n.formatMessage("commands.build.options.network.param"), core.I18n.formatMessage("commands.build.options.network.description"), "!NETWORK")
         .option(core.I18n.formatMessage("commands.build.options.output.param"), core.I18n.formatMessage("commands.build.options.output.description"), "smart-contract-deployments.json")
-        .action(async (inputGlob, opts) => {
-        await actionCommandBuild(inputGlob, opts);
-    });
+        .action(actionCommandBuild);
 }
 /**
  * Action for the build command.
  * @param inputGlob A glob pattern that matches one or more Move files
  * @param opts Additional options.
- * @param opts.network Target network (testnet/devnet/mainnet) - optional if NETWORK env var is set.
+ * @param opts.network Target network (testnet/devnet/mainnet).
  * @param opts.output Where we store the final compiled modules.
  */
 async function actionCommandBuild(inputGlob, opts) {
     try {
-        const network = opts.network ?? process.env.NETWORK;
+        const networkRaw = cliCore.CLIParam.stringValue("network", opts.network);
+        const network = networkRaw;
         core.Guards.arrayOneOf("commands", "network", network, Object.values(dltIota.NetworkTypes));
         // Verify the IOTA SDK before we do anything else
         await verifyIotaSDK();
         const { normalizedGlob, normalizedOutput, executionDir } = normalizePathsAndWorkingDir(inputGlob, opts.output ?? "smart-contract-deployments.json");
         cliCore.CLIDisplay.section(core.I18n.formatMessage("commands.build.section.buildingMoveContracts", {
-            network: network.toUpperCase()
+            network
         }));
         cliCore.CLIDisplay.value(core.I18n.formatMessage("commands.build.labels.inputGlob"), inputGlob);
         cliCore.CLIDisplay.value(core.I18n.formatMessage("commands.build.labels.outputJson"), normalizedOutput);
         cliCore.CLIDisplay.value(core.I18n.formatMessage("commands.build.labels.network"), network);
-        cliCore.CLIDisplay.value(core.I18n.formatMessage("commands.build.labels.platform"), "iota");
         cliCore.CLIDisplay.break();
         // Find matching .move files
         cliCore.CLIDisplay.task(core.I18n.formatMessage("commands.build.progress.searchingFiles"));
@@ -121,7 +119,6 @@ async function actionCommandBuild(inputGlob, opts) {
         }
         const existingJson = await cliCore.CLIUtils.readJsonFile(normalizedOutput);
         const finalJson = existingJson ?? {};
-        finalJson[network] ??= {};
         if (existingJson) {
             cliCore.CLIDisplay.value(core.I18n.formatMessage("commands.build.labels.mergingWithExistingJson"), normalizedOutput);
         }
@@ -134,10 +131,16 @@ async function actionCommandBuild(inputGlob, opts) {
             try {
                 const compiled = await processMoveFile(moveFile);
                 if (compiled) {
-                    const { contractName, packageId, packageData } = compiled;
-                    const targetNetworkData = finalJson[network];
-                    targetNetworkData.packageId = packageId;
-                    targetNetworkData.packageBytecode = packageData;
+                    const { contractName, packageId, packageBytecode } = compiled;
+                    // Capture the last package id before overwriting it
+                    const lastPackageId = finalJson[network]?.packageId;
+                    finalJson[network] ??= { packageId, packageBytecode };
+                    // If the last package id is different we need to clear
+                    // the deployed package id, otherwise calling deploy will
+                    // not do anything as it thinks the package is already deployed.
+                    if (lastPackageId !== packageId) {
+                        delete finalJson[network].deployedPackageId;
+                    }
                     cliCore.CLIDisplay.value(core.I18n.formatMessage("commands.build.labels.updatedNetworkPackage", { network }), contractName, 2);
                 }
             }
@@ -153,12 +156,13 @@ async function actionCommandBuild(inputGlob, opts) {
     }
     catch (err) {
         cliCore.CLIDisplay.error(err);
+        throw err;
     }
 }
 /**
  * Process a single Move file by compiling it, computing the packageId, and base64-encoding the .mv modules.
  * @param moveFile The path to a single Move source file.
- * @returns The compiled results or null if no modules found.
+ * @returns The compiled results or undefined if no modules found.
  */
 async function processMoveFile(moveFile) {
     // The contract name is based on the .move file's base name in kebab-case
@@ -167,7 +171,6 @@ async function processMoveFile(moveFile) {
     // Find the "project root" (the directory containing Move.toml).
     const projectRoot = getProjectRoot(moveFile);
     cliCore.CLIDisplay.value(core.I18n.formatMessage("commands.build.labels.contractName"), contractName, 1);
-    cliCore.CLIDisplay.value(core.I18n.formatMessage("commands.build.labels.platform"), "iota", 1);
     // Compile the contract
     try {
         const cliArgs = ["move", "build"];
@@ -177,7 +180,7 @@ async function processMoveFile(moveFile) {
         cliCore.CLIDisplay.value(core.I18n.formatMessage("commands.build.labels.compileResult"), core.I18n.formatMessage("commands.build.labels.buildCompleted"), 1);
     }
     catch (error) {
-        throw new core.GeneralError("commands", "commands.build.buildFailed", { platform: "iota", file: moveFile }, error);
+        throw new core.GeneralError("commands", "commands.build.buildFailed", { file: moveFile }, error);
     }
     // Get the bytecode modules
     const buildFolderName = core.StringHelper.snakeCase(baseName);
@@ -187,13 +190,13 @@ async function processMoveFile(moveFile) {
     }
     catch {
         cliCore.CLIDisplay.value(core.I18n.formatMessage("commands.build.warnings.noBytecodeModulesFolder", { contractName }), "", 2);
-        return null;
+        return;
     }
     const moduleFiles = await node_fs.promises.readdir(bytecodeModulesPath);
     const mvFiles = moduleFiles.filter(f => f.endsWith(".mv"));
     if (mvFiles.length === 0) {
         cliCore.CLIDisplay.value(core.I18n.formatMessage("commands.build.warnings.noMvFilesFound", { contractName }), "", 2);
-        return null;
+        return;
     }
     // Compute the package ID
     const modulesBytesForHash = [];
@@ -213,7 +216,7 @@ async function processMoveFile(moveFile) {
     return {
         contractName,
         packageId: computedPackageId,
-        packageData
+        packageBytecode: packageData
     };
 }
 /**
@@ -242,66 +245,267 @@ function normalizePathsAndWorkingDir(inputGlob, outputJson) {
     };
 }
 
+// Copyright 2024 IOTA Stiftung.
+// SPDX-License-Identifier: Apache-2.0.
+/**
+ * Executes a command with a timeout.
+ * @param command The command to execute.
+ * @param timeoutMs The timeout in milliseconds.
+ * @returns The stdout and stderr of the command
+ */
+async function execAsyncWithTimeout(command, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const timeoutId = setTimeout(() => {
+            reject(new core.GeneralError("environmentUtils", "error.environmentUtils.commandTimeout", {
+                command,
+                timeout: timeoutMs
+            }));
+        }, timeoutMs);
+        node_child_process.exec(command, { timeout: timeoutMs }, (error, stdout, stderr) => {
+            clearTimeout(timeoutId);
+            if (error) {
+                reject(error);
+            }
+            else {
+                resolve({ stdout, stderr });
+            }
+        });
+    });
+}
+/**
+ * Execute a command with input.
+ * @param command The command to execute.
+ * @param inputs The inputs to provide to the command.
+ * @returns A promise that resolves when the command completes.
+ */
+async function execWithInput(command, inputs) {
+    const child = node_child_process.spawn(command, { shell: true, stdio: ["pipe", "inherit", "inherit"] });
+    for (const input of inputs) {
+        await new Promise(resolve => setTimeout(resolve, 500));
+        child.stdin.write(`${input}\n`);
+    }
+    child.stdin.end();
+    return new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+            child.kill("SIGTERM");
+            reject(new core.GeneralError("environmentUtils", "error.environmentUtils.commandTimeout", {
+                command,
+                inputs,
+                timeout: 5000
+            }));
+        }, 5000);
+        child.on("close", code => {
+            clearTimeout(timeout);
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new core.GeneralError("environmentUtils", "error.environmentUtils.commandFailedWithCode", {
+                    command,
+                    inputs,
+                    code
+                }));
+            }
+        });
+        child.on("error", error => {
+            clearTimeout(timeout);
+            reject(new core.GeneralError("environmentUtils", "error.environmentUtils.commandExecutionFailed", {
+                command,
+                inputs,
+                error
+            }));
+        });
+    });
+}
+/**
+ * Verify that IOTA CLI is installed and available.
+ * @throws GeneralError if IOTA CLI is not installed or version check fails.
+ */
+async function verifyIotaCliInstalled() {
+    try {
+        await execAsyncWithTimeout("iota --version", 5000);
+    }
+    catch (error) {
+        if (error.code === 127 ||
+            error.code === "ENOENT") {
+            throw new core.GeneralError("environmentUtils", "error.environmentUtils.iotaCliNotFound", undefined, error);
+        }
+        throw new core.GeneralError("environmentUtils", "error.environmentUtils.iotaCliVerificationFailed", undefined, error);
+    }
+}
+/**
+ * Check if a specific IOTA environment exists.
+ * @param network The network alias to check for.
+ * @returns Promise<boolean> True if environment exists, false otherwise.
+ */
+async function checkEnvironmentExists(network) {
+    try {
+        const { stdout } = await execAsyncWithTimeout("iota client envs --json", 5000);
+        const envData = JSON.parse(stdout);
+        // The IOTA CLI returns [environments[], currentEnv] format
+        const environments = core.Is.arrayValue(envData) ? envData[0] : envData;
+        if (core.Is.arrayValue(environments)) {
+            return environments.some(env => env.alias === network);
+        }
+        return false;
+    }
+    catch {
+        // Silently return false if environment check fails - let calling code handle messaging
+        return false;
+    }
+}
+/**
+ * Create a new IOTA environment.
+ * @param network The network alias to create.
+ * @param rpcUrl The RPC URL for the network.
+ * @returns Promise<void>
+ */
+async function createEnvironment(network, rpcUrl) {
+    const isWindows = process.platform === "win32";
+    try {
+        const additionalInfo = isWindows ? "" : " || true";
+        await execWithInput(`iota client new-env --alias ${network} --rpc ${rpcUrl}${additionalInfo}`, [
+            "0"
+        ]);
+        await execAsyncWithTimeout(`iota client switch --env ${network}${additionalInfo}`, 5000);
+    }
+    catch (error) {
+        throw new core.GeneralError("environmentUtils", "environmentCreationFailed", { network, rpcUrl }, error);
+    }
+}
+/**
+ * Create default IOTA environments when none exist.
+ * @returns Promise<void>
+ */
+async function createDefaultEnvironments() {
+    const defaultEnvironments = [
+        { alias: "mainnet", rpc: "https://api.mainnet.iota.cafe" },
+        { alias: "devnet", rpc: "https://api.devnet.iota.cafe" },
+        { alias: "testnet", rpc: "https://api.testnet.iota.cafe" },
+        { alias: "localnet", rpc: "http://127.0.0.1:9000" }
+    ];
+    cliCore.CLIDisplay.value(core.I18n.formatMessage("info.environmentUtils.creatingDefaultEnvironments"), `${defaultEnvironments.length} environments`, 1);
+    for (const env of defaultEnvironments) {
+        try {
+            await createEnvironment(env.alias, env.rpc);
+            cliCore.CLIDisplay.value(core.I18n.formatMessage("info.environmentUtils.createdEnvironment"), env.alias, 2);
+        }
+        catch {
+            // Continue creating other environments even if one fails
+        }
+    }
+    // Set testnet as active by default
+    const isWindows = process.platform === "win32";
+    const additionalInfo = isWindows ? "" : " || true";
+    try {
+        await execAsyncWithTimeout(`iota client switch --env testnet${additionalInfo}`, 5000);
+        cliCore.CLIDisplay.value(core.I18n.formatMessage("info.environmentUtils.activeEnvironment"), "testnet", 1);
+    }
+    catch {
+        // Ignore switch failures - testnet might not exist yet
+    }
+}
+/**
+ * Check if any IOTA environments exist by attempting to list them.
+ * If the command times out, it likely means no environments are configured.
+ * @returns Promise<boolean> True if any environments exist, false otherwise.
+ */
+async function checkAnyEnvironmentsExist() {
+    try {
+        const { stdout } = await execAsyncWithTimeout("iota client envs --json", 5000);
+        const envData = JSON.parse(stdout);
+        const environments = core.Is.arrayValue(envData) ? envData[0] : envData;
+        return core.Is.arrayValue(environments);
+    }
+    catch {
+        // Timeout or error likely means no environments exist
+        return false;
+    }
+}
+/**
+ * Ensure that a specific IOTA environment exists, creating it if necessary.
+ * If no environments exist at all, creates default environments first.
+ * @param network The network alias to ensure exists.
+ * @param rpcUrl The RPC URL for the network.
+ * @returns Promise<void>
+ */
+async function ensureEnvironment(network, rpcUrl) {
+    // First verify IOTA CLI is installed
+    await verifyIotaCliInstalled();
+    // Check if any environments exist at all
+    const anyEnvironmentsExist = await checkAnyEnvironmentsExist();
+    if (!anyEnvironmentsExist) {
+        // No environments exist - create defaults
+        cliCore.CLIDisplay.value(core.I18n.formatMessage("info.environmentUtils.noEnvironments"), core.I18n.formatMessage("info.environmentUtils.creatingDefaults"), 1);
+        await createDefaultEnvironments();
+    }
+    // Now check if the specific environment exists
+    const exists = await checkEnvironmentExists(network);
+    if (!exists) {
+        // Use CLI framework for user-facing message
+        cliCore.CLIDisplay.value(core.I18n.formatMessage("info.environmentUtils.creatingEnvironment"), network, 1);
+        await createEnvironment(network, rpcUrl);
+    }
+    else {
+        // Switch to the environment to make sure it's active
+        const isWindows = process.platform === "win32";
+        const additionalInfo = isWindows ? "" : " || true";
+        await execAsyncWithTimeout(`iota client switch --env ${network}${additionalInfo}`, 5000);
+    }
+}
+
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
 /**
  * Validate that required environment variables are set for deployment.
  * @param network The target network.
+ * @param deployerMnemonic The deployer mnemonic to validate.
  * @throws GeneralError if required environment variables are missing.
  */
-async function validateDeploymentEnvironment(network) {
-    await getDeploymentMnemonic(network);
+async function validateDeploymentEnvironment(network, deployerMnemonic) {
+    await getDeploymentMnemonic(network, deployerMnemonic);
 }
 /**
  * Get the deployment mnemonic for a network.
  * @param network The target network.
+ * @param deployerMnemonic The deployer mnemonic from environment variables.
  * @returns The mnemonic string.
  * @throws GeneralError if mnemonic is not found or invalid.
  */
-async function getDeploymentMnemonic(network) {
-    const mnemonic = process.env.DEPLOYER_MNEMONIC;
-    if (!mnemonic) {
+async function getDeploymentMnemonic(network, deployerMnemonic) {
+    if (!core.Is.stringValue(deployerMnemonic)) {
         throw new core.GeneralError("envSetup", "mnemonicMissing", {
             network,
             mnemonicVar: "DEPLOYER_MNEMONIC"
         });
     }
-    // Validate mnemonic format (should be 24 words)
-    const words = mnemonic.trim().split(/\s+/);
-    if (words.length !== 24) {
+    // Validate mnemonic format using Bip39 validation
+    if (!crypto.Bip39.validateMnemonic(deployerMnemonic)) {
         throw new core.GeneralError("envSetup", "mnemonicInvalidFormat", {
             network,
-            mnemonicVar: "DEPLOYER_MNEMONIC",
-            wordCount: words.length
+            mnemonicVar: "DEPLOYER_MNEMONIC"
         });
     }
-    return mnemonic;
+    return deployerMnemonic;
 }
 /**
  * Get the deployment seed for a network (if available).
  * @param network The target network.
+ * @param deployerSeed The deployer seed from environment variables (optional).
  * @returns The seed string or undefined if not set.
  * @throws GeneralError if seed is not found or invalid.
  */
-async function getDeploymentSeed(network) {
-    const seed = process.env.DEPLOYER_SEED;
-    if (!core.Is.stringValue(seed)) {
+async function getDeploymentSeed(network, deployerSeed) {
+    if (!core.Is.stringValue(deployerSeed)) {
         return undefined;
     }
-    if (!core.Is.stringHex(seed, true)) {
+    if (!core.Is.stringHexLength(deployerSeed, 64, true)) {
         throw new core.GeneralError("envSetup", "seedInvalidFormat", {
             network,
             seedVar: "DEPLOYER_SEED"
         });
     }
-    if (seed.length < 66) {
-        // 0x + 64 hex characters
-        throw new core.GeneralError("envSetup", "seedInvalidFormat", {
-            network,
-            seedVar: "DEPLOYER_SEED"
-        });
-    }
-    return seed;
+    return deployerSeed;
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -316,40 +520,134 @@ function buildCommandDeploy(program) {
         .command("deploy")
         .description(core.I18n.formatMessage("commands.deploy.description"))
         .option(core.I18n.formatMessage("commands.deploy.options.contracts.param"), core.I18n.formatMessage("commands.deploy.options.contracts.description"), "smart-contract-deployments.json")
-        .option(core.I18n.formatMessage("commands.deploy.options.network.param"), core.I18n.formatMessage("commands.deploy.options.network.description"))
+        .option(core.I18n.formatMessage("commands.deploy.options.network.param"), core.I18n.formatMessage("commands.deploy.options.network.description"), "!NETWORK")
         .option(core.I18n.formatMessage("commands.deploy.options.dryRun.param"), core.I18n.formatMessage("commands.deploy.options.dryRun.description"))
         .option(core.I18n.formatMessage("commands.deploy.options.force.param"), core.I18n.formatMessage("commands.deploy.options.force.description"))
+        .option(core.I18n.formatMessage("commands.deploy.options.rpcUrl.param"), core.I18n.formatMessage("commands.deploy.options.rpcUrl.description"), "!RPC_URL")
+        .option(core.I18n.formatMessage("commands.deploy.options.addressIndex.param"), core.I18n.formatMessage("commands.deploy.options.addressIndex.description"), "!ADDRESS_INDEX")
+        .option(core.I18n.formatMessage("commands.deploy.options.rpcTimeout.param"), core.I18n.formatMessage("commands.deploy.options.rpcTimeout.description"), "!RPC_TIMEOUT")
+        .option(core.I18n.formatMessage("commands.deploy.options.gasBudget.param"), core.I18n.formatMessage("commands.deploy.options.gasBudget.description"), "!GAS_BUDGET")
+        .option(core.I18n.formatMessage("commands.deploy.options.confirmationTimeout.param"), core.I18n.formatMessage("commands.deploy.options.confirmationTimeout.description"), "!CONFIRMATION_TIMEOUT")
+        .option(core.I18n.formatMessage("commands.deploy.options.faucetUrl.param"), core.I18n.formatMessage("commands.deploy.options.faucetUrl.description"), "!FAUCET_URL")
+        .option(core.I18n.formatMessage("commands.deploy.options.deployerMnemonic.param"), core.I18n.formatMessage("commands.deploy.options.deployerMnemonic.description"), "!DEPLOYER_MNEMONIC")
+        .option(core.I18n.formatMessage("commands.deploy.options.deployerSeed.param"), core.I18n.formatMessage("commands.deploy.options.deployerSeed.description"), "!DEPLOYER_SEED")
         .action(actionCommandDeploy);
 }
+/**
+ * Action for the deploy command.
+ * @param opts Command options.
+ * @param opts.contracts Path to compiled modules JSON.
+ * @param opts.network Network identifier - optional if NETWORK env var is set.
+ * @param opts.dryRun Simulate deployment without executing.
+ * @param opts.force Force redeployment of existing packages.
+ * @param opts.rpcUrl RPC endpoint URL for the network.
+ * @param opts.addressIndex Address index for key derivation.
+ * @param opts.rpcTimeout RPC request timeout in milliseconds.
+ * @param opts.gasBudget Gas budget for transactions.
+ * @param opts.confirmationTimeout Transaction confirmation timeout in milliseconds.
+ * @param opts.faucetUrl Faucet URL for requesting test tokens.
+ * @param opts.deployerMnemonic Deployer wallet mnemonic phrase.
+ * @param opts.deployerSeed Deployer wallet seed (alternative to mnemonic).
+ */
+async function actionCommandDeploy(opts) {
+    try {
+        const contractsPath = opts.contracts ?? "smart-contract-deployments.json";
+        const dryRun = opts.dryRun ?? false;
+        const force = opts.force ?? false;
+        cliCore.CLIDisplay.section(core.I18n.formatMessage("commands.deploy.section.deployContracts"));
+        cliCore.CLIDisplay.section(contractsPath);
+        const networkRaw = cliCore.CLIParam.stringValue("network", opts.network);
+        const network = networkRaw;
+        core.Guards.arrayOneOf("commands", "network", network, Object.values(dltIota.NetworkTypes));
+        // Verify the IOTA SDK before we do anything else
+        await verifyIotaSDK();
+        // Get configuration values needed for environment setup
+        const rpcUrl = cliCore.CLIParam.stringValue("rpcUrl", opts.rpcUrl);
+        const addressIndex = cliCore.CLIParam.number("addressIndex", opts.addressIndex) ?? 0;
+        const rpcTimeout = cliCore.CLIParam.number("rpcTimeout", opts.rpcTimeout);
+        const gasBudget = cliCore.CLIParam.number("gasBudget", opts.gasBudget);
+        const confirmationTimeout = cliCore.CLIParam.number("confirmationTimeout", opts.confirmationTimeout);
+        const faucetUrl = network === dltIota.NetworkTypes.Mainnet
+            ? undefined
+            : cliCore.CLIParam.stringValue("faucetUrl", opts.faucetUrl);
+        let deployerMnemonic;
+        try {
+            deployerMnemonic = cliCore.CLIParam.stringValue("deployerMnemonic", opts.deployerMnemonic);
+        }
+        catch {
+            // Optional parameter, can be undefined
+            deployerMnemonic = undefined;
+        }
+        let deployerSeed;
+        try {
+            deployerSeed = cliCore.CLIParam.stringValue("deployerSeed", opts.deployerSeed);
+        }
+        catch {
+            // Optional parameter, can be undefined
+            deployerSeed = undefined;
+        }
+        // Validate that at least one deployer credential is provided
+        const hasValidMnemonic = core.Is.stringValue(deployerMnemonic);
+        const hasValidSeed = core.Is.stringValue(deployerSeed);
+        if (!hasValidMnemonic && !hasValidSeed) {
+            throw new core.GeneralError("commands", "commands.deploy.deployerCredentialRequired", {
+                network
+            });
+        }
+        // Check/switch to target network environment BEFORE loading config
+        await setIotaEnvironment(network, rpcUrl, addressIndex, dryRun, deployerMnemonic, deployerSeed);
+        const config = await createNetworkConfig(network, rpcUrl, addressIndex, rpcTimeout, gasBudget, confirmationTimeout);
+        validateNetworkConfig(config, network);
+        const contractsData = await loadCompiledContracts(contractsPath);
+        if (network === dltIota.NetworkTypes.Mainnet) {
+            const validatedMnemonic = await getDeploymentMnemonic(network, hasValidMnemonic ? deployerMnemonic : undefined);
+            await validateDeploymentEnvironment(network, validatedMnemonic);
+        }
+        const networkContracts = contractsData[network];
+        if (!core.Is.object(networkContracts)) {
+            throw new core.GeneralError("commands", "commands.deploy.noContractsFound", {
+                network,
+                contractsPath
+            });
+        }
+        await deployContract("contract", networkContracts, config, network, dryRun, force, faucetUrl, deployerMnemonic, deployerSeed);
+        if (!dryRun) {
+            await updateContractsFile(contractsPath, contractsData);
+        }
+        cliCore.CLIDisplay.done();
+    }
+    catch (err) {
+        cliCore.CLIDisplay.error(err);
+        throw err;
+    }
+}
 /**
  * Switch IOTA CLI to the target network environment and set the active address.
  * @param network Target network to switch to
+ * @param rpcUrl The RPC URL for the network
+ * @param addressIndex The address index to derive the target address
  * @param dryRun Whether this is a dry run (checks environment but doesn't switch)
+ * @param deployerMnemonic The deployer mnemonic from environment variables.
+ * @param deployerSeed The deployer seed from environment variables (optional).
  */
-async function setIotaEnvironment(network, dryRun = false) {
+async function setIotaEnvironment(network, rpcUrl, addressIndex, dryRun = false, deployerMnemonic, deployerSeed) {
     try {
         cliCore.CLIDisplay.task(dryRun
             ? core.I18n.formatMessage("commands.deploy.progress.checkingEnvironment")
             : core.I18n.formatMessage("commands.deploy.progress.settingEnvironment"));
-        // Check if the environment exists
-        const { stdout: envListOutput } = await execAsync("iota client envs");
-        if (!envListOutput.includes(network)) {
-            throw new core.GeneralError("commands", "commands.deploy.environmentNotFound", {
-                network,
-                availableEnvironments: envListOutput,
-                setupCommand: `iota client new-env --alias ${network} --rpc <RPC_URL>`
-            });
-        }
+        // Ensure environment exists, create if necessary
+        core.Guards.stringValue("setIotaEnvironment", "rpcUrl", rpcUrl);
+        await ensureEnvironment(network, rpcUrl);
         if (dryRun) {
             cliCore.CLIDisplay.value(core.I18n.formatMessage("commands.deploy.labels.iotaEnvironmentCheck"), `✅ ${network} environment exists`, 1);
             return;
         }
         // Derive the target address from existing mnemonic/seed
-        const addressIndex = core.Coerce.number(process.env.ADDRESS_INDEX) ?? 0;
-        const targetAddress = await getDeploymentWalletAddress(network, addressIndex);
+        const targetAddress = await getDeploymentWalletAddress(network, addressIndex, deployerMnemonic, deployerSeed);
         // Ensure the correct deployer key exists in the keystore
         const aliasName = `deployer-${network}`;
-        await ensureCorrectDeployerKey(network, aliasName, targetAddress, addressIndex);
+        const validatedMnemonic = await getDeploymentMnemonic(network, deployerMnemonic);
+        await ensureCorrectDeployerKey(network, aliasName, targetAddress, addressIndex, validatedMnemonic);
         // Switch both environment and address in one command
         await execAsync(`iota client switch --env ${network} --address ${targetAddress}`);
         cliCore.CLIDisplay.value(core.I18n.formatMessage("commands.deploy.labels.switchedIotaEnvironment"), network, 1);
@@ -377,76 +675,31 @@ async function setIotaEnvironment(network, dryRun = false) {
         throw new core.GeneralError("commands", "commands.deploy.environmentOperationFailed", { network, operation: dryRun ? "check" : "switch to" }, error);
     }
 }
-/**
- * Action for the deploy command.
- * @param opts Command options.
- * @param opts.contracts Path to compiled modules JSON.
- * @param opts.network Network identifier - optional if NETWORK env var is set.
- * @param opts.dryRun Simulate deployment without executing.
- * @param opts.force Force redeployment of existing packages.
- */
-async function actionCommandDeploy(opts) {
-    cliCore.CLIDisplay.section(core.I18n.formatMessage("commands.deploy.section.deployContracts"));
-    cliCore.CLIDisplay.section(opts.contracts ?? "smart-contract-deployments.json");
-    try {
-        const contractsPath = opts.contracts ?? "smart-contract-deployments.json";
-        const dryRun = opts.dryRun ?? false;
-        const force = opts.force ?? false;
-        const network = opts.network ?? process.env.NETWORK;
-        core.Guards.arrayOneOf("commands", "network", network, Object.values(dltIota.NetworkTypes));
-        // Verify the IOTA SDK before we do anything else
-        await verifyIotaSDK();
-        // Check/switch to target network environment BEFORE loading config
-        await setIotaEnvironment(network, dryRun);
-        const config = await createNetworkConfig(network);
-        validateNetworkConfig(config, network);
-        const contractsData = await loadCompiledContracts(contractsPath);
-        if (network === dltIota.NetworkTypes.Mainnet) {
-            await validateDeploymentEnvironment(network);
-        }
-        const networkContracts = contractsData[network];
-        if (!core.Is.object(networkContracts)) {
-            throw new core.GeneralError("commands", "commands.deploy.noContractsFound", {
-                network,
-                contractsPath
-            });
-        }
-        await deployContract("contract", networkContracts, config, network, dryRun, force);
-        if (!dryRun) {
-            await updateContractsFile(contractsPath, contractsData);
-        }
-        cliCore.CLIDisplay.done();
-    }
-    catch (err) {
-        cliCore.CLIDisplay.error(err);
-        throw err;
-    }
-}
 /**
  * Creates the network configuration.
  * @param network Target network to determine which env file to load.
+ * @param rpcUrl The RPC URL for the network.
+ * @param addressIndex The address index for the wallet.
+ * @param rpcTimeout The RPC timeout in milliseconds.
+ * @param gasBudget The gas budget for deployment.
+ * @param confirmationTimeout The confirmation timeout in seconds.
  * @returns Network configuration.
  */
-async function createNetworkConfig(network) {
+async function createNetworkConfig(network, rpcUrl, addressIndex, rpcTimeout, gasBudget, confirmationTimeout) {
     try {
-        const rpcUrl = core.Coerce.string(process.env.RPC_URL);
-        if (!core.Is.stringValue(rpcUrl)) {
-            throw new core.GeneralError("commands", "commands.deploy.rpcUrlRequired", {
-                network
-            });
-        }
+        core.Guards.stringValue("createNetworkConfig", "rpcUrl", rpcUrl);
         const config = {
             network,
             platform: "iota",
             rpc: {
                 url: rpcUrl,
-                timeout: core.Coerce.number(process.env.RPC_TIMEOUT) || 60000
+                timeout: rpcTimeout ?? 60000
             },
             deployment: {
-                gasBudget: core.Coerce.number(process.env.GAS_BUDGET) || 50000000,
-                confirmationTimeout: core.Coerce.number(process.env.CONFIRMATION_TIMEOUT) || 60,
+                gasBudget: gasBudget ?? 50000000,
+                confirmationTimeout: confirmationTimeout ?? 60,
                 wallet: {
-                    addressIndex: core.Coerce.number(process.env.ADDRESS_INDEX) || 0
+                    addressIndex
                 }
             }
         };
@@ -508,10 +761,13 @@ async function loadCompiledContracts(contractsPath) {
  * @param network Target network.
  * @param config Network configuration.
  * @param isDryRun Whether this is a dry run.
+ * @param faucetUrl The faucet URL (optional, defaults to network-specific URL).
+ * @param deployerMnemonic The deployer mnemonic for validation.
+ * @param deployerSeed The deployer seed (optional).
  * @returns Wallet address for the deployment.
  */
-async function validateEnvironmentForNetwork(network, config, isDryRun = false) {
-    const walletAddress = await getDeploymentWalletAddress(network, config.deployment.wallet.addressIndex);
+async function validateEnvironmentForNetwork(network, config, isDryRun = false, faucetUrl, deployerMnemonic, deployerSeed) {
+    const walletAddress = await getDeploymentWalletAddress(network, config.deployment.wallet.addressIndex, deployerMnemonic, deployerSeed);
     if (isDryRun) {
         cliCore.CLIDisplay.value(core.I18n.formatMessage("commands.deploy.labels.dryRunWalletAddress"), walletAddress, 1);
     }
@@ -519,11 +775,12 @@ async function validateEnvironmentForNetwork(network, config, isDryRun = false)
         cliCore.CLIDisplay.value(core.I18n.formatMessage("commands.deploy.labels.walletAddress"), walletAddress, 1);
     }
     if (network === dltIota.NetworkTypes.Mainnet) {
-        await validateDeploymentEnvironment(network);
+        const validatedMnemonic = await getDeploymentMnemonic(network, deployerMnemonic);
+        await validateDeploymentEnvironment(network, validatedMnemonic);
     }
     else if ((network === dltIota.NetworkTypes.Testnet || network === dltIota.NetworkTypes.Devnet) && !isDryRun) {
         // For testnet/devnet, check balance first and only request funds if needed
-        await checkBalanceAndRequestFaucetIfNeeded(network, config, walletAddress);
+        await checkBalanceAndRequestFaucetIfNeeded(network, config, walletAddress, faucetUrl);
     }
     return walletAddress;
 }
@@ -583,13 +840,16 @@ async function checkWalletBalance(network, config, walletAddress, isDryRun = fal
  * @param contractData Contract data.
  * @param config Network configuration.
  * @param network Target network.
+ * @param faucetUrl The faucet URL (optional, defaults to network-specific URL).
+ * @param deployerMnemonic The deployer mnemonic from environment variables.
+ * @param deployerSeed The deployer seed from environment variables (optional).
  */
-async function handleDryRunValidation(contractName, contractData, config, network) {
+async function handleDryRunValidation(contractName, contractData, config, network, faucetUrl, deployerMnemonic, deployerSeed) {
     cliCore.CLIDisplay.value(core.I18n.formatMessage("commands.deploy.labels.dryRunWouldDeploy"), `${contractName} (${network})`, 1);
     cliCore.CLIDisplay.value(core.I18n.formatMessage("commands.deploy.labels.dryRunPackageId"), contractData.packageId, 1);
     cliCore.CLIDisplay.value(core.I18n.formatMessage("commands.deploy.labels.dryRunRpcUrl"), config.rpc.url, 1);
     try {
-        const walletAddress = await validateEnvironmentForNetwork(network, config, true);
+        const walletAddress = await validateEnvironmentForNetwork(network, config, true, faucetUrl, deployerMnemonic, deployerSeed);
         await checkWalletBalance(network, config, walletAddress, true);
     }
     catch (err) {
@@ -604,10 +864,13 @@ async function handleDryRunValidation(contractName, contractData, config, networ
  * @param contractData Contract data.
  * @param config Network configuration.
  * @param network Target network.
+ * @param faucetUrl The faucet URL (optional, defaults to network-specific URL).
+ * @param deployerMnemonic The deployer mnemonic from environment variables.
+ * @param deployerSeed The deployer seed from environment variables (optional).
  */
-async function handleActualDeployment(contractName, contractData, config, network) {
+async function handleActualDeployment(contractName, contractData, config, network, faucetUrl, deployerMnemonic, deployerSeed) {
     try {
-        const walletAddress = await validateEnvironmentForNetwork(network, config, false);
+        const walletAddress = await validateEnvironmentForNetwork(network, config, false, faucetUrl, deployerMnemonic, deployerSeed);
         await checkWalletBalance(network, config, walletAddress, false);
         const deploymentResult = await deployWithIotaCli(config.deployment.gasBudget);
         contractData.deployedPackageId = deploymentResult.packageId;
@@ -638,34 +901,39 @@ async function handleActualDeployment(contractName, contractData, config, networ
  * @param network Target network
  * @param dryRun Whether this is a dry run
  * @param force Whether to force redeployment
+ * @param faucetUrl The faucet URL (optional, defaults to network-specific URL).
+ * @param deployerMnemonic The deployer mnemonic from environment variables.
+ * @param deployerSeed The deployer seed from environment variables (optional).
  */
-async function deployContract(contractName, contractData, config, network, dryRun, force) {
+async function deployContract(contractName, contractData, config, network, dryRun, force, faucetUrl, deployerMnemonic, deployerSeed) {
     cliCore.CLIDisplay.task(core.I18n.formatMessage("commands.deploy.progress.deployingContract", { contractName, network }));
     if (core.Is.stringValue(contractData.deployedPackageId) && !force) {
         cliCore.CLIDisplay.value(core.I18n.formatMessage("commands.deploy.labels.contractAlreadyDeployed"), contractData.deployedPackageId, 1);
         return;
     }
     if (dryRun) {
-        await handleDryRunValidation(contractName, contractData, config, network);
+        await handleDryRunValidation(contractName, contractData, config, network, faucetUrl, deployerMnemonic, deployerSeed);
         return;
     }
-    await handleActualDeployment(contractName, contractData, config, network);
+    await handleActualDeployment(contractName, contractData, config, network, faucetUrl, deployerMnemonic, deployerSeed);
 }
 /**
  * Get wallet address for deployment, preferring seed over mnemonic if available.
  * @param network The target network.
  * @param addressIndex The address index to derive.
+ * @param deployerMnemonic The deployer mnemonic from environment variables.
+ * @param deployerSeed The deployer seed from environment variables (optional).
  * @returns The wallet address.
  */
-async function getDeploymentWalletAddress(network, addressIndex) {
+async function getDeploymentWalletAddress(network, addressIndex, deployerMnemonic, deployerSeed) {
     // Try to use seed first if available
-    const hexSeed = await getDeploymentSeed(network);
+    const hexSeed = await getDeploymentSeed(network, deployerSeed);
     let seed;
     if (core.Is.stringValue(hexSeed)) {
         seed = core.Converter.hexToBytes(hexSeed);
     }
     else {
-        const mnemonic = await getDeploymentMnemonic(network);
+        const mnemonic = await getDeploymentMnemonic(network, deployerMnemonic);
         seed = crypto.Bip39.mnemonicToSeed(mnemonic);
     }
     const addresses = dltIota.Iota.getAddresses(seed, dltIota.Iota.DEFAULT_COIN_TYPE, 0, addressIndex, 1, false);
@@ -683,14 +951,12 @@ function nanosToIota(nanos) {
  * Request funds from the faucet for testnet or devnet deployment.
  * @param network The target network (testnet or devnet).
  * @param walletAddress The wallet address to fund.
+ * @param rpcUrl The RPC URL for the network.
+ * @param faucetUrl The faucet URL (optional, defaults to network-specific URL).
  * @returns Promise that resolves when funding is complete.
  */
-async function requestFaucetFunds(network, walletAddress) {
-    if (network !== dltIota.NetworkTypes.Testnet && network !== dltIota.NetworkTypes.Devnet) {
-        return;
-    }
+async function requestFaucetFunds(network, walletAddress, rpcUrl, faucetUrl) {
     cliCore.CLIDisplay.task(core.I18n.formatMessage("commands.deploy.progress.requestingFaucetFunds", { network }));
-    const faucetUrl = process.env.FAUCET_URL ?? `https://faucet.${network}.iota.cafe`;
     const response = await faucet.requestIotaFromFaucetV0({
         host: faucetUrl,
         recipient: walletAddress
@@ -698,7 +964,7 @@ async function requestFaucetFunds(network, walletAddress) {
     if (response?.error) {
         throw new core.GeneralError("commands", "commands.deploy.fundingFailed", undefined, response.error);
     }
-    const client$1 = new client.IotaClient({ url: process.env.RPC_URL ?? "" });
+    const client$1 = new client.IotaClient({ url: rpcUrl });
     const balanceResponse = await client$1.getBalance({ owner: walletAddress });
     const balanceInNanos = Number(balanceResponse.totalBalance);
     if (balanceInNanos > 0) {
@@ -714,12 +980,10 @@ async function requestFaucetFunds(network, walletAddress) {
  * @param network The target network (testnet or devnet).
  * @param config Network configuration.
  * @param walletAddress The wallet address to check and potentially fund.
+ * @param faucetUrl The faucet URL (optional, defaults to network-specific URL).
  * @returns Promise that resolves when balance check and optional funding is complete.
  */
-async function checkBalanceAndRequestFaucetIfNeeded(network, config, walletAddress) {
-    if (network !== dltIota.NetworkTypes.Testnet && network !== dltIota.NetworkTypes.Devnet) {
-        return;
-    }
+async function checkBalanceAndRequestFaucetIfNeeded(network, config, walletAddress, faucetUrl) {
     // Check current balance
     const client$1 = new client.IotaClient({ url: config.rpc.url });
     const balanceResponse = await client$1.getBalance({ owner: walletAddress });
@@ -736,8 +1000,11 @@ async function checkBalanceAndRequestFaucetIfNeeded(network, config, walletAddre
             currentBalance: balanceInIota.toFixed(2),
             requiredBalance: requiredInIota.toFixed(2)
         }), 1);
+        if (!core.Is.stringValue(faucetUrl)) {
+            throw new core.GeneralError("commands", "error.commands.deploy.noFaucetConfigured");
+        }
         cliCore.CLIDisplay.task(core.I18n.formatMessage("commands.deploy.progress.requestingAdditionalFaucetFunds"));
-        await requestFaucetFunds(network, walletAddress);
+        await requestFaucetFunds(network, walletAddress, config.rpc.url, faucetUrl);
         // Check balance again after faucet request
         const updatedBalanceResponse = await client$1.getBalance({ owner: walletAddress });
         const updatedBalanceInNanos = Number(updatedBalanceResponse.totalBalance);
@@ -829,8 +1096,9 @@ function generateUniqueBackupAlias(baseAlias, existingKeys) {
  * @param aliasName The desired alias name (e.g., "deployer-testnet").
  * @param expectedAddress The expected address from the current mnemonic.
  * @param addressIndex The address index to use.
+ * @param deployerMnemonic The deployer mnemonic.
  */
-async function ensureCorrectDeployerKey(network, aliasName, expectedAddress, addressIndex) {
+async function ensureCorrectDeployerKey(network, aliasName, expectedAddress, addressIndex, deployerMnemonic) {
     try {
         // Check if the alias already exists in keystore
         const { stdout: keysListOutput } = await execAsync("iota keytool list --json");
@@ -847,7 +1115,7 @@ async function ensureCorrectDeployerKey(network, aliasName, expectedAddress, add
                 await execAsync(`iota keytool update-alias "${aliasName}" "${backupAlias}"`);
                 cliCore.CLIDisplay.value(core.I18n.formatMessage("commands.deploy.labels.renamedExistingKey"), `${aliasName} → ${backupAlias} (${existingAddress})`, 1);
                 // Now import the correct key with the desired alias
-                await importCorrectDeployerKey(network, aliasName, addressIndex, expectedAddress);
+                await importCorrectDeployerKey(network, aliasName, addressIndex, expectedAddress, deployerMnemonic);
             }
             else {
                 // Existing key is correct - no action needed
@@ -856,7 +1124,7 @@ async function ensureCorrectDeployerKey(network, aliasName, expectedAddress, add
         }
         else {
             // No existing alias - import the key
-            await importCorrectDeployerKey(network, aliasName, addressIndex, expectedAddress);
+            await importCorrectDeployerKey(network, aliasName, addressIndex, expectedAddress, deployerMnemonic);
         }
         // Verify the address exists in client addresses
         const { stdout: addressListOutput } = await execAsync("iota client addresses --json");
@@ -879,10 +1147,11 @@ async function ensureCorrectDeployerKey(network, aliasName, expectedAddress, add
  * @param aliasName The alias name to use.
  * @param addressIndex The address index.
  * @param targetAddress The expected target address (avoids redundant calculation).
+ * @param deployerMnemonic The deployer mnemonic.
  */
-async function importCorrectDeployerKey(network, aliasName, addressIndex, targetAddress) {
+async function importCorrectDeployerKey(network, aliasName, addressIndex, targetAddress, deployerMnemonic) {
     cliCore.CLIDisplay.task(core.I18n.formatMessage("commands.deploy.progress.importingDeployerKey", { aliasName }));
-    const mnemonic = await getDeploymentMnemonic(network);
+    const mnemonic = await getDeploymentMnemonic(network, deployerMnemonic);
     const derivationPath = crypto.Bip44.path(dltIota.Iota.DEFAULT_COIN_TYPE, 0, false, addressIndex).toString();
     await execAsync(`iota keytool import "${mnemonic}" ed25519 "${derivationPath}" --alias "${aliasName}"`);
     cliCore.CLIDisplay.value(core.I18n.formatMessage("commands.deploy.labels.importedDeployerKey"), `${aliasName} (${targetAddress})`, 1);
@@ -906,7 +1175,7 @@ class CLI extends cliCore.CLIBase {
         return this.execute({
             title: "TWIN Move to JSON",
             appName: "move-to-json",
-            version: "0.0.2-next.6", // x-release-please-version
+            version: "0.0.2-next.8", // x-release-please-version
             icon: "⚙️ ",
             supportsEnvFiles: true,
             overrideOutputWidth: options?.overrideOutputWidth