Struct Account

pub struct Account { /* private fields */ }

Implementations

impl Account

pub fn generate() -> Account

Examples found in repository

examples/sign_offline.rs (line 10)

fn main() -> Result<(), Box<dyn Error>> {
    let account = Account::generate();

    let m = mnemonic::from_key(&account.seed())?;
    println!("Backup phrase: {}", m);
    let fee = MicroAlgos(1000);
    let amount = MicroAlgos(20000);
    let first_round = Round(642_715);
    let last_round = first_round + 1000;

    let base = BaseTransaction {
        sender: account.address(),
        first_valid: first_round,
        last_valid: last_round,
        note: Vec::new(),
        genesis_id: "".to_string(),
        genesis_hash: HashDigest([0; 32]),
    };
    let payment = Payment {
        amount,
        receiver: Address::from_string(
            "4MYUHDWHWXAKA5KA7U5PEN646VYUANBFXVJNONBK3TIMHEMWMD4UBOJBI4",
        )?,
        close_remainder_to: None,
    };

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

    println!("Made unsigned transaction: {:?}", transaction);

    // Sign the transaction
    let signed_transaction = account.sign_transaction(&transaction)?;
    let bytes = rmp_serde::to_vec_named(&signed_transaction)?;

    let filename = "./signed.tx";
    let mut f = File::create(filename)?;
    f.write_all(&bytes)?;

    println!("Saved signed transaction to file: {}", filename);

    Ok(())
}

pub fn from_mnemonic(mnemonic: &str) -> Result<Account, Error>

Create account from human readable mnemonic of a 32 byte seed

pub fn from_seed(seed: [u8; 32]) -> Account

Create account from 32 byte seed

pub fn address(&self) -> Address

Get the public key address of the account

Examples found in repository

examples/sign_offline.rs (line 20)

fn main() -> Result<(), Box<dyn Error>> {
    let account = Account::generate();

    let m = mnemonic::from_key(&account.seed())?;
    println!("Backup phrase: {}", m);
    let fee = MicroAlgos(1000);
    let amount = MicroAlgos(20000);
    let first_round = Round(642_715);
    let last_round = first_round + 1000;

    let base = BaseTransaction {
        sender: account.address(),
        first_valid: first_round,
        last_valid: last_round,
        note: Vec::new(),
        genesis_id: "".to_string(),
        genesis_hash: HashDigest([0; 32]),
    };
    let payment = Payment {
        amount,
        receiver: Address::from_string(
            "4MYUHDWHWXAKA5KA7U5PEN646VYUANBFXVJNONBK3TIMHEMWMD4UBOJBI4",
        )?,
        close_remainder_to: None,
    };

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

    println!("Made unsigned transaction: {:?}", transaction);

    // Sign the transaction
    let signed_transaction = account.sign_transaction(&transaction)?;
    let bytes = rmp_serde::to_vec_named(&signed_transaction)?;

    let filename = "./signed.tx";
    let mut f = File::create(filename)?;
    f.write_all(&bytes)?;

    println!("Saved signed transaction to file: {}", filename);

    Ok(())
}

pub fn mnemonic(&self) -> String

Get the human readable mnemonic of the 32 byte seed

pub fn seed(&self) -> [u8; 32]

Get the 32 byte seed

Examples found in repository

examples/sign_offline.rs (line 12)

fn main() -> Result<(), Box<dyn Error>> {
    let account = Account::generate();

    let m = mnemonic::from_key(&account.seed())?;
    println!("Backup phrase: {}", m);
    let fee = MicroAlgos(1000);
    let amount = MicroAlgos(20000);
    let first_round = Round(642_715);
    let last_round = first_round + 1000;

    let base = BaseTransaction {
        sender: account.address(),
        first_valid: first_round,
        last_valid: last_round,
        note: Vec::new(),
        genesis_id: "".to_string(),
        genesis_hash: HashDigest([0; 32]),
    };
    let payment = Payment {
        amount,
        receiver: Address::from_string(
            "4MYUHDWHWXAKA5KA7U5PEN646VYUANBFXVJNONBK3TIMHEMWMD4UBOJBI4",
        )?,
        close_remainder_to: None,
    };

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

    println!("Made unsigned transaction: {:?}", transaction);

    // Sign the transaction
    let signed_transaction = account.sign_transaction(&transaction)?;
    let bytes = rmp_serde::to_vec_named(&signed_transaction)?;

    let filename = "./signed.tx";
    let mut f = File::create(filename)?;
    f.write_all(&bytes)?;

    println!("Saved signed transaction to file: {}", filename);

    Ok(())
}

pub fn sign_bid(&self, bid: Bid) -> Result<SignedBid, Error>

Sign a bid with the account’s private key

pub fn sign_transaction( &self, transaction: &Transaction, ) -> Result<SignedTransaction, Error>

Sign a transaction with the account’s private key

Examples found in repository

examples/sign_offline.rs (line 40)

fn main() -> Result<(), Box<dyn Error>> {
    let account = Account::generate();

    let m = mnemonic::from_key(&account.seed())?;
    println!("Backup phrase: {}", m);
    let fee = MicroAlgos(1000);
    let amount = MicroAlgos(20000);
    let first_round = Round(642_715);
    let last_round = first_round + 1000;

    let base = BaseTransaction {
        sender: account.address(),
        first_valid: first_round,
        last_valid: last_round,
        note: Vec::new(),
        genesis_id: "".to_string(),
        genesis_hash: HashDigest([0; 32]),
    };
    let payment = Payment {
        amount,
        receiver: Address::from_string(
            "4MYUHDWHWXAKA5KA7U5PEN646VYUANBFXVJNONBK3TIMHEMWMD4UBOJBI4",
        )?,
        close_remainder_to: None,
    };

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

    println!("Made unsigned transaction: {:?}", transaction);

    // Sign the transaction
    let signed_transaction = account.sign_transaction(&transaction)?;
    let bytes = rmp_serde::to_vec_named(&signed_transaction)?;

    let filename = "./signed.tx";
    let mut f = File::create(filename)?;
    f.write_all(&bytes)?;

    println!("Saved signed transaction to file: {}", filename);

    Ok(())
}

pub fn sign_multisig_transaction( &self, from: MultisigAddress, transaction: &Transaction, ) -> Result<SignedTransaction, Error>

Sign the transaction and populate the multisig field of the signed transaction with the given multisig address

pub fn append_multisig_transaction( &self, from: MultisigAddress, transaction: &SignedTransaction, ) -> Result<SignedTransaction, Error>

Appends the multisig signature from the given multisig address to the transaction

pub fn merge_multisig_transactions<T: Borrow<SignedTransaction>>( transactions: &[T], ) -> Result<SignedTransaction, Error>

Returns a signed transaction with the multisig signatures of the passed signed transactions merged