mirror of
https://github.com/serai-dex/serai.git
synced 2025-12-08 12:19:24 +00:00
39ce819876
* add slash tx * ignore unsigned tx replays * verify that provided evidence is valid * fix clippy + fmt * move application tx handling to another module * partially handle the tendermint txs * fix pr comments * support unsigned app txs * add slash target to the votes * enforce provided, unsigned, signed tx ordering within a block * bug fixes * add unit test for tendermint txs * bug fixes * update tests for tendermint txs * add tx ordering test * tidy up tx ordering test * cargo +nightly fmt * Misc fixes from rebasing * Finish resolving clippy * Remove sha3 from tendermint-machine * Resolve a DoS in SlashEvidence's read Also moves Evidence from Vec<Message> to (Message, Option<Message>). That should meet all requirements while being a bit safer. * Make lazy_static a dev-depend for tributary * Various small tweaks One use of sort was inefficient, sorting unsigned || signed when unsigned was already properly sorted. Given how the unsigned TXs were given a nonce of 0, an unstable sort may swap places with an unsigned TX and a signed TX with a nonce of 0 (leading to a faulty block). The extra protection added here sorts signed, then concats. * Fix Tributary tests I broke, start review on tendermint/tx.rs * Finish reviewing everything outside tests and empty_signature * Remove empty_signature empty_signature led to corrupted local state histories. Unfortunately, the API is only sane with a signature. We now use the actual signature, which risks creating a signature over a malicious message if we have ever have an invariant producing malicious messages. Prior, we only signed the message after the local machine confirmed it was okay per the local view of consensus. This is tolerated/preferred over a corrupt state history since production of such messages is already an invariant. TODOs are added to make handling of this theoretical invariant further robust. * Remove async_sequential for tokio::test There was no competition for resources forcing them to be run sequentially. * Modify block order test to be statistically significant without multiple runs * Clean tests --------- Co-authored-by: Luke Parker <lukeparker5132@gmail.com>
57 lines
1.8 KiB
Rust
57 lines
1.8 KiB
Rust
use core::time::Duration;
|
|
|
|
use rand_core::{RngCore, OsRng};
|
|
|
|
use tokio::time::sleep;
|
|
|
|
use serai_db::MemDb;
|
|
|
|
use tributary::{
|
|
transaction::Transaction as TransactionTrait, Transaction as TributaryTransaction, Tributary,
|
|
};
|
|
|
|
use crate::{
|
|
tributary::Transaction,
|
|
tests::{
|
|
LocalP2p,
|
|
tributary::{new_keys, new_spec, new_tributaries, run_tributaries, wait_for_tx_inclusion},
|
|
},
|
|
};
|
|
|
|
#[tokio::test]
|
|
async fn tx_test() {
|
|
let keys = new_keys(&mut OsRng);
|
|
let spec = new_spec(&mut OsRng, &keys);
|
|
|
|
let tributaries = new_tributaries(&keys, &spec).await;
|
|
|
|
// Run the tributaries in the background
|
|
tokio::spawn(run_tributaries(tributaries.clone()));
|
|
|
|
// Send a TX from a random Tributary
|
|
let sender =
|
|
usize::try_from(OsRng.next_u64() % u64::try_from(tributaries.len()).unwrap()).unwrap();
|
|
let key = keys[sender].clone();
|
|
|
|
let attempt = 0;
|
|
let mut commitments = vec![0; 256];
|
|
OsRng.fill_bytes(&mut commitments);
|
|
|
|
// Create the TX with a null signature so we can get its sig hash
|
|
let block_before_tx = tributaries[sender].1.tip().await;
|
|
let mut tx =
|
|
Transaction::DkgCommitments(attempt, commitments.clone(), Transaction::empty_signed());
|
|
tx.sign(&mut OsRng, spec.genesis(), &key, 0);
|
|
|
|
assert!(tributaries[sender].1.add_transaction(tx.clone()).await);
|
|
let included_in = wait_for_tx_inclusion(&tributaries[sender].1, block_before_tx, tx.hash()).await;
|
|
// Also sleep for the block time to ensure the block is synced around before we run checks on it
|
|
sleep(Duration::from_secs(Tributary::<MemDb, Transaction, LocalP2p>::block_time().into())).await;
|
|
|
|
// All tributaries should have acknowledged this transaction in a block
|
|
for (_, tributary) in tributaries {
|
|
let block = tributary.reader().block(&included_in).unwrap();
|
|
assert_eq!(block.transactions, vec![TributaryTransaction::Application(tx.clone())]);
|
|
}
|
|
}
|