blockworks-foundation
/
solana-with-rpc-optimizations
mirror of https://github.com/blockworks-foundation/solana-with-rpc-optimizations.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

removes feature gate code separating durable nonce from blockhash domain (#26055)

This commit is contained in:
behzad nouri 2022-07-06 12:03:13 +00:00 committed by GitHub
parent d33c548660
commit 6f5857a5db
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
14 changed files with 220 additions and 523 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
account-decoder/src/parse_account_data.rs
View File

@ -145,10 +145,7 @@ mod test {
assert_eq!(parsed.program, "vote".to_string());
assert_eq!(parsed.space, VoteState::size_of() as u64);
let nonce_data = Versions::new(
State::Initialized(Data::default()),
true, // separate_domains
);
let nonce_data = Versions::new(State::Initialized(Data::default()));
let nonce_account_data = bincode::serialize(&nonce_data).unwrap();
let parsed = parse_account_data(
&account_pubkey,

5
account-decoder/src/parse_nonce.rs
View File

@ -57,10 +57,7 @@ mod test {
#[test]
fn test_parse_nonce() {
let nonce_data = Versions::new(
State::Initialized(Data::default()),
true, // separate_domains
);
let nonce_data = Versions::new(State::Initialized(Data::default()));
let nonce_account_data = bincode::serialize(&nonce_data).unwrap();
assert_eq!(
parse_nonce(&nonce_account_data).unwrap(),

68
cli/src/nonce.rs
View File

@ -1006,14 +1006,14 @@ mod tests {
#[test]
fn test_check_nonce_account() {
let durable_nonce =
DurableNonce::from_blockhash(&Hash::default(), /*separate_domains:*/ true);
let durable_nonce = DurableNonce::from_blockhash(&Hash::default());
let blockhash = *durable_nonce.as_hash();
let nonce_pubkey = solana_sdk::pubkey::new_rand();
let data = Versions::new(
State::Initialized(nonce::state::Data::new(nonce_pubkey, durable_nonce, 0)),
true, // separate_domains
);
let data = Versions::new(State::Initialized(nonce::state::Data::new(
nonce_pubkey,
durable_nonce,
0,
)));
let valid = Account::new_data(1, &data, &system_program::ID);
assert!(check_nonce_account(&valid.unwrap(), &nonce_pubkey, &blockhash).is_ok());
@ -1031,16 +1031,12 @@ mod tests {
assert_eq!(err, Error::InvalidAccountData,);
}
let invalid_durable_nonce =
DurableNonce::from_blockhash(&hash(b"invalid"), /*separate_domains:*/ true);
let data = Versions::new(
State::Initialized(nonce::state::Data::new(
nonce_pubkey,
invalid_durable_nonce,
0,
)),
true, // separate_domains
);
let invalid_durable_nonce = DurableNonce::from_blockhash(&hash(b"invalid"));
let data = Versions::new(State::Initialized(nonce::state::Data::new(
nonce_pubkey,
invalid_durable_nonce,
0,
)));
let invalid_hash = Account::new_data(1, &data, &system_program::ID).unwrap();
if let CliError::InvalidNonce(err) =
check_nonce_account(&invalid_hash, &nonce_pubkey, &blockhash).unwrap_err()
@ -1055,14 +1051,11 @@ mod tests {
}
let new_nonce_authority = solana_sdk::pubkey::new_rand();
let data = Versions::new(
State::Initialized(nonce::state::Data::new(
new_nonce_authority,
durable_nonce,
0,
)),
true, // separate_domains
);
let data = Versions::new(State::Initialized(nonce::state::Data::new(
new_nonce_authority,
durable_nonce,
0,
)));
let invalid_authority = Account::new_data(1, &data, &system_program::ID);
if let CliError::InvalidNonce(err) =
check_nonce_account(&invalid_authority.unwrap(), &nonce_pubkey, &blockhash).unwrap_err()
@ -1076,7 +1069,7 @@ mod tests {
);
}
let data = Versions::new(State::Uninitialized, /*separate_domains:*/ true);
let data = Versions::new(State::Uninitialized);
let invalid_state = Account::new_data(1, &data, &system_program::ID);
if let CliError::InvalidNonce(err) =
check_nonce_account(&invalid_state.unwrap(), &nonce_pubkey, &blockhash).unwrap_err()
@ -1087,8 +1080,7 @@ mod tests {
#[test]
fn test_account_identity_ok() {
let nonce_account =
nonce_account::create_account(1, /*separate_domains:*/ true).into_inner();
let nonce_account = nonce_account::create_account(1).into_inner();
assert_eq!(account_identity_ok(&nonce_account), Ok(()));
let system_account = Account::new(1, 0, &system_program::id());
@ -1107,18 +1099,13 @@ mod tests {
#[test]
fn test_state_from_account() {
let mut nonce_account =
nonce_account::create_account(1, /*separate_domains:*/ true).into_inner();
let mut nonce_account = nonce_account::create_account(1).into_inner();
assert_eq!(state_from_account(&nonce_account), Ok(State::Uninitialized));
let durable_nonce =
DurableNonce::from_blockhash(&Hash::new(&[42u8; 32]), /*separate_domains:*/ true);
let durable_nonce = DurableNonce::from_blockhash(&Hash::new(&[42u8; 32]));
let data = nonce::state::Data::new(Pubkey::new(&[1u8; 32]), durable_nonce, 42);
nonce_account
.set_state(&Versions::new(
State::Initialized(data.clone()),
true, // separate_domains
))
.set_state(&Versions::new(State::Initialized(data.clone())))
.unwrap();
assert_eq!(
state_from_account(&nonce_account),
@ -1134,8 +1121,7 @@ mod tests {
#[test]
fn test_data_from_helpers() {
let mut nonce_account =
nonce_account::create_account(1, /*separate_domains:*/ true).into_inner();
let mut nonce_account = nonce_account::create_account(1).into_inner();
let state = state_from_account(&nonce_account).unwrap();
assert_eq!(
data_from_state(&state),
@ -1146,14 +1132,10 @@ mod tests {
Err(Error::InvalidStateForOperation)
);
let durable_nonce =
DurableNonce::from_blockhash(&Hash::new(&[42u8; 32]), /*separate_domains:*/ true);
let durable_nonce = DurableNonce::from_blockhash(&Hash::new(&[42u8; 32]));
let data = nonce::state::Data::new(Pubkey::new(&[1u8; 32]), durable_nonce, 42);
nonce_account
.set_state(&Versions::new(
State::Initialized(data.clone()),
true, // separate_domains
))
.set_state(&Versions::new(State::Initialized(data.clone())))
.unwrap();
let state = state_from_account(&nonce_account).unwrap();
assert_eq!(data_from_state(&state), Ok(&data));

8
client/src/blockhash_query.rs
View File

@ -416,8 +416,7 @@ mod tests {
.get_blockhash_and_fee_calculator(&rpc_client, CommitmentConfig::default())
.is_err());
let durable_nonce =
DurableNonce::from_blockhash(&Hash::new(&[2u8; 32]), /*separate_domains:*/ true);
let durable_nonce = DurableNonce::from_blockhash(&Hash::new(&[2u8; 32]));
let nonce_blockhash = *durable_nonce.as_hash();
let nonce_fee_calc = FeeCalculator::new(4242);
let data = nonce::state::Data {
@ -427,10 +426,7 @@ mod tests {
};
let nonce_account = Account::new_data_with_space(
42,
&nonce::state::Versions::new(
nonce::State::Initialized(data),
true, // separate_domains
),
&nonce::state::Versions::new(nonce::State::Initialized(data)),
nonce::State::size(),
&system_program::id(),
)

9
rpc/src/rpc.rs
View File

@ -5582,10 +5582,11 @@ pub mod tests {
let authority = Pubkey::new_unique();
let account = AccountSharedData::new_data(
42,
&nonce::state::Versions::new(
nonce::State::new_initialized(&authority, DurableNonce::default(), 1000),
true, // separate_domains
),
&nonce::state::Versions::new(nonce::State::new_initialized(
&authority,
DurableNonce::default(),
1000,
)),
&system_program::id(),
)
.unwrap();

13
rpc/src/transaction_status_service.rs
View File

@ -347,16 +347,13 @@ pub(crate) mod tests {
let expected_transaction = transaction.clone();
let pubkey = Pubkey::new_unique();
let mut nonce_account =
nonce_account::create_account(1, /*separate_domains:*/ true).into_inner();
let durable_nonce =
DurableNonce::from_blockhash(&Hash::new(&[42u8; 32]), /*separate_domains:*/ true);
let mut nonce_account = nonce_account::create_account(1).into_inner();
let durable_nonce = DurableNonce::from_blockhash(&Hash::new(&[42u8; 32]));
let data = nonce::state::Data::new(Pubkey::new(&[1u8; 32]), durable_nonce, 42);
nonce_account
.set_state(&nonce::state::Versions::new(
nonce::State::Initialized(data),
true, // separate_domains
))
.set_state(&nonce::state::Versions::new(nonce::State::Initialized(
data,
)))
.unwrap();
let message = build_message();

145
runtime/src/accounts.rs
View File

@ -1191,7 +1191,7 @@ impl Accounts {
res: &'a [TransactionExecutionResult],
loaded: &'a mut [TransactionLoadResult],
rent_collector: &RentCollector,
durable_nonce: &(DurableNonce, /*separate_domains:*/ bool),
durable_nonce: &DurableNonce,
lamports_per_signature: u64,
leave_nonce_on_success: bool,
) {
@ -1227,7 +1227,7 @@ impl Accounts {
execution_results: &'a [TransactionExecutionResult],
load_results: &'a mut [TransactionLoadResult],
rent_collector: &RentCollector,
durable_nonce: &(DurableNonce, /*separate_domains:*/ bool),
durable_nonce: &DurableNonce,
lamports_per_signature: u64,
leave_nonce_on_success: bool,
) -> (
@ -1319,7 +1319,7 @@ fn prepare_if_nonce_account<'a>(
execution_result: &Result<()>,
is_fee_payer: bool,
maybe_nonce: Option<(&'a NonceFull, bool)>,
&(durable_nonce, separate_domains): &(DurableNonce, bool),
&durable_nonce: &DurableNonce,
lamports_per_signature: u64,
) -> bool {
if let Some((nonce, rollback)) = maybe_nonce {
@ -1345,7 +1345,7 @@ fn prepare_if_nonce_account<'a>(
durable_nonce,
lamports_per_signature,
);
let nonce_versions = NonceVersions::new(nonce_state, separate_domains);
let nonce_versions = NonceVersions::new(nonce_state);
account.set_state(&nonce_versions).unwrap();
}
true
@ -1728,10 +1728,7 @@ mod tests {
nonce.pubkey(),
AccountSharedData::new_data(
min_balance + lamports_per_signature,
&NonceVersions::new(
NonceState::Initialized(nonce::state::Data::default()),
true, // separate_domains
),
&NonceVersions::new(NonceState::Initialized(nonce::state::Data::default())),
&system_program::id(),
)
.unwrap(),
@ -3038,7 +3035,7 @@ mod tests {
&execution_results,
loaded.as_mut_slice(),
&rent_collector,
&(DurableNonce::default(), /*separate_domains:*/ true),
&DurableNonce::default(),
0,
true, // leave_nonce_on_success
);
@ -3192,24 +3189,20 @@ mod tests {
Pubkey,
AccountSharedData,
AccountSharedData,
(DurableNonce, /*separate_domains:*/ bool),
DurableNonce,
u64,
Option<AccountSharedData>,
) {
let data = NonceVersions::new(
NonceState::Initialized(nonce::state::Data::default()),
true, // separate_domains
);
let data = NonceVersions::new(NonceState::Initialized(nonce::state::Data::default()));
let account = AccountSharedData::new_data(42, &data, &system_program::id()).unwrap();
let mut pre_account = account.clone();
pre_account.set_lamports(43);
let durable_nonce =
DurableNonce::from_blockhash(&Hash::new(&[1u8; 32]), /*separate_domains:*/ true);
let durable_nonce = DurableNonce::from_blockhash(&Hash::new(&[1u8; 32]));
(
Pubkey::default(),
pre_account,
account,
(durable_nonce, /*separate_domains:*/ true),
durable_nonce,
1234,
None,
)
@ -3221,7 +3214,7 @@ mod tests {
tx_result: &Result<()>,
is_fee_payer: bool,
maybe_nonce: Option<(&NonceFull, bool)>,
durable_nonce: &(DurableNonce, /*separate_domains:*/ bool),
durable_nonce: &DurableNonce,
lamports_per_signature: u64,
expect_account: &AccountSharedData,
) -> bool {
@ -3267,14 +3260,9 @@ mod tests {
let mut expect_account = pre_account;
expect_account
.set_state(&NonceVersions::new(
NonceState::Initialized(nonce::state::Data::new(
Pubkey::default(),
blockhash.0,
lamports_per_signature,
)),
true, // separate_domains
))
.set_state(&NonceVersions::new(NonceState::Initialized(
nonce::state::Data::new(Pubkey::default(), blockhash, lamports_per_signature),
)))
.unwrap();
assert!(run_prepare_if_nonce_account_test(
@ -3358,14 +3346,9 @@ mod tests {
let nonce = NonceFull::new(pre_account_address, pre_account, maybe_fee_payer_account);
expect_account
.set_state(&NonceVersions::new(
NonceState::Initialized(nonce::state::Data::new(
Pubkey::default(),
blockhash.0,
lamports_per_signature,
)),
true, // separate_domains
))
.set_state(&NonceVersions::new(NonceState::Initialized(
nonce::state::Data::new(Pubkey::default(), blockhash, lamports_per_signature),
)))
.unwrap();
assert!(run_prepare_if_nonce_account_test(
@ -3405,7 +3388,7 @@ mod tests {
)),
false,
Some((&nonce, true)),
&(DurableNonce::default(), /*separate_domains:*/ true),
&DurableNonce::default(),
1,
&post_fee_payer_account.clone(),
));
@ -3416,7 +3399,7 @@ mod tests {
&Ok(()),
true,
Some((&nonce, true)),
&(DurableNonce::default(), /*separate_domains:*/ true),
&DurableNonce::default(),
1,
&post_fee_payer_account.clone(),
));
@ -3430,7 +3413,7 @@ mod tests {
)),
true,
None,
&(DurableNonce::default(), /*separate_domains:*/ true),
&DurableNonce::default(),
1,
&post_fee_payer_account.clone(),
));
@ -3444,7 +3427,7 @@ mod tests {
)),
true,
Some((&nonce, true)),
&(DurableNonce::default(), /*separate_domains:*/ true),
&DurableNonce::default(),
1,
&pre_fee_payer_account,
));
@ -3459,16 +3442,12 @@ mod tests {
let from = keypair_from_seed(&[1; 32]).unwrap();
let from_address = from.pubkey();
let to_address = Pubkey::new_unique();
let durable_nonce =
DurableNonce::from_blockhash(&Hash::new_unique(), /*separate_domains:*/ true);
let nonce_state = NonceVersions::new(
NonceState::Initialized(nonce::state::Data::new(
nonce_authority.pubkey(),
durable_nonce,
0,
)),
true, // separate_domains
);
let durable_nonce = DurableNonce::from_blockhash(&Hash::new_unique());
let nonce_state = NonceVersions::new(NonceState::Initialized(nonce::state::Data::new(
nonce_authority.pubkey(),
durable_nonce,
0,
)));
let nonce_account_post =
AccountSharedData::new_data(43, &nonce_state, &system_program::id()).unwrap();
let from_account_post = AccountSharedData::new(4199, 0, &Pubkey::default());
@ -3491,16 +3470,12 @@ mod tests {
];
let tx = new_sanitized_tx(&[&nonce_authority, &from], message, blockhash);
let durable_nonce =
DurableNonce::from_blockhash(&Hash::new_unique(), /*separate_domains:*/ true);
let nonce_state = NonceVersions::new(
NonceState::Initialized(nonce::state::Data::new(
nonce_authority.pubkey(),
durable_nonce,
0,
)),
true, // separate_domains
);
let durable_nonce = DurableNonce::from_blockhash(&Hash::new_unique());
let nonce_state = NonceVersions::new(NonceState::Initialized(nonce::state::Data::new(
nonce_authority.pubkey(),
durable_nonce,
0,
)));
let nonce_account_pre =
AccountSharedData::new_data(42, &nonce_state, &system_program::id()).unwrap();
let from_account_pre = AccountSharedData::new(4242, 0, &Pubkey::default());
@ -3523,8 +3498,7 @@ mod tests {
let mut loaded = vec![loaded];
let durable_nonce =
DurableNonce::from_blockhash(&Hash::new_unique(), /*separate_domains:*/ true);
let durable_nonce = DurableNonce::from_blockhash(&Hash::new_unique());
let accounts = Accounts::new_with_config_for_tests(
Vec::new(),
&ClusterType::Development,
@ -3545,7 +3519,7 @@ mod tests {
&execution_results,
loaded.as_mut_slice(),
&rent_collector,
&(durable_nonce, /*separate_domains:*/ true),
&durable_nonce,
0,
true, // leave_nonce_on_success
);
@ -3570,11 +3544,7 @@ mod tests {
nonce_account_pre.lamports(),
);
assert_matches!(
nonce_account::verify_nonce_account(
&collected_nonce_account,
durable_nonce.as_hash(),
true, // separate_domins
),
nonce_account::verify_nonce_account(&collected_nonce_account, durable_nonce.as_hash()),
Some(_)
);
}
@ -3588,16 +3558,12 @@ mod tests {
let from = keypair_from_seed(&[1; 32]).unwrap();
let from_address = from.pubkey();
let to_address = Pubkey::new_unique();
let durable_nonce =
DurableNonce::from_blockhash(&Hash::new_unique(), /*separate_domains:*/ true);
let nonce_state = NonceVersions::new(
NonceState::Initialized(nonce::state::Data::new(
nonce_authority.pubkey(),
durable_nonce,
0,
)),
true, // separate_domains
);
let durable_nonce = DurableNonce::from_blockhash(&Hash::new_unique());
let nonce_state = NonceVersions::new(NonceState::Initialized(nonce::state::Data::new(
nonce_authority.pubkey(),
durable_nonce,
0,
)));
let nonce_account_post =
AccountSharedData::new_data(43, &nonce_state, &system_program::id()).unwrap();
let from_account_post = AccountSharedData::new(4200, 0, &Pubkey::default());
@ -3620,16 +3586,12 @@ mod tests {
];
let tx = new_sanitized_tx(&[&nonce_authority, &from], message, blockhash);
let durable_nonce =
DurableNonce::from_blockhash(&Hash::new_unique(), /*separate_domains:*/ true);
let nonce_state = NonceVersions::new(
NonceState::Initialized(nonce::state::Data::new(
nonce_authority.pubkey(),
durable_nonce,
0,
)),
true, // separate_domains
);
let durable_nonce = DurableNonce::from_blockhash(&Hash::new_unique());
let nonce_state = NonceVersions::new(NonceState::Initialized(nonce::state::Data::new(
nonce_authority.pubkey(),
durable_nonce,
0,
)));
let nonce_account_pre =
AccountSharedData::new_data(42, &nonce_state, &system_program::id()).unwrap();
@ -3651,8 +3613,7 @@ mod tests {
let mut loaded = vec![loaded];
let durable_nonce =
DurableNonce::from_blockhash(&Hash::new_unique(), /*separate_domains:*/ true);
let durable_nonce = DurableNonce::from_blockhash(&Hash::new_unique());
let accounts = Accounts::new_with_config_for_tests(
Vec::new(),
&ClusterType::Development,
@ -3673,7 +3634,7 @@ mod tests {
&execution_results,
loaded.as_mut_slice(),
&rent_collector,
&(durable_nonce, /*separate_domains:*/ true),
&durable_nonce,
0,
true, // leave_nonce_on_success
);
@ -3689,11 +3650,7 @@ mod tests {
nonce_account_pre.lamports()
);
assert_matches!(
nonce_account::verify_nonce_account(
&collected_nonce_account,
durable_nonce.as_hash(),
true, // separate_domins
),
nonce_account::verify_nonce_account(&collected_nonce_account, durable_nonce.as_hash()),
Some(_)
);
}

77
runtime/src/bank.rs
View File

@ -4061,11 +4061,6 @@ impl Bank {
self.rc.accounts.accounts_db.set_shrink_paths(paths);
}
pub fn separate_nonce_from_blockhash(&self) -> bool {
self.feature_set
.is_active(&feature_set::separate_nonce_from_blockhash::id())
}
fn check_age<'a>(
&self,
txs: impl Iterator<Item = &'a SanitizedTransaction>,
@ -4073,15 +4068,12 @@ impl Bank {
max_age: usize,
error_counters: &mut TransactionErrorMetrics,
) -> Vec<TransactionCheckResult> {
let separate_nonce_from_blockhash = self.separate_nonce_from_blockhash();
let enable_durable_nonce = separate_nonce_from_blockhash
&& self
.feature_set
.is_active(&feature_set::enable_durable_nonce::id());
let enable_durable_nonce = self
.feature_set
.is_active(&feature_set::enable_durable_nonce::id());
let hash_queue = self.blockhash_queue.read().unwrap();
let last_blockhash = hash_queue.last_hash();
let next_durable_nonce =
DurableNonce::from_blockhash(&last_blockhash, separate_nonce_from_blockhash);
let next_durable_nonce = DurableNonce::from_blockhash(&last_blockhash);
txs.zip(lock_results)
.map(|(tx, lock_res)| match lock_res {
@ -4155,11 +4147,8 @@ impl Bank {
let nonce_address =
message.get_durable_nonce(self.feature_set.is_active(&nonce_must_be_writable::id()))?;
let nonce_account = self.get_account_with_fixed_root(nonce_address)?;
let nonce_data = nonce_account::verify_nonce_account(
&nonce_account,
message.recent_blockhash(),
self.separate_nonce_from_blockhash(),
)?;
let nonce_data =
nonce_account::verify_nonce_account(&nonce_account, message.recent_blockhash())?;
if self
.feature_set
@ -4946,12 +4935,7 @@ impl Bank {
}
let mut write_time = Measure::start("write_time");
let durable_nonce = {
let separate_nonce_from_blockhash = self.separate_nonce_from_blockhash();
let durable_nonce =
DurableNonce::from_blockhash(&last_blockhash, separate_nonce_from_blockhash);
(durable_nonce, separate_nonce_from_blockhash)
};
let durable_nonce = DurableNonce::from_blockhash(&last_blockhash);
self.rc.accounts.store_cached(
self.slot(),
sanitized_txs,
@ -7893,18 +7877,14 @@ pub(crate) mod tests {
let from_address = from.pubkey();
let to_address = Pubkey::new_unique();
let durable_nonce =
DurableNonce::from_blockhash(&Hash::new_unique(), /*separate_domains:*/ true);
let durable_nonce = DurableNonce::from_blockhash(&Hash::new_unique());
let nonce_account = AccountSharedData::new_data(
43,
&nonce::state::Versions::new(
nonce::State::Initialized(nonce::state::Data::new(
Pubkey::default(),
durable_nonce,
lamports_per_signature,
)),
true, // separate_domains
),
&nonce::state::Versions::new(nonce::State::Initialized(nonce::state::Data::new(
Pubkey::default(),
durable_nonce,
lamports_per_signature,
))),
&system_program::id(),
)
.unwrap();
@ -10516,10 +10496,7 @@ pub(crate) mod tests {
let nonce = Keypair::new();
let nonce_account = AccountSharedData::new_data(
min_balance + 42,
&nonce::state::Versions::new(
nonce::State::Initialized(nonce::state::Data::default()),
true, // separate_domains
),
&nonce::state::Versions::new(nonce::State::Initialized(nonce::state::Data::default())),
&system_program::id(),
)
.unwrap();
@ -12844,12 +12821,9 @@ pub(crate) mod tests {
impl Bank {
fn next_durable_nonce(&self) -> DurableNonce {
let separate_nonce_from_blockhash = self
.feature_set
.is_active(&feature_set::separate_nonce_from_blockhash::id());
let hash_queue = self.blockhash_queue.read().unwrap();
let last_blockhash = hash_queue.last_hash();
DurableNonce::from_blockhash(&last_blockhash, separate_nonce_from_blockhash)
DurableNonce::from_blockhash(&last_blockhash)
}
}
@ -13029,10 +13003,7 @@ pub(crate) mod tests {
let nonce = Keypair::new();
let nonce_account = AccountSharedData::new_data(
42_424_242,
&nonce::state::Versions::new(
nonce::State::Initialized(nonce::state::Data::default()),
true, // separate_domains
),
&nonce::state::Versions::new(nonce::State::Initialized(nonce::state::Data::default())),
&system_program::id(),
)
.unwrap();
@ -13058,18 +13029,14 @@ pub(crate) mod tests {
let bank = Arc::new(bank);
let nonce_keypair = Keypair::new();
let nonce_authority = nonce_keypair.pubkey();
let durable_nonce =
DurableNonce::from_blockhash(&bank.last_blockhash(), true /* separate domains */);
let durable_nonce = DurableNonce::from_blockhash(&bank.last_blockhash());
let nonce_account = AccountSharedData::new_data(
42_424_242,
&nonce::state::Versions::new(
nonce::State::Initialized(nonce::state::Data::new(
nonce_authority,
durable_nonce,
5000,
)),
true, // separate_domains
),
&nonce::state::Versions::new(nonce::State::Initialized(nonce::state::Data::new(
nonce_authority,
durable_nonce,
5000,
))),
&system_program::id(),
)
.unwrap();

54
runtime/src/nonce_keyed_account.rs
View File

@ -16,15 +16,6 @@ use {
std::collections::HashSet,
};
fn get_durable_nonce(invoke_context: &InvokeContext) -> (DurableNonce, /*separate_domains:*/ bool) {
let separate_nonce_from_blockhash = invoke_context
.feature_set
.is_active(&feature_set::separate_nonce_from_blockhash::id());
let durable_nonce =
DurableNonce::from_blockhash(&invoke_context.blockhash, separate_nonce_from_blockhash);
(durable_nonce, separate_nonce_from_blockhash)
}
pub fn advance_nonce_account(
account: &mut BorrowedAccount,
signers: &HashSet<Pubkey>,
@ -58,7 +49,7 @@ pub fn advance_nonce_account(
);
return Err(InstructionError::MissingRequiredSignature);
}
let (next_durable_nonce, separate_domains) = get_durable_nonce(invoke_context);
let next_durable_nonce = DurableNonce::from_blockhash(&invoke_context.blockhash);
if data.durable_nonce == next_durable_nonce {
ic_msg!(
invoke_context,
@ -75,10 +66,7 @@ pub fn advance_nonce_account(
next_durable_nonce,
invoke_context.lamports_per_signature,
);
account.set_state(&Versions::new(
State::Initialized(new_data),
separate_domains,
))
account.set_state(&Versions::new(State::Initialized(new_data)))
}
State::Uninitialized => {
ic_msg!(
@ -139,7 +127,7 @@ pub fn withdraw_nonce_account(
}
State::Initialized(ref data) => {
if lamports == from.get_lamports() {
let (durable_nonce, separate_domains) = get_durable_nonce(invoke_context);
let durable_nonce = DurableNonce::from_blockhash(&invoke_context.blockhash);
if data.durable_nonce == durable_nonce {
ic_msg!(
invoke_context,
@ -150,7 +138,7 @@ pub fn withdraw_nonce_account(
merge_nonce_error_into_system_error,
));
}
from.set_state(&Versions::new(State::Uninitialized, separate_domains))?;
from.set_state(&Versions::new(State::Uninitialized))?;
} else {
let min_balance = rent.minimum_balance(from.get_data().len());
let amount = checked_add(lamports, min_balance)?;
@ -221,14 +209,14 @@ pub fn initialize_nonce_account(
);
return Err(InstructionError::InsufficientFunds);
}
let (durable_nonce, separate_domains) = get_durable_nonce(invoke_context);
let durable_nonce = DurableNonce::from_blockhash(&invoke_context.blockhash);
let data = nonce::state::Data::new(
*nonce_authority,
durable_nonce,
invoke_context.lamports_per_signature,
);
let state = State::Initialized(data);
account.set_state(&Versions::new(state, separate_domains))
account.set_state(&Versions::new(state))
}
State::Initialized(_) => {
ic_msg!(
@ -335,12 +323,9 @@ mod test {
let accounts = vec![
(
Pubkey::new_unique(),
create_account(from_lamports, /*separate_domains:*/ true).into_inner(),
),
(
Pubkey::new_unique(),
create_account(42, /*separate_domains:*/ true).into_inner(),
create_account(from_lamports).into_inner(),
),
(Pubkey::new_unique(), create_account(42).into_inner()),
(system_program::id(), AccountSharedData::default()),
];
let $instruction_accounts = vec![
@ -403,7 +388,7 @@ mod test {
let versions = nonce_account.get_state::<Versions>().unwrap();
let data = nonce::state::Data::new(
data.authority,
get_durable_nonce(&invoke_context).0,
DurableNonce::from_blockhash(&invoke_context.blockhash),
invoke_context.lamports_per_signature,
);
// First nonce instruction drives state from Uninitialized to Initialized
@ -413,7 +398,7 @@ mod test {
let versions = nonce_account.get_state::<Versions>().unwrap();
let data = nonce::state::Data::new(
data.authority,
get_durable_nonce(&invoke_context).0,
DurableNonce::from_blockhash(&invoke_context.blockhash),
invoke_context.lamports_per_signature,
);
// Second nonce instruction consumes and replaces stored nonce
@ -423,7 +408,7 @@ mod test {
let versions = nonce_account.get_state::<Versions>().unwrap();
let data = nonce::state::Data::new(
data.authority,
get_durable_nonce(&invoke_context).0,
DurableNonce::from_blockhash(&invoke_context.blockhash),
invoke_context.lamports_per_signature,
);
// Third nonce instruction for fun and profit
@ -482,7 +467,7 @@ mod test {
let versions = nonce_account.get_state::<Versions>().unwrap();
let data = nonce::state::Data::new(
authority,
get_durable_nonce(&invoke_context).0,
DurableNonce::from_blockhash(&invoke_context.blockhash),
invoke_context.lamports_per_signature,
);
assert_eq!(versions.state(), &State::Initialized(data));
@ -794,7 +779,7 @@ mod test {
let versions = nonce_account.get_state::<Versions>().unwrap();
let data = nonce::state::Data::new(
authority,
get_durable_nonce(&invoke_context).0,
DurableNonce::from_blockhash(&invoke_context.blockhash),
invoke_context.lamports_per_signature,
);
assert_eq!(versions.state(), &State::Initialized(data.clone()));
@ -823,7 +808,7 @@ mod test {
let versions = nonce_account.get_state::<Versions>().unwrap();
let data = nonce::state::Data::new(
data.authority,
get_durable_nonce(&invoke_context).0,
DurableNonce::from_blockhash(&invoke_context.blockhash),
invoke_context.lamports_per_signature,
);
assert_eq!(versions.state(), &State::Initialized(data));
@ -1015,7 +1000,7 @@ mod test {
initialize_nonce_account(&mut nonce_account, &authorized, &rent, &invoke_context);
let data = nonce::state::Data::new(
authorized,
get_durable_nonce(&invoke_context).0,
DurableNonce::from_blockhash(&invoke_context.blockhash),
invoke_context.lamports_per_signature,
);
assert_eq!(result, Ok(()));
@ -1084,7 +1069,7 @@ mod test {
let authority = Pubkey::default();
let data = nonce::state::Data::new(
authority,
get_durable_nonce(&invoke_context).0,
DurableNonce::from_blockhash(&invoke_context.blockhash),
invoke_context.lamports_per_signature,
);
authorize_nonce_account(&mut nonce_account, &authority, &signers, &invoke_context).unwrap();
@ -1164,8 +1149,7 @@ mod test {
.get_account_at_index(NONCE_ACCOUNT_INDEX)
.unwrap()
.borrow(),
get_durable_nonce(&invoke_context).0.as_hash(),
true, // separate_domins
DurableNonce::from_blockhash(&invoke_context.blockhash).as_hash(),
),
Some(_)
);
@ -1187,7 +1171,6 @@ mod test {
.unwrap()
.borrow(),
&Hash::default(),
true, // separate_domins
),
None
);
@ -1227,8 +1210,7 @@ mod test {
.get_account_at_index(NONCE_ACCOUNT_INDEX)
.unwrap()
.borrow(),
get_durable_nonce(&invoke_context).0.as_hash(),
true, // separate_domins
DurableNonce::from_blockhash(&invoke_context.blockhash).as_hash(),
),
None
);

63
runtime/src/system_instruction_processor.rs
View File

@ -488,12 +488,6 @@ pub fn process_instruction(
authorize_nonce_account(&mut me, &nonce_authority, &signers, invoke_context)
}
SystemInstruction::UpgradeNonceAccount => {
let separate_nonce_from_blockhash = invoke_context
.feature_set
.is_active(&feature_set::separate_nonce_from_blockhash::id());
if !separate_nonce_from_blockhash {
return Err(InstructionError::InvalidInstructionData);
}
instruction_context.check_number_of_instruction_accounts(1)?;
let mut nonce_account =
instruction_context.try_borrow_instruction_account(transaction_context, 0)?;
@ -1224,10 +1218,7 @@ mod tests {
let nonce = Pubkey::new_unique();
let nonce_account = AccountSharedData::new_data(
42,
&nonce::state::Versions::new(
nonce::State::Initialized(nonce::state::Data::default()),
true, // separate_domains
),
&nonce::state::Versions::new(nonce::State::Initialized(nonce::state::Data::default())),
&system_program::id(),
)
.unwrap();
@ -1516,13 +1507,10 @@ mod tests {
let from = Pubkey::new_unique();
let from_account = AccountSharedData::new_data(
100,
&nonce::state::Versions::new(
nonce::State::Initialized(nonce::state::Data {
authority: from,
..nonce::state::Data::default()
}),
true, // separate_domains
),
&nonce::state::Versions::new(nonce::State::Initialized(nonce::state::Data {
authority: from,
..nonce::state::Data::default()
})),
&system_program::id(),
)
.unwrap();
@ -1819,8 +1807,7 @@ mod tests {
#[test]
fn test_process_nonce_ix_ok() {
let nonce_address = Pubkey::new_unique();
let nonce_account =
nonce_account::create_account(1_000_000, /*separate_domains:*/ true).into_inner();
let nonce_account = nonce_account::create_account(1_000_000).into_inner();
#[allow(deprecated)]
let blockhash_id = sysvar::recent_blockhashes::id();
let accounts = process_instruction(
@ -1927,8 +1914,7 @@ mod tests {
#[test]
fn test_process_withdraw_ix_ok() {
let nonce_address = Pubkey::new_unique();
let nonce_account =
nonce_account::create_account(1_000_000, /*separate_domains:*/ true).into_inner();
let nonce_account = nonce_account::create_account(1_000_000).into_inner();
let pubkey = Pubkey::new_unique();
#[allow(deprecated)]
let blockhash_id = sysvar::recent_blockhashes::id();
@ -1981,8 +1967,7 @@ mod tests {
#[test]
fn test_process_initialize_ix_only_nonce_acc_fail() {
let nonce_address = Pubkey::new_unique();
let nonce_account =
nonce_account::create_account(1_000_000, /*separate_domains:*/ true).into_inner();
let nonce_account = nonce_account::create_account(1_000_000).into_inner();
process_instruction(
&serialize(&SystemInstruction::InitializeNonceAccount(nonce_address)).unwrap(),
vec![(nonce_address, nonce_account)],
@ -1999,8 +1984,7 @@ mod tests {
#[test]
fn test_process_initialize_ix_ok() {
let nonce_address = Pubkey::new_unique();
let nonce_account =
nonce_account::create_account(1_000_000, /*separate_domains:*/ true).into_inner();
let nonce_account = nonce_account::create_account(1_000_000).into_inner();
#[allow(deprecated)]
let blockhash_id = sysvar::recent_blockhashes::id();
process_instruction(
@ -2035,8 +2019,7 @@ mod tests {
#[test]
fn test_process_authorize_ix_ok() {
let nonce_address = Pubkey::new_unique();
let nonce_account =
nonce_account::create_account(1_000_000, /*separate_domains:*/ true).into_inner();
let nonce_account = nonce_account::create_account(1_000_000).into_inner();
#[allow(deprecated)]
let blockhash_id = sysvar::recent_blockhashes::id();
let accounts = process_instruction(
@ -2105,10 +2088,7 @@ mod tests {
fn test_get_system_account_kind_nonce_ok() {
let nonce_account = AccountSharedData::new_data(
42,
&nonce::state::Versions::new(
nonce::State::Initialized(nonce::state::Data::default()),
true, // separate_domains
),
&nonce::state::Versions::new(nonce::State::Initialized(nonce::state::Data::default())),
&system_program::id(),
)
.unwrap();
@ -2121,9 +2101,7 @@ mod tests {
#[test]
fn test_get_system_account_kind_uninitialized_nonce_account_fail() {
assert_eq!(
get_system_account_kind(
&nonce_account::create_account(42, /*separate_domains:*/ true).borrow()
),
get_system_account_kind(&nonce_account::create_account(42).borrow()),
None
);
}
@ -2139,10 +2117,7 @@ mod tests {
fn test_get_system_account_kind_nonsystem_owner_with_nonce_data_fail() {
let nonce_account = AccountSharedData::new_data(
42,
&nonce::state::Versions::new(
nonce::State::Initialized(nonce::state::Data::default()),
true, // separate_domains
),
&nonce::state::Versions::new(nonce::State::Initialized(nonce::state::Data::default())),
&Pubkey::new_unique(),
)
.unwrap();
@ -2152,8 +2127,7 @@ mod tests {
#[test]
fn test_nonce_initialize_with_empty_recent_blockhashes_fail() {
let nonce_address = Pubkey::new_unique();
let nonce_account =
nonce_account::create_account(1_000_000, /*separate_domains:*/ true).into_inner();
let nonce_account = nonce_account::create_account(1_000_000).into_inner();
#[allow(deprecated)]
let blockhash_id = sysvar::recent_blockhashes::id();
#[allow(deprecated)]
@ -2193,8 +2167,7 @@ mod tests {
#[test]
fn test_nonce_advance_with_empty_recent_blockhashes_fail() {
let nonce_address = Pubkey::new_unique();
let nonce_account =
nonce_account::create_account(1_000_000, /*separate_domains:*/ true).into_inner();
let nonce_account = nonce_account::create_account(1_000_000).into_inner();
#[allow(deprecated)]
let blockhash_id = sysvar::recent_blockhashes::id();
let accounts = process_instruction(
@ -2328,8 +2301,7 @@ mod tests {
assert_eq!(accounts.len(), 1);
assert_eq!(accounts[0], nonce_account);
let blockhash = Hash::from([171; 32]);
let durable_nonce =
DurableNonce::from_blockhash(&blockhash, /*separate_domains:*/ false);
let durable_nonce = DurableNonce::from_blockhash(&blockhash);
let data = NonceData {
authority: Pubkey::new_unique(),
durable_nonce,
@ -2365,8 +2337,7 @@ mod tests {
);
assert_eq!(accounts.len(), 1);
let nonce_account = accounts.remove(0);
let durable_nonce =
DurableNonce::from_blockhash(&blockhash, /*separate_domains:*/ true);
let durable_nonce = DurableNonce::from_blockhash(durable_nonce.as_hash());
assert_ne!(data.durable_nonce, durable_nonce);
let data = NonceData {
durable_nonce,

13
sdk/program/src/nonce/state/current.rs
View File

@ -53,12 +53,8 @@ impl Data {
}
impl DurableNonce {
pub fn from_blockhash(blockhash: &Hash, separate_domains: bool) -> Self {
Self(if separate_domains {
hashv(&[DURABLE_NONCE_HASH_PREFIX, blockhash.as_ref()])
} else {
*blockhash
})
pub fn from_blockhash(blockhash: &Hash) -> Self {
Self(hashv(&[DURABLE_NONCE_HASH_PREFIX, blockhash.as_ref()]))
}
/// Hash value used as recent_blockhash field in Transactions.
@ -110,10 +106,7 @@ mod test {
#[test]
fn test_nonce_state_size() {
let data = Versions::new(
State::Initialized(Data::default()),
true, // separate_domains
);
let data = Versions::new(State::Initialized(Data::default()));
let size = bincode::serialized_size(&data).unwrap();
assert_eq!(State::size() as u64, size);
}

139
sdk/program/src/nonce/state/mod.rs
View File

@ -22,12 +22,8 @@ pub enum AuthorizeNonceError {
}
impl Versions {
pub fn new(state: State, separate_domains: bool) -> Self {
if separate_domains {
Self::Current(Box::new(state))
} else {
Self::Legacy(Box::new(state))
}
pub fn new(state: State) -> Self {
Self::Current(Box::new(state))
}
pub fn state(&self) -> &State {
@ -42,23 +38,17 @@ impl Versions {
pub fn verify_recent_blockhash(
&self,
recent_blockhash: &Hash, // Transaction.message.recent_blockhash
separate_domains: bool,
) -> Option<&Data> {
let state = match self {
Self::Legacy(state) => {
if separate_domains {
// Legacy durable nonces are invalid and should not
// allow durable transactions.
return None;
} else {
state
match self {
// Legacy durable nonces are invalid and should not
// allow durable transactions.
Self::Legacy(_) => None,
Self::Current(state) => match **state {
State::Uninitialized => None,
State::Initialized(ref data) => {
(recent_blockhash == &data.blockhash()).then(|| data)
}
}
Self::Current(state) => state,
};
match **state {
State::Uninitialized => None,
State::Initialized(ref data) => (recent_blockhash == &data.blockhash()).then(|| data),
},
}
}
@ -73,10 +63,7 @@ impl Versions {
// upgrade Uninitialized legacy nonces.
State::Uninitialized => None,
State::Initialized(ref mut data) => {
data.durable_nonce = DurableNonce::from_blockhash(
&data.blockhash(),
true, // separate_domains
);
data.durable_nonce = DurableNonce::from_blockhash(&data.blockhash());
Some(Self::Current(state))
}
}
@ -136,29 +123,12 @@ mod tests {
fn test_verify_recent_blockhash() {
let blockhash = Hash::from([171; 32]);
let versions = Versions::Legacy(Box::new(State::Uninitialized));
for separate_domains in [false, true] {
assert_eq!(
versions.verify_recent_blockhash(&blockhash, separate_domains),
None
);
assert_eq!(
versions.verify_recent_blockhash(&Hash::default(), separate_domains),
None
);
}
assert_eq!(versions.verify_recent_blockhash(&blockhash), None);
assert_eq!(versions.verify_recent_blockhash(&Hash::default()), None);
let versions = Versions::Current(Box::new(State::Uninitialized));
for separate_domains in [false, true] {
assert_eq!(
versions.verify_recent_blockhash(&blockhash, separate_domains),
None
);
assert_eq!(
versions.verify_recent_blockhash(&Hash::default(), separate_domains),
None
);
}
let durable_nonce =
DurableNonce::from_blockhash(&blockhash, /*separate_domains:*/ false);
assert_eq!(versions.verify_recent_blockhash(&blockhash), None);
assert_eq!(versions.verify_recent_blockhash(&Hash::default()), None);
let durable_nonce = DurableNonce::from_blockhash(&blockhash);
let data = Data {
authority: Pubkey::new_unique(),
durable_nonce,
@ -167,66 +137,30 @@ mod tests {
},
};
let versions = Versions::Legacy(Box::new(State::Initialized(data.clone())));
let separate_domains = false;
assert_eq!(versions.verify_recent_blockhash(&Hash::default()), None);
assert_eq!(versions.verify_recent_blockhash(&blockhash), None);
assert_eq!(versions.verify_recent_blockhash(&data.blockhash()), None);
assert_eq!(
versions.verify_recent_blockhash(&Hash::default(), separate_domains),
versions.verify_recent_blockhash(durable_nonce.as_hash()),
None
);
assert_eq!(
versions.verify_recent_blockhash(&blockhash, separate_domains),
Some(&data)
);
assert_eq!(
versions.verify_recent_blockhash(&data.blockhash(), separate_domains),
Some(&data)
);
assert_eq!(
versions.verify_recent_blockhash(durable_nonce.as_hash(), separate_domains),
Some(&data)
);
let separate_domains = true;
assert_eq!(
versions.verify_recent_blockhash(&Hash::default(), separate_domains),
None
);
assert_eq!(
versions.verify_recent_blockhash(&blockhash, separate_domains),
None
);
assert_eq!(
versions.verify_recent_blockhash(&data.blockhash(), separate_domains),
None
);
assert_eq!(
versions.verify_recent_blockhash(durable_nonce.as_hash(), separate_domains),
None
);
let durable_nonce =
DurableNonce::from_blockhash(&blockhash, /*separate_domains:*/ true);
let durable_nonce = DurableNonce::from_blockhash(durable_nonce.as_hash());
assert_ne!(data.durable_nonce, durable_nonce);
let data = Data {
durable_nonce,
..data
};
let versions = Versions::Current(Box::new(State::Initialized(data.clone())));
for separate_domains in [false, true] {
assert_eq!(
versions.verify_recent_blockhash(&blockhash, separate_domains),
None
);
assert_eq!(
versions.verify_recent_blockhash(&Hash::default(), separate_domains),
None
);
assert_eq!(
versions.verify_recent_blockhash(&data.blockhash(), separate_domains),
Some(&data)
);
assert_eq!(
versions.verify_recent_blockhash(durable_nonce.as_hash(), separate_domains),
Some(&data)
);
}
assert_eq!(versions.verify_recent_blockhash(&blockhash), None);
assert_eq!(versions.verify_recent_blockhash(&Hash::default()), None);
assert_eq!(
versions.verify_recent_blockhash(&data.blockhash()),
Some(&data)
);
assert_eq!(
versions.verify_recent_blockhash(durable_nonce.as_hash()),
Some(&data)
);
}
#[test]
@ -236,8 +170,7 @@ mod tests {
assert_eq!(versions.upgrade(), None);
// Initialized
let blockhash = Hash::from([171; 32]);
let durable_nonce =
DurableNonce::from_blockhash(&blockhash, /*separate_domains:*/ false);
let durable_nonce = DurableNonce::from_blockhash(&blockhash);
let data = Data {
authority: Pubkey::new_unique(),
durable_nonce,
@ -246,8 +179,7 @@ mod tests {
},
};
let versions = Versions::Legacy(Box::new(State::Initialized(data.clone())));
let durable_nonce =
DurableNonce::from_blockhash(&blockhash, /*separate_domains:*/ true);
let durable_nonce = DurableNonce::from_blockhash(durable_nonce.as_hash());
assert_ne!(data.durable_nonce, durable_nonce);
let data = Data {
durable_nonce,
@ -277,8 +209,7 @@ mod tests {
);
// Initialized, Legacy
let blockhash = Hash::from([171; 32]);
let durable_nonce =
DurableNonce::from_blockhash(&blockhash, /*separate_domains:*/ false);
let durable_nonce = DurableNonce::from_blockhash(&blockhash);
let data = Data {
authority: Pubkey::new_unique(),
durable_nonce,

109
sdk/src/nonce_account.rs
View File

@ -11,11 +11,11 @@ use {
std::cell::RefCell,
};
pub fn create_account(lamports: u64, separate_domains: bool) -> RefCell<AccountSharedData> {
pub fn create_account(lamports: u64) -> RefCell<AccountSharedData> {
RefCell::new(
AccountSharedData::new_data_with_space(
lamports,
&Versions::new(State::Uninitialized, separate_domains),
&Versions::new(State::Uninitialized),
State::size(),
&crate::system_program::id(),
)
@ -28,13 +28,12 @@ pub fn create_account(lamports: u64, separate_domains: bool) -> RefCell<AccountS
pub fn verify_nonce_account(
account: &AccountSharedData,
recent_blockhash: &Hash, // Transaction.message.recent_blockhash
separate_domains: bool,
) -> Option<Data> {
(account.owner() == &crate::system_program::id())
.then(|| {
StateMut::<Versions>::state(account)
.ok()?
.verify_recent_blockhash(recent_blockhash, separate_domains)
.verify_recent_blockhash(recent_blockhash)
.cloned()
})
.flatten()
@ -65,17 +64,12 @@ mod tests {
assert_ne!(program_id, crate::system_program::id());
let account = AccountSharedData::new_data_with_space(
42,
&Versions::new(State::Uninitialized, /*separate_domains:*/ true),
&Versions::new(State::Uninitialized),
State::size(),
&program_id,
)
.expect("nonce_account");
for separate_domains in [false, true] {
assert_eq!(
verify_nonce_account(&account, &Hash::default(), separate_domains),
None
);
}
assert_eq!(verify_nonce_account(&account, &Hash::default()), None);
}
fn new_nonce_account(versions: Versions) -> AccountSharedData {
@ -92,30 +86,13 @@ mod tests {
let blockhash = Hash::from([171; 32]);
let versions = Versions::Legacy(Box::new(State::Uninitialized));
let account = new_nonce_account(versions);
for separate_domains in [false, true] {
assert_eq!(
verify_nonce_account(&account, &blockhash, separate_domains),
None
);
assert_eq!(
verify_nonce_account(&account, &Hash::default(), separate_domains),
None
);
}
assert_eq!(verify_nonce_account(&account, &blockhash), None);
assert_eq!(verify_nonce_account(&account, &Hash::default()), None);
let versions = Versions::Current(Box::new(State::Uninitialized));
let account = new_nonce_account(versions);
for separate_domains in [false, true] {
assert_eq!(
verify_nonce_account(&account, &blockhash, separate_domains),
None
);
assert_eq!(
verify_nonce_account(&account, &Hash::default(), separate_domains),
None
);
}
let durable_nonce =
DurableNonce::from_blockhash(&blockhash, /*separate_domains:*/ false);
assert_eq!(verify_nonce_account(&account, &blockhash), None);
assert_eq!(verify_nonce_account(&account, &Hash::default()), None);
let durable_nonce = DurableNonce::from_blockhash(&blockhash);
let data = Data {
authority: Pubkey::new_unique(),
durable_nonce,
@ -125,42 +102,14 @@ mod tests {
};
let versions = Versions::Legacy(Box::new(State::Initialized(data.clone())));
let account = new_nonce_account(versions);
let separate_domains = false;
assert_eq!(verify_nonce_account(&account, &blockhash), None);
assert_eq!(verify_nonce_account(&account, &Hash::default()), None);
assert_eq!(verify_nonce_account(&account, &data.blockhash()), None);
assert_eq!(
verify_nonce_account(&account, &blockhash, separate_domains),
Some(data.clone())
);
assert_eq!(
verify_nonce_account(&account, &Hash::default(), separate_domains),
verify_nonce_account(&account, durable_nonce.as_hash()),
None
);
assert_eq!(
verify_nonce_account(&account, &data.blockhash(), separate_domains),
Some(data.clone())
);
assert_eq!(
verify_nonce_account(&account, durable_nonce.as_hash(), separate_domains),
Some(data.clone())
);
let separate_domains = true;
assert_eq!(
verify_nonce_account(&account, &blockhash, separate_domains),
None
);
assert_eq!(
verify_nonce_account(&account, &Hash::default(), separate_domains),
None
);
assert_eq!(
verify_nonce_account(&account, &data.blockhash(), separate_domains),
None
);
assert_eq!(
verify_nonce_account(&account, durable_nonce.as_hash(), separate_domains),
None
);
let durable_nonce =
DurableNonce::from_blockhash(&blockhash, /*separate_domains:*/ true);
let durable_nonce = DurableNonce::from_blockhash(durable_nonce.as_hash());
assert_ne!(data.durable_nonce, durable_nonce);
let data = Data {
durable_nonce,
@ -168,23 +117,15 @@ mod tests {
};
let versions = Versions::Current(Box::new(State::Initialized(data.clone())));
let account = new_nonce_account(versions);
for separate_domains in [false, true] {
assert_eq!(
verify_nonce_account(&account, &blockhash, separate_domains),
None
);
assert_eq!(
verify_nonce_account(&account, &Hash::default(), separate_domains),
None
);
assert_eq!(
verify_nonce_account(&account, &data.blockhash(), separate_domains),
Some(data.clone())
);
assert_eq!(
verify_nonce_account(&account, durable_nonce.as_hash(), separate_domains),
Some(data.clone())
);
}
assert_eq!(verify_nonce_account(&account, &blockhash), None);
assert_eq!(verify_nonce_account(&account, &Hash::default()), None);
assert_eq!(
verify_nonce_account(&account, &data.blockhash()),
Some(data.clone())
);
assert_eq!(
verify_nonce_account(&account, durable_nonce.as_hash()),
Some(data)
);
}
}

35
send-transaction-service/src/send_transaction_service.rs
View File

@ -605,11 +605,8 @@ impl SendTransactionService {
.last_sent_time
.map(|last| now.duration_since(last) >= retry_rate)
.unwrap_or(false);
let verify_nonce_account = nonce_account::verify_nonce_account(
&nonce_account,
&durable_nonce,
working_bank.separate_nonce_from_blockhash(),
);
let verify_nonce_account =
nonce_account::verify_nonce_account(&nonce_account, &durable_nonce);
if verify_nonce_account.is_none() && signature_status.is_none() && expired {
info!("Dropping expired durable-nonce transaction: {}", signature);
result.expired += 1;
@ -1094,16 +1091,10 @@ mod test {
.unwrap();
let nonce_address = Pubkey::new_unique();
let durable_nonce =
DurableNonce::from_blockhash(&Hash::new_unique(), /*separate_domains:*/ true);
let nonce_state = nonce::state::Versions::new(
nonce::State::Initialized(nonce::state::Data::new(
Pubkey::default(),
durable_nonce,
42,
)),
true, // separate_domains
);
let durable_nonce = DurableNonce::from_blockhash(&Hash::new_unique());
let nonce_state = nonce::state::Versions::new(nonce::State::Initialized(
nonce::state::Data::new(Pubkey::default(), durable_nonce, 42),
));
let nonce_account =
AccountSharedData::new_data(43, &nonce_state, &system_program::id()).unwrap();
root_bank.store_account(&nonce_address, &nonce_account);
@ -1351,16 +1342,10 @@ mod test {
for mut transaction in transactions.values_mut() {
transaction.last_sent_time = Some(Instant::now().sub(Duration::from_millis(4000)));
}
let new_durable_nonce =
DurableNonce::from_blockhash(&Hash::new_unique(), /*separate_domains:*/ true);
let new_nonce_state = nonce::state::Versions::new(
nonce::State::Initialized(nonce::state::Data::new(
Pubkey::default(),
new_durable_nonce,
42,
)),
true, // separate_domains
);
let new_durable_nonce = DurableNonce::from_blockhash(&Hash::new_unique());
let new_nonce_state = nonce::state::Versions::new(nonce::State::Initialized(
nonce::state::Data::new(Pubkey::default(), new_durable_nonce, 42),
));
let nonce_account =
AccountSharedData::new_data(43, &new_nonce_state, &system_program::id()).unwrap();
working_bank.store_account(&nonce_address, &nonce_account);