Struct CosmosPrivateKey

pub struct CosmosPrivateKey(/* private fields */);

This structure represents a private key of a Cosmos Network.

Implementations

impl CosmosPrivateKey

pub fn to_public_key( &self, prefix: &str, ) -> Result<CosmosPublicKey, PrivateKeyError>

Obtain a public key for a given private key

Trait Implementations

impl Clone for CosmosPrivateKey

fn clone(&self) -> CosmosPrivateKey

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for CosmosPrivateKey

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

Formats the value using the given formatter.

impl FromStr for CosmosPrivateKey

type Err = PrivateKeyError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for CosmosPrivateKey

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for CosmosPrivateKey

fn eq(&self, other: &CosmosPrivateKey) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PrivateKey for CosmosPrivateKey

fn from_secret(secret: &[u8]) -> CosmosPrivateKey

Create a private key using an arbitrary slice of bytes. This function is not resistant to side channel attacks and may reveal your secret and private key. It is on the other hand more compact than the bip32+bip39 logic.

fn from_phrase( phrase: &str, passphrase: &str, ) -> Result<CosmosPrivateKey, PrivateKeyError>

This function will take the key_import phrase provided by CosmosCLI and import that key. How this is done behind the scenes is quite complex. The actual seed bytes from the key_import are used to derive the root of a Bip32 HD wallet. From that root Cosmos keys are derived on the path m/44’/118’/0’/0/a where a=0 is the most common value used. Most Cosmos wallets do not even expose a=1..n much less the rest of the potential key space. This function returns m/44’/118’/0’/0/0 because that’s going to be the key you want essentially all the time. If you need a different path use from_hd_wallet_path()

fn from_hd_wallet_path( hd_path: &str, phrase: &str, passphrase: &str, ) -> Result<CosmosPrivateKey, PrivateKeyError>

Derives a private key from a mnemonic phrase and passphrase, using a BIP-44 HDPath The actual seed bytes are derived from the mnemonic phrase, which are then used to derive the root of a Bip32 HD wallet. From that application private keys are derived on the given hd_path (e.g. Cosmos’ m/44’/118’/0’/0/a where a=0 is the most common value used). Most Cosmos wallets do not even expose a=1..n much less the rest of the potential key space.

fn to_address(&self, prefix: &str) -> Result<Address, PrivateKeyError>

Obtain an Address for a given private key, skipping the intermediate public key

fn get_signed_tx( &self, messages: &[Msg], args: MessageArgs, memo: &str, ) -> Result<Tx, PrivateKeyError>

Signs a transaction that contains at least one message using a single private key, returns the standard Tx type, useful for simulations

fn sign_std_msg( &self, messages: &[Msg], args: MessageArgs, memo: &str, ) -> Result<Vec<u8>, PrivateKeyError>

Signs a transaction that contains at least one message using a single private key.

impl Copy for CosmosPrivateKey

impl Eq for CosmosPrivateKey

impl StructuralPartialEq for CosmosPrivateKey