use std::convert::TryInto; use std::io::{Error}; use rand::{RngCore, rngs::OsRng}; use ff::{Field, PrimeField, PrimeFieldRepr}; use pairing::bls12_381::Bls12; use protobuf::{Message, UnknownFields, CachedSize, RepeatedField}; use zcash_client_backend::{encoding::encode_payment_address, proto::compact_formats::{ CompactBlock, CompactOutput, CompactSpend, CompactTx, } }; use zcash_primitives::{ block::BlockHash, jubjub::fs::Fs, note_encryption::{Memo, SaplingNoteEncryption}, primitives::{Note, PaymentAddress}, legacy::{Script, TransparentAddress,}, transaction::{ TxId, Transaction, TransactionData, components::{TxOut, TxIn, OutPoint, Amount,}, components::amount::DEFAULT_FEE, }, zip32::{ExtendedFullViewingKey, ExtendedSpendingKey}, JUBJUB, }; use sha2::{Sha256, Digest}; use super::LightWallet; use super::LightClientConfig; use secp256k1::{Secp256k1, key::PublicKey, key::SecretKey}; use crate::SaplingParams; fn get_sapling_params() -> Result<(Vec, Vec), Error> { // Read Sapling Params let mut sapling_output = vec![]; sapling_output.extend_from_slice(SaplingParams::get("sapling-output.params").unwrap().as_ref()); println!("Read output {}", sapling_output.len()); let mut sapling_spend = vec![]; sapling_spend.extend_from_slice(SaplingParams::get("sapling-spend.params").unwrap().as_ref()); println!("Read output {}", sapling_spend.len()); Ok((sapling_spend, sapling_output)) } // send_to_address now takes the fee explicitly; the tests send with the default fee. fn default_fee() -> u64 { u64::from(DEFAULT_FEE) } struct FakeCompactBlock { block: CompactBlock, } impl FakeCompactBlock { fn new(height: i32, prev_hash: BlockHash) -> Self { // Create a fake Note for the account let mut rng = OsRng; let mut cb = CompactBlock::new(); cb.set_height(height as u64); cb.hash.resize(32, 0); rng.fill_bytes(&mut cb.hash); cb.prevHash.extend_from_slice(&prev_hash.0); FakeCompactBlock { block: cb } } fn as_bytes(&self) -> Vec { self.block.write_to_bytes().unwrap() } fn hash(&self) -> BlockHash { BlockHash(self.block.hash[..].try_into().unwrap()) } fn tx_to_compact_tx(tx: &Transaction, index: u64) -> CompactTx { let spends = tx.shielded_spends.iter().map(|s| { let mut c_spend = CompactSpend::default(); c_spend.set_nf(s.nullifier.to_vec()); c_spend }).collect::>(); let outputs = tx.shielded_outputs.iter().map(|o| { let mut c_out = CompactOutput::default(); let mut cmu_bytes = vec![]; o.cmu.into_repr().write_le(&mut cmu_bytes).unwrap(); let mut epk_bytes = vec![]; o.ephemeral_key.write(&mut epk_bytes).unwrap(); c_out.set_cmu(cmu_bytes); c_out.set_epk(epk_bytes); c_out.set_ciphertext(o.enc_ciphertext[0..52].to_vec()); c_out }).collect::>(); CompactTx { index, hash: tx.txid().0.to_vec(), fee: 0, // TODO: Get Fee spends: RepeatedField::from_vec(spends), outputs: RepeatedField::from_vec(outputs), unknown_fields: UnknownFields::default(), cached_size: CachedSize::default(), } } // Convert the transaction into a CompactTx and add it to this block fn add_tx(&mut self, tx: &Transaction) { let ctx = FakeCompactBlock::tx_to_compact_tx(&tx, self.block.vtx.len() as u64); self.block.vtx.push(ctx); } // Add a new tx into the block, paying the given address the amount. // Returns the nullifier of the new note. fn add_tx_paying(&mut self, extfvk: ExtendedFullViewingKey, value: u64) -> (Vec, TxId) { let to = extfvk.default_address().unwrap().1; self.add_tx_paying_to(extfvk, to, value) } // add_tx_paying with an explicit recipient (e.g. a diversified address of `extfvk`). fn add_tx_paying_to(&mut self, extfvk: ExtendedFullViewingKey, to: PaymentAddress, value: u64) -> (Vec, TxId) { let value = Amount::from_u64(value).unwrap(); // Create a fake Note for the account let mut rng = OsRng; let note = Note { g_d: to.diversifier.g_d::(&JUBJUB).unwrap(), pk_d: to.pk_d.clone(), value: value.into(), r: Fs::random(&mut rng), }; let encryptor = SaplingNoteEncryption::new( extfvk.fvk.ovk, note.clone(), to.clone(), Memo::default(), &mut rng, ); let mut cmu = vec![]; note.cm(&JUBJUB).into_repr().write_le(&mut cmu).unwrap(); let mut epk = vec![]; encryptor.epk().write(&mut epk).unwrap(); let enc_ciphertext = encryptor.encrypt_note_plaintext(); // Create a fake CompactBlock containing the note let mut cout = CompactOutput::new(); cout.set_cmu(cmu); cout.set_epk(epk); cout.set_ciphertext(enc_ciphertext[..52].to_vec()); let mut ctx = CompactTx::new(); let mut txid = vec![0; 32]; rng.fill_bytes(&mut txid); ctx.set_hash(txid.clone()); ctx.outputs.push(cout); self.block.vtx.push(ctx); (note.nf(&extfvk.fvk.vk, 0, &JUBJUB), TxId(txid[..].try_into().unwrap())) } fn add_tx_spending(&mut self, (nf, in_value): (Vec, u64), extfvk: ExtendedFullViewingKey, to: PaymentAddress, value: u64) -> TxId { let mut rng = OsRng; let in_value = Amount::from_u64(in_value).unwrap(); let value = Amount::from_u64(value).unwrap(); // Create a fake CompactBlock containing the note let mut cspend = CompactSpend::new(); cspend.set_nf(nf); let mut ctx = CompactTx::new(); let mut txid = vec![0; 32]; rng.fill_bytes(&mut txid); ctx.set_hash(txid.clone()); ctx.spends.push(cspend); // Create a fake Note for the payment ctx.outputs.push({ let note = Note { g_d: to.diversifier.g_d::(&JUBJUB).unwrap(), pk_d: to.pk_d.clone(), value: value.into(), r: Fs::random(&mut rng), }; let encryptor = SaplingNoteEncryption::new( extfvk.fvk.ovk, note.clone(), to, Memo::default(), &mut rng, ); let mut cmu = vec![]; note.cm(&JUBJUB).into_repr().write_le(&mut cmu).unwrap(); let mut epk = vec![]; encryptor.epk().write(&mut epk).unwrap(); let enc_ciphertext = encryptor.encrypt_note_plaintext(); let mut cout = CompactOutput::new(); cout.set_cmu(cmu); cout.set_epk(epk); cout.set_ciphertext(enc_ciphertext[..52].to_vec()); cout }); // Create a fake Note for the change ctx.outputs.push({ let change_addr = extfvk.default_address().unwrap().1; let note = Note { g_d: change_addr.diversifier.g_d::(&JUBJUB).unwrap(), pk_d: change_addr.pk_d.clone(), value: (in_value - value).into(), r: Fs::random(&mut rng), }; let encryptor = SaplingNoteEncryption::new( extfvk.fvk.ovk, note.clone(), change_addr, Memo::default(), &mut rng, ); let mut cmu = vec![]; note.cm(&JUBJUB).into_repr().write_le(&mut cmu).unwrap(); let mut epk = vec![]; encryptor.epk().write(&mut epk).unwrap(); let enc_ciphertext = encryptor.encrypt_note_plaintext(); let mut cout = CompactOutput::new(); cout.set_cmu(cmu); cout.set_epk(epk); cout.set_ciphertext(enc_ciphertext[..52].to_vec()); cout }); self.block.vtx.push(ctx); TxId(txid[..].try_into().unwrap()) } } struct FakeTransaction { tx: Transaction, } impl FakeTransaction { // New FakeTransaction with random txid fn new(rng: &mut R) -> Self { let mut txid = [0u8; 32]; rng.fill_bytes(&mut txid); FakeTransaction::new_with_txid(TxId(txid)) } fn new_with_txid(txid: TxId) -> Self { FakeTransaction { tx: Transaction { txid, data: TransactionData::new() } } } fn get_tx(&self) -> &Transaction { &self.tx } fn add_t_output(&mut self, pk: &PublicKey, value: u64) { let mut hash160 = ripemd160::Ripemd160::new(); hash160.input(Sha256::digest(&pk.serialize()[..].to_vec())); let taddr_bytes = hash160.result(); self.tx.data.vout.push(TxOut { value: Amount::from_u64(value).unwrap(), script_pubkey: TransparentAddress::PublicKey(taddr_bytes.try_into().unwrap()).script(), }); } fn add_t_input(&mut self, txid: TxId, n: u32) { self.tx.data.vin.push(TxIn { prevout: OutPoint{ hash: txid.0, n }, script_sig: Script{0: vec![]}, sequence: 0, }); } } #[test] fn test_z_balances() { let wallet = LightWallet::new(None, &get_test_config(), 0, 0).unwrap(); const AMOUNT1:u64 = 5; // Address is encoded in bech32 let address = Some(encode_payment_address(wallet.config.hrp_sapling_address(), &wallet.zkeys.read().unwrap()[0].extfvk.default_address().unwrap().1)); let mut cb1 = FakeCompactBlock::new(0, BlockHash([0; 32])); cb1.add_tx_paying(wallet.zkeys.read().unwrap()[0].extfvk.clone(), AMOUNT1); // Make sure that the intial state is empty assert_eq!(wallet.txs.read().unwrap().len(), 0); assert_eq!(wallet.blocks.read().unwrap().len(), 0); assert_eq!(wallet.zbalance(None), 0); assert_eq!(wallet.zbalance(address.clone()), 0); wallet.scan_block(&cb1.as_bytes()).unwrap(); assert_eq!(wallet.txs.read().unwrap().len(), 1); assert_eq!(wallet.blocks.read().unwrap().len(), 1); assert_eq!(wallet.zbalance(None), AMOUNT1); assert_eq!(wallet.zbalance(address.clone()), AMOUNT1); const AMOUNT2:u64 = 10; // Add a second block let mut cb2 = FakeCompactBlock::new(1, cb1.hash()); cb2.add_tx_paying(wallet.zkeys.read().unwrap()[0].extfvk.clone(), AMOUNT2); wallet.scan_block(&cb2.as_bytes()).unwrap(); assert_eq!(wallet.txs.read().unwrap().len(), 2); assert_eq!(wallet.blocks.read().unwrap().len(), 2); assert_eq!(wallet.zbalance(None), AMOUNT1 + AMOUNT2); assert_eq!(wallet.zbalance(address.clone()), AMOUNT1 + AMOUNT2); } #[test] fn test_z_change_balances() { let wallet = LightWallet::new(None, &get_test_config(), 0, 0).unwrap(); // First, add an incoming transaction const AMOUNT1:u64 = 5; let mut cb1 = FakeCompactBlock::new(0, BlockHash([0; 32])); let (nf1, txid1) = cb1.add_tx_paying(wallet.zkeys.read().unwrap()[0].extfvk.clone(), AMOUNT1); wallet.scan_block(&cb1.as_bytes()).unwrap(); assert_eq!(wallet.txs.read().unwrap().len(), 1); assert_eq!(wallet.blocks.read().unwrap().len(), 1); assert_eq!(wallet.zbalance(None), AMOUNT1); const AMOUNT2:u64 = 2; // Add a second block, spending the first note let addr2 = ExtendedFullViewingKey::from(&ExtendedSpendingKey::master(&[0u8; 32])) .default_address().unwrap().1; let mut cb2 = FakeCompactBlock::new(1, cb1.hash()); let txid2 = cb2.add_tx_spending((nf1, AMOUNT1), wallet.zkeys.read().unwrap()[0].extfvk.clone(), addr2, AMOUNT2); wallet.scan_block(&cb2.as_bytes()).unwrap(); // Now, the original note should be spent and there should be a change assert_eq!(wallet.zbalance(None), AMOUNT1 - AMOUNT2); let txs = wallet.txs.read().unwrap(); // Old note was spent assert_eq!(txs[&txid1].txid, txid1); assert_eq!(txs[&txid1].notes.len(), 1); assert_eq!(txs[&txid1].notes[0].spent.unwrap(), txid2); assert_eq!(txs[&txid1].notes[0].note.value, AMOUNT1); assert_eq!(txs[&txid1].notes[0].is_change, false); // new note is not spent assert_eq!(txs[&txid2].txid, txid2); assert_eq!(txs[&txid2].notes.len(), 1); assert_eq!(txs[&txid2].notes[0].spent, None); assert_eq!(txs[&txid2].notes[0].note.value, AMOUNT1 - AMOUNT2); assert_eq!(txs[&txid2].notes[0].is_change, true); assert_eq!(txs[&txid2].total_shielded_value_spent, AMOUNT1); } #[test] fn test_t_receive_spend() { let mut rng = OsRng; let secp = Secp256k1::new(); let wallet = LightWallet::new(None, &get_test_config(), 0, 0).unwrap(); let pk = PublicKey::from_secret_key(&secp, &wallet.tkeys.read().unwrap()[0].tkey.unwrap()); let taddr = wallet.address_from_sk(&wallet.tkeys.read().unwrap()[0].tkey.unwrap()); const AMOUNT1: u64 = 20; let mut tx = FakeTransaction::new(&mut rng); tx.add_t_output(&pk, AMOUNT1); let txid1 = tx.get_tx().txid(); wallet.scan_full_tx(&tx.get_tx(), 100, 0); // Pretend it is at height 100 { let txs = wallet.txs.read().unwrap(); // Now make sure the t addr was recieved assert_eq!(txs.len(), 1); assert_eq!(txs[&txid1].utxos.len(), 1); assert_eq!(txs[&txid1].utxos[0].address, taddr); assert_eq!(txs[&txid1].utxos[0].txid, txid1); assert_eq!(txs[&txid1].utxos[0].output_index, 0); assert_eq!(txs[&txid1].utxos[0].value, AMOUNT1); assert_eq!(txs[&txid1].utxos[0].height, 100); assert_eq!(txs[&txid1].utxos[0].spent, None); assert_eq!(txs[&txid1].utxos[0].unconfirmed_spent, None); assert_eq!(wallet.tbalance(None), AMOUNT1); assert_eq!(wallet.tbalance(Some(taddr)), AMOUNT1); } // Create a new Tx, spending this taddr let mut tx = FakeTransaction::new(&mut rng); tx.add_t_input(txid1, 0); let txid2 = tx.get_tx().txid(); wallet.scan_full_tx(&tx.get_tx(), 101, 0); // Pretent it is at height 101 { // Make sure the txid was spent let txs = wallet.txs.read().unwrap(); // Old utxo, that should be spent now assert_eq!(txs.len(), 2); assert_eq!(txs[&txid1].utxos.len(), 1); assert_eq!(txs[&txid1].utxos[0].value, AMOUNT1); assert_eq!(txs[&txid1].utxos[0].spent, Some(txid2)); assert_eq!(txs[&txid1].utxos[0].unconfirmed_spent, None); assert_eq!(txs[&txid2].block, 101); // The second TxId is at block 101 assert_eq!(txs[&txid2].utxos.len(), 0); // The second TxId has no UTXOs assert_eq!(txs[&txid2].total_transparent_value_spent, AMOUNT1); // Make sure there is no t-ZEC left assert_eq!(wallet.tbalance(None), 0); } } #[test] /// This test spends and receives t addresses among non-wallet t addresses to make sure that /// we're detecting and spending only our t addrs. fn test_t_receive_spend_among_tadds() { let mut rng = OsRng; let secp = Secp256k1::new(); let wallet = LightWallet::new(None, &get_test_config(), 0, 0).unwrap(); let pk = PublicKey::from_secret_key(&secp, &wallet.tkeys.read().unwrap()[0].tkey.unwrap()); let taddr = wallet.address_from_sk(&wallet.tkeys.read().unwrap()[0].tkey.unwrap()); let non_wallet_sk = &SecretKey::from_slice(&[1u8; 32]).unwrap(); let non_wallet_pk = PublicKey::from_secret_key(&secp, &non_wallet_sk); const AMOUNT1: u64 = 30; let mut tx = FakeTransaction::new(&mut rng); // Add a non-wallet output tx.add_t_output(&non_wallet_pk, 20); tx.add_t_output(&pk, AMOUNT1); // Our wallet t output tx.add_t_output(&non_wallet_pk, 25); let txid1 = tx.get_tx().txid(); wallet.scan_full_tx(&tx.get_tx(), 100, 0); // Pretend it is at height 100 { let txs = wallet.txs.read().unwrap(); // Now make sure the t addr was received assert_eq!(txs.len(), 1); assert_eq!(txs[&txid1].utxos.len(), 1); assert_eq!(txs[&txid1].utxos[0].address, taddr); assert_eq!(txs[&txid1].utxos[0].txid, txid1); assert_eq!(txs[&txid1].utxos[0].output_index, 1); assert_eq!(txs[&txid1].utxos[0].value, AMOUNT1); assert_eq!(txs[&txid1].utxos[0].height, 100); assert_eq!(txs[&txid1].utxos[0].spent, None); assert_eq!(txs[&txid1].utxos[0].unconfirmed_spent, None); assert_eq!(wallet.tbalance(None), AMOUNT1); assert_eq!(wallet.tbalance(Some(taddr)), AMOUNT1); } // Create a new Tx, spending this taddr let mut tx = FakeTransaction::new(&mut rng); tx.add_t_input(txid1, 1); // Ours was at position 1 in the input tx let txid2 = tx.get_tx().txid(); wallet.scan_full_tx(&tx.get_tx(), 101, 0); // Pretent it is at height 101 { // Make sure the txid was spent let txs = wallet.txs.read().unwrap(); // Old utxo, that should be spent now assert_eq!(txs.len(), 2); assert_eq!(txs[&txid1].utxos.len(), 1); assert_eq!(txs[&txid1].utxos[0].value, AMOUNT1); assert_eq!(txs[&txid1].utxos[0].spent, Some(txid2)); assert_eq!(txs[&txid1].utxos[0].unconfirmed_spent, None); assert_eq!(txs[&txid2].block, 101); // The second TxId is at block 101 assert_eq!(txs[&txid2].utxos.len(), 0); // The second TxId has no UTXOs assert_eq!(txs[&txid2].total_transparent_value_spent, AMOUNT1); // Make sure there is no t-ZEC left assert_eq!(wallet.tbalance(None), 0); } } #[test] fn test_serialization() { let secp = Secp256k1::new(); let config = get_test_config(); let wallet = LightWallet::new(None, &config, 0, 0).unwrap(); // First, add an incoming transaction const AMOUNT1:u64 = 5; let mut cb1 = FakeCompactBlock::new(0, BlockHash([0; 32])); let (nf1, txid1) = cb1.add_tx_paying(wallet.zkeys.read().unwrap()[0].extfvk.clone(), AMOUNT1); wallet.scan_block(&cb1.as_bytes()).unwrap(); assert_eq!(wallet.txs.read().unwrap().len(), 1); assert_eq!(wallet.blocks.read().unwrap().len(), 1); assert_eq!(wallet.zbalance(None), AMOUNT1); // Add a t input at the Tx let pk = PublicKey::from_secret_key(&secp, &wallet.tkeys.read().unwrap()[0].tkey.unwrap()); let taddr = wallet.address_from_sk(&wallet.tkeys.read().unwrap()[0].tkey.unwrap()); const TAMOUNT1: u64 = 20; let mut tx = FakeTransaction::new_with_txid(txid1); tx.add_t_output(&pk, TAMOUNT1); wallet.scan_full_tx(&tx.get_tx(), 0, 0); // Height 0 const AMOUNT2:u64 = 2; // Add a second block, spending the first note let addr2 = ExtendedFullViewingKey::from(&ExtendedSpendingKey::master(&[0u8; 32])) .default_address().unwrap().1; let mut cb2 = FakeCompactBlock::new(1, cb1.hash()); let txid2 = cb2.add_tx_spending((nf1, AMOUNT1), wallet.zkeys.read().unwrap()[0].extfvk.clone(), addr2, AMOUNT2); wallet.scan_block(&cb2.as_bytes()).unwrap(); let mut tx = FakeTransaction::new_with_txid(txid2); tx.add_t_input(txid1, 0); wallet.scan_full_tx(&tx.get_tx(), 1, 0); // Height 1 // Now, the original note should be spent and there should be a change assert_eq!(wallet.zbalance(None), AMOUNT1 - AMOUNT2 ); // The t addr amount is received + spent, so it cancels out // Now, serialize the wallet and read it back again let mut serialized_data = vec![]; wallet.write(&mut serialized_data).expect("Serialize wallet"); let wallet2 = LightWallet::read(&serialized_data[..], &config).unwrap(); assert_eq!(wallet2.zbalance(None), AMOUNT1 - AMOUNT2); // Test the keys were serialized correctly { assert_eq!(wallet.seed, wallet2.seed); assert_eq!(wallet.zkeys.read().unwrap().len(), wallet2.zkeys.read().unwrap().len()); assert_eq!(wallet.zkeys.read().unwrap()[0].extsk, wallet2.zkeys.read().unwrap()[0].extsk); assert_eq!(wallet.zkeys.read().unwrap()[0].extfvk, wallet2.zkeys.read().unwrap()[0].extfvk); assert_eq!(wallet.zkeys.read().unwrap()[0].zaddress, wallet2.zkeys.read().unwrap()[0].zaddress); assert_eq!(wallet.tkeys.read().unwrap().len(), wallet2.tkeys.read().unwrap().len()); assert_eq!(wallet.tkeys.read().unwrap()[0], wallet2.tkeys.read().unwrap()[0]); } // Test blocks were serialized properly { let blks = wallet2.blocks.read().unwrap(); assert_eq!(blks.len(), 2); assert_eq!(blks[0].height, 0); assert_eq!(blks[1].height, 1); } // Test txns were serialized properly. { let txs = wallet2.txs.read().unwrap(); // Old note was spent assert_eq!(txs[&txid1].txid, txid1); assert_eq!(txs[&txid1].notes.len(), 1); assert_eq!(txs[&txid1].notes[0].spent.unwrap(), txid2); assert_eq!(txs[&txid1].notes[0].note.value, AMOUNT1); assert_eq!(txs[&txid1].notes[0].is_change, false); // Old UTXO was spent assert_eq!(txs[&txid1].utxos.len(), 1); assert_eq!(txs[&txid1].utxos[0].address, taddr); assert_eq!(txs[&txid1].utxos[0].txid, txid1); assert_eq!(txs[&txid1].utxos[0].output_index, 0); assert_eq!(txs[&txid1].utxos[0].value, TAMOUNT1); assert_eq!(txs[&txid1].utxos[0].height, 0); assert_eq!(txs[&txid1].utxos[0].spent, Some(txid2)); assert_eq!(txs[&txid1].utxos[0].unconfirmed_spent, None); // new note is not spent assert_eq!(txs[&txid2].txid, txid2); assert_eq!(txs[&txid2].notes.len(), 1); assert_eq!(txs[&txid2].notes[0].spent, None); assert_eq!(txs[&txid2].notes[0].note.value, AMOUNT1 - AMOUNT2); assert_eq!(txs[&txid2].notes[0].is_change, true); assert_eq!(txs[&txid2].total_shielded_value_spent, AMOUNT1); // The UTXO was spent in txid2 assert_eq!(txs[&txid2].utxos.len(), 0); // The second TxId has no UTXOs assert_eq!(txs[&txid2].total_transparent_value_spent, TAMOUNT1); } } #[test] fn test_multi_serialization() { let config = get_test_config(); let wallet = LightWallet::new(None, &config, 0, 0).unwrap(); let taddr1 = wallet.address_from_sk(&wallet.tkeys.read().unwrap()[0].tkey.unwrap()); let taddr2 = wallet.add_taddr(); let (zaddr1, zpk1, _) = &wallet.get_z_private_keys()[0]; let zaddr2 = wallet.add_zaddr(); let mut serialized_data = vec![]; wallet.write(&mut serialized_data).expect("Serialize wallet"); let wallet2 = LightWallet::read(&serialized_data[..], &config).unwrap(); assert_eq!(wallet2.tkeys.read().unwrap().len(), 2); assert_eq!(wallet2.zkeys.read().unwrap().len(), 2); assert_eq!(taddr1, wallet.address_from_sk(&wallet.tkeys.read().unwrap()[0].tkey.unwrap())); assert_eq!(taddr2, wallet.address_from_sk(&wallet.tkeys.read().unwrap()[1].tkey.unwrap())); let (w2_zaddr1, w2_zpk1, _) = &wallet.get_z_private_keys()[0]; let (w2_zaddr2, _, _) = &wallet.get_z_private_keys()[1]; assert_eq!(zaddr1, w2_zaddr1); assert_eq!(zpk1, w2_zpk1); assert_eq!(zaddr2, *w2_zaddr2); } fn get_test_config() -> LightClientConfig { LightClientConfig { server: "0.0.0.0:0".parse().unwrap(), chain_name: "main".to_string(), sapling_activation_height: 0, consensus_branch_id: "000000".to_string(), anchor_offset: 0, no_cert_verification: false, data_dir: None, } } // Get a test wallet already setup with a single note fn get_test_wallet(amount: u64) -> (LightWallet, TxId, BlockHash) { let config = get_test_config(); let wallet = LightWallet::new(None, &config, 0, 0).unwrap(); let mut cb1 = FakeCompactBlock::new(0, BlockHash([0; 32])); let (_, txid1) = cb1.add_tx_paying(wallet.zkeys.read().unwrap()[0].extfvk.clone(), amount); wallet.scan_block(&cb1.as_bytes()).unwrap(); // We have one note { let txs = wallet.txs.read().unwrap(); assert_eq!(txs[&txid1].notes.len(), 1); assert_eq!(txs[&txid1].notes[0].note.value, amount); assert_eq!(txs[&txid1].notes[0].spent, None); assert_eq!(txs[&txid1].notes[0].unconfirmed_spent, None); } assert_eq!(wallet.verified_zbalance(None), amount); // Create a new block so that the note is now verified to be spent let cb2 = FakeCompactBlock::new(1, cb1.hash()); wallet.scan_block(&cb2.as_bytes()).unwrap(); (wallet, txid1, cb2.hash()) } #[test] fn test_z_spend_to_z() { const AMOUNT1: u64 = 50000; let (wallet, txid1, block_hash) = get_test_wallet(AMOUNT1); let fvk = ExtendedFullViewingKey::from(&ExtendedSpendingKey::master(&[1u8; 32])); let ext_address = encode_payment_address(wallet.config.hrp_sapling_address(), &fvk.default_address().unwrap().1); const AMOUNT_SENT: u64 = 20; let outgoing_memo = "Outgoing Memo".to_string(); let fee: u64 = DEFAULT_FEE.try_into().unwrap(); let branch_id = u32::from_str_radix("76b809bb", 16).unwrap(); let (ss, so) = get_sapling_params().unwrap(); // Make sure that the balance exists { assert_eq!(wallet.zbalance(None), AMOUNT1); assert_eq!(wallet.verified_zbalance(None), AMOUNT1); } // Create a tx and send to address let (_, raw_tx) = wallet.send_to_address(branch_id, &ss, &so, false, vec![(&ext_address, AMOUNT_SENT, Some(outgoing_memo.clone()))], &default_fee(), |_| Ok(' '.to_string())).unwrap(); let sent_tx = Transaction::read(&raw_tx[..]).unwrap(); let sent_txid = sent_tx.txid(); // Now, the note should be unconfirmed spent { let txs = wallet.txs.read().unwrap(); assert_eq!(txs[&txid1].notes[0].note.value, AMOUNT1); assert_eq!(txs[&txid1].notes[0].is_change, false); assert_eq!(txs[&txid1].notes[0].spent, None); assert_eq!(txs[&txid1].notes[0].unconfirmed_spent, Some(sent_txid)); } // It should also be in the mempool structure { let mem = wallet.mempool_txs.read().unwrap(); assert_eq!(mem[&sent_txid].block, 1); // block number is the current tip (the fork targets the tip, d2887d0) assert! (mem[&sent_txid].datetime > 0); assert_eq!(mem[&sent_txid].txid, sent_txid); assert_eq!(mem[&sent_txid].outgoing_metadata.len(), 1); assert_eq!(mem[&sent_txid].outgoing_metadata[0].address, ext_address); assert_eq!(mem[&sent_txid].outgoing_metadata[0].value, AMOUNT_SENT); assert_eq!(mem[&sent_txid].outgoing_metadata[0].memo.to_utf8().unwrap().unwrap(), outgoing_memo); } { // The wallet should deduct this from the verified balance. The zbalance excludes it too // (since the fork's mempool integration, eff5dd7, pending spends are not in zbalance) assert_eq!(wallet.zbalance(None), 0); assert_eq!(wallet.verified_zbalance(None), 0); } let mut cb3 = FakeCompactBlock::new(2, block_hash); cb3.add_tx(&sent_tx); wallet.scan_block(&cb3.as_bytes()).unwrap(); // Now this new Spent tx should be in, so the note should be marked confirmed spent { let txs = wallet.txs.read().unwrap(); assert_eq!(txs[&txid1].notes.len(), 1); assert_eq!(txs[&txid1].notes[0].note.value, AMOUNT1); assert_eq!(txs[&txid1].notes[0].spent, Some(sent_txid)); assert_eq!(txs[&txid1].notes[0].unconfirmed_spent, None); // The sent tx should generate change assert_eq!(txs[&sent_txid].notes.len(), 1); assert_eq!(txs[&sent_txid].notes[0].note.value, AMOUNT1 - AMOUNT_SENT - fee); assert_eq!(wallet.zbalance(None), AMOUNT1 - AMOUNT_SENT - fee); assert_eq!(txs[&sent_txid].notes[0].is_change, true); assert_eq!(txs[&sent_txid].notes[0].spent, None); assert_eq!(txs[&sent_txid].notes[0].unconfirmed_spent, None); } { // And the mempool tx should disappear let mem = wallet.mempool_txs.read().unwrap(); assert!(mem.get(&sent_txid).is_none()); } // Now, full scan the Tx, which should populate the Outgoing Meta data wallet.scan_full_tx(&sent_tx, 2, 0); // Check Outgoing Metadata { let txs = wallet.txs.read().unwrap(); assert_eq!(txs[&sent_txid].total_shielded_value_spent, AMOUNT1); assert_eq!(txs[&sent_txid].outgoing_metadata.len(), 1); assert_eq!(txs[&sent_txid].outgoing_metadata[0].address, ext_address); assert_eq!(txs[&sent_txid].outgoing_metadata[0].value, AMOUNT_SENT); assert_eq!(txs[&sent_txid].outgoing_metadata[0].memo.to_utf8().unwrap().unwrap(), outgoing_memo); } } #[test] fn test_self_txns_ttoz_withmemo() { let mut rng = OsRng; let secp = Secp256k1::new(); let (wallet, _txid1, block_hash) = get_test_wallet(0); let pk = PublicKey::from_secret_key(&secp, &wallet.tkeys.read().unwrap()[0].tkey.unwrap()); let taddr = wallet.address_from_sk(&wallet.tkeys.read().unwrap()[0].tkey.unwrap()); const TAMOUNT1: u64 = 50000; let mut tx = FakeTransaction::new(&mut rng); tx.add_t_output(&pk, TAMOUNT1); let txid1 = tx.get_tx().txid(); wallet.scan_full_tx(&tx.get_tx(), 1, 0); { let txs = wallet.txs.read().unwrap(); // Now make sure the t addr was recieved assert_eq!(txs[&txid1].utxos.len(), 1); assert_eq!(txs[&txid1].utxos[0].address, taddr); assert_eq!(txs[&txid1].utxos[0].value, TAMOUNT1); } // Create a new Tx, spending this taddr const AMOUNT_SENT: u64 = 20; let outgoing_memo = "Outgoing Memo".to_string(); let zaddr = wallet.add_zaddr(); let branch_id = u32::from_str_radix("2bb40e60", 16).unwrap(); let (ss, so) =get_sapling_params().unwrap(); // Create a tx and send to address. This should consume both the UTXO and the note let (_, raw_tx) = wallet.send_to_address(branch_id, &ss, &so, false, vec![(&zaddr, AMOUNT_SENT, Some(outgoing_memo.clone()))], &default_fee(), |_| Ok(' '.to_string())).unwrap(); let sent_tx = Transaction::read(&raw_tx[..]).unwrap(); let sent_txid = sent_tx.txid(); let mut cb3 = FakeCompactBlock::new(2, block_hash); cb3.add_tx(&sent_tx); // Scan the compact block and the full Tx wallet.scan_block(&cb3.as_bytes()).unwrap(); wallet.scan_full_tx(&sent_tx, 2, 0); { let txs = wallet.txs.read().unwrap(); // Includes Outgoing meta data, since this is a wallet -> wallet tx with a memo assert_eq!(txs[&sent_txid].outgoing_metadata.len(), 1); assert_eq!(txs[&sent_txid].outgoing_metadata[0].memo.to_utf8().unwrap().unwrap(), outgoing_memo); } } #[test] fn test_self_txns_ttoz_nomemo() { let mut rng = OsRng; let secp = Secp256k1::new(); let (wallet, _txid1, block_hash) = get_test_wallet(0); let pk = PublicKey::from_secret_key(&secp, &wallet.tkeys.read().unwrap()[0].tkey.unwrap()); let taddr = wallet.address_from_sk(&wallet.tkeys.read().unwrap()[0].tkey.unwrap()); const TAMOUNT1: u64 = 50000; let mut tx = FakeTransaction::new(&mut rng); tx.add_t_output(&pk, TAMOUNT1); let txid1 = tx.get_tx().txid(); wallet.scan_full_tx(&tx.get_tx(), 1, 0); { let txs = wallet.txs.read().unwrap(); // Now make sure the t addr was recieved assert_eq!(txs[&txid1].utxos.len(), 1); assert_eq!(txs[&txid1].utxos[0].address, taddr); assert_eq!(txs[&txid1].utxos[0].value, TAMOUNT1); } // Create a new Tx, spending this taddr const AMOUNT_SENT: u64 = 20; let zaddr = wallet.add_zaddr(); let branch_id = u32::from_str_radix("2bb40e60", 16).unwrap(); let (ss, so) =get_sapling_params().unwrap(); // Create a tx and send to address. This should consume both the UTXO and the note let (_, raw_tx) = wallet.send_to_address(branch_id, &ss, &so, false, vec![(&zaddr, AMOUNT_SENT, None)], &default_fee(), |_| Ok(' '.to_string())).unwrap(); let sent_tx = Transaction::read(&raw_tx[..]).unwrap(); let sent_txid = sent_tx.txid(); let mut cb3 = FakeCompactBlock::new(2, block_hash); cb3.add_tx(&sent_tx); // Scan the compact block and the full Tx wallet.scan_block(&cb3.as_bytes()).unwrap(); wallet.scan_full_tx(&sent_tx, 2, 0); { let txs = wallet.txs.read().unwrap(); // No Outgoing meta data, since this is a wallet -> wallet tx without a memo assert_eq!(txs[&sent_txid].outgoing_metadata.len(), 0); } } /// R3 (regression test). The mempool monitor (scan_full_mempool_tx) records our send in `txs` at the height /// the server reports. The block that mines it must become its height: a reorg of that block removes the /// send, un-spends its note and drops its change. Before the fix the entry kept the monitor's height. #[test] fn test_r3_mempool_seen_send_takes_mined_height() { const AMOUNT1: u64 = 50000; let (wallet, txid1, block_hash) = get_test_wallet(AMOUNT1); // note at block 0, tip 1 let fvk = ExtendedFullViewingKey::from(&ExtendedSpendingKey::master(&[1u8; 32])); let ext_address = encode_payment_address(wallet.config.hrp_sapling_address(), &fvk.default_address().unwrap().1); let branch_id = u32::from_str_radix("76b809bb", 16).unwrap(); let (ss, so) = get_sapling_params().unwrap(); let (_, raw_tx) = wallet.send_to_address(branch_id, &ss, &so, false, vec![(&ext_address, 20, None)], &default_fee(), |_| Ok(' '.to_string())).unwrap(); let sent_tx = Transaction::read(&raw_tx[..]).unwrap(); let sent_txid = sent_tx.txid(); wallet.scan_full_mempool_tx(&sent_tx, 1, 0, true); // decrypts the change: entry at the server height 1 assert_eq!(wallet.txs.read().unwrap().get(&sent_txid).map(|t| t.block), Some(1), "setup: monitor entry"); let cb2 = FakeCompactBlock::new(2, block_hash); // not in block 2 wallet.scan_block(&cb2.as_bytes()).unwrap(); let mut cb3 = FakeCompactBlock::new(3, cb2.hash()); // mined in block 3 cb3.add_tx(&sent_tx); wallet.scan_block(&cb3.as_bytes()).unwrap(); assert_eq!(wallet.txs.read().unwrap()[&sent_txid].block, 3, "R3 (regression): mined at 3, but the WalletTx keeps the mempool monitor's height 1"); assert_eq!(wallet.invalidate_block(3), 1); { let txs = wallet.txs.read().unwrap(); assert!(txs.get(&sent_txid).is_none(), "R3 (regression): a reorg of its mining block kept the send"); assert_eq!(txs[&txid1].notes[0].spent, None, "R3 (regression): phantom spend"); assert_eq!(txs[&txid1].notes[0].unconfirmed_spent, None); assert!(!txs[&txid1].notes[0].witnesses.is_empty()); } assert_eq!(wallet.zbalance(None), AMOUNT1); // guard dropped first: zbalance takes txs.read itself } #[test] fn test_self_txns_ztoz() { const AMOUNT1: u64 = 50000; let (wallet, _txid1, block_hash) = get_test_wallet(AMOUNT1); let zaddr2 = wallet.add_zaddr(); // This is acually address #6, since there are 5 initial addresses in the wallet const AMOUNT_SENT: u64 = 20; let outgoing_memo = "Outgoing Memo".to_string(); let branch_id = u32::from_str_radix("2bb40e60", 16).unwrap(); let (ss, so) =get_sapling_params().unwrap(); // Create a tx and send to address let (_, raw_tx) = wallet.send_to_address(branch_id, &ss, &so, false, vec![(&zaddr2, AMOUNT_SENT, Some(outgoing_memo.clone()))], &default_fee(), |_| Ok(' '.to_string())).unwrap(); let sent_tx = Transaction::read(&raw_tx[..]).unwrap(); let sent_txid = sent_tx.txid(); let mut cb3 = FakeCompactBlock::new(2, block_hash); cb3.add_tx(&sent_tx); wallet.scan_block(&cb3.as_bytes()).unwrap(); wallet.scan_full_tx(&sent_tx, 2, 0); { let txs = wallet.txs.read().unwrap(); // Includes Outgoing meta data, since this is a wallet -> wallet tx with a memo assert_eq!(txs[&sent_txid].outgoing_metadata.len(), 1); assert_eq!(txs[&sent_txid].outgoing_metadata[0].memo.to_utf8().unwrap().unwrap(), outgoing_memo); } // Another self tx, this time without a memo let (_, raw_tx) = wallet.send_to_address(branch_id, &ss, &so, false, vec![(&zaddr2, AMOUNT_SENT, None)], &default_fee(), |_| Ok(' '.to_string())).unwrap(); let sent_tx = Transaction::read(&raw_tx[..]).unwrap(); let sent_txid = sent_tx.txid(); let mut cb4 = FakeCompactBlock::new(3, cb3.hash()); cb4.add_tx(&sent_tx); wallet.scan_block(&cb4.as_bytes()).unwrap(); wallet.scan_full_tx(&sent_tx, 3, 0); { let txs = wallet.txs.read().unwrap(); // No Outgoing meta data, since this is a wallet -> wallet tx without a memo assert_eq!(txs[&sent_txid].outgoing_metadata.len(), 0); } } #[test] fn test_multi_z() { const AMOUNT1: u64 = 50000; let (wallet, txid1, block_hash) = get_test_wallet(AMOUNT1); let zaddr2 = wallet.add_zaddr(); // This is acually address #6, since there are 5 initial addresses in the wallet const AMOUNT_SENT: u64 = 20; let outgoing_memo = "Outgoing Memo".to_string(); let fee: u64 = DEFAULT_FEE.try_into().unwrap(); let branch_id = u32::from_str_radix("76b809bb", 16).unwrap(); let (ss, so) =get_sapling_params().unwrap(); // Create a tx and send to address let (_, raw_tx) = wallet.send_to_address(branch_id, &ss, &so, false, vec![(&zaddr2, AMOUNT_SENT, Some(outgoing_memo.clone()))], &default_fee(), |_| Ok(' '.to_string())).unwrap(); let sent_tx = Transaction::read(&raw_tx[..]).unwrap(); let sent_txid = sent_tx.txid(); let mut cb3 = FakeCompactBlock::new(2, block_hash); cb3.add_tx(&sent_tx); wallet.scan_block(&cb3.as_bytes()).unwrap(); wallet.scan_full_tx(&sent_tx, 2, 0); // Because the builder will randomize notes outputted, we need to find // which note number is the change and which is the output note (Because this tx // had both outputs in the same Tx) let (change_note_number, ext_note_number) = { let txs = wallet.txs.read().unwrap(); if txs[&sent_txid].notes[0].is_change { (0,1) } else { (1,0) } }; // Now this new Spent tx should be in, so the note should be marked confirmed spent { let txs = wallet.txs.read().unwrap(); assert_eq!(txs[&txid1].notes.len(), 1); assert_eq!(txs[&txid1].notes[0].note.value, AMOUNT1); assert_eq!(txs[&txid1].notes[0].spent, Some(sent_txid)); assert_eq!(txs[&txid1].notes[0].unconfirmed_spent, None); // The sent tx should generate change + the new incoming note assert_eq!(txs[&sent_txid].notes.len(), 2); assert_eq!(txs[&sent_txid].notes[change_note_number].note.value, AMOUNT1 - AMOUNT_SENT - fee); assert_eq!(txs[&sent_txid].notes[change_note_number].account, 0); assert_eq!(txs[&sent_txid].notes[change_note_number].is_change, true); assert_eq!(txs[&sent_txid].notes[change_note_number].spent, None); assert_eq!(txs[&sent_txid].notes[change_note_number].unconfirmed_spent, None); assert_eq!(LightWallet::memo_str(&txs[&sent_txid].notes[change_note_number].memo), None); assert_eq!(txs[&sent_txid].notes[ext_note_number].note.value, AMOUNT_SENT); assert_eq!(txs[&sent_txid].notes[ext_note_number].account, 6); // The new addr is added after the change addresses assert_eq!(txs[&sent_txid].notes[ext_note_number].is_change, false); assert_eq!(txs[&sent_txid].notes[ext_note_number].spent, None); assert_eq!(txs[&sent_txid].notes[ext_note_number].unconfirmed_spent, None); assert_eq!(LightWallet::memo_str(&txs[&sent_txid].notes[ext_note_number].memo), Some(outgoing_memo.clone())); assert_eq!(txs[&sent_txid].total_shielded_value_spent, AMOUNT1); // Includes Outgoing meta data, since this is a wallet -> wallet tx with a memo assert_eq!(txs[&sent_txid].outgoing_metadata.len(), 1); assert_eq!(txs[&sent_txid].outgoing_metadata[0].memo.to_utf8().unwrap().unwrap(), outgoing_memo); } // Now spend the money, which should pick notes from both addresses let amount_all:u64 = (AMOUNT1 - AMOUNT_SENT - fee) + (AMOUNT_SENT) - fee; let taddr = wallet.address_from_sk(&SecretKey::from_slice(&[1u8; 32]).unwrap()); let (_, raw_tx) = wallet.send_to_address(branch_id, &ss, &so, false, vec![(&taddr, amount_all, None)], &default_fee(), |_| Ok(' '.to_string())).unwrap(); let sent_tx = Transaction::read(&raw_tx[..]).unwrap(); let sent_ext_txid = sent_tx.txid(); let mut cb4 = FakeCompactBlock::new(3, cb3.hash()); cb4.add_tx(&sent_tx); wallet.scan_block(&cb4.as_bytes()).unwrap(); wallet.scan_full_tx(&sent_tx, 3, 0); { // Both notes should be spent now. let txs = wallet.txs.read().unwrap(); assert_eq!(txs[&sent_txid].notes[change_note_number].is_change, true); assert_eq!(txs[&sent_txid].notes[change_note_number].spent, Some(sent_ext_txid)); assert_eq!(txs[&sent_txid].notes[change_note_number].unconfirmed_spent, None); assert_eq!(txs[&sent_txid].notes[ext_note_number].is_change, false); assert_eq!(txs[&sent_txid].notes[ext_note_number].spent, Some(sent_ext_txid)); assert_eq!(txs[&sent_txid].notes[ext_note_number].unconfirmed_spent, None); // Check outgoing metadata for the external sent tx assert_eq!(txs[&sent_ext_txid].notes.len(), 0); // No change was generated assert_eq!(txs[&sent_ext_txid].outgoing_metadata.len(), 1); assert_eq!(txs[&sent_ext_txid].outgoing_metadata[0].address, taddr); assert_eq!(txs[&sent_ext_txid].outgoing_metadata[0].value, amount_all); } } #[test] fn test_z_spend_to_taddr() { const AMOUNT1: u64 = 50000; let (wallet, txid1, block_hash) = get_test_wallet(AMOUNT1); let branch_id = u32::from_str_radix("76b809bb", 16).unwrap(); let (ss, so) = get_sapling_params().unwrap(); let taddr = wallet.address_from_sk(&SecretKey::from_slice(&[1u8; 32]).unwrap()); const AMOUNT_SENT: u64 = 30; let fee: u64 = DEFAULT_FEE.try_into().unwrap(); let (_, raw_tx) = wallet.send_to_address(branch_id, &ss, &so, false, vec![(&taddr, AMOUNT_SENT, None)], &default_fee(), |_| Ok(' '.to_string())).unwrap(); let sent_tx = Transaction::read(&raw_tx[..]).unwrap(); let sent_txid = sent_tx.txid(); // Now, the note should be unconfirmed spent { let txs = wallet.txs.read().unwrap(); assert_eq!(txs[&txid1].notes[0].note.value, AMOUNT1); assert_eq!(txs[&txid1].notes[0].is_change, false); assert_eq!(txs[&txid1].notes[0].spent, None); assert_eq!(txs[&txid1].notes[0].unconfirmed_spent, Some(sent_txid)); } let mut cb3 = FakeCompactBlock::new(2, block_hash); cb3.add_tx(&sent_tx); wallet.scan_block(&cb3.as_bytes()).unwrap(); // Now this new Spent tx should be in, so the note should be marked confirmed spent { let txs = wallet.txs.read().unwrap(); assert_eq!(txs[&txid1].notes.len(), 1); assert_eq!(txs[&txid1].notes[0].note.value, AMOUNT1); assert_eq!(txs[&txid1].notes[0].spent, Some(sent_txid)); assert_eq!(txs[&txid1].notes[0].unconfirmed_spent, None); // The sent tx should generate change assert_eq!(txs[&sent_txid].notes.len(), 1); assert_eq!(txs[&sent_txid].notes[0].note.value, AMOUNT1 - AMOUNT_SENT - fee); assert_eq!(txs[&sent_txid].notes[0].is_change, true); assert_eq!(txs[&sent_txid].notes[0].spent, None); assert_eq!(txs[&sent_txid].notes[0].unconfirmed_spent, None); } // Now, full scan the Tx, which should populate the Outgoing Meta data wallet.scan_full_tx(&sent_tx, 2, 0); // Check Outgoing Metadata for t address { let txs = wallet.txs.read().unwrap(); assert_eq!(txs[&sent_txid].outgoing_metadata.len(), 1); assert_eq!(txs[&sent_txid].outgoing_metadata[0].address, taddr); assert_eq!(txs[&sent_txid].outgoing_metadata[0].value, AMOUNT_SENT); assert_eq!(txs[&sent_txid].total_shielded_value_spent, AMOUNT1); } // Create a new Tx, but this time with a memo. let (_, raw_tx) = wallet.send_to_address(branch_id, &ss, &so, false, vec![(&taddr, AMOUNT_SENT, Some("T address memo".to_string()))], &default_fee(), |_| Ok(' '.to_string())).unwrap(); let sent_tx = Transaction::read(&raw_tx[..]).unwrap(); let sent_txid2 = sent_tx.txid(); // There should be a mempool Tx, but the memo should be dropped, because it was sent to a // t address { let txs = wallet.mempool_txs.read().unwrap(); assert_eq!(txs[&sent_txid2].outgoing_metadata.len(), 1); assert_eq!(txs[&sent_txid2].outgoing_metadata[0].address, taddr); assert_eq!(txs[&sent_txid2].outgoing_metadata[0].value, AMOUNT_SENT); assert_eq!(LightWallet::memo_str(&Some(txs[&sent_txid2].outgoing_metadata[0].memo.clone())), None); } // Now add the block let mut cb4 = FakeCompactBlock::new(3, cb3.hash()); cb4.add_tx(&sent_tx); wallet.scan_block(&cb4.as_bytes()).unwrap(); wallet.scan_full_tx(&sent_tx, 3, 0); // Check Outgoing Metadata for t address, but once again there should be no memo { let txs = wallet.txs.read().unwrap(); assert_eq!(txs[&sent_txid2].outgoing_metadata.len(), 1); assert_eq!(txs[&sent_txid2].outgoing_metadata[0].address, taddr); assert_eq!(txs[&sent_txid2].outgoing_metadata[0].value, AMOUNT_SENT); assert_eq!(LightWallet::memo_str(&Some(txs[&sent_txid2].outgoing_metadata[0].memo.clone())), None); } } #[test] fn test_t_spend_to_z() { let mut rng = OsRng; let secp = Secp256k1::new(); const AMOUNT_Z: u64 = 50000; const AMOUNT_T: u64 = 40000; let (wallet, txid1, block_hash) = get_test_wallet(AMOUNT_Z); let pk = PublicKey::from_secret_key(&secp, &wallet.tkeys.read().unwrap()[0].tkey.unwrap()); let taddr = wallet.address_from_sk(&wallet.tkeys.read().unwrap()[0].tkey.unwrap()); let mut tx = FakeTransaction::new(&mut rng); tx.add_t_output(&pk, AMOUNT_T); let txid_t = tx.get_tx().txid(); wallet.scan_full_tx(&tx.get_tx(), 1, 0); // Pretend it is at height 1 { let txs = wallet.txs.read().unwrap(); // Now make sure the t addr was recieved assert_eq!(txs[&txid_t].utxos.len(), 1); assert_eq!(txs[&txid_t].utxos[0].address, taddr); assert_eq!(txs[&txid_t].utxos[0].spent, None); assert_eq!(txs[&txid_t].utxos[0].unconfirmed_spent, None); assert_eq!(wallet.tbalance(None), AMOUNT_T); } let fvk = ExtendedFullViewingKey::from(&ExtendedSpendingKey::master(&[1u8; 32])); let ext_address = encode_payment_address(wallet.config.hrp_sapling_address(), &fvk.default_address().unwrap().1); const AMOUNT_SENT: u64 = 20; let outgoing_memo = "Outgoing Memo".to_string(); let fee: u64 = DEFAULT_FEE.try_into().unwrap(); let branch_id = u32::from_str_radix("76b809bb", 16).unwrap(); let (ss, so) =get_sapling_params().unwrap(); // Create a tx and send to address. This should consume both the UTXO and the note let (_, raw_tx) = wallet.send_to_address(branch_id, &ss, &so, false, vec![(&ext_address, AMOUNT_SENT, Some(outgoing_memo.clone()))], &default_fee(), |_| Ok(' '.to_string())).unwrap(); let sent_tx = Transaction::read(&raw_tx[..]).unwrap(); let sent_txid = sent_tx.txid(); // Verify the sent_tx for sanity { // The tx has 1 note spent, 1 utxo spent, and (1 note out, 1 note change) assert_eq!(sent_tx.shielded_spends.len(), 1); assert_eq!(sent_tx.vin.len(), 1); assert_eq!(sent_tx.shielded_outputs.len(), 2); } // Now, the note and utxo should be unconfirmed spent { let txs = wallet.txs.read().unwrap(); // UTXO assert_eq!(txs[&txid_t].utxos.len(), 1); assert_eq!(txs[&txid_t].utxos[0].address, taddr); assert_eq!(txs[&txid_t].utxos[0].spent, None); assert_eq!(txs[&txid_t].utxos[0].unconfirmed_spent, Some(sent_txid)); // Note assert_eq!(txs[&txid1].notes[0].note.value, AMOUNT_Z); assert_eq!(txs[&txid1].notes[0].spent, None); assert_eq!(txs[&txid1].notes[0].unconfirmed_spent, Some(sent_txid)); } let mut cb3 = FakeCompactBlock::new(2, block_hash); cb3.add_tx(&sent_tx); // Scan the compact block and the full Tx wallet.scan_block(&cb3.as_bytes()).unwrap(); wallet.scan_full_tx(&sent_tx, 2, 0); // Now this new Spent tx should be in, so the note should be marked confirmed spent { let txs = wallet.txs.read().unwrap(); assert_eq!(txs[&txid1].notes.len(), 1); assert_eq!(txs[&txid1].notes[0].note.value, AMOUNT_Z); assert_eq!(txs[&txid1].notes[0].spent, Some(sent_txid)); assert_eq!(txs[&txid1].notes[0].unconfirmed_spent, None); // The UTXO should also be spent assert_eq!(txs[&txid_t].utxos[0].address, taddr); assert_eq!(txs[&txid_t].utxos[0].spent, Some(sent_txid)); assert_eq!(txs[&txid_t].utxos[0].unconfirmed_spent, None); // The sent tx should generate change assert_eq!(txs[&sent_txid].notes.len(), 1); assert_eq!(txs[&sent_txid].notes[0].note.value, AMOUNT_Z + AMOUNT_T - AMOUNT_SENT - fee); assert_eq!(txs[&sent_txid].notes[0].is_change, true); assert_eq!(txs[&sent_txid].notes[0].spent, None); assert_eq!(txs[&sent_txid].notes[0].unconfirmed_spent, None); } } #[test] fn test_z_incoming_memo() { const AMOUNT1: u64 = 50000; let (wallet, _txid1, block_hash) = get_test_wallet(AMOUNT1); let my_address = encode_payment_address(wallet.config.hrp_sapling_address(), &wallet.zkeys.read().unwrap()[0].extfvk.default_address().unwrap().1); let memo = "Incoming Memo".to_string(); let fee: u64 = DEFAULT_FEE.try_into().unwrap(); let branch_id = u32::from_str_radix("76b809bb", 16).unwrap(); let (ss, so) = get_sapling_params().unwrap(); // Create a tx and send to address let (_, raw_tx) = wallet.send_to_address(branch_id, &ss, &so, false, vec![(&my_address, AMOUNT1 - fee, Some(memo.clone()))], &default_fee(), |_| Ok(' '.to_string())).unwrap(); let sent_tx = Transaction::read(&raw_tx[..]).unwrap(); let sent_txid = sent_tx.txid(); // Add it to a block let mut cb3 = FakeCompactBlock::new(2, block_hash); cb3.add_tx(&sent_tx); wallet.scan_block(&cb3.as_bytes()).unwrap(); // And scan the Full Tx to get the memo wallet.scan_full_tx(&sent_tx, 2, 0); { let txs = wallet.txs.read().unwrap(); assert_eq!(txs[&sent_txid].notes.len(), 1); assert_eq!(txs[&sent_txid].notes[0].extfvk, wallet.zkeys.read().unwrap()[0].extfvk); assert_eq!(txs[&sent_txid].notes[0].note.value, AMOUNT1 - fee); assert_eq!(LightWallet::note_address(wallet.config.hrp_sapling_address(), &txs[&sent_txid].notes[0]), Some(my_address)); assert_eq!(LightWallet::memo_str(&txs[&sent_txid].notes[0].memo), Some(memo)); } } #[test] fn test_add_new_zt_hd_after_incoming() { // When an address recieves funds, a new, unused address should automatically get added const AMOUNT1: u64 = 50000; let (wallet, _txid1, block_hash) = get_test_wallet(AMOUNT1); // Get the last address let my_address = encode_payment_address(wallet.config.hrp_sapling_address(), &wallet.zkeys.read().unwrap().last().unwrap().extfvk.default_address().unwrap().1); let fee: u64 = DEFAULT_FEE.try_into().unwrap(); let branch_id = u32::from_str_radix("2bb40e60", 16).unwrap(); let (ss, so) = get_sapling_params().unwrap(); assert_eq!(wallet.zkeys.read().unwrap().len(), 6); // Starts with 1+5 addresses // Create a tx and send to the last address let (_, raw_tx) = wallet.send_to_address(branch_id, &ss, &so, false, vec![(&my_address, AMOUNT1 - fee, None)], &default_fee(), |_| Ok(' '.to_string())).unwrap(); let sent_tx = Transaction::read(&raw_tx[..]).unwrap(); // Add it to a block let mut cb3 = FakeCompactBlock::new(2, block_hash); cb3.add_tx(&sent_tx); wallet.scan_block(&cb3.as_bytes()).unwrap(); // NOw, 5 new addresses should be created assert_eq!(wallet.zkeys.read().unwrap().len(), 6+5); let mut rng = OsRng; let secp = Secp256k1::new(); // Send a fake transaction to the last taddr let pk = PublicKey::from_secret_key(&secp, &wallet.tkeys.read().unwrap().last().unwrap().tkey.unwrap()); // Start with 1 taddr assert_eq!(wallet.tkeys.read().unwrap().len(), 1); // Send a Tx to the last address let mut tx = FakeTransaction::new(&mut rng); tx.add_t_output(&pk, AMOUNT1); wallet.scan_full_tx(&tx.get_tx(), 3, 0); // Now, 5 new addresses should be created. assert_eq!(wallet.tkeys.read().unwrap().len(), 1+5); } #[test] fn test_z_to_t_withinwallet() { const AMOUNT: u64 = 500000; const AMOUNT_SENT: u64 = 20000; let (wallet, txid1, block_hash) = get_test_wallet(AMOUNT); let taddr = wallet.address_from_sk(&wallet.tkeys.read().unwrap()[0].tkey.unwrap()); let fee: u64 = DEFAULT_FEE.try_into().unwrap(); let branch_id = u32::from_str_radix("76b809bb", 16).unwrap(); let (ss, so) = get_sapling_params().unwrap(); // Create a tx and send to address let (_, raw_tx) = wallet.send_to_address(branch_id, &ss, &so, false, vec![(&taddr, AMOUNT_SENT, None)], &default_fee(), |_| Ok(' '.to_string())).unwrap(); let sent_tx = Transaction::read(&raw_tx[..]).unwrap(); let sent_txid = sent_tx.txid(); // Add it to a block let mut cb3 = FakeCompactBlock::new(2, block_hash); cb3.add_tx(&sent_tx); wallet.scan_block(&cb3.as_bytes()).unwrap(); // And scan the Full Tx to get the memo wallet.scan_full_tx(&sent_tx, 2, 0); { let txs = wallet.txs.read().unwrap(); // We have the original note assert_eq!(txs[&txid1].notes.len(), 1); assert_eq!(txs[&txid1].notes[0].note.value, AMOUNT); // We have the spent tx assert_eq!(txs[&sent_txid].notes.len(), 1); assert_eq!(txs[&sent_txid].notes[0].note.value, AMOUNT - AMOUNT_SENT - fee); assert_eq!(txs[&sent_txid].notes[0].is_change, true); assert_eq!(txs[&sent_txid].notes[0].spent, None); assert_eq!(txs[&sent_txid].notes[0].unconfirmed_spent, None); // Since we sent the Tx to ourself, there should be no outgoing // metadata assert_eq!(txs[&sent_txid].total_shielded_value_spent, AMOUNT); assert_eq!(txs[&sent_txid].outgoing_metadata.len(), 0); // We have the taddr utxo in the same Tx assert_eq!(txs[&sent_txid].utxos.len(), 1); assert_eq!(txs[&sent_txid].utxos[0].address, taddr); assert_eq!(txs[&sent_txid].utxos[0].value, AMOUNT_SENT); assert_eq!(txs[&sent_txid].utxos[0].spent, None); assert_eq!(txs[&sent_txid].utxos[0].unconfirmed_spent, None); } } #[test] fn test_multi_t() { const AMOUNT: u64 = 5000000; const AMOUNT_SENT1: u64 = 20000; const AMOUNT_SENT2: u64 = 10000; let (wallet, txid1, block_hash) = get_test_wallet(AMOUNT); // Add a new taddr let taddr2 = wallet.add_taddr(); let fee: u64 = DEFAULT_FEE.try_into().unwrap(); let branch_id = u32::from_str_radix("76b809bb", 16).unwrap(); let (ss, so) = get_sapling_params().unwrap(); // Create a Tx and send to the second t address let (_, raw_tx) = wallet.send_to_address(branch_id, &ss, &so, false, vec![(&taddr2, AMOUNT_SENT1, None)], &default_fee(), |_| Ok(' '.to_string())).unwrap(); let sent_tx = Transaction::read(&raw_tx[..]).unwrap(); let sent_txid1 = sent_tx.txid(); // Add it to a block let mut cb3 = FakeCompactBlock::new(2, block_hash); cb3.add_tx(&sent_tx); wallet.scan_block(&cb3.as_bytes()).unwrap(); wallet.scan_full_tx(&sent_tx, 2, 0); // Check that the send to the second taddr worked { let txs = wallet.txs.read().unwrap(); // We have the original note assert_eq!(txs[&txid1].notes.len(), 1); assert_eq!(txs[&txid1].notes[0].note.value, AMOUNT); // We have the spent tx assert_eq!(txs[&sent_txid1].notes.len(), 1); assert_eq!(txs[&sent_txid1].notes[0].note.value, AMOUNT - AMOUNT_SENT1 - fee); assert_eq!(txs[&sent_txid1].notes[0].is_change, true); assert_eq!(txs[&sent_txid1].notes[0].spent, None); assert_eq!(txs[&sent_txid1].notes[0].unconfirmed_spent, None); // Since we sent the Tx to ourself, there should be no outgoing // metadata assert_eq!(txs[&sent_txid1].total_shielded_value_spent, AMOUNT); assert_eq!(txs[&sent_txid1].outgoing_metadata.len(), 0); // We have the taddr utxo in the same Tx assert_eq!(txs[&sent_txid1].utxos.len(), 1); assert_eq!(txs[&sent_txid1].utxos[0].address, taddr2); assert_eq!(txs[&sent_txid1].utxos[0].value, AMOUNT_SENT1); assert_eq!(txs[&sent_txid1].utxos[0].spent, None); assert_eq!(txs[&sent_txid1].utxos[0].unconfirmed_spent, None); } // Send some money to the 3rd t addr let taddr3 = wallet.add_taddr(); // Create a Tx and send to the second t address let (_, raw_tx) = wallet.send_to_address(branch_id, &ss, &so, false, vec![(&taddr3, AMOUNT_SENT2, None)], &default_fee(), |_| Ok(' '.to_string())).unwrap(); let sent_tx = Transaction::read(&raw_tx[..]).unwrap(); let sent_txid2 = sent_tx.txid(); // Add it to a block let mut cb4 = FakeCompactBlock::new(3, cb3.hash()); cb4.add_tx(&sent_tx); wallet.scan_block(&cb4.as_bytes()).unwrap(); wallet.scan_full_tx(&sent_tx, 3, 0); // Quickly check we have it { let txs = wallet.txs.read().unwrap(); // We have the taddr utxo in the same Tx assert_eq!(txs[&sent_txid2].utxos.len(), 1); assert_eq!(txs[&sent_txid2].utxos[0].address, taddr3); assert_eq!(txs[&sent_txid2].utxos[0].value, AMOUNT_SENT2); // Old UTXO was spent here assert_eq!(txs[&sent_txid1].utxos.len(), 1); assert_eq!(txs[&sent_txid1].utxos[0].value, AMOUNT_SENT1); assert_eq!(txs[&sent_txid1].utxos[0].address, taddr2); assert_eq!(txs[&sent_txid1].utxos[0].spent, Some(sent_txid2)); assert_eq!(txs[&sent_txid1].utxos[0].unconfirmed_spent, None); } // Now, spend to an external z address, which will select all the utxos let fvk = ExtendedFullViewingKey::from(&ExtendedSpendingKey::master(&[1u8; 32])); let ext_address = encode_payment_address(wallet.config.hrp_sapling_address(), &fvk.default_address().unwrap().1); const AMOUNT_SENT_EXT: u64 = 45; let outgoing_memo = "Outgoing Memo".to_string(); // Create a tx and send to address let (_, raw_tx) = wallet.send_to_address(branch_id, &ss, &so, false, vec![(&ext_address, AMOUNT_SENT_EXT, Some(outgoing_memo.clone()))], &default_fee(), |_| Ok(' '.to_string())).unwrap(); let sent_tx = Transaction::read(&raw_tx[..]).unwrap(); let sent_txid3 = sent_tx.txid(); let mut cb5 = FakeCompactBlock::new(4, cb4.hash()); cb5.add_tx(&sent_tx); wallet.scan_block(&cb5.as_bytes()).unwrap(); wallet.scan_full_tx(&sent_tx, 4, 0); { let txs = wallet.txs.read().unwrap(); assert_eq!(txs[&sent_txid3].outgoing_metadata.len(), 1); assert_eq!(txs[&sent_txid3].outgoing_metadata[0].address, ext_address); assert_eq!(txs[&sent_txid3].outgoing_metadata[0].value, AMOUNT_SENT_EXT); assert_eq!(txs[&sent_txid3].outgoing_metadata[0].memo.to_utf8().unwrap().unwrap(), outgoing_memo); // Test to see that the UTXOs were spent. // UTXO2 assert_eq!(txs[&sent_txid2].utxos[0].value, AMOUNT_SENT2); assert_eq!(txs[&sent_txid2].utxos[0].address, taddr3); assert_eq!(txs[&sent_txid2].utxos[0].spent, Some(sent_txid3)); assert_eq!(txs[&sent_txid2].utxos[0].unconfirmed_spent, None); } } #[test] fn test_multi_spends() { const AMOUNT1: u64 = 50000; let (wallet, txid1, block_hash) = get_test_wallet(AMOUNT1); let zaddr2 = wallet.add_zaddr(); // Address number 6 const ZAMOUNT2:u64 = 30; let outgoing_memo2 = "Outgoing Memo2".to_string(); let zaddr3 = wallet.add_zaddr(); // Address number 7 const ZAMOUNT3:u64 = 40; let outgoing_memo3 = "Outgoing Memo3".to_string(); let taddr2 = wallet.add_taddr(); const TAMOUNT2:u64 = 50; let taddr3 = wallet.add_taddr(); const TAMOUNT3:u64 = 60; let fee: u64 = DEFAULT_FEE.try_into().unwrap(); let branch_id = u32::from_str_radix("76b809bb", 16).unwrap(); let (ss, so) = get_sapling_params().unwrap(); let tos = vec![ (zaddr2.as_str(), ZAMOUNT2, Some(outgoing_memo2.clone())), (zaddr3.as_str(), ZAMOUNT3, Some(outgoing_memo3.clone())), (taddr2.as_str(), TAMOUNT2, None), (taddr3.as_str(), TAMOUNT3, None) ]; let (_, raw_tx) = wallet.send_to_address(branch_id, &ss, &so, false, tos, &default_fee(), |_| Ok(' '.to_string())).unwrap(); let sent_tx = Transaction::read(&raw_tx[..]).unwrap(); let sent_txid = sent_tx.txid(); let mut cb3 = FakeCompactBlock::new(2, block_hash); cb3.add_tx(&sent_tx); wallet.scan_block(&cb3.as_bytes()).unwrap(); wallet.scan_full_tx(&sent_tx, 2, 0); // Make sure all the outputs are there! { let txs = wallet.txs.read().unwrap(); // The single note was spent assert_eq!(txs[&txid1].notes[0].note.value, AMOUNT1); assert_eq!(txs[&txid1].notes[0].spent, Some(sent_txid)); // The outputs are all sent to the wallet, so they should // correspond to notes & utxos. // 2 notes + 1 change assert_eq!(txs[&sent_txid].notes.len(), 3); // Find the change note let change_note = txs[&sent_txid].notes.iter().find(|n| n.is_change).unwrap(); assert_eq!(change_note.note.value, AMOUNT1 - (ZAMOUNT2+ZAMOUNT3+TAMOUNT2+TAMOUNT3+fee)); assert_eq!(change_note.spent, None); assert_eq!(change_note.unconfirmed_spent, None); // Find zaddr2 let zaddr2_note = txs[&sent_txid].notes.iter().find(|n| n.note.value == ZAMOUNT2).unwrap(); assert_eq!(zaddr2_note.account, 6); assert_eq!(zaddr2_note.is_change, false); assert_eq!(zaddr2_note.spent, None); assert_eq!(zaddr2_note.unconfirmed_spent, None); assert_eq!(LightWallet::memo_str(&zaddr2_note.memo), Some(outgoing_memo2)); // Find zaddr3 let zaddr3_note = txs[&sent_txid].notes.iter().find(|n| n.note.value == ZAMOUNT3).unwrap(); assert_eq!(zaddr3_note.account, 7); assert_eq!(zaddr3_note.is_change, false); assert_eq!(zaddr3_note.spent, None); assert_eq!(zaddr3_note.unconfirmed_spent, None); assert_eq!(LightWallet::memo_str(&zaddr3_note.memo), Some(outgoing_memo3)); // Find taddr2 let utxo2 = txs[&sent_txid].utxos.iter().find(|u| u.value == TAMOUNT2).unwrap(); assert_eq!(utxo2.address, taddr2); assert_eq!(utxo2.txid, sent_txid); assert_eq!(utxo2.spent, None); assert_eq!(utxo2.unconfirmed_spent, None); // Find taddr3 let utxo3 = txs[&sent_txid].utxos.iter().find(|u| u.value == TAMOUNT3).unwrap(); assert_eq!(utxo3.address, taddr3); assert_eq!(utxo3.txid, sent_txid); assert_eq!(utxo3.spent, None); assert_eq!(utxo3.unconfirmed_spent, None); } // Now send an outgoing tx to one ext taddr and one ext zaddr let fvk = ExtendedFullViewingKey::from(&ExtendedSpendingKey::master(&[1u8; 32])); let ext_address = encode_payment_address(wallet.config.hrp_sapling_address(), &fvk.default_address().unwrap().1); let ext_memo = "External memo".to_string(); let ext_taddr = wallet.address_from_sk(&SecretKey::from_slice(&[1u8; 32]).unwrap()); const EXT_ZADDR_AMOUNT: u64 = 3000; let ext_taddr_amount = AMOUNT1 - fee - EXT_ZADDR_AMOUNT - fee; // Spend everything println!("taddr amount {}", ext_taddr_amount); let tos = vec![ (ext_address.as_str(), EXT_ZADDR_AMOUNT, Some(ext_memo.clone())), (ext_taddr.as_str(), ext_taddr_amount, None)]; let (_, raw_tx) = wallet.send_to_address(branch_id, &ss, &so, false, tos, &default_fee(), |_| Ok(' '.to_string())).unwrap(); let sent_tx = Transaction::read(&raw_tx[..]).unwrap(); let sent_txid2 = sent_tx.txid(); let mut cb4 = FakeCompactBlock::new(3, cb3.hash()); cb4.add_tx(&sent_tx); wallet.scan_block(&cb4.as_bytes()).unwrap(); wallet.scan_full_tx(&sent_tx, 3, 0); // Make sure all the outputs are there! { let txs = wallet.txs.read().unwrap(); // All notes were spent assert_eq!(txs[&sent_txid].notes[0].spent, Some(sent_txid2)); assert_eq!(txs[&sent_txid].notes[1].spent, Some(sent_txid2)); assert_eq!(txs[&sent_txid].notes[2].spent, Some(sent_txid2)); // All utxos were spent assert_eq!(txs[&sent_txid].utxos[0].spent, Some(sent_txid2)); assert_eq!(txs[&sent_txid].utxos[1].spent, Some(sent_txid2)); // The new tx has no change assert_eq!(txs[&sent_txid2].notes.len(), 0); assert_eq!(txs[&sent_txid2].utxos.len(), 0); // Test the outgoing metadata // Find the znote let zoutgoing = txs[&sent_txid2].outgoing_metadata.iter().find(|o| o.address == ext_address).unwrap(); assert_eq!(zoutgoing.value, EXT_ZADDR_AMOUNT); assert_eq!(LightWallet::memo_str(&Some(zoutgoing.memo.clone())), Some(ext_memo)); // Find the taddr let toutgoing = txs[&sent_txid2].outgoing_metadata.iter().find(|o| o.address == ext_taddr).unwrap(); assert_eq!(toutgoing.value, ext_taddr_amount); assert_eq!(LightWallet::memo_str(&Some(toutgoing.memo.clone())), None); } } #[test] fn test_bad_send() { // Test all the ways in which a send should fail const AMOUNT1: u64 = 50000; let _fee: u64 = DEFAULT_FEE.try_into().unwrap(); let (wallet, _txid1, _block_hash) = get_test_wallet(AMOUNT1); let branch_id = u32::from_str_radix("76b809bb", 16).unwrap(); let (ss, so) = get_sapling_params().unwrap(); let ext_taddr = wallet.address_from_sk(&SecretKey::from_slice(&[1u8; 32]).unwrap()); // Bad address let raw_tx = wallet.send_to_address(branch_id, &ss, &so, false, vec![(&"badaddress", 10, None)], &default_fee(), |_| Ok(' '.to_string())); assert!(raw_tx.err().unwrap().contains("Invalid recipient address")); // Insufficient funds let raw_tx = wallet.send_to_address(branch_id, &ss, &so, false, vec![(&ext_taddr, AMOUNT1 + 10, None)], &default_fee(), |_| Ok(' '.to_string())); assert!(raw_tx.err().unwrap().contains("Insufficient verified funds")); // No addresses let raw_tx = wallet.send_to_address(branch_id, &ss, &so, false, vec![], &default_fee(), |_| Ok(' '.to_string())); assert!(raw_tx.err().unwrap().contains("at least one")); } #[test] fn test_duplicate_outputs() { // Test all the ways in which a send should fail const AMOUNT1: u64 = 50000; let _fee: u64 = DEFAULT_FEE.try_into().unwrap(); let (wallet, _txid1, _block_hash) = get_test_wallet(AMOUNT1); let branch_id = u32::from_str_radix("2bb40e60", 16).unwrap(); let (ss, so) = get_sapling_params().unwrap(); let ext_taddr = wallet.address_from_sk(&SecretKey::from_slice(&[1u8; 32]).unwrap()); // Duplicated addresses with memos are fine too let raw_tx = wallet.send_to_address(branch_id, &ss, &so, false, vec![(&ext_taddr, 100, Some("First memo".to_string())), (&ext_taddr, 0, Some("Second memo".to_string())), (&ext_taddr, 0, Some("Third memo".to_string()))], &default_fee(), |_| Ok(' '.to_string())); assert!(raw_tx.is_ok()); } #[test] #[should_panic] fn test_bad_params() { let (wallet, _, _) = get_test_wallet(100000); let ext_taddr = wallet.address_from_sk(&SecretKey::from_slice(&[1u8; 32]).unwrap()); let branch_id = u32::from_str_radix("76b809bb", 16).unwrap(); // Bad params let _ = wallet.send_to_address(branch_id, &[], &[], false, vec![(&ext_taddr, 10, None)], &default_fee(), |_| Ok(' '.to_string())); } /// Test helper to add blocks fn add_blocks(wallet: &LightWallet, start: i32, num: i32, mut prev_hash: BlockHash) -> Result{ // Add it to a block let mut new_blk = FakeCompactBlock::new(start, prev_hash); for i in 0..num { new_blk = FakeCompactBlock::new(start+i, prev_hash); prev_hash = new_blk.hash(); match wallet.scan_block(&new_blk.as_bytes()) { Ok(_) => {}, // continue Err(e) => return Err(e) }; } Ok(new_blk.hash()) } #[test] fn test_z_mempool_expiry() { const AMOUNT1: u64 = 50000; let (wallet, _, block_hash) = get_test_wallet(AMOUNT1); let fvk = ExtendedFullViewingKey::from(&ExtendedSpendingKey::master(&[1u8; 32])); let ext_address = encode_payment_address(wallet.config.hrp_sapling_address(), &fvk.default_address().unwrap().1); const AMOUNT_SENT: u64 = 20; let outgoing_memo = "Outgoing Memo".to_string(); let branch_id = u32::from_str_radix("76b809bb", 16).unwrap(); let (ss, so) = get_sapling_params().unwrap(); // Create a tx and send to address let (_, raw_tx) = wallet.send_to_address(branch_id, &ss, &so, false, vec![(&ext_address, AMOUNT_SENT, Some(outgoing_memo.clone()))], &default_fee(), |_| Ok(' '.to_string())).unwrap(); let sent_tx = Transaction::read(&raw_tx[..]).unwrap(); let sent_txid = sent_tx.txid(); // It should also be in the mempool structure { let mem = wallet.mempool_txs.read().unwrap(); assert_eq!(mem[&sent_txid].block, 1); // block number is the current tip (the fork targets the tip, d2887d0) assert! (mem[&sent_txid].datetime > 0); assert_eq!(mem[&sent_txid].txid, sent_txid); assert_eq!(mem[&sent_txid].outgoing_metadata.len(), 1); assert_eq!(mem[&sent_txid].outgoing_metadata[0].address, ext_address); assert_eq!(mem[&sent_txid].outgoing_metadata[0].value, AMOUNT_SENT); assert_eq!(mem[&sent_txid].outgoing_metadata[0].memo.to_utf8().unwrap().unwrap(), outgoing_memo); } // Don't mine the Tx, but just add several blocks add_blocks(&wallet, 2, 21, block_hash).unwrap(); // After 21 blocks, it should disappear (expiry is 20 blocks) since it was not mined { let mem = wallet.mempool_txs.read().unwrap(); assert!(mem.get(&sent_txid).is_none()); } } #[test] fn test_block_limit() { const AMOUNT: u64 = 500000; let (wallet, _txid1, block_hash) = get_test_wallet(AMOUNT); let prev_hash = add_blocks(&wallet, 2, 1, block_hash).unwrap(); assert_eq!(wallet.blocks.read().unwrap().len(), 3); let prev_hash = add_blocks(&wallet, 3, 47, prev_hash).unwrap(); assert_eq!(wallet.blocks.read().unwrap().len(), 50); let prev_hash = add_blocks(&wallet, 50, 51, prev_hash).unwrap(); assert_eq!(wallet.blocks.read().unwrap().len(), 101); // Subsequent blocks should start to trim let prev_hash = add_blocks(&wallet, 101, 1, prev_hash).unwrap(); assert_eq!(wallet.blocks.read().unwrap().len(), 101); // Add lots let _ = add_blocks(&wallet, 102, 10, prev_hash).unwrap(); assert_eq!(wallet.blocks.read().unwrap().len(), 101); // Now clear the blocks wallet.clear_blocks(); assert_eq!(wallet.blocks.read().unwrap().len(), 0); let prev_hash = add_blocks(&wallet, 0, 1, BlockHash([0;32])).unwrap(); assert_eq!(wallet.blocks.read().unwrap().len(), 1); let _ = add_blocks(&wallet, 1, 10, prev_hash).unwrap(); assert_eq!(wallet.blocks.read().unwrap().len(), 11); } #[test] fn test_rollback() { const AMOUNT: u64 = 500000; let (wallet, txid1, block_hash) = get_test_wallet(AMOUNT); add_blocks(&wallet, 2, 5, block_hash).unwrap(); // Make sure the note exists with the witnesses { let txs = wallet.txs.read().unwrap(); assert_eq!(txs[&txid1].notes[0].witnesses.len(), 7); } // Invalidate 2 blocks assert_eq!(wallet.last_scanned_height(), 6); assert_eq!(wallet.invalidate_block(5), 2); // THe witnesses should be rolledback { let txs = wallet.txs.read().unwrap(); assert_eq!(txs[&txid1].notes[0].witnesses.len(), 5); } let blk3_hash; let blk4_hash; { let blks = wallet.blocks.read().unwrap(); blk3_hash = blks[3].hash.clone(); blk4_hash = blks[4].hash.clone(); } // This should result in an exception, because the "prevhash" is wrong assert!(add_blocks(&wallet, 5, 2, blk3_hash).is_err(), "Shouldn't be able to add because of invalid prev hash"); // Add with the proper prev hash add_blocks(&wallet, 5, 2, blk4_hash).unwrap(); let blk6_hash; { let blks = wallet.blocks.read().unwrap(); blk6_hash = blks[6].hash.clone(); } // Now do a Tx let taddr = wallet.address_from_sk(&SecretKey::from_slice(&[1u8; 32]).unwrap()); let branch_id = u32::from_str_radix("76b809bb", 16).unwrap(); let (ss, so) = get_sapling_params().unwrap(); // Create a tx and send to address const AMOUNT_SENT: u64 = 30000; let fee: u64 = DEFAULT_FEE.try_into().unwrap(); let (_, raw_tx) = wallet.send_to_address(branch_id, &ss, &so, false, vec![(&taddr, AMOUNT_SENT, None)], &default_fee(), |_| Ok(' '.to_string())).unwrap(); let sent_tx = Transaction::read(&raw_tx[..]).unwrap(); let sent_txid = sent_tx.txid(); let mut cb3 = FakeCompactBlock::new(7, blk6_hash); cb3.add_tx(&sent_tx); wallet.scan_block(&cb3.as_bytes()).unwrap(); wallet.scan_full_tx(&sent_tx, 7, 0); // Make sure the Tx is in. { let txs = wallet.txs.read().unwrap(); assert_eq!(txs[&txid1].notes.len(), 1); assert_eq!(txs[&txid1].notes[0].note.value, AMOUNT); assert_eq!(txs[&txid1].notes[0].spent, Some(sent_txid)); assert_eq!(txs[&txid1].notes[0].unconfirmed_spent, None); // The sent tx should generate change assert_eq!(txs[&sent_txid].notes.len(), 1); assert_eq!(txs[&sent_txid].notes[0].note.value, AMOUNT - AMOUNT_SENT - fee); assert_eq!(txs[&sent_txid].notes[0].is_change, true); assert_eq!(txs[&sent_txid].notes[0].spent, None); assert_eq!(txs[&sent_txid].notes[0].unconfirmed_spent, None); assert_eq!(txs[&sent_txid].notes[0].witnesses.len(), 1); } // Invalidate 3 blocks assert_eq!(wallet.last_scanned_height(), 7); assert_eq!(wallet.invalidate_block(5), 3); assert_eq!(wallet.last_scanned_height(), 4); // Make sure the orig Tx is there, but new Tx has disappeared { let txs = wallet.txs.read().unwrap(); // Orig Tx is still there, since this is in block 0 // But now the spent tx is gone assert_eq!(txs[&txid1].notes.len(), 1); assert_eq!(txs[&txid1].notes[0].note.value, AMOUNT); assert_eq!(txs[&txid1].notes[0].spent, None); assert_eq!(txs[&txid1].notes[0].unconfirmed_spent, None); // The sent tx is missing assert!(txs.get(&sent_txid).is_none()); } } #[test] fn test_t_derivation() { let lc = LightClientConfig { server: "0.0.0.0:0".parse().unwrap(), chain_name: "main".to_string(), sapling_activation_height: 0, consensus_branch_id: "000000".to_string(), anchor_offset: 1, no_cert_verification: false, data_dir: None, }; let seed_phrase = Some("chimney better bulb horror rebuild whisper improve intact letter giraffe brave rib appear bulk aim burst snap salt hill sad merge tennis phrase raise".to_string()); let wallet = LightWallet::new(seed_phrase.clone(), &lc, 0, 0).unwrap(); // t: m/44'/141'/0'/0/i, checked against an independent BIP39/BIP32 derivation. // z: ZIP32 m/32'/141'/0' as produced by this crate (snapshot). let (taddr, pk) = &wallet.get_t_secret_keys()[0]; assert_eq!(taddr, "RUytX9weUJDFqmzZPh7iRm7n99ksh2HmXP"); assert_eq!(pk, "UvdRFABcSj8uXtzdVAb72ddtrKB69UCLg4ykGfkFMKRcvSozEwNe"); // Test a couple more wallet.add_taddr(); let (taddr, pk) = &wallet.get_t_secret_keys()[1]; assert_eq!(taddr, "RMmVfFs82EvHEGny6zD3Hjf1C3Yz9jkQXf"); assert_eq!(pk, "UqzH1HqvD1qyy6xS4fMnowPnDJis9h5VEN2qSUD1TPHa7qJp5WfP"); let (zaddr, sk, _) = &wallet.get_z_private_keys()[0]; assert_eq!(zaddr, "zs1uqgg6nq8uct2wv5pszgw65ea4ft9z0kkcememm5qaspw8c2lgpulf78e46y46r23cz9cz48eqwe"); assert_eq!(sk, "secret-extended-key-main1qv6r09npqqqqpqphzfl70tss2ysdnsv8gjh8zxtk8wuuqd8k48re30nu7gdalh3llalq6mtefpv6w2efm4aklk6dfpe7udpnee08u69gc565mmfv7jcshf2t2llv3424q2kldfks7npww8rc8m2dah3tt67dv0cg4yqpxlsy8nmz65vl5h4wvw5nxtedry77s5hsn73t2lf0c3p6ps5ju959h8y9v03y2yk3vn3kynh6csls9zayqh5xup4l82d5yhwvgmelgvvyfxgcd25xa"); assert_eq!(seed_phrase, Some(wallet.get_seed_phrase())); } #[test] fn test_lock_unlock() { const AMOUNT: u64 = 500000; let (mut wallet, _, _) = get_test_wallet(AMOUNT); let config = wallet.config.clone(); // Add some addresses let zaddr0 = encode_payment_address(config.hrp_sapling_address(), &wallet.zkeys.read().unwrap()[0].extfvk.default_address().unwrap().1); let zaddr1 = wallet.add_zaddr(); // This is actually address at index 6 let zaddr2 = wallet.add_zaddr(); // This is actually address at index 7 let taddr0 = wallet.address_from_sk(&wallet.tkeys.read().unwrap()[0].tkey.unwrap()); let taddr1 = wallet.add_taddr(); let taddr2 = wallet.add_taddr(); let seed = wallet.seed; // Trying to lock a wallet that's not encrpyted is an error assert!(wallet.lock().is_err()); // Encrypt the wallet wallet.encrypt("somepassword".to_string()).unwrap(); // Encrypting an already encrypted wallet should fail assert!(wallet.encrypt("somepassword".to_string()).is_err()); // Serialize a locked wallet let mut serialized_data = vec![]; wallet.write(&mut serialized_data).expect("Serialize wallet"); // Should fail when there's a wrong password assert!(wallet.unlock("differentpassword".to_string()).is_err()); // Properly unlock wallet.unlock("somepassword".to_string()).unwrap(); assert_eq!(seed, wallet.seed); { let zkeys = wallet.zkeys.read().unwrap(); let tkeys = wallet.tkeys.read().unwrap(); assert_eq!(zkeys.len(), 8); // 3 zaddrs + 1 original + 4 extra HD addreses assert_eq!(tkeys.len(), 3); assert_eq!(zaddr0, encode_payment_address(config.hrp_sapling_address(), &ExtendedFullViewingKey::from(zkeys[0].extsk.as_ref().unwrap()).default_address().unwrap().1)); assert_eq!(zaddr1, encode_payment_address(config.hrp_sapling_address(), &ExtendedFullViewingKey::from(zkeys[6].extsk.as_ref().unwrap()).default_address().unwrap().1)); assert_eq!(zaddr2, encode_payment_address(config.hrp_sapling_address(), &ExtendedFullViewingKey::from(zkeys[7].extsk.as_ref().unwrap()).default_address().unwrap().1)); assert_eq!(taddr0, wallet.address_from_sk(&tkeys[0].tkey.unwrap())); assert_eq!(taddr1, wallet.address_from_sk(&tkeys[1].tkey.unwrap())); assert_eq!(taddr2, wallet.address_from_sk(&tkeys[2].tkey.unwrap())); } // Unlocking an already unlocked wallet should fail assert!(wallet.unlock("somepassword".to_string()).is_err()); // Trying to serialize a encrypted but unlocked wallet should fail assert!(wallet.write(&mut vec![]).is_err()); // ...but if we lock it again, it should serialize wallet.lock().unwrap(); wallet.write(&mut vec![]).expect("Serialize wallet"); // Locking an already locked wallet is an error assert!(wallet.lock().is_err()); // Try from a deserialized, locked wallet let mut wallet2 = LightWallet::read(&serialized_data[..], &config).unwrap(); wallet2.unlock("somepassword".to_string()).unwrap(); assert_eq!(seed, wallet2.seed); { let zkeys = wallet2.zkeys.read().unwrap(); let tkeys = wallet2.tkeys.read().unwrap(); assert_eq!(zkeys.len(), 8); assert_eq!(tkeys.len(), 3); assert_eq!(zaddr0, encode_payment_address(wallet2.config.hrp_sapling_address(), &ExtendedFullViewingKey::from(zkeys[0].extsk.as_ref().unwrap()).default_address().unwrap().1)); assert_eq!(zaddr1, encode_payment_address(wallet2.config.hrp_sapling_address(), &ExtendedFullViewingKey::from(zkeys[6].extsk.as_ref().unwrap()).default_address().unwrap().1)); assert_eq!(zaddr2, encode_payment_address(wallet2.config.hrp_sapling_address(), &ExtendedFullViewingKey::from(zkeys[7].extsk.as_ref().unwrap()).default_address().unwrap().1)); assert_eq!(taddr0, wallet2.address_from_sk(&tkeys[0].tkey.unwrap())); assert_eq!(taddr1, wallet2.address_from_sk(&tkeys[1].tkey.unwrap())); assert_eq!(taddr2, wallet2.address_from_sk(&tkeys[2].tkey.unwrap())); } // Remove encryption from a unlocked wallet should succeed wallet2.remove_encryption("somepassword".to_string()).unwrap(); assert_eq!(seed, wallet2.seed); // Now encrypt with a different password wallet2.encrypt("newpassword".to_string()).unwrap(); assert_eq!([0u8; 32], wallet2.seed); // Seed is cleared out // Locking should fail because it is already locked assert!(wallet2.lock().is_err()); // The old password shouldn't work assert!(wallet2.remove_encryption("somepassword".to_string()).is_err()); // Remove encryption with the right password wallet2.remove_encryption("newpassword".to_string()).unwrap(); assert_eq!(seed, wallet2.seed); // Unlocking a wallet without encryption is an error assert!(wallet2.remove_encryption("newpassword".to_string()).is_err()); // Can't lock/unlock a wallet that's not encrypted assert!(wallet2.lock().is_err()); assert!(wallet2.unlock("newpassword".to_string()).is_err()); } #[test] #[should_panic] fn test_invalid_bip39_t() { // Passing a 32-byte seed to bip32 should fail. let config = get_test_config(); LightWallet::get_taddr_from_bip39seed(&config, &[0u8; 32], 0); } #[test] #[should_panic] fn test_invalid_bip39_z() { // Passing a 32-byte seed to bip32 should fail. let config = get_test_config(); LightWallet::get_zaddr_from_bip39seed(&config, &[0u8; 32], 0); } #[test] fn test_invalid_scan_blocks() { const AMOUNT: u64 = 500000; let (wallet, _txid1, block_hash) = get_test_wallet(AMOUNT); let prev_hash = add_blocks(&wallet, 2, 1, block_hash).unwrap(); assert_eq!(wallet.blocks.read().unwrap().len(), 3); // Block fails to scan for bad encoding assert_eq!(wallet.scan_block(&[0; 32]), Err(-1)); // Block is invalid height let new_blk = FakeCompactBlock::new(4, prev_hash); assert_eq!(wallet.scan_block(&new_blk.as_bytes()), Err(2)); // Block is right height, but invalid prev height (for reorgs) let new_blk = FakeCompactBlock::new(2, BlockHash([0; 32])); assert_eq!(wallet.scan_block(&new_blk.as_bytes()), Err(2)); // Block is right height, but invalid prev height (for reorgs) let new_blk = FakeCompactBlock::new(3, BlockHash([0; 32])); assert_eq!(wallet.scan_block(&new_blk.as_bytes()), Err(2)); // Then the rest add properly let _ = add_blocks(&wallet, 3, 2, prev_hash).unwrap(); assert_eq!(wallet.blocks.read().unwrap().len(), 5); } #[test] fn test_encrypted_zreceive() { const AMOUNT1: u64 = 50000; let password: String = "password".to_string(); let (mut wallet, txid1, block_hash) = get_test_wallet(AMOUNT1); let fvk = ExtendedFullViewingKey::from(&ExtendedSpendingKey::master(&[1u8; 32])); let ext_address = encode_payment_address(wallet.config.hrp_sapling_address(), &fvk.default_address().unwrap().1); const AMOUNT_SENT: u64 = 20; let outgoing_memo = "Outgoing Memo".to_string(); let fee: u64 = DEFAULT_FEE.try_into().unwrap(); let branch_id = u32::from_str_radix("76b809bb", 16).unwrap(); let (ss, so) = get_sapling_params().unwrap(); // Create a tx and send to address let (_, raw_tx) = wallet.send_to_address(branch_id, &ss, &so, false, vec![(&ext_address, AMOUNT_SENT, Some(outgoing_memo.clone()))], &default_fee(), |_| Ok(' '.to_string())).unwrap(); // Second z address. Keys can't be added to an encrypted wallet, so derive it now. let zaddr2 = wallet.add_zaddr(); // This is address number 6 // Now that we have the transaction, we'll encrypt the wallet wallet.encrypt(password.clone()).unwrap(); // Scan the tx and make sure it gets added let sent_tx = Transaction::read(&raw_tx[..]).unwrap(); let sent_txid = sent_tx.txid(); let mut cb3 = FakeCompactBlock::new(2, block_hash); cb3.add_tx(&sent_tx); wallet.scan_block(&cb3.as_bytes()).unwrap(); // Now, full scan the Tx, which should populate the Outgoing Meta data wallet.scan_full_tx(&sent_tx, 2, 0); // Now this new Spent tx should be in, so the note should be marked confirmed spent { let txs = wallet.txs.read().unwrap(); assert_eq!(txs[&txid1].notes.len(), 1); assert_eq!(txs[&txid1].notes[0].note.value, AMOUNT1); assert_eq!(txs[&txid1].notes[0].spent, Some(sent_txid)); assert_eq!(txs[&txid1].notes[0].unconfirmed_spent, None); // The sent tx should generate change assert_eq!(txs[&sent_txid].notes.len(), 1); assert_eq!(txs[&sent_txid].notes[0].note.value, AMOUNT1 - AMOUNT_SENT - fee); assert_eq!(txs[&sent_txid].notes[0].is_change, true); assert_eq!(txs[&sent_txid].notes[0].spent, None); assert_eq!(txs[&sent_txid].notes[0].unconfirmed_spent, None); // Outgoing Metadata assert_eq!(txs[&sent_txid].total_shielded_value_spent, AMOUNT1); assert_eq!(txs[&sent_txid].outgoing_metadata.len(), 1); assert_eq!(txs[&sent_txid].outgoing_metadata[0].address, ext_address); assert_eq!(txs[&sent_txid].outgoing_metadata[0].value, AMOUNT_SENT); assert_eq!(txs[&sent_txid].outgoing_metadata[0].memo.to_utf8().unwrap().unwrap(), outgoing_memo); } // Trying to spend from a locked wallet is an error assert!(wallet.send_to_address(branch_id, &ss, &so, false, vec![(&ext_address, AMOUNT_SENT, None)], &default_fee(), |_| Ok(' '.to_string())).is_err()); // unlock the wallet so we can spend to the second z address wallet.unlock(password.clone()).unwrap(); // Second z address (derived before encrypting) const ZAMOUNT2:u64 = 30; let outgoing_memo2 = "Outgoing Memo2".to_string(); let (_, raw_tx) = wallet.send_to_address(branch_id, &ss, &so, false, vec![(&zaddr2, ZAMOUNT2, Some(outgoing_memo2.clone()))], &default_fee(), |_| Ok(' '.to_string())).unwrap(); // Now lock the wallet again wallet.lock().unwrap(); let sent_tx2 = Transaction::read(&raw_tx[..]).unwrap(); let txid2 = sent_tx2.txid(); let mut cb4 = FakeCompactBlock::new(3, cb3.hash()); cb4.add_tx(&sent_tx2); wallet.scan_block(&cb4.as_bytes()).unwrap(); wallet.scan_full_tx(&sent_tx2, 3, 0); { let txs = wallet.txs.read().unwrap(); let prev_change_value = AMOUNT1 - AMOUNT_SENT - fee; // Change note from prev transaction is spent assert_eq!(txs[&sent_txid].notes[0].note.value, prev_change_value); assert_eq!(txs[&sent_txid].notes[0].is_change, true); assert_eq!(txs[&sent_txid].notes[0].spent, Some(txid2)); // New change note. So find it. let change_note = txs[&txid2].notes.iter().find(|n| n.is_change).unwrap(); // New incoming tx is present assert_eq!(change_note.note.value, prev_change_value - (ZAMOUNT2+fee)); assert_eq!(change_note.spent, None); assert_eq!(change_note.unconfirmed_spent, None); // Find zaddr2 let zaddr2_note = txs[&txid2].notes.iter().find(|n| n.note.value == ZAMOUNT2).unwrap(); assert_eq!(zaddr2_note.account, 6); assert_eq!(zaddr2_note.is_change, false); assert_eq!(zaddr2_note.spent, None); assert_eq!(zaddr2_note.unconfirmed_spent, None); assert_eq!(LightWallet::memo_str(&zaddr2_note.memo), Some(outgoing_memo2)); } } #[test] fn test_encrypted_treceive() { const AMOUNT1: u64 = 50000; let password: String = "password".to_string(); let (mut wallet, txid1, block_hash) = get_test_wallet(AMOUNT1); let branch_id = u32::from_str_radix("76b809bb", 16).unwrap(); let (ss, so) = get_sapling_params().unwrap(); let taddr = wallet.address_from_sk(&SecretKey::from_slice(&[1u8; 32]).unwrap()); const AMOUNT_SENT: u64 = 30; let fee: u64 = DEFAULT_FEE.try_into().unwrap(); let (_, raw_tx) = wallet.send_to_address(branch_id, &ss, &so, false, vec![(&taddr, AMOUNT_SENT, None)], &default_fee(), |_| Ok(' '.to_string())).unwrap(); // Second t address. Keys can't be added to an encrypted wallet, so derive it now. let taddr2 = wallet.add_taddr(); // Now that we have the transaction, we'll encrypt the wallet wallet.encrypt(password.clone()).unwrap(); let sent_tx = Transaction::read(&raw_tx[..]).unwrap(); let sent_txid = sent_tx.txid(); let mut cb3 = FakeCompactBlock::new(2, block_hash); cb3.add_tx(&sent_tx); wallet.scan_block(&cb3.as_bytes()).unwrap(); wallet.scan_full_tx(&sent_tx, 2, 0); // Now this new Spent tx should be in, so the note should be marked confirmed spent { let txs = wallet.txs.read().unwrap(); assert_eq!(txs[&txid1].notes.len(), 1); assert_eq!(txs[&txid1].notes[0].note.value, AMOUNT1); assert_eq!(txs[&txid1].notes[0].spent, Some(sent_txid)); assert_eq!(txs[&txid1].notes[0].unconfirmed_spent, None); // The sent tx should generate change assert_eq!(txs[&sent_txid].notes.len(), 1); assert_eq!(txs[&sent_txid].notes[0].note.value, AMOUNT1 - AMOUNT_SENT - fee); assert_eq!(txs[&sent_txid].notes[0].is_change, true); assert_eq!(txs[&sent_txid].notes[0].spent, None); assert_eq!(txs[&sent_txid].notes[0].unconfirmed_spent, None); // Outgoing Metadata assert_eq!(txs[&sent_txid].outgoing_metadata.len(), 1); assert_eq!(txs[&sent_txid].outgoing_metadata[0].address, taddr); assert_eq!(txs[&sent_txid].outgoing_metadata[0].value, AMOUNT_SENT); assert_eq!(txs[&sent_txid].total_shielded_value_spent, AMOUNT1); } // Trying to spend from a locked wallet is an error assert!(wallet.send_to_address(branch_id, &ss, &so, false, vec![(&taddr, AMOUNT_SENT, None)], &default_fee(), |_| Ok(' '.to_string())).is_err()); // unlock the wallet so we can spend to the second z address wallet.unlock(password.clone()).unwrap(); // Second t address (derived before encrypting) const TAMOUNT2:u64 = 50; let (_, raw_tx) = wallet.send_to_address(branch_id, &ss, &so, false, vec![(&taddr2, TAMOUNT2, None)], &default_fee(), |_| Ok(' '.to_string())).unwrap(); // Now lock the wallet again wallet.lock().unwrap(); let sent_tx2 = Transaction::read(&raw_tx[..]).unwrap(); let txid2 = sent_tx2.txid(); let mut cb4 = FakeCompactBlock::new(3, cb3.hash()); cb4.add_tx(&sent_tx2); wallet.scan_block(&cb4.as_bytes()).unwrap(); wallet.scan_full_tx(&sent_tx2, 3, 0); { let txs = wallet.txs.read().unwrap(); let prev_change_value = AMOUNT1 - AMOUNT_SENT - fee; // Change note from prev transaction is spent assert_eq!(txs[&sent_txid].notes[0].note.value, prev_change_value); assert_eq!(txs[&sent_txid].notes[0].is_change, true); assert_eq!(txs[&sent_txid].notes[0].spent, Some(txid2)); // New change note. So find it. let change_note = txs[&txid2].notes.iter().find(|n| n.is_change).unwrap(); // New incoming tx is present assert_eq!(change_note.note.value, prev_change_value - (TAMOUNT2+fee)); assert_eq!(change_note.spent, None); assert_eq!(change_note.unconfirmed_spent, None); // Find taddr2 let utxo2 = txs[&txid2].utxos.iter().find(|u| u.value == TAMOUNT2).unwrap(); assert_eq!(txs[&txid2].utxos.len(), 1); assert_eq!(utxo2.address, taddr2); assert_eq!(utxo2.txid, txid2); assert_eq!(utxo2.spent, None); assert_eq!(utxo2.unconfirmed_spent, None); } } // --------------------------------------------------------------------------------------------- // g1 (C249): note addresses come from the stored pk_d, the z-balance address filters compare // (diversifier, pk_d), and do_balance / do_list_notes use z_balances_by_address / // spendable_zaddress_set. All of it must be exactly equivalent to the pre-change code. The old_* // functions below are verbatim copies of the replaced bodies, taking the wallet as a parameter. // --------------------------------------------------------------------------------------------- use std::collections::HashSet; use super::{SaplingNoteData, WalletTx, IncomingTxMetadata}; fn old_note_address(hrp: &str, note: &SaplingNoteData) -> Option { match note.extfvk.fvk.vk.into_payment_address(note.diversifier, &JUBJUB) { Some(pa) => Some(encode_payment_address(hrp, &pa)), None => None } } fn old_zbalance(w: &LightWallet, addr: Option) -> u64 { let unconfirmed_balance = w.unconfirmed_zbalance(addr.clone()); let confirmed_balance = w.txs.read().unwrap() .values() .map(|tx| { tx.notes.iter() .filter(|nd| { match addr.as_ref() { Some(a) => *a == encode_payment_address( w.config.hrp_sapling_address(), &nd.extfvk.fvk.vk .into_payment_address(nd.diversifier, &JUBJUB).unwrap() ), None => true } }) .map(|nd| { if nd.spent.is_none() && nd.unconfirmed_spent.is_none() { nd.note.value } else { 0 } }) .sum::() }) .sum::(); confirmed_balance + unconfirmed_balance } fn old_verified_zbalance(w: &LightWallet, addr: Option) -> u64 { let anchor_height = match w.get_target_height_and_anchor_offset() { Some((height, anchor_offset)) => height - anchor_offset as u32 , None => return 0, }; w.txs .read() .unwrap() .values() .map(|tx| { if tx.block as u32 <= anchor_height { tx.notes .iter() .filter(|nd| nd.spent.is_none() && nd.unconfirmed_spent.is_none()) .filter(|nd| { match addr.as_ref() { Some(a) => *a == encode_payment_address( w.config.hrp_sapling_address(), &nd.extfvk.fvk.vk .into_payment_address(nd.diversifier, &JUBJUB).unwrap() ), None => true } }) .map(|nd| nd.note.value) .sum::() } else { 0 } }) .sum::() } fn old_spendable_zbalance(w: &LightWallet, addr: Option) -> u64 { let anchor_height = w.get_anchor_height(); w.txs .read() .unwrap() .values() .map(|tx| { if tx.block as u32 <= anchor_height { tx.notes .iter() .filter(|nd| nd.spent.is_none() && nd.unconfirmed_spent.is_none()) .filter(|nd| { // Check to see if we have this note's spending key. w.have_spendingkey_for_extfvk(&nd.extfvk) }) .filter(|nd| { match addr.as_ref() { Some(a) => *a == encode_payment_address( w.config.hrp_sapling_address(), &nd.extfvk.fvk.vk .into_payment_address(nd.diversifier, &JUBJUB).unwrap() ), None => true } }) .map(|nd| nd.note.value) .sum::() } else { 0 } }) .sum::() as u64 } // The old do_list_notes construction of the spendable-address set. fn old_spendable_address_set(w: &LightWallet) -> HashSet { w.get_all_zaddresses().iter() .filter(|address| w.have_spending_key_for_zaddress(address)) .map(|address| address.clone()) .collect() } /// Deterministic xorshift64, so the shape of the g1 chains is reproducible (note randomness and /// txids still come from OsRng). struct G1Rng(u64); impl G1Rng { fn next(&mut self) -> u64 { let mut x = self.0; x ^= x << 13; x ^= x >> 7; x ^= x << 17; self.0 = x; x } fn below(&mut self, n: u64) -> u64 { self.next() % n } } /// A diversified (non-default) address of `extfvk`. fn g1_diversified_address(extfvk: &ExtendedFullViewingKey) -> PaymentAddress { let (mut j, _) = extfvk.default_address().unwrap(); j.increment().unwrap(); extfvk.address(j).unwrap().1 } /// Minimal BIP-173 bech32 encoder, only used to build syntactically valid junk addresses. fn g1_bech32(hrp: &str, data: &[u8]) -> String { const CHARSET: &[u8] = b"qpzry9x8gf2tvdw0s3jn54khce6mua7l"; const GEN: [u32; 5] = [0x3b6a57b2, 0x26508e6d, 0x1ea119fa, 0x3d4233dd, 0x2a1462b3]; let mut five: Vec = vec![]; let mut acc: u32 = 0; let mut bits: u32 = 0; for b in data { acc = (acc << 8) | (*b as u32); bits += 8; while bits >= 5 { bits -= 5; five.push(((acc >> bits) & 31) as u8); } acc &= (1 << bits) - 1; } if bits > 0 { five.push(((acc << (5 - bits)) & 31) as u8); } let mut values: Vec = hrp.bytes().map(|c| c >> 5).collect(); values.push(0); values.extend(hrp.bytes().map(|c| c & 31)); values.extend(five.iter().cloned()); values.extend([0u8; 6].iter().cloned()); let mut chk: u32 = 1; for v in values { let top = chk >> 25; chk = ((chk & 0x1ffffff) << 5) ^ (v as u32); for (i, g) in GEN.iter().enumerate() { if (top >> i) & 1 == 1 { chk ^= *g; } } } let polymod = chk ^ 1; let mut s = String::from(hrp); s.push('1'); for d in five { s.push(CHARSET[d as usize] as char); } for i in 0..6 { s.push(CHARSET[((polymod >> (5 * (5 - i))) & 31) as usize] as char); } s } struct G1Wallet { wallet: LightWallet, keys: Vec, // the 8 keys notes were paid to (6 HD, imported vk, imported sk) diversified: Vec, // diversified addresses of our keys that received notes foreign: String, // default address of a key that is not in the wallet vk_address: String, // the imported view-only key's address sk_address: String, // the imported spending key's address } /// 6 HD keys, another wallet's key imported view-only and an imported spending key. Then `blocks` /// blocks of payments chosen by `seed`: random key and value (zero-value and dust included), /// foreign outputs, compact spends with change, and 3 notes paid to diversified addresses. The /// view-only key's notes are never spent (so verified != spendable), and the tip block always pays /// us (so anchor offsets and the spendable "- 1" matter). fn g1_build(seed: u64, blocks: i32) -> G1Wallet { use zcash_client_backend::encoding::{encode_extended_full_viewing_key, encode_extended_spending_key}; let config = get_test_config(); let hrp = config.hrp_sapling_address().to_string(); let mut rng = G1Rng(seed | 1); let mut wallet = LightWallet::new(None, &config, 0, 0).unwrap(); for _ in 0..5 { wallet.add_zaddr(); } let other = LightWallet::new(None, &config, 0, 0).unwrap(); let vk_extfvk = other.zkeys.read().unwrap()[0].extfvk.clone(); let vk_address = wallet.add_imported_vk( encode_extended_full_viewing_key(config.hrp_sapling_viewing_key(), &vk_extfvk), 0); assert!(vk_address.starts_with(&hrp), "{}", vk_address); let mut sk_seed = [0x5au8; 32]; sk_seed[..8].copy_from_slice(&seed.to_le_bytes()); let extsk = ExtendedSpendingKey::master(&sk_seed); let sk_address = wallet.add_imported_sk( encode_extended_spending_key(config.hrp_sapling_private_key(), &extsk), 0); assert!(sk_address.starts_with(&hrp), "{}", sk_address); let foreign_extfvk = ExtendedFullViewingKey::from(&ExtendedSpendingKey::master(&[7u8; 32])); let foreign_pa = foreign_extfvk.default_address().unwrap().1; let foreign = encode_payment_address(&hrp, &foreign_pa); let keys: Vec = wallet.zkeys.read().unwrap().iter() .map(|zk| zk.extfvk.clone()).collect(); assert_eq!(keys.len(), 8); assert!(keys[6] == vk_extfvk); let diversified_heights = [blocks / 6, blocks / 2, blocks - 3]; let mut diversified: Vec = vec![]; let mut prev = BlockHash([0; 32]); for h in 0..blocks { let mut cb = FakeCompactBlock::new(h, prev); // Sometimes a compact spend (with change) of an unspent, non-zero, spendable-key note. if h > 2 && rng.below(4) == 0 { let candidate = { let txs = wallet.txs.read().unwrap(); let mut c: Vec<(i32, u64, Vec, ExtendedFullViewingKey)> = txs.values() .flat_map(|tx| tx.notes.iter().map(move |nd| (tx.block, nd))) .filter(|(_, nd)| nd.spent.is_none() && nd.note.value > 0 && nd.extfvk != vk_extfvk && !diversified.contains(&old_note_address(&hrp, nd).unwrap())) .map(|(b, nd)| (b, nd.note.value, nd.nullifier.to_vec(), nd.extfvk.clone())) .collect(); // HashMap order is per instance; sort so the pick depends only on the chain. c.sort_by(|x, y| (x.0, x.1, &x.2).cmp(&(y.0, y.1, &y.2))); if c.is_empty() { None } else { let i = rng.below(c.len() as u64) as usize; Some(c.swap_remove(i)) } }; if let Some((_, value, nf, extfvk)) = candidate { let sent = rng.below(value + 1); cb.add_tx_spending((nf, value), extfvk, foreign_pa.clone(), sent); } } // 0-2 incoming payments to random keys (always at least one in the last 4 blocks). let n = if h >= blocks - 4 { 1 + rng.below(2) } else { rng.below(3) }; for _ in 0..n { let k = rng.below(keys.len() as u64) as usize; let value = match rng.below(10) { 0 => 0, // zero-value (HushChat-style) note 1 | 2 => 1 + rng.below(1000), // dust _ => 1 + rng.below(1_000_000_000), }; cb.add_tx_paying(keys[k].clone(), value); } if h == 0 { cb.add_tx_paying(vk_extfvk.clone(), 777_777); } if h == blocks - 1 { cb.add_tx_paying(keys[0].clone(), 333_333); } // A foreign output now and then. if rng.below(3) == 0 { cb.add_tx_paying(foreign_extfvk.clone(), 1 + rng.below(1000)); } // 3 notes paid to diversified addresses of our keys. if diversified_heights.contains(&h) { let k = rng.below(keys.len() as u64) as usize; let to = g1_diversified_address(&keys[k]); assert!(to != keys[k].default_address().unwrap().1); diversified.push(encode_payment_address(&hrp, &to)); cb.add_tx_paying_to(keys[k].clone(), to, 10_000 + rng.below(1_000_000)); } wallet.scan_block(&cb.as_bytes()).unwrap(); prev = cb.hash(); } G1Wallet { wallet, keys, diversified, foreign, vk_address, sk_address } } /// Marks about a third of the unspent notes spent or pending-spent (deterministic per seed), except /// the view-only key's notes and the tip block's notes. fn g1_mark_spent(g: &G1Wallet, seed: u64) { let mut rng = G1Rng(seed | 1); let tip = g.wallet.last_scanned_height(); let mut txs = g.wallet.txs.write().unwrap(); let mut ids: Vec<(i32, u64, TxId)> = txs.values() .map(|tx| (tx.block, tx.notes.iter().map(|nd| nd.note.value).sum::(), tx.txid)) .collect(); ids.sort_by(|x, y| (x.0, x.1, x.2 .0).cmp(&(y.0, y.1, y.2 .0))); for (block, _, txid) in ids { if block == tip { continue; } for nd in txs.get_mut(&txid).unwrap().notes.iter_mut() { if nd.spent.is_some() || nd.extfvk == g.keys[6] { continue; } match rng.below(6) { 0 => nd.spent = Some(TxId([0xab; 32])), 1 => nd.unconfirmed_spent = Some(TxId([0xcd; 32])), _ => {} } } } } /// Adds an incoming mempool tx paying two of our addresses and a diversified one, so the /// unconfirmed term of zbalance is non-zero. fn g1_add_incoming_mempool(g: &G1Wallet) { let hrp = g.wallet.config.hrp_sapling_address().to_string(); let txid = TxId([0x11; 32]); let mut wtx = WalletTx::new(g.wallet.last_scanned_height() + 1, 0, &txid); for (address, value) in vec![ (encode_payment_address(&hrp, &g.keys[1].default_address().unwrap().1), 4242u64), (g.sk_address.clone(), 17), (g.diversified[0].clone(), 99), ] { wtx.incoming_metadata.push(IncomingTxMetadata { address, value, memo: Memo::default(), incoming_mempool: true, }); } g.wallet.incoming_mempool_txs.write().unwrap().insert(txid, vec![wtx]); } /// Every address-filter input of tests 2 and 3: None, the wallet's addresses, the diversified /// addresses, and junk that must keep the old exact string compare (never decoded). fn g1_inputs(g: &G1Wallet) -> Vec> { let hrp = g.wallet.config.hrp_sapling_address().to_string(); let mut inputs: Vec> = vec![None]; let all = g.wallet.get_all_zaddresses(); inputs.extend(all.iter().cloned().map(Some)); inputs.extend(g.diversified.iter().cloned().map(Some)); let valid = all[1].clone(); let mut last_changed = valid.clone(); let last = last_changed.pop().unwrap(); last_changed.push(if last == 'q' { 'p' } else { 'q' }); // The bech32 helper is exact: it reproduces encode_payment_address on a real address. let pa = g.keys[2].default_address().unwrap().1; let mut payload = pa.diversifier.0.to_vec(); pa.pk_d.write(&mut payload).unwrap(); assert_eq!(g1_bech32(&hrp, &payload), encode_payment_address(&hrp, &pa)); inputs.extend(vec![ String::new(), valid.to_uppercase(), last_changed, g.foreign.clone(), "z".repeat(300), g1_bech32(&hrp, &[1, 2, 3, 4, 5]), // valid bech32, short payload g1_bech32(&hrp, &payload[..42]), // valid bech32, one byte short g1_bech32("ztestsapling", &payload), // our key under the testnet hrp format!("{} ", valid), ].into_iter().map(Some)); inputs } fn g1_assert_filters_match_old(w: &LightWallet, inputs: &[Option], what: &str) { for a in inputs { assert_eq!(w.zbalance(a.clone()), old_zbalance(w, a.clone()), "{}: zbalance({:?})", what, a); assert_eq!(w.verified_zbalance(a.clone()), old_verified_zbalance(w, a.clone()), "{}: verified_zbalance({:?})", what, a); assert_eq!(w.spendable_zbalance(a.clone()), old_spendable_zbalance(w, a.clone()), "{}: spendable_zbalance({:?})", what, a); } } #[test] fn test_note_address_pk_d_matches_derivation() { for seed in &[0x9e3779b97f4a7c15u64, 0x0123456789abcdef] { let g = g1_build(*seed, 40); let config = g.wallet.config.clone(); let hrp = config.hrp_sapling_address().to_string(); let check = |w: &LightWallet, what: &str| -> usize { let txs = w.txs.read().unwrap(); let mut n = 0; let mut seen: HashSet = HashSet::new(); for tx in txs.values() { for nd in tx.notes.iter() { let new = LightWallet::note_address(&hrp, nd); assert!(new.is_some(), "{}: no address", what); assert_eq!(new, old_note_address(&hrp, nd), "{}: note address differs", what); seen.insert(new.unwrap()); n += 1; } } for d in g.diversified.iter() { assert!(seen.contains(d), "{}: diversified address {} not derived", what, d); } n }; let n = check(&g.wallet, "scanned"); assert!(n >= 30, "only {} notes", n); let all = g.wallet.get_all_zaddresses(); for d in g.diversified.iter() { assert!(!all.contains(d)); } // Notes rebuilt by SaplingNoteData::read (data.rs:158) give the same addresses, and the // file format is unchanged: write -> read -> write is byte-identical. let mut first = vec![]; g.wallet.write(&mut first).unwrap(); let reread = LightWallet::read(&first[..], &config).unwrap(); assert_eq!(check(&reread, "reread"), n); let mut second = vec![]; reread.write(&mut second).unwrap(); assert!(first == second, "write -> read -> write changed the wallet bytes"); } } #[test] fn test_zbalance_filters_match_old() { for seed in &[0x2545f4914f6cdd1du64, 0x00c0ffee12345678] { let g = g1_build(*seed, 40); g1_mark_spent(&g, *seed ^ 0xff); g1_add_incoming_mempool(&g); let inputs = g1_inputs(&g); // Non-vacuous: pending and confirmed spends exist, view-only notes make verified != // spendable, and the junk inputs match nothing. { let txs = g.wallet.txs.read().unwrap(); let notes = txs.values().flat_map(|tx| tx.notes.iter()); assert!(notes.clone().any(|nd| nd.spent.is_some())); assert!(notes.clone().any(|nd| nd.unconfirmed_spent.is_some())); } assert!(g.wallet.verified_zbalance(None) > g.wallet.spendable_zbalance(None)); assert!(g.wallet.verified_zbalance(Some(g.vk_address.clone())) >= 777_777); assert_eq!(g.wallet.spendable_zbalance(Some(g.vk_address.clone())), 0); assert_eq!(g.wallet.zbalance(Some(g.foreign.clone())), 0); g1_assert_filters_match_old(&g.wallet, &inputs, "offset 0"); // Same wallet read back with anchor_offset 3. read() drops the pending spends, so mark // again. let mut bytes = vec![]; g.wallet.write(&mut bytes).unwrap(); let mut config3 = g.wallet.config.clone(); config3.anchor_offset = 3; let w3 = LightWallet::read(&bytes[..], &config3).unwrap(); g1_assert_filters_match_old(&w3, &inputs, "offset 3, reread"); // The tip block's 333_333 note is above the offset-3 anchor. assert!(w3.verified_zbalance(None) + 333_333 <= w3.zbalance(None) - w3.unconfirmed_zbalance(None)); let g3 = G1Wallet { wallet: w3, keys: g.keys.clone(), diversified: g.diversified.clone(), foreign: g.foreign.clone(), vk_address: g.vk_address.clone(), sk_address: g.sk_address.clone() }; g1_mark_spent(&g3, *seed ^ 0x5555); g1_add_incoming_mempool(&g3); g1_assert_filters_match_old(&g3.wallet, &inputs, "offset 3, re-marked"); } } #[test] fn test_z_balances_by_address_matches_per_address_calls() { for seed in &[0x6a09e667f3bcc908u64, 0x3c6ef372fe94f82b] { let g = g1_build(*seed, 40); g1_add_incoming_mempool(&g); let w = &g.wallet; let by_address = w.z_balances_by_address(); let all = w.get_all_zaddresses(); assert_eq!(by_address.iter().map(|t| t.0.clone()).collect::>(), all); assert_eq!(all.iter().cloned().collect::>().len(), all.len()); let mut confirmed_listed: u64 = 0; for (a, zbalance, unconfirmed, verified, spendable) in by_address.iter() { let s = Some(a.clone()); assert_eq!(*zbalance, w.zbalance(s.clone()), "zbalance {}", a); assert_eq!(*unconfirmed, w.unconfirmed_zbalance(s.clone()), "unconfirmed {}", a); assert_eq!(*verified, w.verified_zbalance(s.clone()), "verified {}", a); assert_eq!(*spendable, w.spendable_zbalance(s.clone()), "spendable {}", a); assert_eq!(*zbalance, old_zbalance(w, s.clone()), "old zbalance {}", a); assert_eq!(*verified, old_verified_zbalance(w, s.clone()), "old verified {}", a); assert_eq!(*spendable, old_spendable_zbalance(w, s.clone()), "old spendable {}", a); confirmed_listed += zbalance - unconfirmed; } assert!(by_address.iter().any(|t| t.2 > 0), "no unconfirmed term exercised"); // Notes paid to diversified addresses belong to no listed address, as before. let hrp = w.config.hrp_sapling_address().to_string(); let diversified_unspent: u64 = w.txs.read().unwrap().values() .flat_map(|tx| tx.notes.iter()) .filter(|nd| nd.spent.is_none() && nd.unconfirmed_spent.is_none() && g.diversified.contains(&old_note_address(&hrp, nd).unwrap())) .map(|nd| nd.note.value) .sum(); assert!(diversified_unspent > 0); let confirmed_all = w.zbalance(None) - w.unconfirmed_zbalance(None); assert_eq!(confirmed_listed + diversified_unspent, confirmed_all); } } #[test] fn test_spendable_zaddress_set_matches_old() { let g = g1_build(0x510e527fade682d1, 12); let vk_address = g.vk_address.clone(); let sk_address = g.sk_address.clone(); let mut w = g.wallet; let check = |w: &LightWallet, what: &str| { let set = w.spendable_zaddress_set(); assert_eq!(set, old_spendable_address_set(w), "{}", what); assert!(!set.contains(&vk_address), "{}: view-only key counted as spendable", what); assert!(set.contains(&sk_address), "{}: imported spending key missing", what); assert_eq!(set.len(), w.get_all_zaddresses().len() - 1, "{}", what); }; check(&w, "plain"); w.encrypt("g1 password".to_string()).unwrap(); check(&w, "encrypted + locked"); w.unlock("g1 password".to_string()).unwrap(); check(&w, "unlocked"); w.remove_encryption("g1 password".to_string()).unwrap(); check(&w, "decrypted"); } #[test] fn test_balances_no_deadlock_with_zkeys_writer() { use std::sync::{Arc, mpsc, atomic::{AtomicBool, Ordering}}; use std::time::Duration; let wallet = Arc::new(LightWallet::new(None, &get_test_config(), 0, 0).unwrap()); for _ in 0..5 { wallet.add_zaddr(); } let writer_done = Arc::new(AtomicBool::new(false)); // Reader: the do_balance and send-path balance calls, back to back. let (rtx, rrx) = mpsc::channel(); let reader = { let w = wallet.clone(); let done = writer_done.clone(); std::thread::spawn(move || { let mut rounds = 0u64; let mut seen = 0u64; while rounds < 300 || (!done.load(Ordering::SeqCst) && rounds < 100_000) { seen += w.z_balances_by_address().len() as u64; seen += w.spendable_zbalance(None) % 2; rounds += 1; } rtx.send((rounds, seen)).unwrap(); }) }; // Writer: add_zaddr (zkeys.write) interleaved with scan_block of blocks paying the newest HD // address, so ensure_hd_zaddresses takes zkeys.write while scan_block holds txs.write. let (wtx, wrx) = mpsc::channel(); let writer = { let w = wallet.clone(); let done = writer_done.clone(); std::thread::spawn(move || { let mut prev = BlockHash([0; 32]); for i in 0..100 { w.add_zaddr(); let newest = w.zkeys.read().unwrap().last().unwrap().extfvk.clone(); let mut cb = FakeCompactBlock::new(i, prev); cb.add_tx_paying(newest, 1000 + i as u64); w.scan_block(&cb.as_bytes()).unwrap(); prev = cb.hash(); } done.store(true, Ordering::SeqCst); wtx.send(w.zkeys.read().unwrap().len()).unwrap(); }) }; let nkeys = wrx.recv_timeout(Duration::from_secs(120)) .expect("add_zaddr/scan_block did not finish within 120 s (lock-order deadlock?)"); let (rounds, _) = rrx.recv_timeout(Duration::from_secs(120)) .expect("z_balances_by_address/spendable_zbalance did not finish within 120 s (deadlock?)"); writer.join().unwrap(); reader.join().unwrap(); // 6 + 100 add_zaddr + 5 per block from the gap rule. assert_eq!(nkeys, 6 + 100 + 5 * 100); assert!(rounds >= 300); assert_eq!(wallet.zbalance(None), (0..100u64).map(|i| 1000 + i).sum::()); assert_eq!(wallet.z_balances_by_address().len(), nkeys); } // --------------------------------------------------------------------------------------------- // g4 (C246): send_to_address picks notes with note_selection::select_spends: the smallest single // covering note, else the fewest notes (largest first); zero-value notes are never spent; at most // MAX_SPENDS_PER_TX spends; the keyed UTXOs only reduce what the notes must cover when the notes // cannot cover the target alone, and then (integration O4) at least the smallest non-zero note is // still spent so the change stays `is_change`. Notes are identified by their (distinct) values. // --------------------------------------------------------------------------------------------- /// A wallet with one note per value, all to zkeys[0]'s default address, in block 0, plus an empty /// block 1 (anchor offset 0: every note is spendable). Returns the wallet and the tip hash. fn g4_wallet(values: &[u64]) -> (LightWallet, BlockHash) { let config = get_test_config(); let wallet = LightWallet::new(None, &config, 0, 0).unwrap(); let extfvk = wallet.zkeys.read().unwrap()[0].extfvk.clone(); let mut cb1 = FakeCompactBlock::new(0, BlockHash([0; 32])); for &v in values { cb1.add_tx_paying(extfvk.clone(), v); } wallet.scan_block(&cb1.as_bytes()).unwrap(); let cb2 = FakeCompactBlock::new(1, cb1.hash()); wallet.scan_block(&cb2.as_bytes()).unwrap(); let mut got: Vec = wallet.txs.read().unwrap().values() .flat_map(|t| t.notes.iter().map(|nd| nd.note.value)).collect(); got.sort(); let mut want = values.to_vec(); want.sort(); assert_eq!(got, want, "every paid note is in the wallet"); (wallet, cb2.hash()) } /// Give the wallet's first t-address one UTXO of `value` (keyed: the wallet holds its secret key). fn g4_add_utxo(wallet: &LightWallet, value: u64) -> TxId { let secp = Secp256k1::new(); let pk = PublicKey::from_secret_key(&secp, &wallet.tkeys.read().unwrap()[0].tkey.unwrap()); let mut tx = FakeTransaction::new(&mut OsRng); tx.add_t_output(&pk, value); let txid = tx.get_tx().txid(); wallet.scan_full_tx(&tx.get_tx(), 1, 0); assert_eq!(wallet.tbalance(None), value); txid } fn g4_ext_address(wallet: &LightWallet) -> String { let fvk = ExtendedFullViewingKey::from(&ExtendedSpendingKey::master(&[1u8; 32])); encode_payment_address(wallet.config.hrp_sapling_address(), &fvk.default_address().unwrap().1) } fn g4_send(wallet: &LightWallet, tos: Vec<(&str, u64, Option)>) -> Result { let branch_id = u32::from_str_radix("76b809bb", 16).unwrap(); let (ss, so) = get_sapling_params().unwrap(); wallet.send_to_address(branch_id, &ss, &so, false, tos, &default_fee(), |_| Ok(' '.to_string())) .map(|(_, raw)| Transaction::read(&raw[..]).unwrap()) } /// The values of the notes `tx` spends, sorted. Also checks that the nullifiers are distinct, are /// all ours, and that `unconfirmed_spent` is set on exactly those notes. fn g4_spent_values(wallet: &LightWallet, tx: &Transaction) -> Vec { let spent: HashSet<[u8; 32]> = tx.shielded_spends.iter().map(|s| s.nullifier).collect(); assert_eq!(spent.len(), tx.shielded_spends.len(), "a nullifier is spent twice in one tx"); let txs = wallet.txs.read().unwrap(); let mut values = vec![]; for nd in txs.values().flat_map(|t| t.notes.iter()) { let marked = nd.unconfirmed_spent == Some(tx.txid()); assert_eq!(marked, spent.contains(&nd.nullifier), "unconfirmed_spent must be set on exactly the spent notes (note value {})", nd.note.value); assert!(nd.unconfirmed_spent.is_none() || marked, "a note is pending for another tx"); if marked { values.push(nd.note.value); } } assert_eq!(values.len(), spent.len(), "every spent nullifier is one of our notes"); values.sort(); values } fn g4_zero_notes_untouched(wallet: &LightWallet) { let txs = wallet.txs.read().unwrap(); for nd in txs.values().flat_map(|t| t.notes.iter()).filter(|nd| nd.note.value == 0) { assert_eq!(nd.unconfirmed_spent, None, "a zero-value note was spent"); assert_eq!(nd.spent, None, "a zero-value note was spent"); } } #[test] fn test_g4_best_fit_single_note() { // B1: the smallest single covering note, on 4 fresh wallets (each with its own HashMap order). for round in 0..4 { let (wallet, _) = g4_wallet(&[0, 0, 5000, 20000, 100000, 300000]); let ext = g4_ext_address(&wallet); let tx = g4_send(&wallet, vec![(ext.as_str(), 50000, None)]).unwrap(); assert_eq!(g4_spent_values(&wallet, &tx), vec![100000], "round {}", round); assert_eq!(tx.vin.len(), 0); g4_zero_notes_untouched(&wallet); } } #[test] fn test_g4_chat_send_spends_one_fee_note() { // B2: a HushChat-style send (value 0 + memo to an own address): target = fee, so exactly the // 10000 note, and none of the zero-value notes. let (wallet, _) = g4_wallet(&[0, 0, 0, 10000, 100000, 100000]); let own = encode_payment_address(wallet.config.hrp_sapling_address(), &wallet.zkeys.read().unwrap()[0].zaddress); let tx = g4_send(&wallet, vec![(own.as_str(), 0, Some("hello".to_string()))]).unwrap(); assert_eq!(g4_spent_values(&wallet, &tx), vec![10000]); g4_zero_notes_untouched(&wallet); } #[test] fn test_g4_fewest_notes_largest_first() { // B3: no single note covers 75000 + fee; the fewest notes are 3, and the last pick is the // smallest one that still covers (20000, not 7000). let (wallet, _) = g4_wallet(&[40000, 30000, 20000, 7000]); let ext = g4_ext_address(&wallet); let tx = g4_send(&wallet, vec![(ext.as_str(), 75000, None)]).unwrap(); assert_eq!(g4_spent_values(&wallet, &tx), vec![20000, 30000, 40000]); } #[test] fn test_g4_too_many_inputs_refused_before_proving() { // B4: 260 x 1000, send 250_000: needs 260 notes > 250. Refused with the max sendable amount, // without the word the GUI retries on, before any proof, and nothing is marked spent. let (wallet, _) = g4_wallet(&vec![1000u64; 260]); let ext = g4_ext_address(&wallet); let (ss, so) = get_sapling_params().unwrap(); let branch_id = u32::from_str_radix("76b809bb", 16).unwrap(); let called = std::sync::atomic::AtomicBool::new(false); let t0 = std::time::Instant::now(); let r = wallet.send_to_address(branch_id, &ss, &so, false, vec![(ext.as_str(), 250_000, None)], &default_fee(), |_| { called.store(true, std::sync::atomic::Ordering::SeqCst); Ok(' '.to_string()) }); let elapsed = t0.elapsed(); let e = r.err().expect("a send needing 260 notes must be refused"); assert!(e.starts_with("Too many inputs:"), "{}", e); assert!(e.contains("0.00240000"), "{}", e); assert!(e.contains("260") && e.contains("250"), "{}", e); assert!(!e.contains("Insufficient"), "{}", e); assert!(!called.load(std::sync::atomic::Ordering::SeqCst), "the broadcast closure was called"); assert!(elapsed.as_secs() < 20, "refusal took {:?}: proofs were built", elapsed); { let txs = wallet.txs.read().unwrap(); assert!(txs.values().flat_map(|t| t.notes.iter()).all(|nd| nd.unconfirmed_spent.is_none())); } assert!(wallet.mempool_txs.read().unwrap().is_empty()); assert_eq!(wallet.verified_zbalance(None), 260_000); // 250 notes fit: 240_000 is exactly the advertised maximum. // (Not proved here: 250 Groth16 proofs take minutes; the pure tests cover the count.) } #[test] fn test_g4_utxos_cover_target_still_spends_smallest_note() { // B5 (integration O4): z [100] + UTXO 50000, send 30000. The notes cannot cover 40000, the // UTXO alone can: the one smallest non-zero note is spent too, so the change is a note's change // (is_change, to the note's address) and `list` shows no phantom receive. let (wallet, tip) = g4_wallet(&[100]); let txid_t = g4_add_utxo(&wallet, 50000); let ext = g4_ext_address(&wallet); let fee = default_fee(); let sent_tx = g4_send(&wallet, vec![(ext.as_str(), 30000, None)]).unwrap(); let sent_txid = sent_tx.txid(); assert_eq!(g4_spent_values(&wallet, &sent_tx), vec![100]); assert_eq!(sent_tx.vin.len(), 1); assert_eq!(sent_tx.shielded_outputs.len(), 2); let mut cb3 = FakeCompactBlock::new(2, tip); cb3.add_tx(&sent_tx); wallet.scan_block(&cb3.as_bytes()).unwrap(); wallet.scan_full_tx(&sent_tx, 2, 0); { let txs = wallet.txs.read().unwrap(); assert_eq!(txs[&txid_t].utxos[0].spent, Some(sent_txid)); let note100 = txs.values().flat_map(|t| t.notes.iter()).find(|nd| nd.note.value == 100).unwrap(); assert_eq!(note100.spent, Some(sent_txid)); assert_eq!(txs[&sent_txid].notes.len(), 1); let change = &txs[&sent_txid].notes[0]; assert_eq!(change.note.value, 50000 + 100 - 30000 - fee); assert!(change.is_change, "the change must be recorded as change"); assert_eq!(change.account, 0); } assert_eq!(wallet.zbalance(None), 50000 + 100 - 30000 - fee); // `list` (LightClient::do_list_transactions) shows the send once, as -(amount + fee), and no // incoming entry for it. The client lives in a temp dir (never the real wallet directory). let tmp = tempdir::TempDir::new("g4-list").unwrap(); let mut config = get_test_config(); config.data_dir = Some(tmp.path().to_str().unwrap().to_string()); let lc = crate::lightclient::LightClient::new(&config, 0).unwrap(); *lc.wallet.write().unwrap() = wallet; let list = lc.do_list_transactions(); let sent_s = format!("{}", sent_txid); let entries: Vec<&json::JsonValue> = list.members().filter(|e| e["txid"].as_str() == Some(sent_s.as_str())).collect(); assert_eq!(entries.len(), 1, "list entries for the send: {}", list.pretty(2)); assert_eq!(entries[0]["amount"].as_i64(), Some(-((30000 + fee) as i64)), "{}", list.pretty(2)); assert!(entries[0]["address"].is_null(), "the send shows as a receive: {}", list.pretty(2)); } #[test] fn test_g4_utxos_reduce_what_notes_cover() { // B6: z [20000, 15000, 100] + UTXO 10000, send 30000: the notes alone (35100) cannot cover // 40000, so they cover 40000 - 10000 with the fewest notes: {20000, 15000}; the 100 stays. let (wallet, _) = g4_wallet(&[20000, 15000, 100]); let txid_t = g4_add_utxo(&wallet, 10000); let ext = g4_ext_address(&wallet); let tx = g4_send(&wallet, vec![(ext.as_str(), 30000, None)]).unwrap(); assert_eq!(g4_spent_values(&wallet, &tx), vec![15000, 20000]); assert_eq!(tx.vin.len(), 1); let txs = wallet.txs.read().unwrap(); assert_eq!(txs[&txid_t].utxos[0].unconfirmed_spent, Some(tx.txid())); } #[test] fn test_g4_insufficient_text_unchanged() { // B7: the insufficient-funds text the GUI matches on is unchanged. let (wallet, _) = g4_wallet(&[5000]); let ext = g4_ext_address(&wallet); let e = g4_send(&wallet, vec![(ext.as_str(), 50000, None)]).err().unwrap(); assert!(e.starts_with("Insufficient verified funds (have 5000, need "), "{}", e); let txs = wallet.txs.read().unwrap(); assert!(txs.values().flat_map(|t| t.notes.iter()).all(|nd| nd.unconfirmed_spent.is_none())); } #[test] fn test_g4_transaction_too_large_refused() { // 200 shielded outputs (+ change) leave no room for a single spend in the size budget: the // send is refused before proving with the "Transaction too large" text (no "Insufficient"). let (wallet, _) = g4_wallet(&[1_000_000]); let ext = g4_ext_address(&wallet); let tos: Vec<(&str, u64, Option)> = (0..200).map(|_| (ext.as_str(), 1u64, None)).collect(); let e = g4_send(&wallet, tos).err().unwrap(); assert!(e.starts_with("Transaction too large:"), "{}", e); assert!(!e.contains("Insufficient"), "{}", e); let txs = wallet.txs.read().unwrap(); assert!(txs.values().flat_map(|t| t.notes.iter()).all(|nd| nd.unconfirmed_spent.is_none())); }