Struct KmdClient

pub struct KmdClient { /* private fields */ }

Client for interacting with the key management daemon

Implementations

impl KmdClient

pub fn new(address: &str, token: &str) -> KmdClient

Examples found in repository

examples/quickstart.rs (line 10)

fn main() {
    let algod_address = "http://localhost:8080";
    let algod_token = "contents-of-algod.token";
    let kmd_address = "http://localhost:7833";
    let kmd_token = "contents-of-kmd.token";

    let algod_client = AlgodClient::new(algod_address, algod_token);
    let kmd_client = KmdClient::new(kmd_address, kmd_token);

    println!(
        "Algod versions: {:?}",
        algod_client.versions().unwrap().versions
    );
    println!(
        "Kmd versions: {:?}",
        kmd_client.versions().unwrap().versions
    );
}

examples/kmd_client.rs (line 9)

fn main() -> Result<(), Box<dyn Error>> {
    let kmd_address = "http://localhost:8080";
    let kmd_token = "contents-of-kmd.token";

    let kmd_client = KmdClient::new(kmd_address, kmd_token);

    let create_wallet_response = kmd_client.create_wallet(
        "testwallet",
        "testpassword",
        "sqlite",
        MasterDerivationKey([0; 32]),
    )?;
    let wallet_id = create_wallet_response.wallet.id;

    let init_response = kmd_client.init_wallet_handle(&wallet_id, "testpassword")?;
    let wallet_handle_token = init_response.wallet_handle_token;

    let gen_response = kmd_client.generate_key(&wallet_handle_token)?;
    println!("Generated address: {}", gen_response.address);

    Ok(())
}

examples/wallet_restore.rs (line 9)

fn main() -> Result<(), Box<dyn Error>> {
    let kmd_address = "http://localhost:8080";
    let kmd_token = "contents-of-kmd.token";

    let kmd_client = KmdClient::new(kmd_address, kmd_token);

    let backup_phrase = "fire enlist diesel stamp nuclear chunk student stumble call snow flock brush example slab guide choice option recall south kangaroo hundred matrix school above zero";
    let key_bytes = mnemonic::to_key(backup_phrase)?;
    let mdk = MasterDerivationKey(key_bytes);

    let create_wallet_response =
        kmd_client.create_wallet("testwallet", "testpassword", "sqlite", mdk)?;
    let wallet = create_wallet_response.wallet;

    println!("Created wallet {} with ID: {}", wallet.name, wallet.id);

    Ok(())
}

examples/wallet_backup.rs (line 9)

fn main() -> Result<(), Box<dyn Error>> {
    let kmd_address = "http://localhost:8080";
    let kmd_token = "contents-of-kmd.token";

    let kmd_client = KmdClient::new(kmd_address, kmd_token);

    let list_response = kmd_client.list_wallets()?;

    let wallet_id = match list_response
        .wallets
        .into_iter()
        .find(|wallet| wallet.name == "testwallet")
    {
        Some(wallet) => wallet.id,
        None => return Err("Wallet not found".into()),
    };

    let init_response = kmd_client.init_wallet_handle(&wallet_id, "testpassword")?;
    let wallet_handle_token = init_response.wallet_handle_token;

    let export_response =
        kmd_client.export_master_derivation_key(&wallet_handle_token, "testpassword")?;
    let mdk = export_response.master_derivation_key;

    // String representation of the mdk, keep in safe place and don't share it
    let string_to_save = mnemonic::from_key(&mdk.0)?;

    println!("Backup phrase: {}", string_to_save);

    Ok(())
}

examples/sign_submit_transaction.rs (line 12)

fn main() -> Result<(), Box<dyn Error>> {
    let kmd_address = "http://localhost:7833";
    let kmd_token = "contents-of-kmd.token";
    let algod_address = "http://localhost:8080";
    let algod_token = "contents-of-algod.token";

    let kmd_client = KmdClient::new(kmd_address, kmd_token);
    let algod_client = AlgodClient::new(algod_address, algod_token);

    let list_response = kmd_client.list_wallets()?;

    let wallet_id = match list_response
        .wallets
        .into_iter()
        .find(|wallet| wallet.name == "testwallet")
    {
        Some(wallet) => wallet.id,
        None => return Err("Wallet not found".into()),
    };

    let init_response = kmd_client.init_wallet_handle(&wallet_id, "testpassword")?;
    let wallet_handle_token = init_response.wallet_handle_token;

    let gen_response = kmd_client.generate_key(&wallet_handle_token)?;
    let from_address = Address::from_string(&gen_response.address)?;

    let gen_response = kmd_client.generate_key(&wallet_handle_token)?;
    let to_address = Address::from_string(&gen_response.address)?;

    let transaction_params = algod_client.transaction_params()?;

    let genesis_id = transaction_params.genesis_id;
    let genesis_hash = transaction_params.genesis_hash;

    let base = BaseTransaction {
        sender: from_address,
        first_valid: transaction_params.last_round,
        last_valid: transaction_params.last_round + 1000,
        note: Vec::new(),
        genesis_id,
        genesis_hash,
    };

    let payment = Payment {
        amount: MicroAlgos(200_000),
        receiver: to_address,
        close_remainder_to: None,
    };

    let transaction = Transaction::new(base, MicroAlgos(1000), TransactionType::Payment(payment))?;

    let sign_response =
        kmd_client.sign_transaction(&wallet_handle_token, "testpassword", &transaction)?;

    println!(
        "kmd made signed transaction with {} bytes",
        sign_response.signed_transaction.len()
    );

    // Broadcast the transaction to the network
    // Note this transaction will get rejected because the accounts do not have any tokens
    let send_response = algod_client.raw_transaction(&sign_response.signed_transaction)?;

    println!("Transaction ID: {}", send_response.tx_id);

    Ok(())
}

pub fn versions(&self) -> Result<VersionsResponse, Error>

Retrieves the current version

Examples found in repository

examples/quickstart.rs (line 18)

fn main() {
    let algod_address = "http://localhost:8080";
    let algod_token = "contents-of-algod.token";
    let kmd_address = "http://localhost:7833";
    let kmd_token = "contents-of-kmd.token";

    let algod_client = AlgodClient::new(algod_address, algod_token);
    let kmd_client = KmdClient::new(kmd_address, kmd_token);

    println!(
        "Algod versions: {:?}",
        algod_client.versions().unwrap().versions
    );
    println!(
        "Kmd versions: {:?}",
        kmd_client.versions().unwrap().versions
    );
}

pub fn list_wallets(&self) -> Result<ListWalletsResponse, Error>

List all of the wallets that kmd is aware of

Examples found in repository

examples/wallet_backup.rs (line 11)

fn main() -> Result<(), Box<dyn Error>> {
    let kmd_address = "http://localhost:8080";
    let kmd_token = "contents-of-kmd.token";

    let kmd_client = KmdClient::new(kmd_address, kmd_token);

    let list_response = kmd_client.list_wallets()?;

    let wallet_id = match list_response
        .wallets
        .into_iter()
        .find(|wallet| wallet.name == "testwallet")
    {
        Some(wallet) => wallet.id,
        None => return Err("Wallet not found".into()),
    };

    let init_response = kmd_client.init_wallet_handle(&wallet_id, "testpassword")?;
    let wallet_handle_token = init_response.wallet_handle_token;

    let export_response =
        kmd_client.export_master_derivation_key(&wallet_handle_token, "testpassword")?;
    let mdk = export_response.master_derivation_key;

    // String representation of the mdk, keep in safe place and don't share it
    let string_to_save = mnemonic::from_key(&mdk.0)?;

    println!("Backup phrase: {}", string_to_save);

    Ok(())
}

examples/sign_submit_transaction.rs (line 15)

fn main() -> Result<(), Box<dyn Error>> {
    let kmd_address = "http://localhost:7833";
    let kmd_token = "contents-of-kmd.token";
    let algod_address = "http://localhost:8080";
    let algod_token = "contents-of-algod.token";

    let kmd_client = KmdClient::new(kmd_address, kmd_token);
    let algod_client = AlgodClient::new(algod_address, algod_token);

    let list_response = kmd_client.list_wallets()?;

    let wallet_id = match list_response
        .wallets
        .into_iter()
        .find(|wallet| wallet.name == "testwallet")
    {
        Some(wallet) => wallet.id,
        None => return Err("Wallet not found".into()),
    };

    let init_response = kmd_client.init_wallet_handle(&wallet_id, "testpassword")?;
    let wallet_handle_token = init_response.wallet_handle_token;

    let gen_response = kmd_client.generate_key(&wallet_handle_token)?;
    let from_address = Address::from_string(&gen_response.address)?;

    let gen_response = kmd_client.generate_key(&wallet_handle_token)?;
    let to_address = Address::from_string(&gen_response.address)?;

    let transaction_params = algod_client.transaction_params()?;

    let genesis_id = transaction_params.genesis_id;
    let genesis_hash = transaction_params.genesis_hash;

    let base = BaseTransaction {
        sender: from_address,
        first_valid: transaction_params.last_round,
        last_valid: transaction_params.last_round + 1000,
        note: Vec::new(),
        genesis_id,
        genesis_hash,
    };

    let payment = Payment {
        amount: MicroAlgos(200_000),
        receiver: to_address,
        close_remainder_to: None,
    };

    let transaction = Transaction::new(base, MicroAlgos(1000), TransactionType::Payment(payment))?;

    let sign_response =
        kmd_client.sign_transaction(&wallet_handle_token, "testpassword", &transaction)?;

    println!(
        "kmd made signed transaction with {} bytes",
        sign_response.signed_transaction.len()
    );

    // Broadcast the transaction to the network
    // Note this transaction will get rejected because the accounts do not have any tokens
    let send_response = algod_client.raw_transaction(&sign_response.signed_transaction)?;

    println!("Transaction ID: {}", send_response.tx_id);

    Ok(())
}

pub fn create_wallet( &self, wallet_name: &str, wallet_password: &str, wallet_driver_name: &str, master_derivation_key: MasterDerivationKey, ) -> Result<CreateWalletResponse, Error>

Creates a wallet

Examples found in repository

examples/kmd_client.rs (lines 11-16)

fn main() -> Result<(), Box<dyn Error>> {
    let kmd_address = "http://localhost:8080";
    let kmd_token = "contents-of-kmd.token";

    let kmd_client = KmdClient::new(kmd_address, kmd_token);

    let create_wallet_response = kmd_client.create_wallet(
        "testwallet",
        "testpassword",
        "sqlite",
        MasterDerivationKey([0; 32]),
    )?;
    let wallet_id = create_wallet_response.wallet.id;

    let init_response = kmd_client.init_wallet_handle(&wallet_id, "testpassword")?;
    let wallet_handle_token = init_response.wallet_handle_token;

    let gen_response = kmd_client.generate_key(&wallet_handle_token)?;
    println!("Generated address: {}", gen_response.address);

    Ok(())
}

examples/wallet_restore.rs (line 16)

fn main() -> Result<(), Box<dyn Error>> {
    let kmd_address = "http://localhost:8080";
    let kmd_token = "contents-of-kmd.token";

    let kmd_client = KmdClient::new(kmd_address, kmd_token);

    let backup_phrase = "fire enlist diesel stamp nuclear chunk student stumble call snow flock brush example slab guide choice option recall south kangaroo hundred matrix school above zero";
    let key_bytes = mnemonic::to_key(backup_phrase)?;
    let mdk = MasterDerivationKey(key_bytes);

    let create_wallet_response =
        kmd_client.create_wallet("testwallet", "testpassword", "sqlite", mdk)?;
    let wallet = create_wallet_response.wallet;

    println!("Created wallet {} with ID: {}", wallet.name, wallet.id);

    Ok(())
}

pub fn init_wallet_handle( &self, wallet_id: &str, wallet_password: &str, ) -> Result<InitWalletHandleResponse, Error>

Unlock the wallet and return a wallet token that can be used for subsequent operations

These tokens expire periodically and must be renewed. You can see how much time remains until expiration with get_wallet and renew it with renew_wallet_handle. When you’re done, you can invalidate the token with release_wallet_handle

Examples found in repository

examples/kmd_client.rs (line 19)

fn main() -> Result<(), Box<dyn Error>> {
    let kmd_address = "http://localhost:8080";
    let kmd_token = "contents-of-kmd.token";

    let kmd_client = KmdClient::new(kmd_address, kmd_token);

    let create_wallet_response = kmd_client.create_wallet(
        "testwallet",
        "testpassword",
        "sqlite",
        MasterDerivationKey([0; 32]),
    )?;
    let wallet_id = create_wallet_response.wallet.id;

    let init_response = kmd_client.init_wallet_handle(&wallet_id, "testpassword")?;
    let wallet_handle_token = init_response.wallet_handle_token;

    let gen_response = kmd_client.generate_key(&wallet_handle_token)?;
    println!("Generated address: {}", gen_response.address);

    Ok(())
}

examples/wallet_backup.rs (line 22)

fn main() -> Result<(), Box<dyn Error>> {
    let kmd_address = "http://localhost:8080";
    let kmd_token = "contents-of-kmd.token";

    let kmd_client = KmdClient::new(kmd_address, kmd_token);

    let list_response = kmd_client.list_wallets()?;

    let wallet_id = match list_response
        .wallets
        .into_iter()
        .find(|wallet| wallet.name == "testwallet")
    {
        Some(wallet) => wallet.id,
        None => return Err("Wallet not found".into()),
    };

    let init_response = kmd_client.init_wallet_handle(&wallet_id, "testpassword")?;
    let wallet_handle_token = init_response.wallet_handle_token;

    let export_response =
        kmd_client.export_master_derivation_key(&wallet_handle_token, "testpassword")?;
    let mdk = export_response.master_derivation_key;

    // String representation of the mdk, keep in safe place and don't share it
    let string_to_save = mnemonic::from_key(&mdk.0)?;

    println!("Backup phrase: {}", string_to_save);

    Ok(())
}

examples/sign_submit_transaction.rs (line 26)

fn main() -> Result<(), Box<dyn Error>> {
    let kmd_address = "http://localhost:7833";
    let kmd_token = "contents-of-kmd.token";
    let algod_address = "http://localhost:8080";
    let algod_token = "contents-of-algod.token";

    let kmd_client = KmdClient::new(kmd_address, kmd_token);
    let algod_client = AlgodClient::new(algod_address, algod_token);

    let list_response = kmd_client.list_wallets()?;

    let wallet_id = match list_response
        .wallets
        .into_iter()
        .find(|wallet| wallet.name == "testwallet")
    {
        Some(wallet) => wallet.id,
        None => return Err("Wallet not found".into()),
    };

    let init_response = kmd_client.init_wallet_handle(&wallet_id, "testpassword")?;
    let wallet_handle_token = init_response.wallet_handle_token;

    let gen_response = kmd_client.generate_key(&wallet_handle_token)?;
    let from_address = Address::from_string(&gen_response.address)?;

    let gen_response = kmd_client.generate_key(&wallet_handle_token)?;
    let to_address = Address::from_string(&gen_response.address)?;

    let transaction_params = algod_client.transaction_params()?;

    let genesis_id = transaction_params.genesis_id;
    let genesis_hash = transaction_params.genesis_hash;

    let base = BaseTransaction {
        sender: from_address,
        first_valid: transaction_params.last_round,
        last_valid: transaction_params.last_round + 1000,
        note: Vec::new(),
        genesis_id,
        genesis_hash,
    };

    let payment = Payment {
        amount: MicroAlgos(200_000),
        receiver: to_address,
        close_remainder_to: None,
    };

    let transaction = Transaction::new(base, MicroAlgos(1000), TransactionType::Payment(payment))?;

    let sign_response =
        kmd_client.sign_transaction(&wallet_handle_token, "testpassword", &transaction)?;

    println!(
        "kmd made signed transaction with {} bytes",
        sign_response.signed_transaction.len()
    );

    // Broadcast the transaction to the network
    // Note this transaction will get rejected because the accounts do not have any tokens
    let send_response = algod_client.raw_transaction(&sign_response.signed_transaction)?;

    println!("Transaction ID: {}", send_response.tx_id);

    Ok(())
}

pub fn release_wallet_handle( &self, wallet_handle: &str, ) -> Result<ReleaseWalletHandleResponse, Error>

Release a wallet handle token

pub fn renew_wallet_handle( &self, wallet_handle: &str, ) -> Result<RenewWalletHandleResponse, Error>

Renew a wallet handle token

pub fn rename_wallet( &self, wallet_id: &str, wallet_password: &str, new_name: &str, ) -> Result<RenameWalletResponse, Error>

Rename a wallet

pub fn get_wallet( &self, wallet_handle: &str, ) -> Result<GetWalletResponse, Error>

Get wallet info

pub fn export_master_derivation_key( &self, wallet_handle: &str, wallet_password: &str, ) -> Result<ExportMasterDerivationKeyResponse, Error>

Export the master derivation key from a wallet

Examples found in repository

examples/wallet_backup.rs (line 26)

fn main() -> Result<(), Box<dyn Error>> {
    let kmd_address = "http://localhost:8080";
    let kmd_token = "contents-of-kmd.token";

    let kmd_client = KmdClient::new(kmd_address, kmd_token);

    let list_response = kmd_client.list_wallets()?;

    let wallet_id = match list_response
        .wallets
        .into_iter()
        .find(|wallet| wallet.name == "testwallet")
    {
        Some(wallet) => wallet.id,
        None => return Err("Wallet not found".into()),
    };

    let init_response = kmd_client.init_wallet_handle(&wallet_id, "testpassword")?;
    let wallet_handle_token = init_response.wallet_handle_token;

    let export_response =
        kmd_client.export_master_derivation_key(&wallet_handle_token, "testpassword")?;
    let mdk = export_response.master_derivation_key;

    // String representation of the mdk, keep in safe place and don't share it
    let string_to_save = mnemonic::from_key(&mdk.0)?;

    println!("Backup phrase: {}", string_to_save);

    Ok(())
}

pub fn import_key( &self, wallet_handle: &str, private_key: [u8; 32], ) -> Result<ImportKeyResponse, Error>

Import an externally generated key into the wallet

pub fn export_key( &self, wallet_handle: &str, wallet_password: &str, address: &str, ) -> Result<ExportKeyResponse, Error>

Export the Ed25519 seed associated with the passed address

Note the first 32 bytes of the returned value is the seed, the second 32 bytes is the public key

pub fn generate_key( &self, wallet_handle: &str, ) -> Result<GenerateKeyResponse, Error>

Generates a key and adds it to the wallet, returning the public key

Examples found in repository

examples/kmd_client.rs (line 22)

fn main() -> Result<(), Box<dyn Error>> {
    let kmd_address = "http://localhost:8080";
    let kmd_token = "contents-of-kmd.token";

    let kmd_client = KmdClient::new(kmd_address, kmd_token);

    let create_wallet_response = kmd_client.create_wallet(
        "testwallet",
        "testpassword",
        "sqlite",
        MasterDerivationKey([0; 32]),
    )?;
    let wallet_id = create_wallet_response.wallet.id;

    let init_response = kmd_client.init_wallet_handle(&wallet_id, "testpassword")?;
    let wallet_handle_token = init_response.wallet_handle_token;

    let gen_response = kmd_client.generate_key(&wallet_handle_token)?;
    println!("Generated address: {}", gen_response.address);

    Ok(())
}

examples/sign_submit_transaction.rs (line 29)

fn main() -> Result<(), Box<dyn Error>> {
    let kmd_address = "http://localhost:7833";
    let kmd_token = "contents-of-kmd.token";
    let algod_address = "http://localhost:8080";
    let algod_token = "contents-of-algod.token";

    let kmd_client = KmdClient::new(kmd_address, kmd_token);
    let algod_client = AlgodClient::new(algod_address, algod_token);

    let list_response = kmd_client.list_wallets()?;

    let wallet_id = match list_response
        .wallets
        .into_iter()
        .find(|wallet| wallet.name == "testwallet")
    {
        Some(wallet) => wallet.id,
        None => return Err("Wallet not found".into()),
    };

    let init_response = kmd_client.init_wallet_handle(&wallet_id, "testpassword")?;
    let wallet_handle_token = init_response.wallet_handle_token;

    let gen_response = kmd_client.generate_key(&wallet_handle_token)?;
    let from_address = Address::from_string(&gen_response.address)?;

    let gen_response = kmd_client.generate_key(&wallet_handle_token)?;
    let to_address = Address::from_string(&gen_response.address)?;

    let transaction_params = algod_client.transaction_params()?;

    let genesis_id = transaction_params.genesis_id;
    let genesis_hash = transaction_params.genesis_hash;

    let base = BaseTransaction {
        sender: from_address,
        first_valid: transaction_params.last_round,
        last_valid: transaction_params.last_round + 1000,
        note: Vec::new(),
        genesis_id,
        genesis_hash,
    };

    let payment = Payment {
        amount: MicroAlgos(200_000),
        receiver: to_address,
        close_remainder_to: None,
    };

    let transaction = Transaction::new(base, MicroAlgos(1000), TransactionType::Payment(payment))?;

    let sign_response =
        kmd_client.sign_transaction(&wallet_handle_token, "testpassword", &transaction)?;

    println!(
        "kmd made signed transaction with {} bytes",
        sign_response.signed_transaction.len()
    );

    // Broadcast the transaction to the network
    // Note this transaction will get rejected because the accounts do not have any tokens
    let send_response = algod_client.raw_transaction(&sign_response.signed_transaction)?;

    println!("Transaction ID: {}", send_response.tx_id);

    Ok(())
}

pub fn delete_key( &self, wallet_handle: &str, wallet_password: &str, address: &str, ) -> Result<DeleteKeyResponse, Error>

Deletes the key from the wallet

pub fn list_keys(&self, wallet_handle: &str) -> Result<ListKeysResponse, Error>

List all of the public keys in the wallet

pub fn sign_transaction( &self, wallet_handle: &str, wallet_password: &str, transaction: &Transaction, ) -> Result<SignTransactionResponse, Error>

Sign a transaction

Examples found in repository

examples/sign_submit_transaction.rs (line 58)

fn main() -> Result<(), Box<dyn Error>> {
    let kmd_address = "http://localhost:7833";
    let kmd_token = "contents-of-kmd.token";
    let algod_address = "http://localhost:8080";
    let algod_token = "contents-of-algod.token";

    let kmd_client = KmdClient::new(kmd_address, kmd_token);
    let algod_client = AlgodClient::new(algod_address, algod_token);

    let list_response = kmd_client.list_wallets()?;

    let wallet_id = match list_response
        .wallets
        .into_iter()
        .find(|wallet| wallet.name == "testwallet")
    {
        Some(wallet) => wallet.id,
        None => return Err("Wallet not found".into()),
    };

    let init_response = kmd_client.init_wallet_handle(&wallet_id, "testpassword")?;
    let wallet_handle_token = init_response.wallet_handle_token;

    let gen_response = kmd_client.generate_key(&wallet_handle_token)?;
    let from_address = Address::from_string(&gen_response.address)?;

    let gen_response = kmd_client.generate_key(&wallet_handle_token)?;
    let to_address = Address::from_string(&gen_response.address)?;

    let transaction_params = algod_client.transaction_params()?;

    let genesis_id = transaction_params.genesis_id;
    let genesis_hash = transaction_params.genesis_hash;

    let base = BaseTransaction {
        sender: from_address,
        first_valid: transaction_params.last_round,
        last_valid: transaction_params.last_round + 1000,
        note: Vec::new(),
        genesis_id,
        genesis_hash,
    };

    let payment = Payment {
        amount: MicroAlgos(200_000),
        receiver: to_address,
        close_remainder_to: None,
    };

    let transaction = Transaction::new(base, MicroAlgos(1000), TransactionType::Payment(payment))?;

    let sign_response =
        kmd_client.sign_transaction(&wallet_handle_token, "testpassword", &transaction)?;

    println!(
        "kmd made signed transaction with {} bytes",
        sign_response.signed_transaction.len()
    );

    // Broadcast the transaction to the network
    // Note this transaction will get rejected because the accounts do not have any tokens
    let send_response = algod_client.raw_transaction(&sign_response.signed_transaction)?;

    println!("Transaction ID: {}", send_response.tx_id);

    Ok(())
}

pub fn list_multisig( &self, wallet_handle: &str, ) -> Result<ListMultisigResponse, Error>

Lists all of the multisig accounts whose preimages this wallet stores

pub fn import_multisig( &self, wallet_handle: &str, version: u8, threshold: u8, pks: &[Ed25519PublicKey], ) -> Result<ImportMultisigResponse, Error>

Import a multisig account

pub fn export_multisig( &self, wallet_handle: &str, address: &str, ) -> Result<ExportMultisigResponse, Error>

Export multisig address metadata

pub fn delete_multisig( &self, wallet_handle: &str, wallet_password: &str, address: &str, ) -> Result<DeleteMultisigResponse, Error>

Delete a multisig from the wallet

pub fn sign_multisig_transaction( &self, wallet_handle: &str, wallet_password: &str, transaction: &Transaction, public_key: Ed25519PublicKey, partial_multisig: Option<MultisigSignature>, ) -> Result<SignMultisigTransactionResponse, Error>

Start a multisig signature or add a signature to a partially completed multisig signature