493963000

Build Type

github

Committed by GitHub

Commit Message

Merge 099b46067 into 6d38f6bfc

Pull Request Pull Request #227: fix(address): `get_new_address` checking if the address list is empty

Run Details

4107 of 21352 branches covered (19.23%)

Branch coverage included in aggregate %.

0 of 4 new or added lines in 1 file covered. (0.0%)

10 existing lines in 1 file now uncovered.

1639 of 3455 relevant lines covered (47.44%)

446.75 hits per line

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

11.42

/src/address.rs

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

use crate::{account::Account, message::MessageType, signing::GenerateAddressMetadata};
use getset::{Getters, Setters};
pub use iota::{client::builder::Network, 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},
    str::FromStr,
};

/// 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(crate) struct AddressBuilder {
    address: Option<AddressWrapper>,
    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: AddressWrapper) -> 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::error::AddressBuildRequiredField::Address,
        ))?;
        let address = Address {
            address: iota_address,
            balance: self.balance.ok_or(crate::Error::AddressBuildRequiredField(
                crate::error::AddressBuildRequiredField::Balance,
            ))?,
            key_index: self.key_index.ok_or(crate::Error::AddressBuildRequiredField(
                crate::error::AddressBuildRequiredField::KeyIndex,
            ))?,
            internal: self.internal,
            outputs: self.outputs.ok_or(crate::Error::AddressBuildRequiredField(
                crate::error::AddressBuildRequiredField::Outputs,
            ))?,
        };
        Ok(address)
    }
}

/// An address and its network type.
#[derive(Debug, Clone, PartialEq, Eq, Getters)]
pub struct AddressWrapper {
    inner: IotaAddress,
    #[getset(get = "pub(crate)")]
    hrp: String,
}

impl AsRef<IotaAddress> for AddressWrapper {
    fn as_ref(&self) -> &IotaAddress {
        &self.inner
    }
}

impl AddressWrapper {
    pub(crate) fn new(address: IotaAddress, hrp: String) -> Self {
        Self { inner: address, hrp }
    }

    /// Encodes the address as bech32.
    pub fn to_bech32(&self) -> String {
        self.inner.to_bech32(&self.hrp)
    }
}

impl PartialEq<IotaAddress> for AddressWrapper {
    fn eq(&self, other: &iota::Address) -> bool {
        self == other
    }
}

/// 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: AddressWrapper,
    /// 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<A: AsRef<str>>(address: A) -> crate::Result<AddressWrapper> {
    let address = address.as_ref();
    let mut tokens = address.split('1');
    let hrp = tokens.next().unwrap();
    let address = iota::Address::try_from_bech32(address).or_else(|_| {
        if let Ok(ed25519_address) = Ed25519Address::from_str(address) {
            Ok(IotaAddress::Ed25519(ed25519_address))
        } else {
            Err(crate::Error::InvalidAddress)
        }
    });
    Ok(AddressWrapper::new(address?, hrp.to_string()))
}

pub(crate) async fn get_iota_address(
    account: &Account,
    address_index: usize,
    internal: bool,
    bech32_hrp: String,
    metadata: GenerateAddressMetadata,
) -> crate::Result<AddressWrapper> {
    let signer = crate::signing::get_signer(account.signer_type()).await;
    let mut signer = signer.lock().await;
    let address = signer
        .generate_address(&account, address_index, internal, metadata)
        .await?;
    Ok(AddressWrapper::new(address, bech32_hrp))
}

/// 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 bech32_hrp = match account.addresses().first() {
        Some(address) => address.address().hrp().to_string(),
        None => {
            crate::client::get_client(account.client_options())
                .read()
                .await
                .get_network_info()
                .bech32_hrp
        }
    };
    let iota_address = get_iota_address(&account, key_index, false, bech32_hrp, 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, address.address().hrp().to_string(), 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: &AddressWrapper) -> bool {
    !account
        .list_messages(0, 0, Some(MessageType::Sent))
        .iter()
        .any(|message| message.addresses().contains(&address.as_ref()))
}

1	// Copyright 2020 IOTA Stiftung	×
2	// SPDX-License-Identifier: Apache-2.0
3
4	use crate::{account::Account, message::MessageType, signing::GenerateAddressMetadata};
5	use getset::{Getters, Setters};
6	pub use iota::{client::builder::Network, Address as IotaAddress, Ed25519Address, Input, Payload, UTXOInput};
7	use iota::{
8	message::prelude::{MessageId, TransactionId},
9	OutputMetadata,
10	};
11	use serde::{Deserialize, Serialize};
12	use std::{
13	cmp::Ordering,
14	convert::{TryFrom, TryInto},
15	hash::{Hash, Hasher},
16	str::FromStr,
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,928✔
84	pub(crate) struct AddressBuilder {
85	address: Option<AddressWrapper>,	2,464✔
86	balance: Option<u64>,	2,464!
87	key_index: Option<usize>,	2,464!
88	internal: bool,	2,464!
89	outputs: Option<Vec<AddressOutput>>,	2,464!
90	}
91
92	impl AddressBuilder {
93	/// Initialises a new instance of the address builder.
94	pub fn new() -> AddressBuilder {	2,464✔
95	Default::default()	2,464✔
96	}	2,464✔
97
98	/// Defines the address.
99	pub fn address(mut self, address: AddressWrapper) -> Self {	2,464✔
100	self.address = Some(address);	2,464!
101	self	2,464✔
102	}	2,464✔
103
104	/// Sets the address balance.
105	pub fn balance(mut self, balance: u64) -> Self {	2,463✔
106	self.balance = Some(balance);	2,463✔
107	self	2,463✔
108	}	2,463✔
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,463✔
118	self.outputs = Some(outputs);	2,463!
119	self	2,463✔
120	}	2,463✔
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::error::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::error::AddressBuildRequiredField::Balance,
137	))?,	2,464!
138	key_index: self.key_index.ok_or(crate::Error::AddressBuildRequiredField(	4,928!
139	crate::error::AddressBuildRequiredField::KeyIndex,
140	))?,	2,464!
141	internal: self.internal,	2,464✔
142	outputs: self.outputs.ok_or(crate::Error::AddressBuildRequiredField(	4,928!
143	crate::error::AddressBuildRequiredField::Outputs,
144	))?,	2,464!
145	};	×
146	Ok(address)	2,464✔
147	}	2,464!
148	}
149
150	/// An address and its network type.
151	#[derive(Debug, Clone, PartialEq, Eq, Getters)]	63,399✔
152	pub struct AddressWrapper {
153	inner: IotaAddress,	63,472✔
154	#[getset(get = "pub(crate)")]
155	hrp: String,	31,736!
156	}
157
158	impl AsRef<IotaAddress> for AddressWrapper {
159	fn as_ref(&self) -> &IotaAddress {	18✔
160	&self.inner	18✔
161	}	18✔
162	}
163
164	impl AddressWrapper {
165	pub(crate) fn new(address: IotaAddress, hrp: String) -> Self {	2,482✔
166	Self { inner: address, hrp }	2,482✔
167	}	2,482✔
168
169	/// Encodes the address as bech32.
170	pub fn to_bech32(&self) -> String {	2✔
171	self.inner.to_bech32(&self.hrp)	2✔
172	}	2✔
173	}
174
175	impl PartialEq<IotaAddress> for AddressWrapper {
176	fn eq(&self, other: &iota::Address) -> bool {	×
177	self == other	×
178	}	×
179	}
180
181	/// An address.
182	#[derive(Debug, Getters, Setters, Clone, Eq, Serialize, Deserialize)]	4!
183	#[getset(get = "pub")]
184	pub struct Address {
185	/// The address.
186	#[serde(with = "crate::serde::iota_address_serde")]
187	address: AddressWrapper,	×
188	/// The address balance.
189	#[getset(set = "pub")]
190	balance: u64,	×
191	/// The address key index.
192	#[serde(rename = "keyIndex")]
193	key_index: usize,	×
194	/// Determines if an address is a public or an internal (change) address.
195	internal: bool,	×
196	/// The address outputs.
197	#[getset(set = "pub(crate)")]
198	pub(crate) outputs: Vec<AddressOutput>,	×
199	}
200
201	impl PartialOrd for Address {
202	fn partial_cmp(&self, other: &Self) -> Option<Ordering> {	×
203	Some(self.cmp(other))	×
204	}	×
205	}
206
207	impl Ord for Address {
208	fn cmp(&self, other: &Self) -> Ordering {	×
209	self.address.to_bech32().cmp(&other.address.to_bech32())	×
210	}	×
211	}
212
213	impl Hash for Address {
214	fn hash<H: Hasher>(&self, state: &mut H) {
215	self.address.to_bech32().hash(state);
216	}
217	}
218
219	impl PartialEq for Address {
220	fn eq(&self, other: &Self) -> bool {	×
221	self.address.to_bech32() == other.address.to_bech32()	×
222	}	×
223	}
224
225	impl Address {
226	pub(crate) fn handle_new_output(&mut self, output: AddressOutput) {	×
227	if !self.outputs.iter().any(\|o\| o == &output) {	×
228	let spent_existing_output = self.outputs.iter().position(\|o\| {	×
229	o.message_id == output.message_id	×
230	&& o.transaction_id == output.transaction_id	×
231	&& o.index == output.index	×
232	&& o.amount == output.amount	×
233	&& (!o.is_spent && output.is_spent)	×
234	});	×
235	if let Some(spent_output) = spent_existing_output {	×
236	log::debug!("[ADDRESS] got spent of {:?}", spent_output);	×
237	self.balance -= output.amount;	×
238	self.outputs.remove(spent_output);	×
239	} else {
240	log::debug!("[ADDRESS] got new output {:?}", output);	×
241	self.balance += output.amount;	×
242	self.outputs.push(output);	×
243	}
244	}
245	}	×
246
247	/// Gets the list of outputs that aren't spent or pending.
248	pub fn available_outputs(&self, account: &Account) -> Vec<&AddressOutput> {	×
249	self.outputs.iter().filter(\|o\| !o.is_used(account)).collect()	×
250	}	×
251
252	pub(crate) fn available_balance(&self, account: &Account) -> u64 {	×
253	self.available_outputs(account)	×
254	.iter()
255	.fold(0, \|acc, o\| acc + *o.amount())	×
256	}	×
257	}
258
259	/// Parses a bech32 address string.
260	pub fn parse<A: AsRef<str>>(address: A) -> crate::Result<AddressWrapper> {	×
261	let address = address.as_ref();	×
262	let mut tokens = address.split('1');	×
263	let hrp = tokens.next().unwrap();	×
264	let address = iota::Address::try_from_bech32(address).or_else(\|_\| {	×
265	if let Ok(ed25519_address) = Ed25519Address::from_str(address) {	×
266	Ok(IotaAddress::Ed25519(ed25519_address))	×
267	} else {
268	Err(crate::Error::InvalidAddress)	×
269	}
270	});	×
271	Ok(AddressWrapper::new(address?, hrp.to_string()))	×
272	}	×
273
274	pub(crate) async fn get_iota_address(	18✔
275	account: &Account,	18✔
276	address_index: usize,	18✔
277	internal: bool,	18✔
278	bech32_hrp: String,	18✔
279	metadata: GenerateAddressMetadata,	18✔
280	) -> crate::Result<AddressWrapper> {	171!
281	let signer = crate::signing::get_signer(account.signer_type()).await;	18!
282	let mut signer = signer.lock().await;	26!
283	let address = signer	145!
284	.generate_address(&account, address_index, internal, metadata)	18!
285	.await?;	18!
286	Ok(AddressWrapper::new(address, bech32_hrp))	18!
287	}	54!
288
289	/// Gets an unused public address for the given account.
290	pub(crate) async fn get_new_address(account: &Account, metadata: GenerateAddressMetadata) -> crate::Result<Address> {	×
291	let key_index = account.addresses().iter().filter(\|a\| !a.internal()).count();	×
NEW 292	let bech32_hrp = match account.addresses().first() {	×
NEW 293	Some(address) => address.address().hrp().to_string(),	×
294	None => {
NEW 295	crate::client::get_client(account.client_options())	×
296	.read()
297	.await
298	.get_network_info()
299	.bech32_hrp
NEW 300	}	×
301	};
302	let iota_address = get_iota_address(&account, key_index, false, bech32_hrp, metadata).await?;	×
303	let address = Address {	×
304	address: iota_address,	×
305	balance: 0,
306	key_index,	×
307	internal: false,
308	outputs: vec![],	×
309	};	×
310	Ok(address)	×
311	}	×
312
313	/// Gets an unused change address for the given account and address.
314	pub(crate) async fn get_new_change_address(	×
315	account: &Account,	×
316	address: &Address,	×
317	metadata: GenerateAddressMetadata,	×
318	) -> crate::Result<Address> {	×
319	let key_index = *address.key_index();	×
320	let iota_address =
321	get_iota_address(&account, key_index, true, address.address().hrp().to_string(), metadata).await?;	×
322	let address = Address {	×
323	address: iota_address,	×
324	balance: 0,
325	key_index,	×
326	internal: true,
327	outputs: vec![],	×
328	};	×
329	Ok(address)	×
330	}	×
331
332	pub(crate) fn is_unspent(account: &Account, address: &AddressWrapper) -> bool {	×
333	!account	×
334	.list_messages(0, 0, Some(MessageType::Sent))	×
335	.iter()
336	.any(\|message\| message.addresses().contains(&address.as_ref()))	×
337	}	×

iotaledger / wallet.rs / 493963000

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