Struct solana_clap_utils::keypair::DefaultSigner

pub struct DefaultSigner {
    pub arg_name: String,
    pub path: String,
    /* private fields */
}

A command line argument that loads a default signer in absence of other signers.

This type manages a default signing source which may be overridden by other signing sources via its generate_unique_signers method.

path is a signing source as documented by signer_from_path, and arg_name is the name of its clap command line argument, which is passed to signer_from_path as its keypair_name argument.

Fields

arg_name: String

The name of the signers command line argument.

path: String

The signing source.

Implementations

impl DefaultSigner

pub fn new<AN: AsRef<str>, P: AsRef<str>>(arg_name: AN, path: P) -> Self

Create a new DefaultSigner.

path is a signing source as documented by signer_from_path, and arg_name is the name of its clap command line argument, which is passed to signer_from_path as its keypair_name argument.

Examples

use clap::{App, Arg, value_t_or_exit};
use solana_clap_utils::keypair::DefaultSigner;
use solana_clap_utils::offline::OfflineArgs;

let clap_app = App::new("my-program")
    // The argument we'll parse as a signer "path"
    .arg(Arg::with_name("keypair")
        .required(true)
        .help("The default signer"))
    .offline_args();

let clap_matches = clap_app.get_matches();
let keypair_str = value_t_or_exit!(clap_matches, "keypair", String);

let default_signer = DefaultSigner::new("keypair", &keypair_str);
assert_eq!(default_signer.path, keypair_str);

pub fn generate_unique_signers( &self, bulk_signers: Vec<Option<Box<dyn Signer>>>, matches: &ArgMatches<'_>, wallet_manager: &mut Option<Arc<RemoteWalletManager>> ) -> Result<CliSignerInfo, Box<dyn Error>>

Generate a unique set of signers, possibly excluding this default signer.

This function allows a command line application to have a default signer, perhaps representing a default wallet, but to override that signer and instead sign with one or more other signers.

bulk_signers is a vector of signers, all of which are optional. If any of those signers is None, then the default signer will be loaded; if all of those signers are Some, then the default signer will not be loaded.

The returned value includes all of the bulk_signers that were not None, and maybe the default signer, if it was loaded.

Examples

use clap::{App, Arg, value_t_or_exit};
use solana_clap_utils::keypair::{DefaultSigner, signer_from_path};
use solana_clap_utils::offline::OfflineArgs;
use solana_sdk::signer::Signer;

let clap_app = App::new("my-program")
    // The argument we'll parse as a signer "path"
    .arg(Arg::with_name("keypair")
        .required(true)
        .help("The default signer"))
    .arg(Arg::with_name("payer")
        .long("payer")
        .help("The account paying for the transaction"))
    .offline_args();

let mut wallet_manager = None;

let clap_matches = clap_app.get_matches();
let keypair_str = value_t_or_exit!(clap_matches, "keypair", String);
let maybe_payer = clap_matches.value_of("payer");

let default_signer = DefaultSigner::new("keypair", &keypair_str);
let maybe_payer_signer = maybe_payer.map(|payer| {
    signer_from_path(&clap_matches, payer, "payer", &mut wallet_manager)
}).transpose()?;
let bulk_signers = vec![maybe_payer_signer];

let unique_signers = default_signer.generate_unique_signers(
    bulk_signers,
    &clap_matches,
    &mut wallet_manager,
)?;

pub fn signer_from_path( &self, matches: &ArgMatches<'_>, wallet_manager: &mut Option<Arc<RemoteWalletManager>> ) -> Result<Box<dyn Signer>, Box<dyn Error>>

Loads the default Signer from one of several possible sources.

The path is not strictly a file system path, but is interpreted as various types of signing source, depending on its format, one of which is a path to a keypair file. Some sources may require user interaction in the course of calling this function.

This simply delegates to the signer_from_path free function, passing it the DefaultSigners path and arg_name fields as the path and keypair_name arguments.

See the signer_from_path free function for full documentation of how this function interprets its arguments.

Examples

use clap::{App, Arg, value_t_or_exit};
use solana_clap_utils::keypair::DefaultSigner;
use solana_clap_utils::offline::OfflineArgs;

let clap_app = App::new("my-program")
    // The argument we'll parse as a signer "path"
    .arg(Arg::with_name("keypair")
        .required(true)
        .help("The default signer"))
    .offline_args();

let clap_matches = clap_app.get_matches();
let keypair_str = value_t_or_exit!(clap_matches, "keypair", String);
let default_signer = DefaultSigner::new("keypair", &keypair_str);
let mut wallet_manager = None;

let signer = default_signer.signer_from_path(
    &clap_matches,
    &mut wallet_manager,
)?;

pub fn signer_from_path_with_config( &self, matches: &ArgMatches<'_>, wallet_manager: &mut Option<Arc<RemoteWalletManager>>, config: &SignerFromPathConfig ) -> Result<Box<dyn Signer>, Box<dyn Error>>

Loads the default Signer from one of several possible sources.

The path is not strictly a file system path, but is interpreted as various types of signing source, depending on its format, one of which is a path to a keypair file. Some sources may require user interaction in the course of calling this function.

This simply delegates to the signer_from_path_with_config free function, passing it the DefaultSigners path and arg_name fields as the path and keypair_name arguments.

See the signer_from_path free function for full documentation of how this function interprets its arguments.

Examples

use clap::{App, Arg, value_t_or_exit};
use solana_clap_utils::keypair::{SignerFromPathConfig, DefaultSigner};
use solana_clap_utils::offline::OfflineArgs;

let clap_app = App::new("my-program")
    // The argument we'll parse as a signer "path"
    .arg(Arg::with_name("keypair")
        .required(true)
        .help("The default signer"))
    .offline_args();

let clap_matches = clap_app.get_matches();
let keypair_str = value_t_or_exit!(clap_matches, "keypair", String);
let default_signer = DefaultSigner::new("keypair", &keypair_str);
let mut wallet_manager = None;

// Allow pubkey signers without accompanying signatures
let config = SignerFromPathConfig {
    allow_null_signer: true,
};

let signer = default_signer.signer_from_path_with_config(
    &clap_matches,
    &mut wallet_manager,
    &config,
)?;

Trait Implementations

impl Debug for DefaultSigner

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

Formats the value using the given formatter.

impl Default for DefaultSigner

fn default() -> DefaultSigner

Returns the “default value” for a type.