Struct sc_cli::KeystoreParams

pub struct KeystoreParams {
    pub keystore_uri: Option<String>,
    pub keystore_path: Option<PathBuf>,
    pub password_interactive: bool,
    pub password: Option<SecretString>,
    pub password_filename: Option<PathBuf>,
}

Parameters of the keystore

Fields

keystore_uri: Option<String>

Specify custom URIs to connect to for keystore-services

keystore_path: Option<PathBuf>

Specify custom keystore path.

password_interactive: bool

Use interactive shell for entering the password used by the keystore.

password: Option<SecretString>

Password used by the keystore. This allows appending an extra user-defined secret to the seed.

password_filename: Option<PathBuf>

File that contains the password used by the keystore.

Implementations

impl KeystoreParams

pub fn keystore_config(
    &self,
    config_dir: &Path
) -> Result<(Option<String>, KeystoreConfig)>

Get the keystore configuration for the parameters

Returns a vector of remote-urls and the local Keystore configuration

Examples found in repository

src/config.rs (line 190)

	fn keystore_config(&self, config_dir: &PathBuf) -> Result<(Option<String>, KeystoreConfig)> {
		self.keystore_params()
			.map(|x| x.keystore_config(config_dir))
			.unwrap_or_else(|| Ok((None, KeystoreConfig::InMemory)))
	}

src/commands/insert_key.rs (line 69)

	pub fn run<C: SubstrateCli>(&self, cli: &C) -> Result<(), Error> {
		let suri = utils::read_uri(self.suri.as_ref())?;
		let base_path = self
			.shared_params
			.base_path()?
			.unwrap_or_else(|| BasePath::from_project("", "", &C::executable_name()));
		let chain_id = self.shared_params.chain_id(self.shared_params.is_dev());
		let chain_spec = cli.load_spec(&chain_id)?;
		let config_dir = base_path.config_dir(chain_spec.id());

		let (keystore, public) = match self.keystore_params.keystore_config(&config_dir)? {
			(_, KeystoreConfig::Path { path, password }) => {
				let public = with_crypto_scheme!(self.scheme, to_vec(&suri, password.clone()))?;
				let keystore: SyncCryptoStorePtr = Arc::new(LocalKeystore::open(path, password)?);
				(keystore, public)
			},
			_ => unreachable!("keystore_config always returns path and password; qed"),
		};

		let key_type =
			KeyTypeId::try_from(self.key_type.as_str()).map_err(|_| Error::KeyTypeInvalid)?;

		SyncCryptoStore::insert_unknown(&*keystore, key_type, &suri, &public[..])
			.map_err(|_| Error::KeyStoreOperation)?;

		Ok(())
	}

pub fn read_password(&self) -> Result<Option<SecretString>>

helper method to fetch password from KeyParams or read from stdin

Examples found in repository

src/commands/sign.rs (line 57)

	pub fn run(&self) -> error::Result<()> {
		let message = utils::read_message(self.message.as_ref(), self.hex)?;
		let suri = utils::read_uri(self.suri.as_ref())?;
		let password = self.keystore_params.read_password()?;

		let signature =
			with_crypto_scheme!(self.crypto_scheme.scheme, sign(&suri, password, message))?;

		println!("{}", signature);
		Ok(())
	}

src/commands/generate.rs (line 63)

	pub fn run(&self) -> Result<(), Error> {
		let words = match self.words {
			Some(words) => MnemonicType::for_word_count(words).map_err(|_| {
				Error::Input(
					"Invalid number of words given for phrase: must be 12/15/18/21/24".into(),
				)
			})?,
			None => MnemonicType::Words12,
		};
		let mnemonic = Mnemonic::new(words, Language::English);
		let password = self.keystore_params.read_password()?;
		let output = self.output_scheme.output_type;

		with_crypto_scheme!(
			self.crypto_scheme.scheme,
			print_from_uri(mnemonic.phrase(), password, self.network_scheme.network, output)
		);
		Ok(())
	}

src/commands/inspect_key.rs (line 83)

	pub fn run(&self) -> Result<(), Error> {
		let uri = utils::read_uri(self.uri.as_ref())?;
		let password = self.keystore_params.read_password()?;

		if self.public {
			with_crypto_scheme!(
				self.crypto_scheme.scheme,
				print_from_public(
					&uri,
					self.network_scheme.network,
					self.output_scheme.output_type,
				)
			)?;
		} else {
			if let Some(ref expect_public) = self.expect_public {
				with_crypto_scheme!(
					self.crypto_scheme.scheme,
					expect_public_from_phrase(expect_public, &uri, password.as_ref())
				)?;
			}

			with_crypto_scheme!(
				self.crypto_scheme.scheme,
				print_from_uri(
					&uri,
					password,
					self.network_scheme.network,
					self.output_scheme.output_type,
				)
			);
		}

		Ok(())
	}

Trait Implementations

impl Args for KeystoreParams

fn group_id() -> Option<Id>

Report the ArgGroup::id for this set of arguments

fn augment_args<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate Self.

fn augment_args_for_update<'b>(__clap_app: Command) -> Command

Append to Command so it can update self.

impl Clone for KeystoreParams

fn clone(&self) -> KeystoreParams

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for KeystoreParams

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl FromArgMatches for KeystoreParams

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn from_arg_matches_mut(
    __clap_arg_matches: &mut ArgMatches
) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn update_from_arg_matches(
    &mut self,
    __clap_arg_matches: &ArgMatches
) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut(
    &mut self,
    __clap_arg_matches: &mut ArgMatches
) -> Result<(), Error>

Assign values from ArgMatches to self.