487845148

Build Type

github

Committed by GitHub

Commit Message

Merge ce4fdc1b9 into 59e4ccb8e

Pull Request Pull Request #206: feat(signing): add metadata param to sign_message and generate_address

Run Details

4070 of 21143 branches covered (19.25%)

Branch coverage included in aggregate %.

5 of 60 new or added lines in 7 files covered. (8.33%)

2 existing lines in 1 file now uncovered.

1584 of 3449 relevant lines covered (45.93%)

440.81 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

10.46

/src/address.rs

// Copyright 2020 IOTA Stiftung
// SPDX-License-Identifier: Apache-2.0

use crate::{account::Account, message::MessageType, signing::GenerateAddressMetadata};
use bech32::FromBase32;
use getset::{Getters, Setters};
pub use iota::message::prelude::{Address as IotaAddress, Ed25519Address, Input, Payload, UTXOInput};
use iota::{
    message::prelude::{MessageId, TransactionId},
    OutputMetadata,
};
use serde::{Deserialize, Serialize};
use std::{
    cmp::Ordering,
    convert::{TryFrom, TryInto},
    hash::{Hash, Hasher},
};

/// An Address output.
#[derive(Debug, Getters, Setters, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[getset(get = "pub")]
pub struct AddressOutput {
    /// Transaction ID of the output
    transaction_id: TransactionId,
    /// Message ID of the output
    message_id: MessageId,
    /// Output index.
    index: u16,
    /// Output amount.
    amount: u64,
    /// Spend status of the output,
    is_spent: bool,
}

impl AddressOutput {
    /// Checks if the output is referenced on a pending message or a confirmed message
    pub(crate) fn is_used(&self, account: &Account) -> bool {
        let output_id = UTXOInput::new(self.transaction_id, self.index).unwrap();
        account.list_messages(0, 0, None).iter().any(|m| {
            // message is pending or confirmed
            if m.confirmed().unwrap_or(true) {
                match m.payload() {
                    Payload::Transaction(tx) => tx.essence().inputs().iter().any(|input| {
                        if let Input::UTXO(x) = input {
                            x == &output_id
                        } else {
                            false
                        }
                    }),
                    _ => false,
                }
            } else {
                false
            }
        })
    }
}

impl TryFrom<OutputMetadata> for AddressOutput {
    type Error = crate::Error;

    fn try_from(output: OutputMetadata) -> crate::Result<Self> {
        let output = Self {
            transaction_id: TransactionId::new(
                output.transaction_id[..]
                    .try_into()
                    .map_err(|_| crate::Error::InvalidTransactionId)?,
            ),
            message_id: MessageId::new(
                output.message_id[..]
                    .try_into()
                    .map_err(|_| crate::Error::InvalidMessageId)?,
            ),
            index: output.output_index,
            amount: output.amount,
            is_spent: output.is_spent,
        };
        Ok(output)
    }
}

/// The address builder.
#[derive(Default)]
pub struct AddressBuilder {
    address: Option<IotaAddress>,
    balance: Option<u64>,
    key_index: Option<usize>,
    internal: bool,
    outputs: Option<Vec<AddressOutput>>,
}

impl AddressBuilder {
    /// Initialises a new instance of the address builder.
    pub fn new() -> AddressBuilder {
        Default::default()
    }

    /// Defines the address.
    pub fn address(mut self, address: IotaAddress) -> Self {
        self.address = Some(address);
        self
    }

    /// Sets the address balance.
    pub fn balance(mut self, balance: u64) -> Self {
        self.balance = Some(balance);
        self
    }

    /// Sets the address key index.
    pub fn key_index(mut self, key_index: usize) -> Self {
        self.key_index = Some(key_index);
        self
    }

    /// Sets the address outputs.
    pub fn outputs(mut self, outputs: Vec<AddressOutput>) -> Self {
        self.outputs = Some(outputs);
        self
    }

    /// Sets the `internal` flag.
    pub fn internal(mut self, internal: bool) -> Self {
        self.internal = internal;
        self
    }

    /// Builds the address.
    pub fn build(self) -> crate::Result<Address> {
        let iota_address = self.address.ok_or(crate::Error::AddressBuildRequiredField(
            crate::AddressBuildRequiredField::Address,
        ))?;
        let address = Address {
            address: iota_address,
            balance: self.balance.ok_or(crate::Error::AddressBuildRequiredField(
                crate::AddressBuildRequiredField::Balance,
            ))?,
            key_index: self.key_index.ok_or(crate::Error::AddressBuildRequiredField(
                crate::AddressBuildRequiredField::KeyIndex,
            ))?,
            internal: self.internal,
            outputs: self.outputs.ok_or(crate::Error::AddressBuildRequiredField(
                crate::AddressBuildRequiredField::Outputs,
            ))?,
        };
        Ok(address)
    }
}

/// An address.
#[derive(Debug, Getters, Setters, Clone, Eq, Serialize, Deserialize)]
#[getset(get = "pub")]
pub struct Address {
    /// The address.
    #[serde(with = "crate::serde::iota_address_serde")]
    address: IotaAddress,
    /// The address balance.
    #[getset(set = "pub")]
    balance: u64,
    /// The address key index.
    #[serde(rename = "keyIndex")]
    key_index: usize,
    /// Determines if an address is a public or an internal (change) address.
    internal: bool,
    /// The address outputs.
    #[getset(set = "pub(crate)")]
    pub(crate) outputs: Vec<AddressOutput>,
}

impl PartialOrd for Address {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

impl Ord for Address {
    fn cmp(&self, other: &Self) -> Ordering {
        self.address.to_bech32().cmp(&other.address.to_bech32())
    }
}

impl Hash for Address {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.address.to_bech32().hash(state);
    }
}

impl PartialEq for Address {
    fn eq(&self, other: &Self) -> bool {
        self.address.to_bech32() == other.address.to_bech32()
    }
}

impl Address {
    pub(crate) fn handle_new_output(&mut self, output: AddressOutput) {
        if !self.outputs.iter().any(|o| o == &output) {
            let spent_existing_output = self.outputs.iter().position(|o| {
                o.message_id == output.message_id
                    && o.transaction_id == output.transaction_id
                    && o.index == output.index
                    && o.amount == output.amount
                    && (!o.is_spent && output.is_spent)
            });
            if let Some(spent_output) = spent_existing_output {
                log::debug!("[ADDRESS] got spent of {:?}", spent_output);
                self.balance -= output.amount;
                self.outputs.remove(spent_output);
            } else {
                log::debug!("[ADDRESS] got new output {:?}", output);
                self.balance += output.amount;
                self.outputs.push(output);
            }
        }
    }

    /// Gets the list of outputs that aren't spent or pending.
    pub fn available_outputs(&self, account: &Account) -> Vec<&AddressOutput> {
        self.outputs.iter().filter(|o| !o.is_used(account)).collect()
    }

    pub(crate) fn available_balance(&self, account: &Account) -> u64 {
        self.available_outputs(account)
            .iter()
            .fold(0, |acc, o| acc + *o.amount())
    }
}

/// Parses a bech32 address string.
pub fn parse(address: String) -> crate::Result<IotaAddress> {
    let address_ed25519 = Vec::from_base32(&bech32::decode(&address)?.1)?;
    let iota_address = IotaAddress::Ed25519(Ed25519Address::new(
        address_ed25519[1..]
            .try_into()
            .map_err(|_| crate::Error::InvalidAddressLength)?,
    ));
    Ok(iota_address)
}

pub(crate) async fn get_iota_address(
    account: &Account,
    address_index: usize,
    internal: bool,
    metadata: GenerateAddressMetadata,
) -> crate::Result<IotaAddress> {
    let signer = crate::signing::get_signer(account.signer_type()).await;
    let signer = signer.lock().await;
    signer
        .generate_address(&account, address_index, internal, metadata)
        .await
}

/// Gets an unused public address for the given account.
pub(crate) async fn get_new_address(account: &Account, metadata: GenerateAddressMetadata) -> crate::Result<Address> {
    let key_index = account.addresses().iter().filter(|a| !a.internal()).count();
    let iota_address = get_iota_address(&account, key_index, false, metadata).await?;
    let address = Address {
        address: iota_address,
        balance: 0,
        key_index,
        internal: false,
        outputs: vec![],
    };
    Ok(address)
}

/// Gets an unused change address for the given account and address.
pub(crate) async fn get_new_change_address(
    account: &Account,
    address: &Address,
    metadata: GenerateAddressMetadata,
) -> crate::Result<Address> {
    let key_index = *address.key_index();
    let iota_address = get_iota_address(&account, key_index, true, metadata).await?;
    let address = Address {
        address: iota_address,
        balance: 0,
        key_index,
        internal: true,
        outputs: vec![],
    };
    Ok(address)
}

pub(crate) fn is_unspent(account: &Account, address: &IotaAddress) -> bool {
    !account
        .list_messages(0, 0, Some(MessageType::Sent))
        .iter()
        .any(|message| message.addresses().contains(&address))
}

1	// Copyright 2020 IOTA Stiftung	×
2	// SPDX-License-Identifier: Apache-2.0
3
4	use crate::{account::Account, message::MessageType, signing::GenerateAddressMetadata};
5	use bech32::FromBase32;
6	use getset::{Getters, Setters};
7	pub use iota::message::prelude::{Address as IotaAddress, Ed25519Address, Input, Payload, UTXOInput};
8	use iota::{
9	message::prelude::{MessageId, TransactionId},
10	OutputMetadata,
11	};
12	use serde::{Deserialize, Serialize};
13	use std::{
14	cmp::Ordering,
15	convert::{TryFrom, TryInto},
16	hash::{Hash, Hasher},
17	};
18
19	/// An Address output.
20	#[derive(Debug, Getters, Setters, Clone, PartialEq, Eq, Serialize, Deserialize)]	×
21	#[getset(get = "pub")]
22	pub struct AddressOutput {
23	/// Transaction ID of the output
24	transaction_id: TransactionId,	×
25	/// Message ID of the output
26	message_id: MessageId,	×
27	/// Output index.
28	index: u16,	×
29	/// Output amount.
30	amount: u64,	×
31	/// Spend status of the output,
32	is_spent: bool,	×
33	}
34
35	impl AddressOutput {
36	/// Checks if the output is referenced on a pending message or a confirmed message
37	pub(crate) fn is_used(&self, account: &Account) -> bool {	×
38	let output_id = UTXOInput::new(self.transaction_id, self.index).unwrap();	×
39	account.list_messages(0, 0, None).iter().any(\|m\| {	×
40	// message is pending or confirmed
41	if m.confirmed().unwrap_or(true) {	×
42	match m.payload() {	×
43	Payload::Transaction(tx) => tx.essence().inputs().iter().any(\|input\| {	×
44	if let Input::UTXO(x) = input {	×
45	x == &output_id	×
46	} else {
47	false	×
48	}
49	}),	×
50	_ => false,	×
51	}
52	} else {
53	false	×
54	}
55	})	×
56	}	×
57	}
58
59	impl TryFrom<OutputMetadata> for AddressOutput {
60	type Error = crate::Error;
61
62	fn try_from(output: OutputMetadata) -> crate::Result<Self> {	×
63	let output = Self {	×
64	transaction_id: TransactionId::new(	×
65	output.transaction_id[..]	×
66	.try_into()
67	.map_err(\|_\| crate::Error::InvalidTransactionId)?,	×
68	),
69	message_id: MessageId::new(	×
70	output.message_id[..]	×
71	.try_into()
72	.map_err(\|_\| crate::Error::InvalidMessageId)?,	×
73	),
74	index: output.output_index,	×
75	amount: output.amount,	×
76	is_spent: output.is_spent,	×
77	};	×
78	Ok(output)	×
79	}	×
80	}
81
82	/// The address builder.
83	#[derive(Default)]	4,925✔
84	pub struct AddressBuilder {
85	address: Option<IotaAddress>,	2,463✔
86	balance: Option<u64>,	2,463✔
87	key_index: Option<usize>,	2,463✔
88	internal: bool,	2,463✔
89	outputs: Option<Vec<AddressOutput>>,	2,462✔
90	}
91
92	impl AddressBuilder {
93	/// Initialises a new instance of the address builder.
94	pub fn new() -> AddressBuilder {	2,463✔
95	Default::default()	2,463✔
96	}	2,462✔
97
98	/// Defines the address.
99	pub fn address(mut self, address: IotaAddress) -> Self {	2,463✔
100	self.address = Some(address);	2,463✔
101	self	2,463✔
102	}	2,463✔
103
104	/// Sets the address balance.
105	pub fn balance(mut self, balance: u64) -> Self {	2,464✔
106	self.balance = Some(balance);	2,464✔
107	self	2,464✔
108	}	2,464✔
109
110	/// Sets the address key index.
111	pub fn key_index(mut self, key_index: usize) -> Self {	2,464✔
112	self.key_index = Some(key_index);	2,464✔
113	self	2,464✔
114	}	2,464✔
115
116	/// Sets the address outputs.
117	pub fn outputs(mut self, outputs: Vec<AddressOutput>) -> Self {	2,464✔
118	self.outputs = Some(outputs);	2,464!
119	self	2,464✔
120	}	2,464✔
121
122	/// Sets the `internal` flag.
123	pub fn internal(mut self, internal: bool) -> Self {	×
124	self.internal = internal;	×
125	self	×
126	}	×
127
128	/// Builds the address.
129	pub fn build(self) -> crate::Result<Address> {	2,464✔
130	let iota_address = self.address.ok_or(crate::Error::AddressBuildRequiredField(	4,928!
131	crate::AddressBuildRequiredField::Address,
132	))?;	2,464!
133	let address = Address {	2,464✔
134	address: iota_address,	2,464✔
135	balance: self.balance.ok_or(crate::Error::AddressBuildRequiredField(	4,928!
136	crate::AddressBuildRequiredField::Balance,
137	))?,	2,464!
138	key_index: self.key_index.ok_or(crate::Error::AddressBuildRequiredField(	4,928!
139	crate::AddressBuildRequiredField::KeyIndex,
140	))?,	2,464!
141	internal: self.internal,	2,464✔
142	outputs: self.outputs.ok_or(crate::Error::AddressBuildRequiredField(	4,928!
143	crate::AddressBuildRequiredField::Outputs,
144	))?,	2,464!
145	};	×
146	Ok(address)	2,464✔
147	}	2,464!
148	}
149
150	/// An address.
151	#[derive(Debug, Getters, Setters, Clone, Eq, Serialize, Deserialize)]	4!
152	#[getset(get = "pub")]
153	pub struct Address {
154	/// The address.
155	#[serde(with = "crate::serde::iota_address_serde")]
156	address: IotaAddress,	×
157	/// The address balance.
158	#[getset(set = "pub")]
159	balance: u64,	×
160	/// The address key index.
161	#[serde(rename = "keyIndex")]
162	key_index: usize,	×
163	/// Determines if an address is a public or an internal (change) address.
164	internal: bool,	×
165	/// The address outputs.
166	#[getset(set = "pub(crate)")]
167	pub(crate) outputs: Vec<AddressOutput>,	×
168	}
169
170	impl PartialOrd for Address {
171	fn partial_cmp(&self, other: &Self) -> Option<Ordering> {	×
172	Some(self.cmp(other))	×
173	}	×
174	}
175
176	impl Ord for Address {
177	fn cmp(&self, other: &Self) -> Ordering {	×
178	self.address.to_bech32().cmp(&other.address.to_bech32())	×
179	}	×
180	}
181
182	impl Hash for Address {
183	fn hash<H: Hasher>(&self, state: &mut H) {
184	self.address.to_bech32().hash(state);
185	}
186	}
187
188	impl PartialEq for Address {
189	fn eq(&self, other: &Self) -> bool {	×
190	self.address.to_bech32() == other.address.to_bech32()	×
191	}	×
192	}
193
194	impl Address {
195	pub(crate) fn handle_new_output(&mut self, output: AddressOutput) {	×
196	if !self.outputs.iter().any(\|o\| o == &output) {	×
197	let spent_existing_output = self.outputs.iter().position(\|o\| {	×
198	o.message_id == output.message_id	×
199	&& o.transaction_id == output.transaction_id	×
200	&& o.index == output.index	×
201	&& o.amount == output.amount	×
202	&& (!o.is_spent && output.is_spent)	×
203	});	×
204	if let Some(spent_output) = spent_existing_output {	×
205	log::debug!("[ADDRESS] got spent of {:?}", spent_output);	×
206	self.balance -= output.amount;	×
207	self.outputs.remove(spent_output);	×
208	} else {
209	log::debug!("[ADDRESS] got new output {:?}", output);	×
210	self.balance += output.amount;	×
211	self.outputs.push(output);	×
212	}
213	}
214	}	×
215
216	/// Gets the list of outputs that aren't spent or pending.
217	pub fn available_outputs(&self, account: &Account) -> Vec<&AddressOutput> {	×
218	self.outputs.iter().filter(\|o\| !o.is_used(account)).collect()	×
219	}	×
220
221	pub(crate) fn available_balance(&self, account: &Account) -> u64 {	×
222	self.available_outputs(account)	×
223	.iter()
224	.fold(0, \|acc, o\| acc + *o.amount())	×
225	}	×
226	}
227
228	/// Parses a bech32 address string.
229	pub fn parse(address: String) -> crate::Result<IotaAddress> {	×
230	let address_ed25519 = Vec::from_base32(&bech32::decode(&address)?.1)?;	×
231	let iota_address = IotaAddress::Ed25519(Ed25519Address::new(	×
232	address_ed25519[1..]	×
233	.try_into()
234	.map_err(\|_\| crate::Error::InvalidAddressLength)?,	×
235	));	×
236	Ok(iota_address)	×
237	}	×
238
239	pub(crate) async fn get_iota_address(	18✔
240	account: &Account,	18✔
241	address_index: usize,	18✔
242	internal: bool,	18✔
243	metadata: GenerateAddressMetadata,	18✔
244	) -> crate::Result<IotaAddress> {	153!
245	let signer = crate::signing::get_signer(account.signer_type()).await;	18!
246	let signer = signer.lock().await;	27!
247	signer	126!
248	.generate_address(&account, address_index, internal, metadata)	18!
249	.await
250	}	36!
251
252	/// Gets an unused public address for the given account.
NEW 253	pub(crate) async fn get_new_address(account: &Account, metadata: GenerateAddressMetadata) -> crate::Result<Address> {	×
254	let key_index = account.addresses().iter().filter(\|a\| !a.internal()).count();	×
NEW 255	let iota_address = get_iota_address(&account, key_index, false, metadata).await?;	×
256	let address = Address {	×
257	address: iota_address,	×
258	balance: 0,
259	key_index,	×
260	internal: false,
261	outputs: vec![],	×
262	};
263	Ok(address)	×
264	}	×
265
266	/// Gets an unused change address for the given account and address.
NEW 267	pub(crate) async fn get_new_change_address(	×
NEW 268	account: &Account,	×
NEW 269	address: &Address,	×
NEW 270	metadata: GenerateAddressMetadata,	×
NEW 271	) -> crate::Result<Address> {	×
272	let key_index = *address.key_index();	×
NEW 273	let iota_address = get_iota_address(&account, key_index, true, metadata).await?;	×
274	let address = Address {	×
275	address: iota_address,	×
276	balance: 0,
277	key_index,	×
278	internal: true,
279	outputs: vec![],	×
280	};
281	Ok(address)	×
282	}	×
283
284	pub(crate) fn is_unspent(account: &Account, address: &IotaAddress) -> bool {	×
285	!account	×
286	.list_messages(0, 0, Some(MessageType::Sent))	×
287	.iter()
288	.any(\|message\| message.addresses().contains(&address))	×
289	}	×

iotaledger / wallet.rs / 487845148

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous