493989232

Build Type

github

Committed by GitHub

Commit Message

Merge d1df95027 into 6d38f6bfc

Pull Request Pull Request #228: fix(account): update addresses bech32 hrp on `set_client_options`

Run Details

4105 of 21327 branches covered (19.25%)

Branch coverage included in aggregate %.

1 of 6 new or added lines in 1 file covered. (16.67%)

9 existing lines in 1 file now uncovered.

1639 of 3455 relevant lines covered (47.44%)

457.5 hits per line

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

11.69

/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)]
pub struct AddressWrapper {
    inner: IotaAddress,
    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())
    }

    pub(crate) fn set_bec32_hrp(&mut self, hrp: String) {
        self.address.hrp = hrp;
    }
}

/// 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 = account.addresses().first().unwrap().address().hrp.to_string();
    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,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::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)]	66,731✔
152	pub struct AddressWrapper {
153	inner: IotaAddress,	66,750✔
154	hrp: String,	33,375!
155	}
156
157	impl AsRef<IotaAddress> for AddressWrapper {
158	fn as_ref(&self) -> &IotaAddress {	18✔
159	&self.inner	18✔
160	}	18✔
161	}
162
163	impl AddressWrapper {
164	pub(crate) fn new(address: IotaAddress, hrp: String) -> Self {	2,482✔
165	Self { inner: address, hrp }	2,482✔
166	}	2,482✔
167
168	/// Encodes the address as bech32.
169	pub fn to_bech32(&self) -> String {	2✔
170	self.inner.to_bech32(&self.hrp)	2✔
171	}	2✔
172	}
173
174	impl PartialEq<IotaAddress> for AddressWrapper {
175	fn eq(&self, other: &iota::Address) -> bool {	×
176	self == other	×
177	}	×
178	}
179
180	/// An address.
181	#[derive(Debug, Getters, Setters, Clone, Eq, Serialize, Deserialize)]	4!
182	#[getset(get = "pub")]
183	pub struct Address {
184	/// The address.
185	#[serde(with = "crate::serde::iota_address_serde")]
186	address: AddressWrapper,	×
187	/// The address balance.
188	#[getset(set = "pub")]
189	balance: u64,	×
190	/// The address key index.
191	#[serde(rename = "keyIndex")]
192	key_index: usize,	×
193	/// Determines if an address is a public or an internal (change) address.
194	internal: bool,	×
195	/// The address outputs.
196	#[getset(set = "pub(crate)")]
197	pub(crate) outputs: Vec<AddressOutput>,	×
198	}
199
200	impl PartialOrd for Address {
201	fn partial_cmp(&self, other: &Self) -> Option<Ordering> {	×
202	Some(self.cmp(other))	×
203	}	×
204	}
205
206	impl Ord for Address {
207	fn cmp(&self, other: &Self) -> Ordering {	×
208	self.address.to_bech32().cmp(&other.address.to_bech32())	×
209	}	×
210	}
211
212	impl Hash for Address {
213	fn hash<H: Hasher>(&self, state: &mut H) {
214	self.address.to_bech32().hash(state);
215	}
216	}
217
218	impl PartialEq for Address {
219	fn eq(&self, other: &Self) -> bool {	×
220	self.address.to_bech32() == other.address.to_bech32()	×
221	}	×
222	}
223
224	impl Address {
225	pub(crate) fn handle_new_output(&mut self, output: AddressOutput) {	×
226	if !self.outputs.iter().any(\|o\| o == &output) {	×
227	let spent_existing_output = self.outputs.iter().position(\|o\| {	×
228	o.message_id == output.message_id	×
229	&& o.transaction_id == output.transaction_id	×
230	&& o.index == output.index	×
231	&& o.amount == output.amount	×
232	&& (!o.is_spent && output.is_spent)	×
233	});	×
234	if let Some(spent_output) = spent_existing_output {	×
235	log::debug!("[ADDRESS] got spent of {:?}", spent_output);	×
236	self.balance -= output.amount;	×
237	self.outputs.remove(spent_output);	×
238	} else {
239	log::debug!("[ADDRESS] got new output {:?}", output);	×
240	self.balance += output.amount;	×
241	self.outputs.push(output);	×
242	}
243	}
244	}	×
245
246	/// Gets the list of outputs that aren't spent or pending.
247	pub fn available_outputs(&self, account: &Account) -> Vec<&AddressOutput> {	×
248	self.outputs.iter().filter(\|o\| !o.is_used(account)).collect()	×
249	}	×
250
251	pub(crate) fn available_balance(&self, account: &Account) -> u64 {	×
252	self.available_outputs(account)	×
253	.iter()
254	.fold(0, \|acc, o\| acc + *o.amount())	×
255	}	×
256
NEW 257	pub(crate) fn set_bec32_hrp(&mut self, hrp: String) {	×
NEW 258	self.address.hrp = hrp;	×
NEW 259	}	×
260	}
261
262	/// Parses a bech32 address string.
263	pub fn parse<A: AsRef<str>>(address: A) -> crate::Result<AddressWrapper> {	×
264	let address = address.as_ref();	×
265	let mut tokens = address.split('1');	×
266	let hrp = tokens.next().unwrap();	×
267	let address = iota::Address::try_from_bech32(address).or_else(\|_\| {	×
268	if let Ok(ed25519_address) = Ed25519Address::from_str(address) {	×
269	Ok(IotaAddress::Ed25519(ed25519_address))	×
270	} else {
271	Err(crate::Error::InvalidAddress)	×
272	}
273	});	×
274	Ok(AddressWrapper::new(address?, hrp.to_string()))	×
275	}	×
276
277	pub(crate) async fn get_iota_address(	18✔
278	account: &Account,	18✔
279	address_index: usize,	18✔
280	internal: bool,	18✔
281	bech32_hrp: String,	18✔
282	metadata: GenerateAddressMetadata,	18✔
283	) -> crate::Result<AddressWrapper> {	171!
284	let signer = crate::signing::get_signer(account.signer_type()).await;	18!
285	let mut signer = signer.lock().await;	27!
286	let address = signer	144!
287	.generate_address(&account, address_index, internal, metadata)	18!
288	.await?;	18!
289	Ok(AddressWrapper::new(address, bech32_hrp))	18!
290	}	54!
291
292	/// Gets an unused public address for the given account.
293	pub(crate) async fn get_new_address(account: &Account, metadata: GenerateAddressMetadata) -> crate::Result<Address> {	×
294	let key_index = account.addresses().iter().filter(\|a\| !a.internal()).count();	×
295	let bech32_hrp = account.addresses().first().unwrap().address().hrp.to_string();	×
NEW 296	let iota_address = get_iota_address(&account, key_index, false, bech32_hrp, metadata).await?;	×
UNCOV 297	let address = Address {	×
298	address: iota_address,	×
299	balance: 0,
UNCOV 300	key_index,	×
301	internal: false,
UNCOV 302	outputs: vec![],	×
303	};	×
UNCOV 304	Ok(address)	×
305	}	×
306
307	/// Gets an unused change address for the given account and address.
UNCOV 308	pub(crate) async fn get_new_change_address(	×
309	account: &Account,	×
UNCOV 310	address: &Address,	×
311	metadata: GenerateAddressMetadata,	×
312	) -> crate::Result<Address> {	×
313	let key_index = *address.key_index();	×
314	let iota_address = get_iota_address(&account, key_index, true, address.address().hrp.to_string(), metadata).await?;	×
UNCOV 315	let address = Address {	×
UNCOV 316	address: iota_address,	×
317	balance: 0,
318	key_index,	×
319	internal: true,
320	outputs: vec![],	×
321	};	×
322	Ok(address)	×
NEW 323	}	×
324
325	pub(crate) fn is_unspent(account: &Account, address: &AddressWrapper) -> bool {	×
UNCOV 326	!account	×
327	.list_messages(0, 0, Some(MessageType::Sent))	×
328	.iter()
329	.any(\|message\| message.addresses().contains(&address.as_ref()))	×
330	}	×

iotaledger / wallet.rs / 493989232

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