zec
/
librustzcash
mirror of https://github.com/zcash/librustzcash.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
librustzcash/zcash_client_sqlite/src/testing/pool.rs

2222 lines
75 KiB
Rust
Raw Blame History

//! Test logic involving a single shielded pool.
//!
//! Generalised for sharing across the Sapling and Orchard implementations.
use std::{
convert::Infallible,
num::{NonZeroU32, NonZeroU8},
};
use incrementalmerkletree::{frontier::Frontier, Level};
use rand_core::RngCore;
use rusqlite::params;
use secrecy::Secret;
use shardtree::error::ShardTreeError;
use zcash_primitives::{
block::BlockHash,
consensus::{BranchId, NetworkUpgrade, Parameters},
legacy::TransparentAddress,
memo::{Memo, MemoBytes},
transaction::{
components::amount::NonNegativeAmount,
fees::{
fixed::FeeRule as FixedFeeRule, zip317::FeeError as Zip317FeeError, StandardFeeRule,
},
Transaction,
},
zip32::Scope,
};
use zcash_client_backend::{
address::Address,
data_api::{
self,
chain::{self, ChainState, CommitmentTreeRoot, ScanSummary},
error::Error,
wallet::{
decrypt_and_store_transaction,
input_selection::{GreedyInputSelector, GreedyInputSelectorError},
},
AccountBirthday, DecryptedTransaction, Ratio, WalletRead, WalletSummary, WalletWrite,
},
decrypt_transaction,
fees::{fixed, standard, DustOutputPolicy},
keys::UnifiedSpendingKey,
scanning::ScanError,
wallet::{Note, OvkPolicy, ReceivedNote},
zip321::{self, Payment, TransactionRequest},
ShieldedProtocol,
};
use zcash_protocol::consensus::BlockHeight;
use super::TestFvk;
use crate::{
error::SqliteClientError,
testing::{input_selector, AddressType, BlockCache, InitialChainState, TestBuilder, TestState},
wallet::{block_max_scanned, commitment_tree, parse_scope, truncate_to_height},
AccountId, NoteId, ReceivedNoteId,
};
#[cfg(feature = "transparent-inputs")]
use {
zcash_client_backend::{
fees::TransactionBalance, proposal::Step, wallet::WalletTransparentOutput, PoolType,
},
zcash_primitives::transaction::components::{OutPoint, TxOut},
};
pub(crate) type OutputRecoveryError = Error<
SqliteClientError,
commitment_tree::Error,
GreedyInputSelectorError<Zip317FeeError, ReceivedNoteId>,
Zip317FeeError,
>;
/// Trait that exposes the pool-specific types and operations necessary to run the
/// single-shielded-pool tests on a given pool.
pub(crate) trait ShieldedPoolTester {
const SHIELDED_PROTOCOL: ShieldedProtocol;
const TABLES_PREFIX: &'static str;
type Sk;
type Fvk: TestFvk;
type MerkleTreeHash;
type Note;
fn test_account_fvk<Cache>(st: &TestState<Cache>) -> Self::Fvk;
fn usk_to_sk(usk: &UnifiedSpendingKey) -> &Self::Sk;
fn sk(seed: &[u8]) -> Self::Sk;
fn sk_to_fvk(sk: &Self::Sk) -> Self::Fvk;
fn sk_default_address(sk: &Self::Sk) -> Address;
fn fvk_default_address(fvk: &Self::Fvk) -> Address;
fn fvks_equal(a: &Self::Fvk, b: &Self::Fvk) -> bool;
fn random_fvk(mut rng: impl RngCore) -> Self::Fvk {
let sk = {
let mut sk_bytes = vec![0; 32];
rng.fill_bytes(&mut sk_bytes);
Self::sk(&sk_bytes)
};
Self::sk_to_fvk(&sk)
}
fn random_address(rng: impl RngCore) -> Address {
Self::fvk_default_address(&Self::random_fvk(rng))
}
fn empty_tree_leaf() -> Self::MerkleTreeHash;
fn empty_tree_root(level: Level) -> Self::MerkleTreeHash;
fn put_subtree_roots<Cache>(
st: &mut TestState<Cache>,
start_index: u64,
roots: &[CommitmentTreeRoot<Self::MerkleTreeHash>],
) -> Result<(), ShardTreeError<commitment_tree::Error>>;
fn next_subtree_index(s: &WalletSummary<AccountId>) -> u64;
fn select_spendable_notes<Cache>(
st: &TestState<Cache>,
account: AccountId,
target_value: NonNegativeAmount,
anchor_height: BlockHeight,
exclude: &[ReceivedNoteId],
) -> Result<Vec<ReceivedNote<ReceivedNoteId, Self::Note>>, SqliteClientError>;
fn decrypted_pool_outputs_count(d_tx: &DecryptedTransaction<'_, AccountId>) -> usize;
fn with_decrypted_pool_memos(
d_tx: &DecryptedTransaction<'_, AccountId>,
f: impl FnMut(&MemoBytes),
);
fn try_output_recovery<Cache>(
st: &TestState<Cache>,
height: BlockHeight,
tx: &Transaction,
fvk: &Self::Fvk,
) -> Result<Option<(Note, Address, MemoBytes)>, OutputRecoveryError>;
fn received_note_count(summary: &ScanSummary) -> usize;
}
pub(crate) fn send_single_step_proposed_transfer<T: ShieldedPoolTester>() {
let mut st = TestBuilder::new()
.with_block_cache()
.with_account_from_sapling_activation(BlockHash([0; 32]))
.build();
let account = st.test_account().cloned().unwrap();
let dfvk = T::test_account_fvk(&st);
// Add funds to the wallet in a single note
let value = NonNegativeAmount::const_from_u64(60000);
let (h, _, _) = st.generate_next_block(&dfvk, AddressType::DefaultExternal, value);
st.scan_cached_blocks(h, 1);
// Spendable balance matches total balance
assert_eq!(st.get_total_balance(account.account_id()), value);
assert_eq!(st.get_spendable_balance(account.account_id(), 1), value);
assert_eq!(
block_max_scanned(&st.wallet().conn, &st.wallet().params)
.unwrap()
.unwrap()
.block_height(),
h
);
let to_extsk = T::sk(&[0xf5; 32]);
let to: Address = T::sk_default_address(&to_extsk);
let request = zip321::TransactionRequest::new(vec![Payment::without_memo(
to.to_zcash_address(&st.network()),
NonNegativeAmount::const_from_u64(10000),
)])
.unwrap();
// TODO: This test was originally written to use the pre-zip-313 fee rule
// and has not yet been updated.
#[allow(deprecated)]
let fee_rule = StandardFeeRule::PreZip313;
let change_memo = "Test change memo".parse::<Memo>().unwrap();
let change_strategy = standard::SingleOutputChangeStrategy::new(
fee_rule,
Some(change_memo.clone().into()),
T::SHIELDED_PROTOCOL,
);
let input_selector = &GreedyInputSelector::new(change_strategy, DustOutputPolicy::default());
let proposal = st
.propose_transfer(
account.account_id(),
input_selector,
request,
NonZeroU32::new(1).unwrap(),
)
.unwrap();
let create_proposed_result = st.create_proposed_transactions::<Infallible, _>(
account.usk(),
OvkPolicy::Sender,
&proposal,
);
assert_matches!(&create_proposed_result, Ok(txids) if txids.len() == 1);
let sent_tx_id = create_proposed_result.unwrap()[0];
// Verify that the sent transaction was stored and that we can decrypt the memos
let tx = st
.wallet()
.get_transaction(sent_tx_id)
.unwrap()
.expect("Created transaction was stored.");
let ufvks = [(
account.account_id(),
account.usk().to_unified_full_viewing_key(),
)]
.into_iter()
.collect();
let d_tx = decrypt_transaction(&st.network(), h + 1, &tx, &ufvks);
assert_eq!(T::decrypted_pool_outputs_count(&d_tx), 2);
let mut found_tx_change_memo = false;
let mut found_tx_empty_memo = false;
T::with_decrypted_pool_memos(&d_tx, |memo| {
if Memo::try_from(memo).unwrap() == change_memo {
found_tx_change_memo = true
}
if Memo::try_from(memo).unwrap() == Memo::Empty {
found_tx_empty_memo = true
}
});
assert!(found_tx_change_memo);
assert!(found_tx_empty_memo);
// Verify that the stored sent notes match what we're expecting
let sent_note_ids = {
let mut stmt_sent_notes = st
.wallet()
.conn
.prepare(
"SELECT output_index
FROM sent_notes
JOIN transactions ON transactions.id_tx = sent_notes.tx
WHERE transactions.txid = ?",
)
.unwrap();
stmt_sent_notes
.query(rusqlite::params![sent_tx_id.as_ref()])
.unwrap()
.mapped(|row| Ok(NoteId::new(sent_tx_id, T::SHIELDED_PROTOCOL, row.get(0)?)))
.collect::<Result<Vec<_>, _>>()
.unwrap()
};
assert_eq!(sent_note_ids.len(), 2);
// The sent memo should be the empty memo for the sent output, and the
// change output's memo should be as specified.
let mut found_sent_change_memo = false;
let mut found_sent_empty_memo = false;
for sent_note_id in sent_note_ids {
match st
.wallet()
.get_memo(sent_note_id)
.expect("Note id is valid")
.as_ref()
{
Some(m) if m == &change_memo => {
found_sent_change_memo = true;
}
Some(m) if m == &Memo::Empty => {
found_sent_empty_memo = true;
}
Some(other) => panic!("Unexpected memo value: {:?}", other),
None => panic!("Memo should not be stored as NULL"),
}
}
assert!(found_sent_change_memo);
assert!(found_sent_empty_memo);
// Check that querying for a nonexistent sent note returns None
assert_matches!(
st.wallet()
.get_memo(NoteId::new(sent_tx_id, T::SHIELDED_PROTOCOL, 12345)),
Ok(None)
);
let tx_history = st.get_tx_history().unwrap();
assert_eq!(tx_history.len(), 2);
assert_matches!(
decrypt_and_store_transaction(&st.network(), st.wallet_mut(), &tx),
Ok(_)
);
}
#[cfg(feature = "transparent-inputs")]
pub(crate) fn send_multi_step_proposed_transfer<T: ShieldedPoolTester>() {
use nonempty::NonEmpty;
use zcash_client_backend::proposal::{Proposal, StepOutput, StepOutputIndex};
use zcash_primitives::legacy::keys::IncomingViewingKey;
let mut st = TestBuilder::new()
.with_block_cache()
.with_account_from_sapling_activation(BlockHash([0; 32]))
.build();
let account = st.test_account().cloned().unwrap();
let dfvk = T::test_account_fvk(&st);
// Add funds to the wallet in a single note
let value = NonNegativeAmount::const_from_u64(65000);
let (h, _, _) = st.generate_next_block(&dfvk, AddressType::DefaultExternal, value);
st.scan_cached_blocks(h, 1);
// Spendable balance matches total balance
assert_eq!(st.get_total_balance(account.account_id()), value);
assert_eq!(st.get_spendable_balance(account.account_id(), 1), value);
assert_eq!(
block_max_scanned(&st.wallet().conn, &st.wallet().params)
.unwrap()
.unwrap()
.block_height(),
h
);
// Generate a single-step proposal. Then, instead of executing that proposal,
// we will use its only step as the first step in a multi-step proposal that
// spends the first step's output.
// The first step will deshield to the wallet's default transparent address
let to0 = Address::Transparent(account.usk().default_transparent_address().0);
let request0 = zip321::TransactionRequest::new(vec![Payment::without_memo(
to0.to_zcash_address(&st.network()),
NonNegativeAmount::const_from_u64(50000),
)])
.unwrap();
let fee_rule = StandardFeeRule::Zip317;
let input_selector = GreedyInputSelector::new(
standard::SingleOutputChangeStrategy::new(fee_rule, None, T::SHIELDED_PROTOCOL),
DustOutputPolicy::default(),
);
let proposal0 = st
.propose_transfer(
account.account_id(),
&input_selector,
request0,
NonZeroU32::new(1).unwrap(),
)
.unwrap();
let min_target_height = proposal0.min_target_height();
let step0 = &proposal0.steps().head;
assert!(step0.balance().proposed_change().is_empty());
assert_eq!(
step0.balance().fee_required(),
NonNegativeAmount::const_from_u64(15000)
);
// We'll use an internal transparent address that hasn't been added to the wallet
// to simulate an external transparent recipient.
let to1 = Address::Transparent(
account
.usk()
.transparent()
.to_account_pubkey()
.derive_internal_ivk()
.unwrap()
.default_address()
.0,
);
let request1 = zip321::TransactionRequest::new(vec![Payment::without_memo(
to1.to_zcash_address(&st.network()),
NonNegativeAmount::const_from_u64(40000),
)])
.unwrap();
let step1 = Step::from_parts(
&[step0.clone()],
request1,
[(0, PoolType::Transparent)].into_iter().collect(),
vec![],
None,
vec![StepOutput::new(0, StepOutputIndex::Payment(0))],
TransactionBalance::new(vec![], NonNegativeAmount::const_from_u64(10000)).unwrap(),
false,
)
.unwrap();
let proposal = Proposal::multi_step(
fee_rule,
min_target_height,
NonEmpty::from_vec(vec![step0.clone(), step1]).unwrap(),
)
.unwrap();
let create_proposed_result = st.create_proposed_transactions::<Infallible, _>(
account.usk(),
OvkPolicy::Sender,
&proposal,
);
assert_matches!(&create_proposed_result, Ok(txids) if txids.len() == 2);
let txids = create_proposed_result.unwrap();
// Verify that the stored sent outputs match what we're expecting
let mut stmt_sent = st
.wallet()
.conn
.prepare(
"SELECT value
FROM sent_notes
JOIN transactions ON transactions.id_tx = sent_notes.tx
WHERE transactions.txid = ?",
)
.unwrap();
let confirmed_sent = txids
.iter()
.map(|sent_txid| {
// check that there's a sent output with the correct value corresponding to
stmt_sent
.query(rusqlite::params![sent_txid.as_ref()])
.unwrap()
.mapped(|row| {
let value: u32 = row.get(0)?;
Ok((sent_txid, value))
})
.collect::<Result<Vec<_>, _>>()
.unwrap()
})
.collect::<Vec<_>>();
assert_eq!(
confirmed_sent.get(0).and_then(|v| v.get(0)),
Some(&(&txids[0], 50000))
);
assert_eq!(
confirmed_sent.get(1).and_then(|v| v.get(0)),
Some(&(&txids[1], 40000))
);
}
#[allow(deprecated)]
pub(crate) fn create_to_address_fails_on_incorrect_usk<T: ShieldedPoolTester>() {
let mut st = TestBuilder::new()
.with_account_from_sapling_activation(BlockHash([0; 32]))
.build();
let dfvk = T::test_account_fvk(&st);
let to = T::fvk_default_address(&dfvk);
// Create a USK that doesn't exist in the wallet
let acct1 = zip32::AccountId::try_from(1).unwrap();
let usk1 = UnifiedSpendingKey::from_seed(&st.network(), &[1u8; 32], acct1).unwrap();
// Attempting to spend with a USK that is not in the wallet results in an error
assert_matches!(
st.create_spend_to_address(
&usk1,
&to,
NonNegativeAmount::const_from_u64(1),
None,
OvkPolicy::Sender,
NonZeroU32::new(1).unwrap(),
None,
T::SHIELDED_PROTOCOL,
),
Err(data_api::error::Error::KeyNotRecognized)
);
}
#[allow(deprecated)]
pub(crate) fn proposal_fails_with_no_blocks<T: ShieldedPoolTester>() {
let mut st = TestBuilder::new()
.with_account_from_sapling_activation(BlockHash([0; 32]))
.build();
let account_id = st.test_account().unwrap().account_id();
let dfvk = T::test_account_fvk(&st);
let to = T::fvk_default_address(&dfvk);
// Wallet summary is not yet available
assert_eq!(st.get_wallet_summary(0), None);
// We cannot do anything if we aren't synchronised
assert_matches!(
st.propose_standard_transfer::<Infallible>(
account_id,
StandardFeeRule::PreZip313,
NonZeroU32::new(1).unwrap(),
&to,
NonNegativeAmount::const_from_u64(1),
None,
None,
T::SHIELDED_PROTOCOL,
),
Err(data_api::error::Error::ScanRequired)
);
}
pub(crate) fn spend_fails_on_unverified_notes<T: ShieldedPoolTester>() {
let mut st = TestBuilder::new()
.with_block_cache()
.with_account_from_sapling_activation(BlockHash([0; 32]))
.build();
let account = st.test_account().cloned().unwrap();
let account_id = account.account_id();
let dfvk = T::test_account_fvk(&st);
// Add funds to the wallet in a single note
let value = NonNegativeAmount::const_from_u64(50000);
let (h1, _, _) = st.generate_next_block(&dfvk, AddressType::DefaultExternal, value);
st.scan_cached_blocks(h1, 1);
// Spendable balance matches total balance at 1 confirmation.
assert_eq!(st.get_total_balance(account_id), value);
assert_eq!(st.get_spendable_balance(account_id, 1), value);
// Value is considered pending at 10 confirmations.
assert_eq!(st.get_pending_shielded_balance(account_id, 10), value);
assert_eq!(
st.get_spendable_balance(account_id, 10),
NonNegativeAmount::ZERO
);
// Wallet is fully scanned
let summary = st.get_wallet_summary(1);
assert_eq!(
summary.and_then(|s| s.scan_progress()),
Some(Ratio::new(1, 1))
);
// Add more funds to the wallet in a second note
let (h2, _, _) = st.generate_next_block(&dfvk, AddressType::DefaultExternal, value);
st.scan_cached_blocks(h2, 1);
// Verified balance does not include the second note
let total = (value + value).unwrap();
assert_eq!(st.get_spendable_balance(account_id, 2), value);
assert_eq!(st.get_pending_shielded_balance(account_id, 2), value);
assert_eq!(st.get_total_balance(account_id), total);
// Wallet is still fully scanned
let summary = st.get_wallet_summary(1);
assert_eq!(
summary.and_then(|s| s.scan_progress()),
Some(Ratio::new(2, 2))
);
// Spend fails because there are insufficient verified notes
let extsk2 = T::sk(&[0xf5; 32]);
let to = T::sk_default_address(&extsk2);
assert_matches!(
st.propose_standard_transfer::<Infallible>(
account_id,
StandardFeeRule::Zip317,
NonZeroU32::new(2).unwrap(),
&to,
NonNegativeAmount::const_from_u64(70000),
None,
None,
T::SHIELDED_PROTOCOL,
),
Err(data_api::error::Error::InsufficientFunds {
available,
required
})
if available == NonNegativeAmount::const_from_u64(50000)
&& required == NonNegativeAmount::const_from_u64(80000)
);
// Mine blocks SAPLING_ACTIVATION_HEIGHT + 2 to 9 until just before the second
// note is verified
for _ in 2..10 {
st.generate_next_block(&dfvk, AddressType::DefaultExternal, value);
}
st.scan_cached_blocks(h2 + 1, 8);
// Total balance is value * number of blocks scanned (10).
assert_eq!(st.get_total_balance(account_id), (value * 10).unwrap());
// Spend still fails
assert_matches!(
st.propose_standard_transfer::<Infallible>(
account_id,
StandardFeeRule::Zip317,
NonZeroU32::new(10).unwrap(),
&to,
NonNegativeAmount::const_from_u64(70000),
None,
None,
T::SHIELDED_PROTOCOL,
),
Err(data_api::error::Error::InsufficientFunds {
available,
required
})
if available == NonNegativeAmount::const_from_u64(50000)
&& required == NonNegativeAmount::const_from_u64(80000)
);
// Mine block 11 so that the second note becomes verified
let (h11, _, _) = st.generate_next_block(&dfvk, AddressType::DefaultExternal, value);
st.scan_cached_blocks(h11, 1);
// Total balance is value * number of blocks scanned (11).
assert_eq!(st.get_total_balance(account_id), (value * 11).unwrap());
// Spendable balance at 10 confirmations is value * 2.
assert_eq!(
st.get_spendable_balance(account_id, 10),
(value * 2).unwrap()
);
assert_eq!(
st.get_pending_shielded_balance(account_id, 10),
(value * 9).unwrap()
);
// Should now be able to generate a proposal
let amount_sent = NonNegativeAmount::from_u64(70000).unwrap();
let min_confirmations = NonZeroU32::new(10).unwrap();
let proposal = st
.propose_standard_transfer::<Infallible>(
account_id,
StandardFeeRule::Zip317,
min_confirmations,
&to,
amount_sent,
None,
None,
T::SHIELDED_PROTOCOL,
)
.unwrap();
// Executing the proposal should succeed
let txid = st
.create_proposed_transactions::<Infallible, _>(account.usk(), OvkPolicy::Sender, &proposal)
.unwrap()[0];
let (h, _) = st.generate_next_block_including(txid);
st.scan_cached_blocks(h, 1);
// TODO: send to an account so that we can check its balance.
assert_eq!(
st.get_total_balance(account_id),
((value * 11).unwrap()
- (amount_sent + NonNegativeAmount::from_u64(10000).unwrap()).unwrap())
.unwrap()
);
}
pub(crate) fn spend_fails_on_locked_notes<T: ShieldedPoolTester>() {
let mut st = TestBuilder::new()
.with_block_cache()
.with_account_from_sapling_activation(BlockHash([0; 32]))
.build();
let account = st.test_account().cloned().unwrap();
let account_id = account.account_id();
let dfvk = T::test_account_fvk(&st);
// TODO: This test was originally written to use the pre-zip-313 fee rule
// and has not yet been updated.
#[allow(deprecated)]
let fee_rule = StandardFeeRule::PreZip313;
// Add funds to the wallet in a single note
let value = NonNegativeAmount::const_from_u64(50000);
let (h1, _, _) = st.generate_next_block(&dfvk, AddressType::DefaultExternal, value);
st.scan_cached_blocks(h1, 1);
// Spendable balance matches total balance at 1 confirmation.
assert_eq!(st.get_total_balance(account_id), value);
assert_eq!(st.get_spendable_balance(account_id, 1), value);
// Send some of the funds to another address, but don't mine the tx.
let extsk2 = T::sk(&[0xf5; 32]);
let to = T::sk_default_address(&extsk2);
let min_confirmations = NonZeroU32::new(1).unwrap();
let proposal = st
.propose_standard_transfer::<Infallible>(
account_id,
fee_rule,
min_confirmations,
&to,
NonNegativeAmount::const_from_u64(15000),
None,
None,
T::SHIELDED_PROTOCOL,
)
.unwrap();
// Executing the proposal should succeed
assert_matches!(
st.create_proposed_transactions::<Infallible, _>(account.usk(), OvkPolicy::Sender, &proposal,),
Ok(txids) if txids.len() == 1
);
// A second proposal fails because there are no usable notes
assert_matches!(
st.propose_standard_transfer::<Infallible>(
account_id,
fee_rule,
NonZeroU32::new(1).unwrap(),
&to,
NonNegativeAmount::const_from_u64(2000),
None,
None,
T::SHIELDED_PROTOCOL,
),
Err(data_api::error::Error::InsufficientFunds {
available,
required
})
if available == NonNegativeAmount::ZERO && required == NonNegativeAmount::const_from_u64(12000)
);
// Mine blocks SAPLING_ACTIVATION_HEIGHT + 1 to 41 (that don't send us funds)
// until just before the first transaction expires
for i in 1..42 {
st.generate_next_block(
&T::sk_to_fvk(&T::sk(&[i as u8; 32])),
AddressType::DefaultExternal,
value,
);
}
st.scan_cached_blocks(h1 + 1, 40);
// Second proposal still fails
assert_matches!(
st.propose_standard_transfer::<Infallible>(
account_id,
fee_rule,
NonZeroU32::new(1).unwrap(),
&to,
NonNegativeAmount::const_from_u64(2000),
None,
None,
T::SHIELDED_PROTOCOL,
),
Err(data_api::error::Error::InsufficientFunds {
available,
required
})
if available == NonNegativeAmount::ZERO && required == NonNegativeAmount::const_from_u64(12000)
);
// Mine block SAPLING_ACTIVATION_HEIGHT + 42 so that the first transaction expires
let (h43, _, _) = st.generate_next_block(
&T::sk_to_fvk(&T::sk(&[42; 32])),
AddressType::DefaultExternal,
value,
);
st.scan_cached_blocks(h43, 1);
// Spendable balance matches total balance at 1 confirmation.
assert_eq!(st.get_total_balance(account_id), value);
assert_eq!(st.get_spendable_balance(account_id, 1), value);
// Second spend should now succeed
let amount_sent2 = NonNegativeAmount::const_from_u64(2000);
let min_confirmations = NonZeroU32::new(1).unwrap();
let proposal = st
.propose_standard_transfer::<Infallible>(
account_id,
fee_rule,
min_confirmations,
&to,
amount_sent2,
None,
None,
T::SHIELDED_PROTOCOL,
)
.unwrap();
let txid2 = st
.create_proposed_transactions::<Infallible, _>(account.usk(), OvkPolicy::Sender, &proposal)
.unwrap()[0];
let (h, _) = st.generate_next_block_including(txid2);
st.scan_cached_blocks(h, 1);
// TODO: send to an account so that we can check its balance.
assert_eq!(
st.get_total_balance(account_id),
(value - (amount_sent2 + NonNegativeAmount::from_u64(10000).unwrap()).unwrap()).unwrap()
);
}
pub(crate) fn ovk_policy_prevents_recovery_from_chain<T: ShieldedPoolTester>() {
let mut st = TestBuilder::new()
.with_block_cache()
.with_account_from_sapling_activation(BlockHash([0; 32]))
.build();
let account = st.test_account().cloned().unwrap();
let account_id = account.account_id();
let dfvk = T::test_account_fvk(&st);
// Add funds to the wallet in a single note
let value = NonNegativeAmount::const_from_u64(50000);
let (h1, _, _) = st.generate_next_block(&dfvk, AddressType::DefaultExternal, value);
st.scan_cached_blocks(h1, 1);
// Spendable balance matches total balance at 1 confirmation.
assert_eq!(st.get_total_balance(account_id), value);
assert_eq!(st.get_spendable_balance(account_id, 1), value);
let extsk2 = T::sk(&[0xf5; 32]);
let addr2 = T::sk_default_address(&extsk2);
// TODO: This test was originally written to use the pre-zip-313 fee rule
// and has not yet been updated.
#[allow(deprecated)]
let fee_rule = StandardFeeRule::PreZip313;
#[allow(clippy::type_complexity)]
let send_and_recover_with_policy = |st: &mut TestState<BlockCache>,
ovk_policy|
-> Result<
Option<(Note, Address, MemoBytes)>,
Error<
SqliteClientError,
commitment_tree::Error,
GreedyInputSelectorError<Zip317FeeError, ReceivedNoteId>,
Zip317FeeError,
>,
> {
let min_confirmations = NonZeroU32::new(1).unwrap();
let proposal = st.propose_standard_transfer(
account_id,
fee_rule,
min_confirmations,
&addr2,
NonNegativeAmount::const_from_u64(15000),
None,
None,
T::SHIELDED_PROTOCOL,
)?;
// Executing the proposal should succeed
let txid = st.create_proposed_transactions(account.usk(), ovk_policy, &proposal)?[0];
// Fetch the transaction from the database
let raw_tx: Vec<_> = st
.wallet()
.conn
.query_row(
"SELECT raw FROM transactions
WHERE txid = ?",
[txid.as_ref()],
|row| row.get(0),
)
.unwrap();
let tx = Transaction::read(&raw_tx[..], BranchId::Canopy).unwrap();
T::try_output_recovery(st, h1, &tx, &dfvk)
};
// Send some of the funds to another address, keeping history.
// The recipient output is decryptable by the sender.
assert_matches!(
send_and_recover_with_policy(&mut st, OvkPolicy::Sender),
Ok(Some((_, recovered_to, _))) if recovered_to == addr2
);
// Mine blocks SAPLING_ACTIVATION_HEIGHT + 1 to 42 (that don't send us funds)
// so that the first transaction expires
for i in 1..=42 {
st.generate_next_block(
&T::sk_to_fvk(&T::sk(&[i as u8; 32])),
AddressType::DefaultExternal,
value,
);
}
st.scan_cached_blocks(h1 + 1, 42);
// Send the funds again, discarding history.
// Neither transaction output is decryptable by the sender.
assert_matches!(
send_and_recover_with_policy(&mut st, OvkPolicy::Discard),
Ok(None)
);
}
pub(crate) fn spend_succeeds_to_t_addr_zero_change<T: ShieldedPoolTester>() {
let mut st = TestBuilder::new()
.with_block_cache()
.with_account_from_sapling_activation(BlockHash([0; 32]))
.build();
let account = st.test_account().cloned().unwrap();
let account_id = account.account_id();
let dfvk = T::test_account_fvk(&st);
// Add funds to the wallet in a single note
let value = NonNegativeAmount::const_from_u64(60000);
let (h, _, _) = st.generate_next_block(&dfvk, AddressType::DefaultExternal, value);
st.scan_cached_blocks(h, 1);
// Spendable balance matches total balance at 1 confirmation.
assert_eq!(st.get_total_balance(account_id), value);
assert_eq!(st.get_spendable_balance(account_id, 1), value);
// TODO: This test was originally written to use the pre-zip-313 fee rule
// and has not yet been updated.
#[allow(deprecated)]
let fee_rule = StandardFeeRule::PreZip313;
// TODO: generate_next_block_from_tx does not currently support transparent outputs.
let to = TransparentAddress::PublicKeyHash([7; 20]).into();
let min_confirmations = NonZeroU32::new(1).unwrap();
let proposal = st
.propose_standard_transfer::<Infallible>(
account_id,
fee_rule,
min_confirmations,
&to,
NonNegativeAmount::const_from_u64(50000),
None,
None,
T::SHIELDED_PROTOCOL,
)
.unwrap();
// Executing the proposal should succeed
assert_matches!(
st.create_proposed_transactions::<Infallible, _>(account.usk(), OvkPolicy::Sender, &proposal),
Ok(txids) if txids.len() == 1
);
}
pub(crate) fn change_note_spends_succeed<T: ShieldedPoolTester>() {
let mut st = TestBuilder::new()
.with_block_cache()
.with_account_from_sapling_activation(BlockHash([0; 32]))
.build();
let account = st.test_account().cloned().unwrap();
let account_id = account.account_id();
let dfvk = T::test_account_fvk(&st);
// Add funds to the wallet in a single note owned by the internal spending key
let value = NonNegativeAmount::const_from_u64(60000);
let (h, _, _) = st.generate_next_block(&dfvk, AddressType::Internal, value);
st.scan_cached_blocks(h, 1);
// Spendable balance matches total balance at 1 confirmation.
assert_eq!(st.get_total_balance(account_id), value);
assert_eq!(st.get_spendable_balance(account_id, 1), value);
// Value is considered pending at 10 confirmations.
assert_eq!(st.get_pending_shielded_balance(account_id, 10), value);
assert_eq!(
st.get_spendable_balance(account_id, 10),
NonNegativeAmount::ZERO
);
let change_note_scope = st.wallet().conn.query_row(
&format!(
"SELECT recipient_key_scope
FROM {}_received_notes
WHERE value = ?",
T::TABLES_PREFIX,
),
params![u64::from(value)],
|row| Ok(parse_scope(row.get(0)?)),
);
assert_matches!(change_note_scope, Ok(Some(Scope::Internal)));
// TODO: This test was originally written to use the pre-zip-313 fee rule
// and has not yet been updated.
#[allow(deprecated)]
let fee_rule = StandardFeeRule::PreZip313;
// TODO: generate_next_block_from_tx does not currently support transparent outputs.
let to = TransparentAddress::PublicKeyHash([7; 20]).into();
let min_confirmations = NonZeroU32::new(1).unwrap();
let proposal = st
.propose_standard_transfer::<Infallible>(
account_id,
fee_rule,
min_confirmations,
&to,
NonNegativeAmount::const_from_u64(50000),
None,
None,
T::SHIELDED_PROTOCOL,
)
.unwrap();
// Executing the proposal should succeed
assert_matches!(
st.create_proposed_transactions::<Infallible, _>(account.usk(), OvkPolicy::Sender, &proposal),
Ok(txids) if txids.len() == 1
);
}
pub(crate) fn external_address_change_spends_detected_in_restore_from_seed<
T: ShieldedPoolTester,
>() {
let mut st = TestBuilder::new().with_block_cache().build();
// Add two accounts to the wallet.
let seed = Secret::new([0u8; 32].to_vec());
let birthday = AccountBirthday::from_sapling_activation(&st.network(), BlockHash([0; 32]));
let (account_id, usk) = st.wallet_mut().create_account(&seed, &birthday).unwrap();
let dfvk = T::sk_to_fvk(T::usk_to_sk(&usk));
let (account2, usk2) = st.wallet_mut().create_account(&seed, &birthday).unwrap();
let dfvk2 = T::sk_to_fvk(T::usk_to_sk(&usk2));
// Add funds to the wallet in a single note
let value = NonNegativeAmount::from_u64(100000).unwrap();
let (h, _, _) = st.generate_next_block(&dfvk, AddressType::DefaultExternal, value);
st.scan_cached_blocks(h, 1);
// Spendable balance matches total balance
assert_eq!(st.get_total_balance(account_id), value);
assert_eq!(st.get_spendable_balance(account_id, 1), value);
assert_eq!(st.get_total_balance(account2), NonNegativeAmount::ZERO);
let amount_sent = NonNegativeAmount::from_u64(20000).unwrap();
let amount_legacy_change = NonNegativeAmount::from_u64(30000).unwrap();
let addr = T::fvk_default_address(&dfvk);
let addr2 = T::fvk_default_address(&dfvk2);
let req = TransactionRequest::new(vec![
// payment to an external recipient
Payment::without_memo(addr2.to_zcash_address(&st.network()), amount_sent),
// payment back to the originating wallet, simulating legacy change
Payment::without_memo(addr.to_zcash_address(&st.network()), amount_legacy_change),
])
.unwrap();
#[allow(deprecated)]
let fee_rule = FixedFeeRule::standard();
let input_selector = GreedyInputSelector::new(
fixed::SingleOutputChangeStrategy::new(fee_rule, None, T::SHIELDED_PROTOCOL),
DustOutputPolicy::default(),
);
let txid = st
.spend(
&input_selector,
&usk,
req,
OvkPolicy::Sender,
NonZeroU32::new(1).unwrap(),
)
.unwrap()[0];
let amount_left = (value - (amount_sent + fee_rule.fixed_fee()).unwrap()).unwrap();
let pending_change = (amount_left - amount_legacy_change).unwrap();
// The "legacy change" is not counted by get_pending_change().
assert_eq!(st.get_pending_change(account_id, 1), pending_change);
// We spent the only note so we only have pending change.
assert_eq!(st.get_total_balance(account_id), pending_change);
let (h, _) = st.generate_next_block_including(txid);
st.scan_cached_blocks(h, 1);
assert_eq!(st.get_total_balance(account2), amount_sent,);
assert_eq!(st.get_total_balance(account_id), amount_left);
st.reset();
// Account creation and DFVK derivation should be deterministic.
let (_, restored_usk) = st.wallet_mut().create_account(&seed, &birthday).unwrap();
assert!(T::fvks_equal(
&T::sk_to_fvk(T::usk_to_sk(&restored_usk)),
&dfvk,
));
let (_, restored_usk2) = st.wallet_mut().create_account(&seed, &birthday).unwrap();
assert!(T::fvks_equal(
&T::sk_to_fvk(T::usk_to_sk(&restored_usk2)),
&dfvk2,
));
st.scan_cached_blocks(st.sapling_activation_height(), 2);
assert_eq!(st.get_total_balance(account2), amount_sent,);
assert_eq!(st.get_total_balance(account_id), amount_left);
}
#[allow(dead_code)]
pub(crate) fn zip317_spend<T: ShieldedPoolTester>() {
let mut st = TestBuilder::new()
.with_block_cache()
.with_account_from_sapling_activation(BlockHash([0; 32]))
.build();
let account = st.test_account().cloned().unwrap();
let account_id = account.account_id();
let dfvk = T::test_account_fvk(&st);
// Add funds to the wallet
let (h1, _, _) = st.generate_next_block(
&dfvk,
AddressType::Internal,
NonNegativeAmount::const_from_u64(50000),
);
// Add 10 dust notes to the wallet
for _ in 1..=10 {
st.generate_next_block(
&dfvk,
AddressType::DefaultExternal,
NonNegativeAmount::const_from_u64(1000),
);
}
st.scan_cached_blocks(h1, 11);
// Spendable balance matches total balance
let total = NonNegativeAmount::const_from_u64(60000);
assert_eq!(st.get_total_balance(account_id), total);
assert_eq!(st.get_spendable_balance(account_id, 1), total);
let input_selector = input_selector(StandardFeeRule::Zip317, None, T::SHIELDED_PROTOCOL);
// This first request will fail due to insufficient non-dust funds
let req = TransactionRequest::new(vec![Payment::without_memo(
T::fvk_default_address(&dfvk).to_zcash_address(&st.network()),
NonNegativeAmount::const_from_u64(50000),
)])
.unwrap();
assert_matches!(
st.spend(
&input_selector,
account.usk(),
req,
OvkPolicy::Sender,
NonZeroU32::new(1).unwrap(),
),
Err(Error::InsufficientFunds { available, required })
if available == NonNegativeAmount::const_from_u64(51000)
&& required == NonNegativeAmount::const_from_u64(60000)
);
// This request will succeed, spending a single dust input to pay the 10000
// ZAT fee in addition to the 41000 ZAT output to the recipient
let req = TransactionRequest::new(vec![Payment::without_memo(
T::fvk_default_address(&dfvk).to_zcash_address(&st.network()),
NonNegativeAmount::const_from_u64(41000),
)])
.unwrap();
let txid = st
.spend(
&input_selector,
account.usk(),
req,
OvkPolicy::Sender,
NonZeroU32::new(1).unwrap(),
)
.unwrap()[0];
let (h, _) = st.generate_next_block_including(txid);
st.scan_cached_blocks(h, 1);
// TODO: send to an account so that we can check its balance.
// We sent back to the same account so the amount_sent should be included
// in the total balance.
assert_eq!(
st.get_total_balance(account_id),
(total - NonNegativeAmount::const_from_u64(10000)).unwrap()
);
}
#[cfg(feature = "transparent-inputs")]
pub(crate) fn shield_transparent<T: ShieldedPoolTester>() {
let mut st = TestBuilder::new()
.with_block_cache()
.with_account_from_sapling_activation(BlockHash([0; 32]))
.build();
let account = st.test_account().cloned().unwrap();
let dfvk = T::test_account_fvk(&st);
let uaddr = st
.wallet()
.get_current_address(account.account_id())
.unwrap()
.unwrap();
let taddr = uaddr.transparent().unwrap();
// Ensure that the wallet has at least one block
let (h, _, _) = st.generate_next_block(
&dfvk,
AddressType::Internal,
NonNegativeAmount::const_from_u64(50000),
);
st.scan_cached_blocks(h, 1);
let utxo = WalletTransparentOutput::from_parts(
OutPoint::new([1u8; 32], 1),
TxOut {
value: NonNegativeAmount::const_from_u64(10000),
script_pubkey: taddr.script(),
},
h,
)
.unwrap();
let res0 = st.wallet_mut().put_received_transparent_utxo(&utxo);
assert!(matches!(res0, Ok(_)));
// TODO: This test was originally written to use the pre-zip-313 fee rule
// and has not yet been updated.
#[allow(deprecated)]
let fee_rule = StandardFeeRule::PreZip313;
let input_selector = GreedyInputSelector::new(
standard::SingleOutputChangeStrategy::new(fee_rule, None, T::SHIELDED_PROTOCOL),
DustOutputPolicy::default(),
);
assert_matches!(
st.shield_transparent_funds(
&input_selector,
NonNegativeAmount::from_u64(10000).unwrap(),
account.usk(),
&[*taddr],
1
),
Ok(_)
);
}
// FIXME: This requires fixes to the test framework.
#[allow(dead_code)]
pub(crate) fn birthday_in_anchor_shard<T: ShieldedPoolTester>() {
// Set up the following situation:
//
// |<------ 500 ------->|<--- 10 --->|<--- 10 --->|
// last_shard_start wallet_birthday received_tx anchor_height
//
// We set the Sapling and Orchard frontiers at the birthday block initial state to 1234
// notes beyond the end of the first shard.
let frontier_tree_size: u32 = (0x1 << 16) + 1234;
let mut st = TestBuilder::new()
.with_block_cache()
.with_initial_chain_state(|rng, network| {
let birthday_height = network.activation_height(NetworkUpgrade::Nu5).unwrap() + 1000;
// Construct a fake chain state for the end of the block with the given
// birthday_offset from the Nu5 birthday.
let (prior_sapling_roots, sapling_initial_tree) =
Frontier::random_with_prior_subtree_roots(
rng,
frontier_tree_size.into(),
NonZeroU8::new(16).unwrap(),
);
// There will only be one prior root
let prior_sapling_roots = prior_sapling_roots
.into_iter()
.map(|root| CommitmentTreeRoot::from_parts(birthday_height - 500, root))
.collect::<Vec<_>>();
#[cfg(feature = "orchard")]
let (prior_orchard_roots, orchard_initial_tree) =
Frontier::random_with_prior_subtree_roots(
rng,
frontier_tree_size.into(),
NonZeroU8::new(16).unwrap(),
);
// There will only be one prior root
#[cfg(feature = "orchard")]
let prior_orchard_roots = prior_orchard_roots
.into_iter()
.map(|root| CommitmentTreeRoot::from_parts(birthday_height - 500, root))
.collect::<Vec<_>>();
InitialChainState {
chain_state: ChainState::new(
birthday_height - 1,
BlockHash([5; 32]),
sapling_initial_tree,
#[cfg(feature = "orchard")]
orchard_initial_tree,
),
prior_sapling_roots,
#[cfg(feature = "orchard")]
prior_orchard_roots,
}
})
.with_account_having_current_birthday()
.build();
// Generate 9 blocks that have no value for us, starting at the birthday height.
let not_our_value = NonNegativeAmount::const_from_u64(10000);
let not_our_key = T::random_fvk(st.rng_mut());
let (initial_height, _, _) =
st.generate_next_block(&not_our_key, AddressType::DefaultExternal, not_our_value);
for _ in 1..9 {
st.generate_next_block(&not_our_key, AddressType::DefaultExternal, not_our_value);
}
// Now, generate a block that belongs to our wallet
let (received_tx_height, _, _) = st.generate_next_block(
&T::test_account_fvk(&st),
AddressType::DefaultExternal,
NonNegativeAmount::const_from_u64(500000),
);
// Generate some more blocks to get above our anchor height
for _ in 0..15 {
st.generate_next_block(&not_our_key, AddressType::DefaultExternal, not_our_value);
}
// Scan a block range that includes our received note, but skips some blocks we need to
// make it spendable.
st.scan_cached_blocks(initial_height + 5, 20);
// Verify that the received note is not considered spendable
let account = st.test_account().unwrap();
let account_id = account.account_id();
let spendable = T::select_spendable_notes(
&st,
account_id,
NonNegativeAmount::const_from_u64(300000),
received_tx_height + 10,
&[],
)
.unwrap();
assert_eq!(spendable.len(), 0);
// Scan the blocks we skipped
st.scan_cached_blocks(initial_height, 5);
// Verify that the received note is now considered spendable
let spendable = T::select_spendable_notes(
&st,
account_id,
NonNegativeAmount::const_from_u64(300000),
received_tx_height + 10,
&[],
)
.unwrap();
assert_eq!(spendable.len(), 1);
}
pub(crate) fn checkpoint_gaps<T: ShieldedPoolTester>() {
let mut st = TestBuilder::new()
.with_block_cache()
.with_account_from_sapling_activation(BlockHash([0; 32]))
.build();
let account = st.test_account().cloned().unwrap();
let dfvk = T::test_account_fvk(&st);
// Generate a block with funds belonging to our wallet.
st.generate_next_block(
&dfvk,
AddressType::DefaultExternal,
NonNegativeAmount::const_from_u64(500000),
);
st.scan_cached_blocks(account.birthday().height(), 1);
// Create a gap of 10 blocks having no shielded outputs, then add a block that doesn't
// belong to us so that we can get a checkpoint in the tree.
let not_our_key = T::sk_to_fvk(&T::sk(&[0xf5; 32]));
let not_our_value = NonNegativeAmount::const_from_u64(10000);
st.generate_block_at(
account.birthday().height() + 10,
BlockHash([0; 32]),
&not_our_key,
AddressType::DefaultExternal,
not_our_value,
st.latest_cached_block().unwrap().sapling_end_size,
st.latest_cached_block().unwrap().orchard_end_size,
false,
);
// Scan the block
st.scan_cached_blocks(account.birthday().height() + 10, 1);
// Fake that everything has been scanned
st.wallet()
.conn
.execute_batch("UPDATE scan_queue SET priority = 10")
.unwrap();
// Verify that our note is considered spendable
let spendable = T::select_spendable_notes(
&st,
account.account_id(),
NonNegativeAmount::const_from_u64(300000),
account.birthday().height() + 5,
&[],
)
.unwrap();
assert_eq!(spendable.len(), 1);
// Attempt to spend the note with 5 confirmations
let to = T::fvk_default_address(&not_our_key);
assert_matches!(
st.create_spend_to_address(
account.usk(),
&to,
NonNegativeAmount::const_from_u64(10000),
None,
OvkPolicy::Sender,
NonZeroU32::new(5).unwrap(),
None,
T::SHIELDED_PROTOCOL,
),
Ok(_)
);
}
#[cfg(feature = "orchard")]
pub(crate) fn pool_crossing_required<P0: ShieldedPoolTester, P1: ShieldedPoolTester>() {
let mut st = TestBuilder::new()
.with_block_cache()
.with_account_from_sapling_activation(BlockHash([0; 32])) // TODO: Allow for Orchard
// activation after Sapling
.build();
let account = st.test_account().cloned().unwrap();
let p0_fvk = P0::test_account_fvk(&st);
let p1_fvk = P1::test_account_fvk(&st);
let p1_to = P1::fvk_default_address(&p1_fvk);
let note_value = NonNegativeAmount::const_from_u64(350000);
st.generate_next_block(&p0_fvk, AddressType::DefaultExternal, note_value);
st.scan_cached_blocks(account.birthday().height(), 2);
let initial_balance = note_value;
assert_eq!(st.get_total_balance(account.account_id()), initial_balance);
assert_eq!(
st.get_spendable_balance(account.account_id(), 1),
initial_balance
);
let transfer_amount = NonNegativeAmount::const_from_u64(200000);
let p0_to_p1 = zip321::TransactionRequest::new(vec![Payment::without_memo(
p1_to.to_zcash_address(&st.network()),
transfer_amount,
)])
.unwrap();
let fee_rule = StandardFeeRule::Zip317;
let input_selector = GreedyInputSelector::new(
standard::SingleOutputChangeStrategy::new(fee_rule, None, P1::SHIELDED_PROTOCOL),
DustOutputPolicy::default(),
);
let proposal0 = st
.propose_transfer(
account.account_id(),
&input_selector,
p0_to_p1,
NonZeroU32::new(1).unwrap(),
)
.unwrap();
let _min_target_height = proposal0.min_target_height();
assert_eq!(proposal0.steps().len(), 1);
let step0 = &proposal0.steps().head;
// We expect 4 logical actions, two per pool (due to padding).
let expected_fee = NonNegativeAmount::const_from_u64(20000);
assert_eq!(step0.balance().fee_required(), expected_fee);
let expected_change = (note_value - transfer_amount - expected_fee).unwrap();
let proposed_change = step0.balance().proposed_change();
assert_eq!(proposed_change.len(), 1);
let change_output = proposed_change.get(0).unwrap();
// Since this is a cross-pool transfer, change will be sent to the preferred pool.
assert_eq!(
change_output.output_pool(),
std::cmp::max(ShieldedProtocol::Sapling, ShieldedProtocol::Orchard)
);
assert_eq!(change_output.value(), expected_change);
let create_proposed_result = st.create_proposed_transactions::<Infallible, _>(
account.usk(),
OvkPolicy::Sender,
&proposal0,
);
assert_matches!(&create_proposed_result, Ok(txids) if txids.len() == 1);
let (h, _) = st.generate_next_block_including(create_proposed_result.unwrap()[0]);
st.scan_cached_blocks(h, 1);
assert_eq!(
st.get_total_balance(account.account_id()),
(initial_balance - expected_fee).unwrap()
);
assert_eq!(
st.get_spendable_balance(account.account_id(), 1),
(initial_balance - expected_fee).unwrap()
);
}
#[cfg(feature = "orchard")]
pub(crate) fn fully_funded_fully_private<P0: ShieldedPoolTester, P1: ShieldedPoolTester>() {
let mut st = TestBuilder::new()
.with_block_cache()
.with_account_from_sapling_activation(BlockHash([0; 32])) // TODO: Allow for Orchard
// activation after Sapling
.build();
let account = st.test_account().cloned().unwrap();
let p0_fvk = P0::test_account_fvk(&st);
let p1_fvk = P1::test_account_fvk(&st);
let p1_to = P1::fvk_default_address(&p1_fvk);
let note_value = NonNegativeAmount::const_from_u64(350000);
st.generate_next_block(&p0_fvk, AddressType::DefaultExternal, note_value);
st.generate_next_block(&p1_fvk, AddressType::DefaultExternal, note_value);
st.scan_cached_blocks(account.birthday().height(), 2);
let initial_balance = (note_value * 2).unwrap();
assert_eq!(st.get_total_balance(account.account_id()), initial_balance);
assert_eq!(
st.get_spendable_balance(account.account_id(), 1),
initial_balance
);
let transfer_amount = NonNegativeAmount::const_from_u64(200000);
let p0_to_p1 = zip321::TransactionRequest::new(vec![Payment::without_memo(
p1_to.to_zcash_address(&st.network()),
transfer_amount,
)])
.unwrap();
let fee_rule = StandardFeeRule::Zip317;
let input_selector = GreedyInputSelector::new(
// We set the default change output pool to P0, because we want to verify later that
// change is actually sent to P1 (as the transaction is fully fundable from P1).
standard::SingleOutputChangeStrategy::new(fee_rule, None, P0::SHIELDED_PROTOCOL),
DustOutputPolicy::default(),
);
let proposal0 = st
.propose_transfer(
account.account_id(),
&input_selector,
p0_to_p1,
NonZeroU32::new(1).unwrap(),
)
.unwrap();
let _min_target_height = proposal0.min_target_height();
assert_eq!(proposal0.steps().len(), 1);
let step0 = &proposal0.steps().head;
// We expect 2 logical actions, since either pool can pay the full balance required
// and note selection should choose the fully-private path.
let expected_fee = NonNegativeAmount::const_from_u64(10000);
assert_eq!(step0.balance().fee_required(), expected_fee);
let expected_change = (note_value - transfer_amount - expected_fee).unwrap();
let proposed_change = step0.balance().proposed_change();
assert_eq!(proposed_change.len(), 1);
let change_output = proposed_change.get(0).unwrap();
// Since there are sufficient funds in either pool, change is kept in the same pool as
// the source note (the target pool), and does not necessarily follow preference order.
assert_eq!(change_output.output_pool(), P1::SHIELDED_PROTOCOL);
assert_eq!(change_output.value(), expected_change);
let create_proposed_result = st.create_proposed_transactions::<Infallible, _>(
account.usk(),
OvkPolicy::Sender,
&proposal0,
);
assert_matches!(&create_proposed_result, Ok(txids) if txids.len() == 1);
let (h, _) = st.generate_next_block_including(create_proposed_result.unwrap()[0]);
st.scan_cached_blocks(h, 1);
assert_eq!(
st.get_total_balance(account.account_id()),
(initial_balance - expected_fee).unwrap()
);
assert_eq!(
st.get_spendable_balance(account.account_id(), 1),
(initial_balance - expected_fee).unwrap()
);
}
#[cfg(feature = "orchard")]
pub(crate) fn fully_funded_send_to_t<P0: ShieldedPoolTester, P1: ShieldedPoolTester>() {
let mut st = TestBuilder::new()
.with_block_cache()
.with_account_from_sapling_activation(BlockHash([0; 32])) // TODO: Allow for Orchard
// activation after Sapling
.build();
let account = st.test_account().cloned().unwrap();
let p0_fvk = P0::test_account_fvk(&st);
let p1_fvk = P1::test_account_fvk(&st);
let (p1_to, _) = account.usk().default_transparent_address();
let note_value = NonNegativeAmount::const_from_u64(350000);
st.generate_next_block(&p0_fvk, AddressType::DefaultExternal, note_value);
st.generate_next_block(&p1_fvk, AddressType::DefaultExternal, note_value);
st.scan_cached_blocks(account.birthday().height(), 2);
let initial_balance = (note_value * 2).unwrap();
assert_eq!(st.get_total_balance(account.account_id()), initial_balance);
assert_eq!(
st.get_spendable_balance(account.account_id(), 1),
initial_balance
);
let transfer_amount = NonNegativeAmount::const_from_u64(200000);
let p0_to_p1 = zip321::TransactionRequest::new(vec![Payment::without_memo(
Address::Transparent(p1_to).to_zcash_address(&st.network()),
transfer_amount,
)])
.unwrap();
let fee_rule = StandardFeeRule::Zip317;
let input_selector = GreedyInputSelector::new(
// We set the default change output pool to P0, because we want to verify later that
// change is actually sent to P1 (as the transaction is fully fundable from P1).
standard::SingleOutputChangeStrategy::new(fee_rule, None, P0::SHIELDED_PROTOCOL),
DustOutputPolicy::default(),
);
let proposal0 = st
.propose_transfer(
account.account_id(),
&input_selector,
p0_to_p1,
NonZeroU32::new(1).unwrap(),
)
.unwrap();
let _min_target_height = proposal0.min_target_height();
assert_eq!(proposal0.steps().len(), 1);
let step0 = &proposal0.steps().head;
// We expect 3 logical actions, one for the transparent output and two for the source pool.
let expected_fee = NonNegativeAmount::const_from_u64(15000);
assert_eq!(step0.balance().fee_required(), expected_fee);
let expected_change = (note_value - transfer_amount - expected_fee).unwrap();
let proposed_change = step0.balance().proposed_change();
assert_eq!(proposed_change.len(), 1);
let change_output = proposed_change.get(0).unwrap();
// Since there are sufficient funds in either pool, change is kept in the same pool as
// the source note (the target pool), and does not necessarily follow preference order.
// The source note will always be sapling, as we spend Sapling funds preferentially.
assert_eq!(change_output.output_pool(), ShieldedProtocol::Sapling);
assert_eq!(change_output.value(), expected_change);
let create_proposed_result = st.create_proposed_transactions::<Infallible, _>(
account.usk(),
OvkPolicy::Sender,
&proposal0,
);
assert_matches!(&create_proposed_result, Ok(txids) if txids.len() == 1);
let (h, _) = st.generate_next_block_including(create_proposed_result.unwrap()[0]);
st.scan_cached_blocks(h, 1);
assert_eq!(
st.get_total_balance(account.account_id()),
(initial_balance - transfer_amount - expected_fee).unwrap()
);
assert_eq!(
st.get_spendable_balance(account.account_id(), 1),
(initial_balance - transfer_amount - expected_fee).unwrap()
);
}
#[cfg(feature = "orchard")]
pub(crate) fn multi_pool_checkpoint<P0: ShieldedPoolTester, P1: ShieldedPoolTester>() {
let mut st = TestBuilder::new()
.with_block_cache()
.with_account_from_sapling_activation(BlockHash([0; 32])) // TODO: Allow for Orchard
// activation after Sapling
.build();
let account = st.test_account().cloned().unwrap();
let acct_id = account.account_id();
let p0_fvk = P0::test_account_fvk(&st);
let p1_fvk = P1::test_account_fvk(&st);
// Add some funds to the wallet; we add two notes to allow successive spends. Also,
// we will generate a note in the P1 pool to ensure that we have some tree state.
let note_value = NonNegativeAmount::const_from_u64(500000);
let (start_height, _, _) =
st.generate_next_block(&p0_fvk, AddressType::DefaultExternal, note_value);
st.generate_next_block(&p0_fvk, AddressType::DefaultExternal, note_value);
st.generate_next_block(&p1_fvk, AddressType::DefaultExternal, note_value);
let scanned = st.scan_cached_blocks(start_height, 3);
let next_to_scan = scanned.scanned_range().end;
let initial_balance = (note_value * 3).unwrap();
assert_eq!(st.get_total_balance(acct_id), initial_balance);
assert_eq!(st.get_spendable_balance(acct_id, 1), initial_balance);
// Generate several empty blocks
for _ in 0..10 {
st.generate_empty_block();
}
// Scan into the middle of the empty range
let scanned = st.scan_cached_blocks(next_to_scan, 5);
let next_to_scan = scanned.scanned_range().end;
// The initial balance should be unchanged.
assert_eq!(st.get_total_balance(acct_id), initial_balance);
assert_eq!(st.get_spendable_balance(acct_id, 1), initial_balance);
// Set up the fee rule and input selector we'll use for all the transfers.
let fee_rule = StandardFeeRule::Zip317;
let input_selector = GreedyInputSelector::new(
standard::SingleOutputChangeStrategy::new(fee_rule, None, P1::SHIELDED_PROTOCOL),
DustOutputPolicy::default(),
);
// First, send funds just to P0
let transfer_amount = NonNegativeAmount::const_from_u64(200000);
let p0_transfer = zip321::TransactionRequest::new(vec![Payment::without_memo(
P0::random_address(&mut st.rng).to_zcash_address(&st.network()),
transfer_amount,
)])
.unwrap();
let res = st
.spend(
&input_selector,
account.usk(),
p0_transfer,
OvkPolicy::Sender,
NonZeroU32::new(1).unwrap(),
)
.unwrap();
st.generate_next_block_including(*res.first());
let expected_fee = NonNegativeAmount::const_from_u64(10000);
let expected_change = (note_value - transfer_amount - expected_fee).unwrap();
assert_eq!(
st.get_total_balance(acct_id),
((note_value * 2).unwrap() + expected_change).unwrap()
);
assert_eq!(st.get_pending_change(acct_id, 1), expected_change);
// In the next block, send funds to both P0 and P1
let both_transfer = zip321::TransactionRequest::new(vec![
Payment::without_memo(
P0::random_address(&mut st.rng).to_zcash_address(&st.network()),
transfer_amount,
),
Payment::without_memo(
P1::random_address(&mut st.rng).to_zcash_address(&st.network()),
transfer_amount,
),
])
.unwrap();
let res = st
.spend(
&input_selector,
account.usk(),
both_transfer,
OvkPolicy::Sender,
NonZeroU32::new(1).unwrap(),
)
.unwrap();
st.generate_next_block_including(*res.first());
// Generate a few more empty blocks
for _ in 0..5 {
st.generate_empty_block();
}
// Generate another block with funds for us
let (max_height, _, _) =
st.generate_next_block(&p0_fvk, AddressType::DefaultExternal, note_value);
// Scan everything.
st.scan_cached_blocks(
next_to_scan,
usize::try_from(u32::from(max_height) - u32::from(next_to_scan) + 1).unwrap(),
);
let expected_final = (initial_balance + note_value
- (transfer_amount * 3).unwrap()
- (expected_fee * 3).unwrap())
.unwrap();
assert_eq!(st.get_total_balance(acct_id), expected_final);
use incrementalmerkletree::Position;
let expected_checkpoints_p0: Vec<(BlockHeight, ShieldedProtocol, Option<Position>)> = [
(99999, None),
(100000, Some(0)),
(100001, Some(1)),
(100002, Some(1)),
(100007, Some(1)), // synthetic checkpoint in empty span from scan start
(100013, Some(3)),
(100014, Some(5)),
(100020, Some(6)),
]
.into_iter()
.map(|(h, pos)| {
(
BlockHeight::from(h),
P0::SHIELDED_PROTOCOL,
pos.map(Position::from),
)
})
.collect();
let expected_checkpoints_p1: Vec<(BlockHeight, ShieldedProtocol, Option<Position>)> = [
(99999, None),
(100000, None),
(100001, None),
(100002, Some(0)),
(100007, Some(0)), // synthetic checkpoint in empty span from scan start
(100013, Some(0)),
(100014, Some(2)),
(100020, Some(2)),
]
.into_iter()
.map(|(h, pos)| {
(
BlockHeight::from(h),
P1::SHIELDED_PROTOCOL,
pos.map(Position::from),
)
})
.collect();
let actual_checkpoints = st.get_checkpoint_history().unwrap();
assert_eq!(
actual_checkpoints
.iter()
.filter(|(_, p, _)| p == &P0::SHIELDED_PROTOCOL)
.cloned()
.collect::<Vec<_>>(),
expected_checkpoints_p0
);
assert_eq!(
actual_checkpoints
.iter()
.filter(|(_, p, _)| p == &P1::SHIELDED_PROTOCOL)
.cloned()
.collect::<Vec<_>>(),
expected_checkpoints_p1
);
}
#[cfg(feature = "orchard")]
pub(crate) fn multi_pool_checkpoints_with_pruning<
P0: ShieldedPoolTester,
P1: ShieldedPoolTester,
>() {
let mut st = TestBuilder::new()
.with_block_cache()
.with_account_from_sapling_activation(BlockHash([0; 32])) // TODO: Allow for Orchard
// activation after Sapling
.build();
let account = st.test_account().cloned().unwrap();
let p0_fvk = P0::random_fvk(&mut st.rng);
let p1_fvk = P1::random_fvk(&mut st.rng);
let note_value = NonNegativeAmount::const_from_u64(10000);
// Generate 100 P0 blocks, then 100 P1 blocks, then another 100 P0 blocks.
for _ in 0..10 {
for _ in 0..10 {
st.generate_next_block(&p0_fvk, AddressType::DefaultExternal, note_value);
}
for _ in 0..10 {
st.generate_next_block(&p1_fvk, AddressType::DefaultExternal, note_value);
}
}
st.scan_cached_blocks(account.birthday().height(), 200);
for _ in 0..100 {
st.generate_next_block(&p0_fvk, AddressType::DefaultExternal, note_value);
st.generate_next_block(&p1_fvk, AddressType::DefaultExternal, note_value);
}
st.scan_cached_blocks(account.birthday().height() + 200, 200);
}
pub(crate) fn valid_chain_states<T: ShieldedPoolTester>() {
let mut st = TestBuilder::new()
.with_block_cache()
.with_account_from_sapling_activation(BlockHash([0; 32]))
.build();
let dfvk = T::test_account_fvk(&st);
// Empty chain should return None
assert_matches!(st.wallet().chain_height(), Ok(None));
// Create a fake CompactBlock sending value to the address
let (h1, _, _) = st.generate_next_block(
&dfvk,
AddressType::DefaultExternal,
NonNegativeAmount::const_from_u64(5),
);
// Scan the cache
st.scan_cached_blocks(h1, 1);
// Create a second fake CompactBlock sending more value to the address
let (h2, _, _) = st.generate_next_block(
&dfvk,
AddressType::DefaultExternal,
NonNegativeAmount::const_from_u64(7),
);
// Scanning should detect no inconsistencies
st.scan_cached_blocks(h2, 1);
}
// FIXME: This requires fixes to the test framework.
#[allow(dead_code)]
pub(crate) fn invalid_chain_cache_disconnected<T: ShieldedPoolTester>() {
let mut st = TestBuilder::new()
.with_block_cache()
.with_account_from_sapling_activation(BlockHash([0; 32]))
.build();
let dfvk = T::test_account_fvk(&st);
// Create some fake CompactBlocks
let (h, _, _) = st.generate_next_block(
&dfvk,
AddressType::DefaultExternal,
NonNegativeAmount::const_from_u64(5),
);
let (last_contiguous_height, _, _) = st.generate_next_block(
&dfvk,
AddressType::DefaultExternal,
NonNegativeAmount::const_from_u64(7),
);
// Scanning the cache should find no inconsistencies
st.scan_cached_blocks(h, 2);
// Create more fake CompactBlocks that don't connect to the scanned ones
let disconnect_height = last_contiguous_height + 1;
st.generate_block_at(
disconnect_height,
BlockHash([1; 32]),
&dfvk,
AddressType::DefaultExternal,
NonNegativeAmount::const_from_u64(8),
2,
2,
true,
);
st.generate_next_block(
&dfvk,
AddressType::DefaultExternal,
NonNegativeAmount::const_from_u64(3),
);
// Data+cache chain should be invalid at the data/cache boundary
assert_matches!(
st.try_scan_cached_blocks(
disconnect_height,
2
),
Err(chain::error::Error::Scan(ScanError::PrevHashMismatch { at_height }))
if at_height == disconnect_height
);
}
pub(crate) fn data_db_truncation<T: ShieldedPoolTester>() {
let mut st = TestBuilder::new()
.with_block_cache()
.with_account_from_sapling_activation(BlockHash([0; 32]))
.build();
let account = st.test_account().cloned().unwrap();
let dfvk = T::test_account_fvk(&st);
// Wallet summary is not yet available
assert_eq!(st.get_wallet_summary(0), None);
// Create fake CompactBlocks sending value to the address
let value = NonNegativeAmount::const_from_u64(5);
let value2 = NonNegativeAmount::const_from_u64(7);
let (h, _, _) = st.generate_next_block(&dfvk, AddressType::DefaultExternal, value);
st.generate_next_block(&dfvk, AddressType::DefaultExternal, value2);
// Scan the cache
st.scan_cached_blocks(h, 2);
// Spendable balance should reflect both received notes
assert_eq!(
st.get_spendable_balance(account.account_id(), 1),
(value + value2).unwrap()
);
// "Rewind" to height of last scanned block (this is a no-op)
st.wallet_mut()
.transactionally(|wdb| truncate_to_height(wdb.conn.0, &wdb.params, h + 1))
.unwrap();
// Spendable balance should be unaltered
assert_eq!(
st.get_spendable_balance(account.account_id(), 1),
(value + value2).unwrap()
);
// Rewind so that one block is dropped
st.wallet_mut()
.transactionally(|wdb| truncate_to_height(wdb.conn.0, &wdb.params, h))
.unwrap();
// Spendable balance should only contain the first received note;
// the rest should be pending.
assert_eq!(st.get_spendable_balance(account.account_id(), 1), value);
assert_eq!(
st.get_pending_shielded_balance(account.account_id(), 1),
value2
);
// Scan the cache again
st.scan_cached_blocks(h, 2);
// Account balance should again reflect both received notes
assert_eq!(
st.get_spendable_balance(account.account_id(), 1),
(value + value2).unwrap()
);
}
pub(crate) fn scan_cached_blocks_allows_blocks_out_of_order<T: ShieldedPoolTester>() {
let mut st = TestBuilder::new()
.with_block_cache()
.with_account_from_sapling_activation(BlockHash([0; 32]))
.build();
let account = st.test_account().cloned().unwrap();
let dfvk = T::test_account_fvk(&st);
let value = NonNegativeAmount::const_from_u64(50000);
let (h1, _, _) = st.generate_next_block(&dfvk, AddressType::DefaultExternal, value);
st.scan_cached_blocks(h1, 1);
assert_eq!(st.get_total_balance(account.account_id()), value);
// Create blocks to reach height + 2
let (h2, _, _) = st.generate_next_block(&dfvk, AddressType::DefaultExternal, value);
let (h3, _, _) = st.generate_next_block(&dfvk, AddressType::DefaultExternal, value);
// Scan the later block first
st.scan_cached_blocks(h3, 1);
// Now scan the block of height height + 1
st.scan_cached_blocks(h2, 1);
assert_eq!(
st.get_total_balance(account.account_id()),
NonNegativeAmount::const_from_u64(150_000)
);
// We can spend the received notes
let req = TransactionRequest::new(vec![Payment::without_memo(
T::fvk_default_address(&dfvk).to_zcash_address(&st.network()),
NonNegativeAmount::const_from_u64(110_000),
)])
.unwrap();
#[allow(deprecated)]
let input_selector = GreedyInputSelector::new(
standard::SingleOutputChangeStrategy::new(
StandardFeeRule::Zip317,
None,
T::SHIELDED_PROTOCOL,
),
DustOutputPolicy::default(),
);
assert_matches!(
st.spend(
&input_selector,
account.usk(),
req,
OvkPolicy::Sender,
NonZeroU32::new(1).unwrap(),
),
Ok(_)
);
}
pub(crate) fn scan_cached_blocks_finds_received_notes<T: ShieldedPoolTester>() {
let mut st = TestBuilder::new()
.with_block_cache()
.with_account_from_sapling_activation(BlockHash([0; 32]))
.build();
let account = st.test_account().cloned().unwrap();
let dfvk = T::test_account_fvk(&st);
// Wallet summary is not yet available
assert_eq!(st.get_wallet_summary(0), None);
// Create a fake CompactBlock sending value to the address
let value = NonNegativeAmount::const_from_u64(5);
let (h1, _, _) = st.generate_next_block(&dfvk, AddressType::DefaultExternal, value);
// Scan the cache
let summary = st.scan_cached_blocks(h1, 1);
assert_eq!(summary.scanned_range().start, h1);
assert_eq!(summary.scanned_range().end, h1 + 1);
assert_eq!(T::received_note_count(&summary), 1);
// Account balance should reflect the received note
assert_eq!(st.get_total_balance(account.account_id()), value);
// Create a second fake CompactBlock sending more value to the address
let value2 = NonNegativeAmount::const_from_u64(7);
let (h2, _, _) = st.generate_next_block(&dfvk, AddressType::DefaultExternal, value2);
// Scan the cache again
let summary = st.scan_cached_blocks(h2, 1);
assert_eq!(summary.scanned_range().start, h2);
assert_eq!(summary.scanned_range().end, h2 + 1);
assert_eq!(T::received_note_count(&summary), 1);
// Account balance should reflect both received notes
assert_eq!(
st.get_total_balance(account.account_id()),
(value + value2).unwrap()
);
}
// TODO: This test can probably be entirely removed, as the following test duplicates it entirely.
pub(crate) fn scan_cached_blocks_finds_change_notes<T: ShieldedPoolTester>() {
let mut st = TestBuilder::new()
.with_block_cache()
.with_account_from_sapling_activation(BlockHash([0; 32]))
.build();
let account = st.test_account().cloned().unwrap();
let dfvk = T::test_account_fvk(&st);
// Wallet summary is not yet available
assert_eq!(st.get_wallet_summary(0), None);
// Create a fake CompactBlock sending value to the address
let value = NonNegativeAmount::const_from_u64(5);
let (received_height, _, nf) =
st.generate_next_block(&dfvk, AddressType::DefaultExternal, value);
// Scan the cache
st.scan_cached_blocks(received_height, 1);
// Account balance should reflect the received note
assert_eq!(st.get_total_balance(account.account_id()), value);
// Create a second fake CompactBlock spending value from the address
let not_our_key = T::sk_to_fvk(&T::sk(&[0xf5; 32]));
let to2 = T::fvk_default_address(&not_our_key);
let value2 = NonNegativeAmount::const_from_u64(2);
let (spent_height, _) = st.generate_next_block_spending(&dfvk, (nf, value), to2, value2);
// Scan the cache again
st.scan_cached_blocks(spent_height, 1);
// Account balance should equal the change
assert_eq!(
st.get_total_balance(account.account_id()),
(value - value2).unwrap()
);
}
pub(crate) fn scan_cached_blocks_detects_spends_out_of_order<T: ShieldedPoolTester>() {
let mut st = TestBuilder::new()
.with_block_cache()
.with_account_from_sapling_activation(BlockHash([0; 32]))
.build();
let account = st.test_account().cloned().unwrap();
let dfvk = T::test_account_fvk(&st);
// Wallet summary is not yet available
assert_eq!(st.get_wallet_summary(0), None);
// Create a fake CompactBlock sending value to the address
let value = NonNegativeAmount::const_from_u64(5);
let (received_height, _, nf) =
st.generate_next_block(&dfvk, AddressType::DefaultExternal, value);
// Create a second fake CompactBlock spending value from the address
let not_our_key = T::sk_to_fvk(&T::sk(&[0xf5; 32]));
let to2 = T::fvk_default_address(&not_our_key);
let value2 = NonNegativeAmount::const_from_u64(2);
let (spent_height, _) = st.generate_next_block_spending(&dfvk, (nf, value), to2, value2);
// Scan the spending block first.
st.scan_cached_blocks(spent_height, 1);
// Account balance should equal the change
assert_eq!(
st.get_total_balance(account.account_id()),
(value - value2).unwrap()
);
// Now scan the block in which we received the note that was spent.
st.scan_cached_blocks(received_height, 1);
// Account balance should be the same.
assert_eq!(
st.get_total_balance(account.account_id()),
(value - value2).unwrap()
);
}
Reference in New Issue View Git Blame Copy Permalink