Skip to content

Commit ff2f7a8

Browse files
dkijaniadkijania
committed
cargo clippy
1 parent 4c996e2 commit ff2f7a8

File tree

24 files changed

+547
-274
lines changed

24 files changed

+547
-274
lines changed

‎src/vit-testing/integration-tests/src/common/snapshot/mock.rs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
1-
use assert_fs::fixture::PathChild;
21
use crate::common::get_available_port;
32
use crate::common::snapshot::SnapshotServiceStarter;
3+
use assert_fs::fixture::PathChild;
44
use assert_fs::TempDir;
55
use mainnet_lib::{DbSyncError, InMemoryDbSync};
66
use snapshot_trigger_service::client::SnapshotResult;
@@ -13,7 +13,7 @@ pub fn do_snapshot(
1313
job_parameters: JobParameters,
1414
testing_directory: &TempDir,
1515
) -> Result<SnapshotResult, Error> {
16-
let mock_json_file = testing_directory.child("database.json");
16+
let mock_json_file = testing_directory.child("database.json");
1717
db_sync_instance.persist(mock_json_file.path())?;
1818

1919
let params = VotingToolsParams {

‎src/vit-testing/integration-tests/src/integration/from_snapshot_to_vitup.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
use crate::common::snapshot::mock;
2-
use crate::common::{CardanoWallet, SnapshotFilter, RepsVoterAssignerSource};
2+
use crate::common::{CardanoWallet, RepsVoterAssignerSource, SnapshotFilter};
33
use assert_fs::TempDir;
44
use chain_impl_mockchain::certificate::VotePlan;
55
use fraction::Fraction;

‎src/vit-testing/mainnet-lib/src/blockfrost/mod.rs‎

Lines changed: 64 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -1,64 +1,101 @@
1-
use blockfrost::{load, BlockFrostApi, BlockFrostSettings, AddressTransaction};
2-
use cardano_serialization_lib::address::Address;
3-
use cardano_serialization_lib::metadata::{GeneralTransactionMetadata, MetadataJsonSchema};
41
use crate::wallet::GeneralTransactionMetadataInfo;
52
use crate::{REGISTRATION_METADATA_IDX, REGISTRATION_SIGNATURE_METADATA_IDX};
3+
use blockfrost::{load, AddressTransaction, BlockFrostApi, BlockFrostSettings};
4+
use cardano_serialization_lib::address::Address;
5+
use cardano_serialization_lib::metadata::{GeneralTransactionMetadata, MetadataJsonSchema};
66

77
/// Wrapper on Blockfrost api tailored for catalyst needs
8-
pub struct CatalystBlockFrostApi{
9-
api: BlockFrostApi
8+
pub struct CatalystBlockFrostApi {
9+
api: BlockFrostApi,
1010
}
1111

1212
impl CatalystBlockFrostApi {
1313
/// build blockfrost sdk
14+
///
15+
/// # Errors
16+
///
17+
/// On blockfrost related error
18+
///
19+
/// # Panics
20+
///
21+
/// On internal blockfrost configuration error
1422
pub fn new() -> Result<CatalystBlockFrostApi, Error> {
1523
let configurations = load::configurations_from_env()?;
1624
let project_id = configurations["project_id"].as_str().unwrap();
1725
let settings = BlockFrostSettings::new().use_testnet();
18-
Ok(
19-
Self {
20-
api: BlockFrostApi::new(project_id, settings)
21-
}
22-
)
26+
Ok(Self {
27+
api: BlockFrostApi::new(project_id, settings),
28+
})
2329
}
2430

25-
pub async fn get_stake(&self,address: &Address) -> Result<u64,Error> {
31+
/// Gets funds for given address
32+
///
33+
/// # Errors
34+
///
35+
/// On internal blockfrost error
36+
///
37+
/// # Panics
38+
///
39+
/// On blockfrost wrong internal ada representation
40+
pub async fn get_stake(&self, address: &Address) -> Result<u64, Error> {
2641
let address = self.api.accounts(&address.to_hex()).await?;
2742
//we trust blockfrost API
2843
Ok(address.controlled_amount.parse().unwrap())
2944
}
3045

31-
async fn get_registration_tx(&self,tx: &AddressTransaction) -> Result<Option<GeneralTransactionMetadata>,Error> {
46+
async fn get_registration_tx(
47+
&self,
48+
tx: &AddressTransaction,
49+
) -> Result<Option<GeneralTransactionMetadata>, Error> {
3250
let metadata = self.api.transactions_metadata(&tx.tx_hash).await?;
3351

34-
let registration_part = metadata.iter().find(|x| x.label == REGISTRATION_METADATA_IDX.to_string());
35-
let signature_part = metadata.iter().find(|x| x.label == REGISTRATION_SIGNATURE_METADATA_IDX.to_string());
52+
let registration_part = metadata
53+
.iter()
54+
.find(|x| x.label == REGISTRATION_METADATA_IDX.to_string());
55+
let signature_part = metadata
56+
.iter()
57+
.find(|x| x.label == REGISTRATION_SIGNATURE_METADATA_IDX.to_string());
3658

37-
Ok(if let (Some(registration), Some(signature)) = (registration_part, signature_part) {
38-
Some(GeneralTransactionMetadata::from_jsons(registration.clone().json_metadata,signature.clone().json_metadata, MetadataJsonSchema::BasicConversions)?)
39-
}
40-
else {
41-
None
42-
})
59+
Ok(
60+
if let (Some(registration), Some(signature)) = (registration_part, signature_part) {
61+
Some(GeneralTransactionMetadata::from_jsons(
62+
registration.clone().json_metadata,
63+
signature.clone().json_metadata,
64+
MetadataJsonSchema::BasicConversions,
65+
)?)
66+
} else {
67+
None
68+
},
69+
)
4370
}
4471

4572
/// Retrieve all registration metadata for address
46-
pub async fn list_registrations_for_address(&self, address: impl Into<String>) -> Result<Vec<GeneralTransactionMetadata>,Error> {
73+
///
74+
/// # Errors
75+
///
76+
/// On internal blockfrost api error
77+
pub async fn list_registrations_for_address(
78+
&self,
79+
address: impl Into<String>,
80+
) -> Result<Vec<GeneralTransactionMetadata>, Error> {
4781
let txs = self.api.addresses_transactions(&address.into()).await?;
4882
let mut output = vec![];
4983
for tx in txs {
50-
if let Some(metadata) = self.get_registration_tx(&tx).await? {
51-
output.push(metadata);
52-
}
84+
if let Some(metadata) = self.get_registration_tx(&tx).await? {
85+
output.push(metadata);
86+
}
5387
}
5488
Ok(output)
5589
}
5690
}
5791

58-
#[derive(thiserror::Error,Debug)]
59-
pub enum Error{
92+
/// Blockfrost api related Error
93+
#[derive(thiserror::Error, Debug)]
94+
pub enum Error {
95+
/// General blockfrost api error
6096
#[error("blockfrost")]
6197
Blockfrost(#[from] blockfrost::Error),
98+
/// Json conversion error
6299
#[error("blockfrost")]
63100
JsonConversion(#[from] crate::JsonConversionError),
64-
}
101+
}

‎src/vit-testing/mainnet-lib/src/cardano_node/block.rs‎

Lines changed: 81 additions & 38 deletions
Original file line numberDiff line numberDiff line change
@@ -1,74 +1,117 @@
1-
use cardano_serialization_lib::{AuxiliaryDataSet, Block, Header, HeaderBody, OperationalCert, ProtocolVersion, Transaction, TransactionBodies, TransactionWitnessSets};
1+
use crate::Settings;
2+
use cardano_serialization_lib::crypto::{
3+
BlockHash, Ed25519Signature, KESSignature, KESVKey, PrivateKey, VRFCert, VRFVKey, Vkey,
4+
};
25
use cardano_serialization_lib::metadata::AuxiliaryData;
3-
use cardano_serialization_lib::crypto::{BlockHash, Ed25519Signature, KESSignature, KESVKey, PrivateKey, Vkey, VRFCert, VRFVKey};
46
use cardano_serialization_lib::utils::BigNum;
5-
use crate::Settings;
6-
7-
8-
pub struct Block0{
7+
use cardano_serialization_lib::{
8+
AuxiliaryDataSet, Block, Header, HeaderBody, OperationalCert, ProtocolVersion, Transaction,
9+
TransactionBodies, TransactionWitnessSets,
10+
};
11+
12+
/// Block0 representation
13+
pub struct Block0 {
14+
/// Block containing transactions
915
pub block: Block,
10-
pub settings: Settings
16+
/// Consensus settings
17+
pub settings: Settings,
1118
}
1219

13-
1420
impl Default for Block0 {
1521
fn default() -> Self {
1622
Self {
17-
block: BlockBuilder::next_block(None,vec![]),
18-
settings: Default::default()
23+
block: BlockBuilder::next_block(None, &[]),
24+
settings: Settings::default(),
1925
}
2026
}
2127
}
2228

29+
/// Block builder responsible for building blocks
2330
pub struct BlockBuilder;
2431

2532
impl BlockBuilder {
26-
27-
pub fn next_block(prev: Option<&Block>, transactions: Vec<Transaction>) -> Block {
33+
/// Mint new block based on previous block and transactions
34+
///
35+
/// # Panics
36+
///
37+
/// On integer conversion
38+
#[must_use]
39+
pub fn next_block(prev: Option<&Block>, transactions: &[Transaction]) -> Block {
2840
let header_body = Self::block_header(
29-
prev.map(|b| b.header().header_body().block_number()).unwrap_or(1),
30-
prev.map(|b| b.header().header_body().block_body_hash())
41+
prev.map_or(1, |b| b.header().header_body().block_number()),
42+
prev.map(|b| b.header().header_body().block_body_hash()),
3143
);
3244

33-
let header = Header::new(&header_body,&Self::random_kes_signature());
45+
let header = Header::new(&header_body, &Self::random_kes_signature());
3446

35-
let bodies = transactions.iter().map(|x| x.body()).fold(TransactionBodies::new(),|mut acc,x| {
47+
let bodies = transactions.iter().map(Transaction::body).fold(
48+
TransactionBodies::new(),
49+
|mut acc, x| {
3650
acc.add(&x);
3751
acc
38-
});
52+
},
53+
);
3954

40-
let metadata = transactions.iter().filter_map(|x| x.auxiliary_data().map(|x| x.metadata())).enumerate().fold(AuxiliaryDataSet::new(),|mut acc,x| {
41-
let mut auxiliary_data = AuxiliaryData::new();
42-
if let Some(metadata) = &x.1 {
43-
auxiliary_data.set_metadata(metadata);
44-
}
45-
acc.insert(x.0 as u32, &auxiliary_data);
46-
acc
47-
});
55+
let metadata = transactions
56+
.iter()
57+
.filter_map(|x| x.auxiliary_data().map(|x| x.metadata()))
58+
.enumerate()
59+
.fold(AuxiliaryDataSet::new(), |mut acc, x| {
60+
let mut auxiliary_data = AuxiliaryData::new();
61+
if let Some(metadata) = &x.1 {
62+
auxiliary_data.set_metadata(metadata);
63+
}
64+
acc.insert(u32::try_from(x.0).unwrap(), &auxiliary_data);
65+
acc
66+
});
4867

49-
Block::new(&header,&bodies,&TransactionWitnessSets::new(), &metadata, vec![])
68+
Block::new(
69+
&header,
70+
&bodies,
71+
&TransactionWitnessSets::new(),
72+
&metadata,
73+
vec![],
74+
)
5075
}
5176

5277
fn random_kes_signature() -> KESSignature {
53-
KESSignature::from_bytes(Self::generate_random_bytes_of_len(KESSignature::BYTE_COUNT)).unwrap()
78+
KESSignature::from_bytes(Self::generate_random_bytes_of_len(KESSignature::BYTE_COUNT))
79+
.unwrap()
5480
}
5581

5682
fn generate_random_bytes_of_len(len: usize) -> Vec<u8> {
57-
(0..len).map(|_| { rand::random::<u8>() }).collect()
83+
(0..len).map(|_| rand::random::<u8>()).collect()
5884
}
5985

86+
/// Builds new block header based on block number and previous block hash
87+
///
88+
/// # Panics
89+
///
90+
/// On random bytes generation issue
91+
#[must_use]
6092
pub fn block_header(block_number: u32, prev_hash: Option<BlockHash>) -> HeaderBody {
6193
let issuer_vkey = PrivateKey::generate_ed25519extended().unwrap().to_public();
6294

63-
HeaderBody::new_headerbody(block_number,
64-
&BigNum::from(block_number),
65-
prev_hash,
66-
&Vkey::new(&issuer_vkey),
67-
&VRFVKey::from_bytes(Self::generate_random_bytes_of_len(32)).unwrap(),
68-
&VRFCert::new(Self::generate_random_bytes_of_len(32),Self::generate_random_bytes_of_len(VRFCert::PROOF_LEN)).unwrap(),
69-
0,
70-
&BlockHash::from_bytes(Self::generate_random_bytes_of_len(32)).unwrap(),
71-
&OperationalCert::new(&KESVKey::from_bytes(Self::generate_random_bytes_of_len(32)).unwrap(),0,0,&Ed25519Signature::from_bytes(Self::generate_random_bytes_of_len(64)).unwrap()), &ProtocolVersion::new(0,1))
72-
95+
HeaderBody::new_headerbody(
96+
block_number,
97+
&BigNum::from(block_number),
98+
prev_hash,
99+
&Vkey::new(&issuer_vkey),
100+
&VRFVKey::from_bytes(Self::generate_random_bytes_of_len(32)).unwrap(),
101+
&VRFCert::new(
102+
Self::generate_random_bytes_of_len(32),
103+
Self::generate_random_bytes_of_len(VRFCert::PROOF_LEN),
104+
)
105+
.unwrap(),
106+
0,
107+
&BlockHash::from_bytes(Self::generate_random_bytes_of_len(32)).unwrap(),
108+
&OperationalCert::new(
109+
&KESVKey::from_bytes(Self::generate_random_bytes_of_len(32)).unwrap(),
110+
0,
111+
0,
112+
&Ed25519Signature::from_bytes(Self::generate_random_bytes_of_len(64)).unwrap(),
113+
),
114+
&ProtocolVersion::new(0, 1),
115+
)
73116
}
74117
}

0 commit comments

Comments
 (0)