Enum Signer 

pub enum Signer {
    RawSigner(RawSigner),
    KeyStore(Keystore),
}

A unified interface for cryptographic signing operations.

The Signer enum provides a single interface for different types of signing backends, allowing seamless switching between raw private key signing and keystore-based signing.

Variants

• RawSigner: Uses a private key directly loaded from a string
• KeyStore: Uses a private key loaded from a file-based keystore with an alias

Examples

From a raw private key

use crypto::Signer;

let signer: Signer = "iotaprivkey1qrsd2u9ztqr6z2y78sp2ch8kcyak9cx3ezphkpp4acqaqruajxr6qye2645".into();
println!("Address: {}", signer.address());

From a keystore

use crypto::{Signer, keystore::Keystore};

let keystore = Keystore::new_with_alias("./keystore", "my_account").unwrap();
let signer: Signer = keystore.into();
println!("Address: {}", signer.address());

Variants

RawSigner(RawSigner)

A signer that uses a raw private key directly

KeyStore(Keystore)

A signer that uses a keystore file with an alias

Implementations

impl Signer

pub fn address(&self) -> String

Returns the IOTA address associated with this signer’s public key.

The address is derived from the public key using IOTA’s standard address derivation algorithm.

Returns

A string representation of the IOTA address (e.g., “0x123abc…”)

Examples

use crypto::Signer;

let signer: Signer = "iotaprivkey1qrsd2u9ztqr6z2y78sp2ch8kcyak9cx3ezphkpp4acqaqruajxr6qye2645".into();
let address = signer.address();
println!("My address: {}", address);

pub fn pubkey(&self) -> String

Returns the base64-encoded public key associated with this signer.

The encoded bytes are the scheme flag followed by the key itself, so an Ed25519 public key decodes to 33 bytes, not 32.

Returns

A base64-encoded string representation of the public key

Examples

use crypto::Signer;

let signer: Signer = "iotaprivkey1qrsd2u9ztqr6z2y78sp2ch8kcyak9cx3ezphkpp4acqaqruajxr6qye2645".into();
let pubkey = signer.pubkey();
println!("Public key: {}", pubkey);

pub fn sign_message(&self, message: &str) -> String

Signs a message using this signer’s private key.

The message is wrapped in IOTA’s PersonalMessage intent, BCS-encoded and hashed with blake2b256; the Ed25519 key signs that digest. This matches IOTA’s own signature verification and domain-separates the signature from other intent scopes.

Arguments

• message - The message string to sign

Returns

A base64-encoded signature string

Examples

use crypto::Signer;

let signer: Signer = "iotaprivkey1qrsd2u9ztqr6z2y78sp2ch8kcyak9cx3ezphkpp4acqaqruajxr6qye2645".into();
let signature = signer.sign_message("Hello, world!");

// Verify the signature
let address = signer.address();
assert!(crypto::verify_message_signature(&address, "Hello, world!", &signature).is_ok());

pub fn sign_secure<T>(&self, msg: &T, intent: Intent) -> SimpleSignature

where T: Serialize,

Signs a serializable message with a custom IOTA intent.

This is an advanced signing method that allows you to specify a custom intent for the signature, rather than using the default PersonalMessage intent. This is useful for signing transactions, smart contract calls, or other IOTA-specific operations that require specific intent scopes.

Arguments

• msg - Any serializable value to sign
• intent - The IOTA intent to use for signing (defines app_id, scope, and version)

Returns

An iota_sdk_types::SimpleSignature containing the cryptographic signature

Examples

use crypto::Signer;
use iota_sdk_types::{Intent, IntentAppId, IntentScope, IntentVersion};
use serde::Serialize;

#[derive(Serialize)]
struct Transaction {
    to: String,
    amount: u64,
}

let signer: Signer = "iotaprivkey1qrsd2u9ztqr6z2y78sp2ch8kcyak9cx3ezphkpp4acqaqruajxr6qye2645".into();
let tx = Transaction { to: "0x123...".to_string(), amount: 1000 };

let intent = Intent {
    app_id: IntentAppId::Iota,
    scope: IntentScope::TransactionData,
    version: IntentVersion::V0,
};

let signature = signer.sign_secure(&tx, intent);

Trait Implementations

impl Clone for Signer

fn clone(&self) -> Signer

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Signer

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

Formats the value using the given formatter.

impl From<&Signer> for Signer

fn from(value: &Signer) -> Signer

Converts to this type from the input type.

impl From<Keystore> for Signer

fn from(value: Keystore) -> Signer

Converts to this type from the input type.

impl From<RawSigner> for Signer

fn from(value: RawSigner) -> Signer

Converts to this type from the input type.

impl<T> From<T> for Signer

where T: AsRef<str>,

fn from(value: T) -> Signer

Converts to this type from the input type.