diff --git a/manifest/channel-manifest.json b/manifest/channel-manifest.json index 8f03d983..16e40975 100644 --- a/manifest/channel-manifest.json +++ b/manifest/channel-manifest.json @@ -33,13 +33,13 @@ "revision": "83df2aa115b2617e211d1d929a1189ffabbd137b", "installed_executable": "miden-client", "aliases": { - "account": ["executable", "new-account"], - "deploy": ["executable", "-s", "public", "--account-type", "regular-account-immutable-code"], - "faucet": ["executable", "mint"], - "new-wallet": ["executable", "new-wallet", "--deploy"], - "call": ["executable", "call", "--show"], - "send": ["executable", "send"], - "simulate": ["executable", "exec"] + "account": [["executable", "client", "new-account"]], + "deploy": [["executable", "client", "-s", "public", "--account-type", "regular-account-immutable-code"]], + "faucet": [["executable", "client", "mint"]], + "new-wallet": [["executable", "client", "new-wallet", "--deploy"]], + "call": [["executable", "client", "call", "--show"]], + "send": [["executable", "client", "send"]], + "simulate": [["executable", "client", "exec"]] } }, { @@ -54,8 +54,8 @@ "version": "0.1.0", "rustup_channel": "nightly-2025-03-20", "aliases": { - "new": ["cargo", "miden", "new"], - "build": ["cargo", "miden", "build"] + "new": [["cargo", "miden", "new"]], + "build": [["cargo", "miden", "build"]] }, "symlink_name": "cargo-miden" }, @@ -65,7 +65,7 @@ "installed_executable": "miden-node", "version": "0.10.1", "aliases": { - "start-node": ["executable", "bundled", "start", "--data-directory", "data", "--rpc.url", "http://0.0.0.0:57291"] + "start-node": [["executable", "node", "bundled", "start", "--data-directory", "data", "--rpc.url", "http://0.0.0.0:57291"]] } } ] @@ -100,13 +100,13 @@ "version": "0.10.2", "installed_executable": "miden-client", "aliases": { - "account": ["executable", "new-account"], - "deploy": ["executable", "-s", "public", "--account-type", "regular-account-immutable-code"], - "faucet": ["executable", "mint"], - "new-wallet": ["executable", "new-wallet", "--deploy"], - "call": ["executable", "call", "--show"], - "send": ["executable", "send"], - "simulate": ["executable", "exec"] + "account": [["executable", "client", "new-account"]], + "deploy": [["executable", "client", "-s", "public", "--account-type", "regular-account-immutable-code"]], + "faucet": [["executable", "client", "mint"]], + "new-wallet": [["executable", "client", "new-wallet", "--deploy"]], + "call": [["executable", "client", "call", "--show"]], + "send": [["executable", "client", "send"]], + "simulate": [["executable", "client", "exec"]] } }, { @@ -121,8 +121,8 @@ "version": "0.1.0", "rustup_channel": "nightly-2025-03-20", "aliases": { - "new": ["cargo", "miden", "new"], - "build": ["cargo", "miden", "build"] + "new": [["cargo", "miden", "new"]], + "build": [["cargo", "miden", "build"]] }, "symlink_name": "cargo-miden" }, @@ -132,7 +132,7 @@ "installed_executable": "miden-node", "version": "0.10.1", "aliases": { - "start-node": ["executable", "bundled", "start", "--data-directory", "data", "--rpc.url", "http://0.0.0.0:57291"] + "start-node": [["executable", "node", "bundled", "start", "--data-directory", "data", "--rpc.url", "http://0.0.0.0:57291"]] } } ] @@ -167,13 +167,13 @@ "version": "0.11.8", "installed_executable": "miden-client", "aliases": { - "account": ["executable", "new-account"], - "deploy": ["executable", "-s", "public", "--account-type", "regular-account-immutable-code"], - "faucet": ["executable", "mint"], - "new-wallet": ["executable", "new-wallet", "--deploy"], - "call": ["executable", "call", "--show"], - "send": ["executable", "send"], - "simulate": ["executable", "exec"] + "account": [["executable", "client", "new-account"]], + "deploy": [["executable", "client", "-s", "public", "--account-type", "regular-account-immutable-code"]], + "faucet": [["executable", "client", "mint"]], + "new-wallet": [["executable", "client", "new-wallet", "--deploy"]], + "call": [["executable", "client", "call", "--show"]], + "send": [["executable", "client", "send"]], + "simulate": [["executable", "client", "exec"]] } }, { @@ -188,8 +188,8 @@ "version": "0.4.1", "rustup_channel": "nightly-2025-07-20", "aliases": { - "new": ["cargo", "miden", "new"], - "build": ["cargo", "miden", "build"] + "new": [["cargo", "miden", "new"]], + "build": [["cargo", "miden", "build"]] }, "symlink_name": "cargo-miden" }, @@ -200,7 +200,7 @@ "branch": "fabrizioorsi/create-account-data-dirs", "installed_executable": "miden-node", "aliases": { - "start-node": ["executable", "bundled", "start", "--data-directory", "var_path", "data", "--rpc.url", "http://0.0.0.0:57291"] + "start-node": [["executable", "node", "bundled", "start", "--data-directory", "var_path", "data", "--rpc.url", "http://0.0.0.0:57291"]] } } ] diff --git a/src/channel.rs b/src/channel.rs index 92fe79f2..aefac80b 100644 --- a/src/channel.rs +++ b/src/channel.rs @@ -1,6 +1,7 @@ use std::{ borrow::Cow, collections::HashMap, + ffi::OsString, fmt::{self, Display}, hash::{Hash, Hasher}, path::PathBuf, @@ -12,6 +13,7 @@ use serde::{Deserialize, Serialize}; use crate::{ Config, + miden_wrapper::ExecutableTarget, toolchain::{Toolchain, ToolchainJustification}, utils, version::{Authority, GitTarget}, @@ -50,6 +52,12 @@ pub struct Channel { /// The set of toolchain components available in this channel pub components: Vec, + + /// These aliases correspond to series of [[CLICommand]]s from multiple + /// different binaries. + #[serde(default)] + #[serde(skip_serializing_if = "HashMap::is_empty")] + pub aliases: Aliases, } enum InstallationMotive { @@ -74,8 +82,9 @@ impl Channel { alias: Option, components: Vec, tags: Vec, + aliases: Aliases, ) -> Self { - Self { name, alias, components, tags } + Self { name, alias, components, tags, aliases } } pub fn get_component(&self, name: impl AsRef) -> Option<&Component> { @@ -118,12 +127,18 @@ impl Channel { installed_toolchains_dir.join(format!("{}", self.name)) } - /// Get all the aliases that the Channel is aware of - pub fn get_aliases(&self) -> HashMap { - self.components.iter().fold(HashMap::new(), |mut acc, component| { - acc.extend(component.aliases.clone()); - acc - }) + /// Aggregate all the aliases that the channel is aware of. This includes: + /// - The Channel wide aliases + /// - The Component specific aliases + pub fn get_aliases(&self) -> Aliases { + self.components + .iter() + .map(|comp| &comp.aliases) + .chain([self.aliases.clone()].iter()) + .fold(HashMap::new(), |mut acc, aliases| { + acc.extend(aliases.clone()); + acc + }) } /// Creates a "partial channel" from the original channel, given a toolchain @@ -206,6 +221,7 @@ impl Channel { alias: self.alias.clone(), tags: vec![Tags::Partial], components: components_to_install, + aliases: self.aliases.clone(), }; Some(partial_channel) @@ -368,7 +384,14 @@ impl Display for InstalledFile { /// line. These are used to resolve an [[Alias]] to its associated command. /// NOTE: In the manifest pub enum CliCommand { - /// Resolve the command to a [[Component]]'s corresponding executable. + /// Resolve the command to a [[Component]]'s corresponding executable. This + /// requires the following CliCommand in the manifest to be a + /// [[CliCommand::Verbatim]] with the name of the executable to execute. + /// For example: + /// + /// "aliases": { + /// "account": [["executable", "client", "new-account"]], + /// } Executable, /// Resolve the command to a [[Toolchain]]'s library path (/lib) #[serde(rename = "lib_path")] @@ -379,6 +402,11 @@ pub enum CliCommand { // NOTE: Potentially in the future, we might want this to be an Optional field #[serde(rename = "var_path")] VarPath, + /// Represents the nth passed in argument by the user. + /// This uses 0 based indexing BUT skips the first *two* arguments from + /// argv, i.e.: `miden `. + #[serde(untagged)] + PositionalArgument(u32), /// An argument that is passed verbatim, as is. #[serde(untagged)] Verbatim(String), @@ -390,6 +418,7 @@ impl fmt::Display for CliCommand { CliCommand::Executable => write!(f, "executable"), CliCommand::LibPath => write!(f, "lib_path"), CliCommand::VarPath => write!(f, "var_path"), + CliCommand::PositionalArgument(nth) => write!(f, "positional argument: {nth}"), CliCommand::Verbatim(word) => write!(f, "verbatim: {word}"), } } @@ -397,26 +426,38 @@ impl fmt::Display for CliCommand { pub fn resolve_command( commands: &[CliCommand], + argv: &[OsString], channel: &Channel, - component: &Component, - config: &Config, -) -> anyhow::Result> { +) -> anyhow::Result { let mut resolution = Vec::with_capacity(commands.len()); let mut commands = commands.iter(); while let Some(command) = commands.next() { match command { CliCommand::Executable => { - let name = &component.name; - let component = channel.get_component(name).with_context(|| { - format!( - "Component named {} is not present in toolchain version {}", - name, channel.name - ) - })?; - - resolution.push(component.get_cli_display()); + let next_command = commands.next().context( + "ERROR: no command was found after 'executable'. It needs to \ + be followed by a component name in verbatim form.", + )?; + + let CliCommand::Verbatim(component_name) = next_command else { + bail!(format!( + "After 'executable' verbatim component name is required. Got: {}", + next_command + )) + }; + + let component_executable = channel + .get_component(component_name) + .map(|comp| comp.get_cli_display()) + .with_context(|| { + format!( + "Error in manifest: 'executable' needs to be followed by an executable component name. Could not find executable named {component_name}." + ) + })?; + + resolution.push(component_executable) }, CliCommand::LibPath => { let channel_dir = channel.get_channel_dir(config); @@ -442,16 +483,42 @@ pub fn resolve_command( resolution.push(full_path.to_string_lossy().to_string()) }, + CliCommand::PositionalArgument(pos) => { + let arg_at_pos = argv + .iter() + // The first two arguments are: + // `miden ` + .skip(2) + .nth(*pos as usize) + .with_context(|| format!("Requested positional argument at \ + position {pos}, however, not enough \ + arguments were passed."))?; + + resolution.push(arg_at_pos.to_string_lossy().to_string()); + }, CliCommand::Verbatim(name) => resolution.push(name.to_string()), } } - Ok(resolution) + // SAFETY: Safe under the assumption that every executable has at least one + // argument, which is guaranteed. + let command = resolution.first().unwrap().clone(); + + let args: Vec = resolution.into_iter().skip(1).map(OsString::from).collect(); + + let executable = ExecutableTarget { target_exe: command, args }; + + Ok(executable) } pub type Alias = String; + /// List of the commands that need to be run when [[Alias]] is called. pub type CLICommand = Vec; + +/// Mapping from an alias name to its associated list of Commands. +pub type Aliases = HashMap>; + /// An installable component of a toolchain #[derive(Serialize, Deserialize, Debug, Clone)] pub struct Component { @@ -491,29 +558,31 @@ pub struct Component { #[serde(skip_serializing_if = "Option::is_none")] #[serde(flatten)] installed_file: Option, - /// This HashMap associates each alias to the corresponding command that - /// needs to be executed. - /// NOTE: The list of commands that is resolved can have an "arbitrary" - /// ordering: the executable associated with this command is not forced to - /// come in first. + /// Mapping from alias name to its corresponding command(s). /// - /// Here's an example aliases entry in a manifest.json: + /// Here's an example "aliases" entry in a manifest.json (taken from the + /// `miden-client`'s and `miden-node`'s manifest entries respectively). /// /// ```json /// { - /// "name": "component-name", - /// "package": "component-package", - /// "version": "X.Y.Z", - /// "installed_executable": "miden-component", + /// "name": "client", + /// (...) /// "aliases": { - /// "alias1": [{"resolve": "component-name"}, {"verbatim": "argument"}], - /// "alias2": [{"verbatim": "cargo"}, {"resolve": "component-name"}, {"verbatim": "build"}] + /// "account": ["executable", "new-account"], + /// "deploy": ["executable", "-s", "public", "--account-type", "regular-account-immutable-code"], /// } /// }, + /// { + /// "name": "node", + /// (...) + /// "aliases": { + /// "start-node": ["executable", "bundled", "start", "--data-directory", "var_path", "data", "--rpc.url", "http://0.0.0.0:57291"] + /// } + /// } /// ``` #[serde(default)] #[serde(skip_serializing_if = "HashMap::is_empty")] - pub aliases: HashMap, + pub aliases: Aliases, /// The file used by midenup's 'miden' to call the components executable. /// If None, then the component's file will be saved as 'miden '. /// This distinction exists mainly for components like cargo-miden, which @@ -616,10 +685,7 @@ impl Component { let local_latest = last_modification_a; let latest_registered_modification = - utils::fs::latest_modification(path_b).ok().map(|modification| { - // std::dbg!(&modification.1); - modification.0 - }); + utils::fs::latest_modification(path_b).ok().map(|modification| modification.0); // last_modification_b should almost always be None, since the // latest modification time is checked on demand. However, if @@ -693,7 +759,7 @@ impl Component { /// Returns the String representation under which midenup calls a component. pub fn get_call_format(&self) -> Vec { if self.call_format.is_empty() { - vec![CliCommand::Executable] + vec![CliCommand::Executable, CliCommand::Verbatim(self.name.to_string())] } else { self.call_format.clone() } diff --git a/src/commands/update.rs b/src/commands/update.rs index ccc6b5a1..8b3d261a 100644 --- a/src/commands/update.rs +++ b/src/commands/update.rs @@ -59,6 +59,7 @@ midenup install stable alias: upstream_stable.alias.clone(), tags: local_stable.tags.clone(), components, + aliases: upstream_stable.aliases.clone(), } }; @@ -162,6 +163,7 @@ fn update_channel( alias: upstream_channel.alias.clone(), tags: local_channel.tags.clone(), components, + aliases: upstream_channel.aliases.clone(), } }; let mut path_warning_displayed = false; diff --git a/src/config.rs b/src/config.rs index 873449cf..8709bc88 100644 --- a/src/config.rs +++ b/src/config.rs @@ -2,7 +2,10 @@ use std::{ffi::OsString, path::PathBuf}; use anyhow::{Context, bail}; -use crate::{channel::Channel, manifest::Manifest, toolchain::Toolchain, utils}; +use crate::{ + channel::Channel, manifest::Manifest, miden_wrapper::ExecutableTarget, toolchain::Toolchain, + utils, +}; #[derive(Debug)] /// This struct holds contextual information about the environment in which @@ -115,8 +118,7 @@ impl Config { pub fn execute_command( &self, active_toolchain: &Channel, - target_exe: &str, - args: &Vec, + target_exe: ExecutableTarget, ) -> Result { let toolchain_opt = self .midenup_home @@ -133,10 +135,10 @@ impl Config { None => toolchain_opt.into_os_string(), }; - std::process::Command::new(target_exe) + std::process::Command::new(target_exe.target_exe) .env("MIDENUP_HOME", &self.midenup_home) .env("PATH", path) - .args(args) + .args(target_exe.args) .stderr(std::process::Stdio::inherit()) .stdout(std::process::Stdio::inherit()) .spawn() diff --git a/src/manifest.rs b/src/manifest.rs index 761a0595..eed4302a 100644 --- a/src/manifest.rs +++ b/src/manifest.rs @@ -239,20 +239,6 @@ mod tests { assert!(stable.get_component("std").is_some()); } - #[test] - /// Validates that the *published* channel manifest is parseable. - /// NOTE: This test is mainly intended for backwards compatibilty reasons. - fn validate_published_channel_manifest() { - let manifest = Manifest::load_from(Manifest::PUBLISHED_MANIFEST_URI) - .expect("Failed to parse upstream manifest."); - - let stable = manifest - .get_channel(&UserChannel::Stable) - .expect("Could not convert UserChannel to internal channel representation"); - - assert!(stable.get_component("std").is_some()); - } - #[test] /// Validates that non-standard manifest features are parsed correctly, these include: /// - Non stable channels (custom tags, nightly) diff --git a/src/miden_wrapper.rs b/src/miden_wrapper.rs index d094968b..3b6528e4 100644 --- a/src/miden_wrapper.rs +++ b/src/miden_wrapper.rs @@ -32,11 +32,12 @@ enum HelpMessage { /// The possible non-help commands that a user's input can be resolved into. #[derive(Debug)] +#[allow(clippy::large_enum_variant)] enum MidenArgument { /// The passed argument was an Alias stored in the local [[Manifest]]. [[AliasResolution]] /// represents the list of commands that need to be executed. NOTE: Some of these might need /// to get resolved. - Alias(Component, CLICommand), + Alias(Vec), /// The argument was the name of a component stored in the [[Manifest]]. Component(Component), } @@ -48,6 +49,30 @@ struct ExecutionEnvironment<'a> { active_channel: &'a Channel, } +pub struct ExecutableTarget { + pub target_exe: String, + pub args: Vec, +} + +impl ExecutableTarget { + // Add the user's passed in arguments to the resolved command. If help was + // requested, no arguments are passed in order for the underlying executable + // to provide help. + fn add_arguments(&mut self, argv: Vec, help_flag: Option) { + if let Some(help_flag) = help_flag { + let help_flag = OsString::from(help_flag); + self.args.extend([help_flag]); + } else { + // argv is of the form: + // miden ... + // So we skip the first two and pass the rest to the underlying executable. + let args = argv.into_iter().skip(2); + + self.args.extend(args); + }; + } +} + enum EnvironmentError { UnkownArgument(String), } @@ -92,7 +117,7 @@ impl<'a> ToolchainEnvironment<'a> { /// Parses the user's input and returns the required ExecutionEnvironment to /// execute the requested command. - fn resolve(&self, argument: String) -> Result, EnvironmentError> { + fn resolve(&self, argument: &str) -> Result, EnvironmentError> { let (_, active_channel_type) = self.get_active_channel(); let (channel, argument) = [ @@ -103,13 +128,12 @@ impl<'a> ToolchainEnvironment<'a> { // We only consider the channel as available if it's not None. We can // always fallback on the installed channel. .filter_map(|(ch, ch_type)| ch.map(|ch| (ch, ch_type))) - .flat_map(|(ch, ch_type)| ch.components.iter().map(move |comp| (comp, ch_type, ch))) - .find_map(|(comp, ch_type, ch)| { - if let Some(associated_command) = comp.aliases.get(&argument) { - Some((ch, (MidenArgument::Alias(comp.clone(), associated_command.to_owned()), ch_type)) + .find_map(|(ch, ch_type)| { + if let Some(associated_commands) = ch.get_aliases().get(argument) { + Some((ch, (MidenArgument::Alias(associated_commands.to_owned()), ch_type)) ) - } else if comp.name == argument { - Some((ch, (MidenArgument::Component(comp.clone()), ch_type)) + } else if let Some(component) = ch.get_component(argument) { + Some((ch, (MidenArgument::Component(component.clone()), ch_type)) ) } else { None @@ -120,11 +144,10 @@ impl<'a> ToolchainEnvironment<'a> { // We only display an eror message if a user tried to access a // component that was available via the installed channel while // having an active channel that was missing said component. - ((MidenArgument::Alias(comp, _ ), ChannelType::Installed), ChannelType::Active) => Some(format!( - "{}: {} is an alias from component {}, which is installed but is not part of the current active toolchain.", + ((MidenArgument::Alias(_), ChannelType::Installed), ChannelType::Active) => Some(format!( + "{}: {} is an alias which is installed but is not part of the current active toolchain.", "WARNING".yellow().bold(), argument, - comp.name, )), ((MidenArgument::Component(comp), ChannelType::Installed), ChannelType::Active) => Some(format!( @@ -140,7 +163,7 @@ impl<'a> ToolchainEnvironment<'a> { } ) .map(|(ch, (argument, _))| (ch, argument)) - .ok_or(EnvironmentError::UnkownArgument(argument))?; + .ok_or(EnvironmentError::UnkownArgument(argument.to_string()))?; Ok(ExecutionEnvironment { argument, active_channel: channel }) } @@ -288,7 +311,7 @@ For more information, try 'miden help'. // We obtain the target executable and prefixes that are associated with the // passed subcommand. - let (target_exe, mut prefix_args, active_channel) = match parsed_subcommand { + let (target_exe, active_channel) = match parsed_subcommand { MidenSubcommand::Version => unreachable!(), MidenSubcommand::Help(HelpMessage::Default) => unreachable!(), MidenSubcommand::Help(HelpMessage::Toolchain) => unreachable!(), @@ -296,81 +319,55 @@ For more information, try 'miden help'. // only difference is wheter we append "--help" at the end and if we // process additional arguments. MidenSubcommand::Help(HelpMessage::Resolve(resolve)) - | MidenSubcommand::Resolve(resolve) => { - match toolchain_environment.resolve(resolve.clone()) { - Ok(ExecutionEnvironment { - argument: MidenArgument::Alias(component, alias_resolutions), - active_channel, - }) => { - let commands = - resolve_command(&alias_resolutions, active_channel, &component, config)?; - - // SAFETY: Safe under the assumption that every alias has an - // associated command. - let command = commands.first().unwrap().clone(); - let aliased_arguments: Vec = commands.into_iter().skip(1).collect(); - - (command, aliased_arguments, active_channel) - }, - Ok(ExecutionEnvironment { - argument: MidenArgument::Component(component), - active_channel, - }) => { - let call_convention = resolve_command( - &component.get_call_format(), - active_channel, - &component, - config, - )?; - - // SAFETY: Safe under the assumption that every call_format has at least one - // argument - let command = call_convention.first().unwrap().clone(); - let args: Vec = call_convention.into_iter().skip(1).collect(); - - (command, args, active_channel) - }, - Err(EnvironmentError::UnkownArgument(argument)) => { - let help_message = toolchain_help(&toolchain_environment); - let err_msg = format!( - "Failed to resolve '{}': Neither known alias or component. + | MidenSubcommand::Resolve(resolve) => match toolchain_environment.resolve(&resolve) { + Ok(ExecutionEnvironment { + argument: MidenArgument::Alias(alias_resolutions), + active_channel, + }) => { + let executables = alias_resolutions + .iter() + .map(|commands| resolve_command(commands, &argv, active_channel, config)) + .collect::, _>>()?; + + (executables, active_channel) + }, + Ok(ExecutionEnvironment { + argument: MidenArgument::Component(component), + active_channel, + }) => { + let executables = + resolve_command(&component.get_call_format(), &argv, active_channel, config)?; + + (vec![executables], active_channel) + }, + Err(EnvironmentError::UnkownArgument(argument)) => { + let help_message = toolchain_help(&toolchain_environment); + let err_msg = format!( + "Failed to resolve '{}': Neither known alias or component. {}", - argument, help_message - ); - bail!(err_msg); - }, - } + argument, help_message + ); + bail!(err_msg); + }, }, }; - let rest_of_args = if let Some(help_flag) = help_flag { - prefix_args.extend([help_flag]); - // If the user requested for help for a specific component, we skip any - // additional passed in arguments. - argv.iter().skip(argv.len()) - } else { - // argv is of the form: - // miden ... - // So we skip the first two and pass the rest to the underlying executable. - argv.iter().skip(2) - }; - - let prefix_args = prefix_args.iter().map(OsString::from).chain(rest_of_args.cloned()).collect(); - - let mut command = config - .execute_command(active_channel, &target_exe, &prefix_args) - .with_context(|| format!("failed to run 'miden {subcommand}'"))?; - - let status = command.wait().with_context(|| { - format!("error occurred while waiting for 'miden {subcommand}' to finish executing") - })?; + for mut exe in target_exe { + exe.add_arguments(argv.clone(), help_flag.clone()); + let mut command = config + .execute_command(active_channel, exe) + .with_context(|| format!("failed to run 'miden {subcommand}'"))?; + let status = command.wait().with_context(|| { + format!("error occurred while waiting for 'miden {subcommand}' to finish executing") + })?; - if status.success() { - Ok(()) - } else { - bail!("'miden {}' failed with status {}", subcommand, status.code().unwrap_or(1)) + if !status.success() { + bail!("'miden {}' failed with status {}", subcommand, status.code().unwrap_or(1)) + } } + + Ok(()) } fn display_version(config: &Config) -> String { diff --git a/tests/data/integration_initialize_component/channel-manifest.json b/tests/data/integration_initialize_component/channel-manifest.json index 9c295dd5..f6c11f5b 100644 --- a/tests/data/integration_initialize_component/channel-manifest.json +++ b/tests/data/integration_initialize_component/channel-manifest.json @@ -12,8 +12,8 @@ "branch": "fabrizioorsi/create-account-data-dirs", "installed_executable": "miden-node", "aliases": { - "start-node": ["executable", "bundled", "start", "--data-directory", "var_path", "data", "--rpc.url", "http://0.0.0.0:57291"], - "init-node": ["executable", "bundled", "bootstrap", "--data-directory", "var_path", "data", "--accounts-directory", "var_path", "accounts"] + "start-node": [["executable", "node", "bundled", "start", "--data-directory", "var_path", "data", "--rpc.url", "http://0.0.0.0:57291"]], + "init-node": [["executable", "node", "bundled", "bootstrap", "--data-directory", "var_path", "data", "--accounts-directory", "var_path", "accounts"]] } } ] diff --git a/tests/data/integration_install_from_non_cargo/channel-manifest-1.json b/tests/data/integration_install_from_non_cargo/channel-manifest-1.json index 9cf9ba02..d25eba96 100644 --- a/tests/data/integration_install_from_non_cargo/channel-manifest-1.json +++ b/tests/data/integration_install_from_non_cargo/channel-manifest-1.json @@ -32,13 +32,13 @@ "revision": "83df2aa115b2617e211d1d929a1189ffabbd137b", "installed_executable": "miden-client", "aliases": { - "account": ["executable", "new-account"], - "deploy": ["executable", "-s", "public", "--account-type", "regular-account-immutable-code"], - "faucet": ["executable", "mint"], - "new-wallet": ["executable", "new-wallet", "--deploy"], - "call": ["executable", "call", "--show"], - "send": ["executable", "send"], - "simulate": ["executable", "exec"] + "account": [["executable", "client", "new-account"]], + "deploy": [["executable", "client", "-s", "public", "--account-type", "regular-account-immutable-code"]], + "faucet": [["executable", "client", "mint"]], + "new-wallet": [["executable", "client", "new-wallet", "--deploy"]], + "call": [["executable", "client", "call", "--show"]], + "send": [["executable", "client", "send"]], + "simulate": [["executable", "client", "exec"]] } } ] diff --git a/tests/data/integration_install_from_non_cargo/channel-manifest-2.json b/tests/data/integration_install_from_non_cargo/channel-manifest-2.json index 8851f812..7ae557c6 100644 --- a/tests/data/integration_install_from_non_cargo/channel-manifest-2.json +++ b/tests/data/integration_install_from_non_cargo/channel-manifest-2.json @@ -32,13 +32,13 @@ "revision": "c107cbed69a1313d67d03229fec59e37db720e6c", "installed_executable": "miden-client", "aliases": { - "account": ["executable", "new-account"], - "deploy": ["executable", "-s", "public", "--account-type", "regular-account-immutable-code"], - "faucet": ["executable", "mint"], - "new-wallet": ["executable", "new-wallet", "--deploy"], - "call": ["executable", "call", "--show"], - "send": ["executable", "send"], - "simulate": ["executable", "exec"] + "account": [["executable", "client", "new-account"]], + "deploy": [["executable", "client", "-s", "public", "--account-type", "regular-account-immutable-code"]], + "faucet": [["executable", "client", "mint"]], + "new-wallet": [["executable", "client", "new-wallet", "--deploy"]], + "call": [["executable", "client", "call", "--show"]], + "send": [["executable", "client", "send"]], + "simulate": [["executable", "client", "exec"]] } } ]