vacp2p/status-rln-prover
1
0
Fork 0
mirror of https://github.com/vacp2p/status-rln-prover.git synced 2026-01-08 21:18:05 -05:00
Code Issues Packages Projects Releases Wiki Activity

Various clippy fixes (#26)

Browse Source
This commit is contained in:
Sydhds
2025-08-13 14:53:35 +02:00
committed by GitHub
parent 802872e155
commit dc9d7947b3
5 changed files with 47 additions and 64 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
prover/src/grpc_service.rs
View File

@@ -1,3 +1,5 @@
#![allow(clippy::type_complexity)]
// std
use std::net::SocketAddr;
use std::sync::Arc;

16
prover/src/tier.rs
View File

@@ -52,16 +52,16 @@ impl TierLimits {
.0
.iter()
.try_fold(Context::default(), |mut state, tier| {
if let Some(prev_min) = state.prev_min {
if tier.min_karma <= *prev_min {
return Err(ValidateTierLimitsError::InvalidMinKarmaAmount);
}
if let Some(prev_min) = state.prev_min
&& tier.min_karma <= *prev_min
{
return Err(ValidateTierLimitsError::InvalidMinKarmaAmount);
}
if let Some(prev_max) = state.prev_max {
if tier.min_karma <= *prev_max {
return Err(ValidateTierLimitsError::InvalidMinKarmaAmount);
}
if let Some(prev_max) = state.prev_max
&& tier.min_karma <= *prev_max
{
return Err(ValidateTierLimitsError::InvalidMinKarmaAmount);
}
if tier.min_karma >= tier.max_karma {

22
smart_contract/src/karma_sc_test.rs
View File

@@ -34,23 +34,20 @@ async fn main() -> Result<(), KarmaScError> {
println!("Connecting to RPC: {}", args.rpc_url);
let karma_contract_addr = Address::from_str(&args.karma_contract_address).map_err(|e| {
KarmaScError::SignerConnectionError(format!("Invalid karma contract address: {}", e))
KarmaScError::SignerConnectionError(format!("Invalid karma contract address: {e}"))
})?;
let account_addr = Address::from_str(&args.test_account).map_err(|e| {
KarmaScError::SignerConnectionError(format!("Invalid account address: {}", e))
KarmaScError::SignerConnectionError(format!("Invalid account address: {e}"))
})?;
let url = Url::parse(&args.rpc_url)
.map_err(|e| KarmaScError::SignerConnectionError(format!("Invalid URL: {}", e)))?;
.map_err(|e| KarmaScError::SignerConnectionError(format!("Invalid URL: {e}")))?;
// Connect to Karma contract
let karma_contract = KarmaSC::KarmaSCInstance::try_new(url, karma_contract_addr).await?;
println!(
"Successfully connected to Karma contract at {}",
karma_contract_addr
);
println!("Successfully connected to Karma contract at {karma_contract_addr}",);
println!("\nTesting Contract Functions:");
println!("=====================================");
@@ -61,28 +58,27 @@ async fn main() -> Result<(), KarmaScError> {
// Test 1: Get account balance (karma_amount test)
match karma_contract.balanceOf(account_addr).call().await {
Ok(balance) => {
println!("Account {} balance: {} KARMA", account_addr, balance);
println!("Account {account_addr} balance: {balance} KARMA");
// Additional test to verify karma_amount matches balanceOf
match smart_contract::KarmaAmountExt::karma_amount(&karma_contract, &account_addr).await
{
Ok(karma_amount) => {
if balance == karma_amount {
println!("✓ karma_amount matches balanceOf: {}", karma_amount);
println!("✓ karma_amount matches balanceOf: {karma_amount}");
} else {
println!(
"✗ karma_amount mismatch! balanceOf: {}, karma_amount: {}",
balance, karma_amount
"✗ karma_amount mismatch! balanceOf: {balance}, karma_amount: {karma_amount}"
);
}
}
Err(e) => {
eprintln!("Failed to get karma_amount: {}", e);
eprintln!("Failed to get karma_amount: {e}");
}
}
}
Err(e) => {
eprintln!("Failed to get balance: {}", e);
eprintln!("Failed to get balance: {e}");
}
}

33
smart_contract/src/karma_tiers_test.rs
View File

@@ -37,11 +37,11 @@ async fn main() -> Result<(), KarmaTiersError> {
println!("Connecting to RPC: {}", args.ws_rpc_url);
let contract_addr = Address::from_str(&args.contract_address).map_err(|e| {
KarmaTiersError::SignerConnectionError(format!("Invalid contract address: {}", e))
KarmaTiersError::SignerConnectionError(format!("Invalid contract address: {e}"))
})?;
let url = Url::parse(&args.ws_rpc_url)
.map_err(|e| KarmaTiersError::SignerConnectionError(format!("Invalid URL: {}", e)))?;
.map_err(|e| KarmaTiersError::SignerConnectionError(format!("Invalid URL: {e}")))?;
if args.private_key.is_empty() {
return Err(KarmaTiersError::EmptyPrivateKey);
@@ -55,10 +55,7 @@ async fn main() -> Result<(), KarmaTiersError> {
)
.await?;
println!(
"Successfully connected to KarmaTiers contract for reading at {}",
contract_addr
);
println!("Successfully connected to KarmaTiers contract for reading at {contract_addr}",);
println!("\nChecking Current Contract State:");
println!("=====================================");
@@ -70,9 +67,9 @@ async fn main() -> Result<(), KarmaTiersError> {
) {
(Ok(tier_count), Ok(max_length)) => {
let is_empty = tier_count == U256::ZERO;
println!("Current tier count: {}", tier_count);
println!("Maximum tier name length: {}", max_length);
println!("Contract is empty: {}", is_empty);
println!("Current tier count: {tier_count}");
println!("Maximum tier name length: {max_length}");
println!("Contract is empty: {is_empty}");
(tier_count, is_empty)
}
@@ -170,9 +167,9 @@ async fn main() -> Result<(), KarmaTiersError> {
println!("Tier update transaction failed");
}
}
Err(e) => eprintln!("Failed to get receipt: {}", e),
Err(e) => eprintln!("Failed to get receipt: {e}"),
},
Err(e) => eprintln!("Failed to send tier update transaction: {}", e),
Err(e) => eprintln!("Failed to send tier update transaction: {e}"),
}
}
@@ -182,7 +179,7 @@ async fn main() -> Result<(), KarmaTiersError> {
match karma_tiers_contract.getTierCount().call().await {
Ok(new_tier_count) => {
println!("New tier count: {}", new_tier_count);
println!("New tier count: {new_tier_count}");
if new_tier_count > U256::ZERO {
println!("\nUpdated tiers in contract:");
@@ -201,7 +198,7 @@ async fn main() -> Result<(), KarmaTiersError> {
}
}
Err(e) => {
eprintln!("Failed to get new tier count: {}", e);
eprintln!("Failed to get new tier count: {e}");
}
}
@@ -216,16 +213,10 @@ async fn main() -> Result<(), KarmaTiersError> {
.await
{
Ok(_tier) => {
println!(
"Unexpectedly found a tier for invalid tier ID {}",
invalid_tier_id
);
println!("Unexpectedly found a tier for invalid tier ID: {invalid_tier_id}",);
}
Err(e) => {
println!(
"Expected error for invalid tier ID {}: {}",
invalid_tier_id, e
);
println!("Expected error for invalid tier ID {invalid_tier_id}: {e}",);
}
}

38
smart_contract/src/rln_sc_test.rs
View File

@@ -50,10 +50,10 @@ async fn main() -> Result<(), RlnScError> {
let test_identity_commitment = U256::from(args.test_identity_commitment);
let test_user_address = Address::from_str(&args.test_user_address)
.map_err(|e| RlnScError::SignerConnectionError(format!("Invalid user address: {}", e)))?;
.map_err(|e| RlnScError::SignerConnectionError(format!("Invalid user address: {e}")))?;
let url = Url::parse(&args.ws_rpc_url)
.map_err(|e| RlnScError::SignerConnectionError(format!("Invalid URL: {}", e)))?;
.map_err(|e| RlnScError::SignerConnectionError(format!("Invalid URL: {e}")))?;
if args.private_key.is_empty() {
return Err(RlnScError::EmptyPrivateKey);
@@ -64,10 +64,7 @@ async fn main() -> Result<(), RlnScError> {
KarmaRLNSC::KarmaRLNSCInstance::try_new_with_signer(url, contract_addr, args.private_key)
.await?;
println!(
"Successfully connected to RLN contract with signer at {}",
contract_addr
);
println!("Successfully connected to RLN contract with signer at {contract_addr}",);
println!("\nTesting RLN Contract Functions:");
println!("=====================================");
@@ -106,11 +103,11 @@ async fn main() -> Result<(), RlnScError> {
println!(" User address: {}", member.userAddress);
println!(" Index: {}", member.index);
} else {
println!("Member {} is not registered", test_identity_commitment);
println!("Member {test_identity_commitment} is not registered");
}
}
Err(e) => {
eprintln!("Failed to check member status: {}", e);
eprintln!("Failed to check member status: {e}");
}
}
@@ -141,12 +138,9 @@ async fn main() -> Result<(), RlnScError> {
.await
{
Ok(can_register) => {
println!(
"Account {} can register: {}",
test_user_address, can_register
);
println!("Account {test_user_address} can register: {can_register}",);
}
Err(e) => eprintln!("Failed to check register permission: {}", e),
Err(e) => eprintln!("Failed to check register permission: {e}"),
}
match rln_contract
@@ -155,9 +149,9 @@ async fn main() -> Result<(), RlnScError> {
.await
{
Ok(can_slash) => {
println!("Account {} can slash: {}", test_user_address, can_slash);
println!("Account {test_user_address} can slash: {can_slash}");
}
Err(e) => eprintln!("Failed to check slash permission: {}", e),
Err(e) => eprintln!("Failed to check slash permission: {e}"),
}
}
_ => {
@@ -170,8 +164,8 @@ async fn main() -> Result<(), RlnScError> {
Ok(member) => {
if member.userAddress == Address::ZERO {
println!("Attempting to register new member...");
println!(" Identity commitment: {}", test_identity_commitment);
println!(" User address: {}", test_user_address);
println!(" Identity commitment: {test_identity_commitment}");
println!(" User address: {test_user_address}");
// Test 6: Register new member using the register function
match rln_contract
@@ -196,29 +190,29 @@ async fn main() -> Result<(), RlnScError> {
}
}
Err(e) => {
eprintln!("Failed to verify registration: {}", e);
eprintln!("Failed to verify registration: {e}");
}
}
}
Err(e) => {
eprintln!("Failed to wait for transaction: {}", e);
eprintln!("Failed to wait for transaction: {e}");
return Err(RlnScError::PendingTransactionError(e));
}
}
}
Err(e) => {
eprintln!("Failed to register member: {}", e);
eprintln!("Failed to register member: {e}");
return Err(RlnScError::Alloy(e));
}
}
} else {
println!("Member {} already registered:", test_identity_commitment);
println!("Member {test_identity_commitment} already registered:");
println!(" User: {}", member.userAddress);
println!(" Index: {}", member.index);
}
}
Err(e) => {
eprintln!("Failed to check if member exists: {}", e);
eprintln!("Failed to check if member exists: {e}");
return Err(RlnScError::Alloy(e));
}
}