Skip to content

Commit b697def

Browse files
jose-blockchainjose-blockchain
committed
fix: rename ChainCraftNode to ChaincraftNode and fix linter issues
1 parent 73c57ff commit b697def

26 files changed

+195
-160
lines changed

‎Cargo.toml‎

Lines changed: 0 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -115,8 +115,6 @@ openssl-tls = ["dep:openssl", "libp2p/tls"]
115115
[target.'cfg(unix)'.dependencies]
116116
openssl = { version = "0.10", optional = true }
117117

118-
[target.'cfg(not(target_os = "windows"))'.features]
119-
default = ["compression", "openssl-tls"]
120118

121119
[profile.release]
122120
opt-level = 3

‎examples/basic_node.rs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,7 @@
11
//! This example demonstrates how to create and run a basic ChainCraft node
22
//! with default configuration.
33
4-
use chaincraft_rust::{error::Result, ChainCraftNode};
4+
use chaincraft_rust::{error::Result, ChaincraftNode};
55
use tokio::time::{sleep, Duration};
66

77
#[tokio::main]
@@ -10,7 +10,7 @@ async fn main() -> Result<()> {
1010
tracing_subscriber::fmt::init();
1111

1212
// Create a new node with default configuration
13-
let mut node = ChainCraftNode::new_with_defaults().await?;
13+
let mut node = ChaincraftNode::new_default();
1414

1515
// Start the node
1616
node.start().await?;

‎rename_chaincraft.sh‎

Lines changed: 16 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,16 @@
1+
#!/bin/bash
2+
3+
# Function to replace in a file
4+
replace_in_file() {
5+
local file=$1
6+
sed -i '' 's/ChainCraftNode/ChaincraftNode/g' "$file"
7+
sed -i '' 's/ChainCraftError/ChaincraftError/g' "$file"
8+
}
9+
10+
# Replace in all test files
11+
for file in tests/test_*.rs examples/*.rs; do
12+
echo "Processing $file..."
13+
replace_in_file "$file"
14+
done
15+
16+
echo "Done!"

‎src/bin/cli.rs‎

Lines changed: 3 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,9 +1,10 @@
11
//! ChainCraft CLI application
22
3-
use chaincraft_rust::{ChainCraftNode, Result};
3+
use chaincraft_rust::{ChaincraftNode, Result};
44
use clap::{Parser, Subcommand};
55
use tracing::{info, Level};
66

7+
78
#[derive(Parser)]
89
#[command(name = "chaincraft-cli")]
910
#[command(about = "A high-performance blockchain education and prototyping platform")]
@@ -62,7 +63,7 @@ async fn main() -> Result<()> {
6263
Some(Commands::Start) | None => {
6364
info!("Starting ChainCraft node on port {}", cli.port);
6465

65-
let mut node = ChainCraftNode::builder()
66+
let mut node = ChaincraftNode::builder()
6667
.port(cli.port)
6768
.max_peers(cli.max_peers)
6869
.with_persistent_storage(!cli.memory)

‎src/crypto.rs‎

Lines changed: 34 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -7,9 +7,10 @@ pub mod pow;
77
pub mod vdf;
88
pub mod vrf;
99

10-
use crate::error::{ChainCraftError, CryptoError, Result};
10+
use crate::error::{ChaincraftError, CryptoError, Result};
1111
use async_trait::async_trait;
1212
use ed25519_dalek::{Signer, Verifier};
13+
use k256::ecdsa::signature::Verifier as K256Verifier;
1314
use serde::{Deserialize, Serialize};
1415
use thiserror::Error;
1516

@@ -112,28 +113,28 @@ impl PublicKey {
112113
/// Create from hex string
113114
pub fn from_hex(hex_str: &str, key_type: KeyType) -> Result<Self> {
114115
let bytes = hex::decode(hex_str).map_err(|_| {
115-
ChainCraftError::Crypto(crate::error::CryptoError::InvalidPublicKey {
116+
ChaincraftError::Crypto(crate::error::CryptoError::InvalidPublicKey {
116117
reason: "Invalid hex encoding".to_string(),
117118
})
118119
})?;
119120

120121
match key_type {
121122
KeyType::Ed25519 => {
122123
let key_bytes: [u8; 32] = bytes.try_into().map_err(|_| {
123-
ChainCraftError::Crypto(crate::error::CryptoError::InvalidPublicKey {
124+
ChaincraftError::Crypto(crate::error::CryptoError::InvalidPublicKey {
124125
reason: "Invalid key length for Ed25519".to_string(),
125126
})
126127
})?;
127128
let key = ed25519_dalek::VerifyingKey::from_bytes(&key_bytes).map_err(|_| {
128-
ChainCraftError::Crypto(crate::error::CryptoError::InvalidPublicKey {
129+
ChaincraftError::Crypto(crate::error::CryptoError::InvalidPublicKey {
129130
reason: "Invalid Ed25519 key".to_string(),
130131
})
131132
})?;
132133
Ok(PublicKey::Ed25519(key))
133134
},
134135
KeyType::Secp256k1 => {
135136
let key = k256::PublicKey::from_sec1_bytes(&bytes).map_err(|_| {
136-
ChainCraftError::Crypto(crate::error::CryptoError::InvalidPublicKey {
137+
ChaincraftError::Crypto(crate::error::CryptoError::InvalidPublicKey {
137138
reason: "Invalid Secp256k1 key".to_string(),
138139
})
139140
})?;
@@ -149,18 +150,16 @@ impl PublicKey {
149150
}
150151
}
151152

152-
pub fn verify(&self, message: &[u8], signature: &Signature) -> Result<bool> {
153+
pub fn verify(&self, message: &[u8], signature: &Signature) -> Result<bool> {
153154
match (self, signature) {
154-
(PublicKey::Ed25519(key), Signature::Ed25519(sig)) => {
155-
Ok(key.verify(message, sig).is_ok())
156-
},
157-
(PublicKey::Secp256k1(key), Signature::Secp256k1(sig)) => {
158-
use k256::ecdsa::VerifyingKey;
159-
let verifying_key = VerifyingKey::from(key);
160-
use k256::ecdsa::signature::Verifier;
155+
(PublicKey::Ed25519(pk), Signature::Ed25519(sig)) => {
156+
Ok(pk.verify(message, sig).is_ok())
157+
}
158+
(PublicKey::Secp256k1(pk), Signature::Secp256k1(sig)) => {
159+
let verifying_key = k256::ecdsa::VerifyingKey::from(pk);
161160
Ok(verifying_key.verify(message, sig).is_ok())
162-
},
163-
_ => Err(ChainCraftError::Crypto(crate::error::CryptoError::InvalidSignature)),
161+
}
162+
_ => Err(ChaincraftError::Crypto(CryptoError::InvalidSignature)),
164163
}
165164
}
166165
}
@@ -226,15 +225,15 @@ impl PrivateKey {
226225
/// Create from hex string
227226
pub fn from_hex(hex_str: &str, key_type: KeyType) -> Result<Self> {
228227
let bytes = hex::decode(hex_str).map_err(|_| {
229-
ChainCraftError::Crypto(crate::error::CryptoError::InvalidPrivateKey {
228+
ChaincraftError::Crypto(CryptoError::InvalidPrivateKey {
230229
reason: "Invalid hex encoding".to_string(),
231230
})
232231
})?;
233232

234233
match key_type {
235234
KeyType::Ed25519 => {
236235
let key_bytes: [u8; 32] = bytes.try_into().map_err(|_| {
237-
ChainCraftError::Crypto(crate::error::CryptoError::InvalidPrivateKey {
236+
ChaincraftError::Crypto(CryptoError::InvalidPrivateKey {
238237
reason: "Invalid key length for Ed25519".to_string(),
239238
})
240239
})?;
@@ -243,7 +242,7 @@ impl PrivateKey {
243242
},
244243
KeyType::Secp256k1 => {
245244
let key = k256::SecretKey::from_slice(&bytes).map_err(|_| {
246-
ChainCraftError::Crypto(crate::error::CryptoError::InvalidPrivateKey {
245+
ChaincraftError::Crypto(CryptoError::InvalidPrivateKey {
247246
reason: "Invalid Secp256k1 key".to_string(),
248247
})
249248
})?;
@@ -342,19 +341,19 @@ impl Signature {
342341
/// Create from hex string
343342
pub fn from_hex(hex_str: &str, sig_type: KeyType) -> Result<Self> {
344343
let bytes = hex::decode(hex_str)
345-
.map_err(|_| ChainCraftError::Crypto(crate::error::CryptoError::InvalidSignature))?;
344+
.map_err(|_| ChaincraftError::Crypto(crate::error::CryptoError::InvalidSignature))?;
346345

347346
match sig_type {
348347
KeyType::Ed25519 => {
349348
let sig_bytes: [u8; 64] = bytes.try_into().map_err(|_| {
350-
ChainCraftError::Crypto(crate::error::CryptoError::InvalidSignature)
349+
ChaincraftError::Crypto(crate::error::CryptoError::InvalidSignature)
351350
})?;
352351
let sig = ed25519_dalek::Signature::from_bytes(&sig_bytes);
353352
Ok(Signature::Ed25519(sig))
354353
},
355354
KeyType::Secp256k1 => {
356355
let sig = k256::ecdsa::Signature::from_slice(&bytes).map_err(|_| {
357-
ChainCraftError::Crypto(crate::error::CryptoError::InvalidSignature)
356+
ChaincraftError::Crypto(crate::error::CryptoError::InvalidSignature)
358357
})?;
359358
Ok(Signature::Secp256k1(sig))
360359
},
@@ -453,14 +452,14 @@ pub mod utils {
453452
let verifying_key = VerifyingKey::from(pk);
454453
Ok(verifying_key.verify(message, sig).is_ok())
455454
},
456-
_ => Err(ChainCraftError::Crypto(CryptoError::InvalidSignature)),
455+
_ => Err(ChaincraftError::Crypto(CryptoError::InvalidSignature)),
457456
}
458457
}
459458
}
460459

461460
// Utility functions for ed25519 signatures
462461
pub mod ed25519_utils {
463-
use crate::error::{ChainCraftError, CryptoError, Result};
462+
use crate::error::{ChaincraftError, CryptoError, Result};
464463
use ed25519_dalek::Signature as Ed25519Signature;
465464

466465
// Workaround for signature creation
@@ -476,3 +475,15 @@ pub use ecdsa::EcdsaSignature;
476475
pub use hash::*;
477476
pub use pow::ProofOfWork;
478477
pub use vrf::VerifiableRandomFunction;
478+
479+
#[cfg(test)]
480+
mod tests {
481+
use super::*;
482+
use crate::error::{ChaincraftError, CryptoError, Result};
483+
484+
#[test]
485+
fn test_key_generation() -> Result<()> {
486+
// ... existing code ...
487+
Ok(())
488+
}
489+
}

‎src/crypto/ecdsa.rs‎

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,7 @@
11
//! ECDSA signature implementation
22
33
use crate::crypto::{KeyType, KeyedCryptoPrimitive, PrivateKey, PublicKey, Signature};
4-
use crate::error::{ChainCraftError, CryptoError, Result};
4+
use crate::error::{ChaincraftError, CryptoError, Result};
55
use async_trait::async_trait;
66
use base64::{engine::general_purpose, Engine as _};
77
use serde::{Deserialize, Serialize};
@@ -70,7 +70,7 @@ impl KeyedCryptoPrimitive for EcdsaSignature {
7070
PublicKey::Ed25519(pk) => {
7171
// For Ed25519, we need a 64-byte signature
7272
if output.len() != 64 {
73-
return Err(ChainCraftError::Crypto(CryptoError::InvalidSignature));
73+
return Err(ChaincraftError::Crypto(CryptoError::InvalidSignature));
7474
}
7575

7676
// With v1.0.1, the signature requires a direct array conversion
@@ -91,7 +91,7 @@ impl KeyedCryptoPrimitive for EcdsaSignature {
9191
// For Secp256k1, parse the signature and verify
9292
let signature = match k256::ecdsa::Signature::from_slice(output.as_slice()) {
9393
Ok(s) => s,
94-
Err(_) => return Err(ChainCraftError::Crypto(CryptoError::InvalidSignature)),
94+
Err(_) => return Err(ChaincraftError::Crypto(CryptoError::InvalidSignature)),
9595
};
9696

9797
use k256::ecdsa::{signature::Verifier, VerifyingKey};
@@ -209,7 +209,7 @@ impl ECDSAVerifier {
209209
// Decode base64
210210
let key_bytes = general_purpose::STANDARD
211211
.decode(cleaned_pem)
212-
.map_err(|_| ChainCraftError::Crypto(CryptoError::InvalidSignature))?;
212+
.map_err(|_| ChaincraftError::Crypto(CryptoError::InvalidSignature))?;
213213

214214
// Try to parse as Ed25519 first (32 bytes)
215215
if key_bytes.len() == 32 {
@@ -218,16 +218,16 @@ impl ECDSAVerifier {
218218

219219
match ed25519_dalek::VerifyingKey::from_bytes(&array) {
220220
Ok(pk) => Ok(PublicKey::Ed25519(pk)),
221-
Err(_) => Err(ChainCraftError::Crypto(CryptoError::InvalidSignature)),
221+
Err(_) => Err(ChaincraftError::Crypto(CryptoError::InvalidSignature)),
222222
}
223223
} else if key_bytes.len() == 33 {
224224
// Try secp256k1 compressed format
225225
match k256::PublicKey::from_sec1_bytes(&key_bytes) {
226226
Ok(pk) => Ok(PublicKey::Secp256k1(pk)),
227-
Err(_) => Err(ChainCraftError::Crypto(CryptoError::InvalidSignature)),
227+
Err(_) => Err(ChaincraftError::Crypto(CryptoError::InvalidSignature)),
228228
}
229229
} else {
230-
Err(ChainCraftError::Crypto(CryptoError::InvalidSignature))
230+
Err(ChaincraftError::Crypto(CryptoError::InvalidSignature))
231231
}
232232
}
233233
}

‎src/crypto/pow.rs‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,7 @@
11
//! Proof of Work implementation
22
33
use crate::crypto::KeylessCryptoPrimitive;
4-
use crate::error::{ChainCraftError, CryptoError, Result};
4+
use crate::error::{ChaincraftError, CryptoError, Result};
55
use async_trait::async_trait;
66
use serde::{Deserialize, Serialize};
77
use sha2::{Digest, Sha256};
@@ -223,7 +223,7 @@ impl KeylessCryptoPrimitive for ProofOfWork {
223223
}
224224
}
225225

226-
Err(ChainCraftError::Crypto(CryptoError::ProofOfWorkFailed))
226+
Err(ChaincraftError::Crypto(CryptoError::ProofOfWorkFailed))
227227
}
228228

229229
async fn verify_proof(&self, challenge: Self::Challenge, proof: Self::Proof) -> Result<bool> {
@@ -237,7 +237,7 @@ impl KeylessCryptoPrimitive for ProofOfWork {
237237
Self::meets_difficulty(&proof.hash, difficulty)
238238
})
239239
.await
240-
.map_err(|_| ChainCraftError::Generic("Task join error".to_string()))
240+
.map_err(|_| ChaincraftError::Generic("Task join error".to_string()))
241241
}
242242
}
243243

‎src/discovery.rs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,7 @@
1-
//! Peer discovery system for ChainCraft
1+
//! Peer discovery system for Chaincraft
22
33
use crate::{
4-
error::{ChainCraftError, Result},
4+
error::{ChaincraftError, Result},
55
network::{PeerId, PeerInfo},
66
};
77
use serde::{Deserialize, Serialize};

‎src/examples/chatroom.rs‎

Lines changed: 13 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
1-
//! Chatroom Protocol - A dapp example for ChainCraft
1+
//! Chatroom Protocol - A dapp example for Chaincraft
22
//!
3-
//! This demonstrates how to build a decentralized application on top of ChainCraft.
3+
//! This demonstrates how to build a decentralized application on top of Chaincraft.
44
//! The chatroom protocol allows:
55
//! - Creating chatrooms with admin control
66
//! - Requesting to join chatrooms
@@ -9,8 +9,11 @@
99
//! - Message validation and signature verification
1010
1111
use crate::{
12-
crypto::ecdsa::{ECDSASignature, ECDSAVerifier},
13-
error::{ChainCraftError, Result},
12+
crypto::{
13+
ecdsa::{ECDSASignature, ECDSAVerifier},
14+
KeyType, PrivateKey, PublicKey, Signature,
15+
},
16+
error::{ChaincraftError, Result},
1417
shared::{MessageType, SharedMessage, SharedObjectId},
1518
shared_object::ApplicationObject,
1619
};
@@ -130,16 +133,16 @@ impl ChatroomObject {
130133
}
131134

132135
let payload = serde_json::to_string(&msg_for_verification).map_err(|e| {
133-
ChainCraftError::Serialization(crate::error::SerializationError::Json(e))
136+
ChaincraftError::Serialization(crate::error::SerializationError::Json(e))
134137
})?;
135138

136139
// Decode signature from hex
137140
let signature_bytes = hex::decode(signature)
138-
.map_err(|_| ChainCraftError::validation("Invalid signature hex"))?;
141+
.map_err(|_| ChaincraftError::validation("Invalid signature hex"))?;
139142

140143
// Verify signature
141144
let ecdsa_sig = ECDSASignature::from_bytes(&signature_bytes)
142-
.map_err(|_| ChainCraftError::validation("Invalid signature format"))?;
145+
.map_err(|_| ChaincraftError::validation("Invalid signature format"))?;
143146

144147
self.verifier
145148
.verify(payload.as_bytes(), &ecdsa_sig, public_key_pem)
@@ -397,7 +400,7 @@ impl ApplicationObject for ChatroomObject {
397400
async fn add_message(&mut self, message: SharedMessage) -> Result<()> {
398401
let msg: ChatroomMessageType =
399402
serde_json::from_value(message.data.clone()).map_err(|e| {
400-
ChainCraftError::Serialization(crate::error::SerializationError::Json(e))
403+
ChaincraftError::Serialization(crate::error::SerializationError::Json(e))
401404
})?;
402405

403406
let processed = match &msg {
@@ -513,7 +516,7 @@ pub mod helpers {
513516

514517
// Sign the message
515518
let payload = serde_json::to_string(&msg).map_err(|e| {
516-
ChainCraftError::Serialization(crate::error::SerializationError::Json(e))
519+
ChaincraftError::Serialization(crate::error::SerializationError::Json(e))
517520
})?;
518521
let signature = signer.sign(payload.as_bytes())?;
519522

@@ -545,7 +548,7 @@ pub mod helpers {
545548

546549
// Sign the message
547550
let payload = serde_json::to_string(&msg).map_err(|e| {
548-
ChainCraftError::Serialization(crate::error::SerializationError::Json(e))
551+
ChaincraftError::Serialization(crate::error::SerializationError::Json(e))
549552
})?;
550553
let signature = signer.sign(payload.as_bytes())?;
551554

0 commit comments

Comments
 (0)