Feature/contracts routes

Cargo.toml

@@ -37,15 +37,23 @@ use-self = "warn"
 [dependencies]
 anyhow = "1.0.100"
 bigdecimal = "0.4.8"
+blake2 = "0.10.6"
+bs58 = "0.5.1"
 clap = { version = "4", features = ["derive", "env"] }
-regex = "1.11.2"
-reqwest = { version = "0.12.23", features = ["json"] }
-serde = {version = "1.0.226", features = ["derive"] }
-serde_json = "1.0.145"
-strum = { version = "0.26.3", features = ["derive"] }
+futures = { version = "0.3.31", default-features = false }
 hex = "0.4.3"
+i256 = "0.2.3"
+indexmap = {version = "2.11.4", features = ["serde"]}
+regex = "1.12.2"
+reqwest = { version = "0.12.24", features = ["json"] }
 secp256k1 = "0.30.0"
-tokio = { version = "1.47.1", features = ["full"] }
+serde = { version = "1.0.228", features = ["derive"] }
+serde_json = { version = "1.0.145", features = ["raw_value"] }
+serde_yaml = "0.9.34"
+sha2 = "0.10.9"
+strum = { version = "0.27.2", features = ["derive"] }
+tokio = { version = "1.48.0", features = ["full"] }
+walkdir = "2.5.0"
 
 [dev-dependencies]
 insta = { version = "1", features = ["filters"] }

README.md

@@ -129,7 +129,7 @@ Here are some examples of how to use the Kermit CLI:
 4. Compile a contract:
 
     ```bash
-    kermit contracts compile tests/sub_contract.ral --contract-type project
+    kermit contracts compile tests/contracts/sub_contract.ral --contract-type project
     ```
 
 You can do again more with kermit. I let you check the `kermit --help`, to take a look on all possibilities

src/account/account_struct.rs

@@ -0,0 +1,23 @@
+use anyhow::Result;
+
+use crate::account::{address::Address, signature::PrivateKey};
+
+pub struct Account {
+    pub private_key: Box<dyn PrivateKey>,
+    pub address: Address,
+    pub group: u8,
+}
+
+impl Account {
+    pub fn new(private_key: Box<dyn PrivateKey>) -> Result<Self> {
+        let public_key = private_key.get_public_key()?;
+        let address = Address::new(&public_key)?;
+        let group = address.group_from_bytes();
+
+        Ok(Self {
+            private_key,
+            address,
+            group,
+        })
+    }
+}

src/account/address.rs

@@ -0,0 +1,96 @@
+use anyhow::{Context, Result, bail};
+use blake2::{
+    Blake2bVar,
+    digest::{Update, VariableOutput},
+};
+use bs58;
+use serde::{Deserialize, Serialize, Serializer};
+
+use crate::common::{djb2, xor_byte};
+
+const TOTAL_NUMBER_OF_GROUPS: u8 = 4;
+
+#[repr(u8)]
+#[allow(dead_code)]
+pub enum AddressType {
+    P2PKH = 0x00,
+    P2MPKH = 0x01,
+    P2SH = 0x02,
+    P2C = 0x03,
+    P2PK = 0x04,
+    P2HMPK = 0x05,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Address {
+    pub key: String,
+    pub full_bytes: Vec<u8>,
+    pub bytes: Vec<u8>,
+}
+
+impl Serialize for Address {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str(&self.key)
+    }
+}
+
+impl<'de> Deserialize<'de> for Address {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let key = String::deserialize(deserializer)?;
+        Self::new(&key).map_err(serde::de::Error::custom)
+    }
+}
+
+impl Address {
+    pub fn new(public_key_str: &str) -> Result<Self> {
+        let public_key_bytes = hex::decode(public_key_str).context("Invalid hex")?;
+        let mut hasher = Blake2bVar::new(32).context("Failed to create Blake2bVar")?;
+        hasher.update(&public_key_bytes);
+        let mut hash_bytes = [0u8; 32];
+        hasher
+            .finalize_variable(&mut hash_bytes)
+            .context("Failed to finalize Blake2bVar")?;
+        let hash_bytes = &hash_bytes[..32];
+
+        let mut address_bytes = Vec::with_capacity(1 + 32);
+        address_bytes.push(AddressType::P2PKH as u8);
+        address_bytes.extend_from_slice(hash_bytes);
+
+        Ok(Self {
+            key: bs58::encode(&address_bytes).into_string(),
+            full_bytes: address_bytes,
+            bytes: hash_bytes.into(),
+        })
+    }
+
+    pub fn new_b58(b58_str: &str) -> Result<Self> {
+        let address_bytes = bs58::decode(b58_str)
+            .into_vec()
+            .context("Invalid base58 string")?;
+        if address_bytes.len() < 33 {
+            bail!("Invalid address length");
+        }
+
+        let key = b58_str.to_string();
+        let full_bytes = address_bytes.clone();
+        let bytes = address_bytes[1..].to_vec(); // The length > 1 was already checked
+
+        Ok(Self {
+            key,
+            full_bytes,
+            bytes,
+        })
+    }
+
+    pub fn group_from_bytes(&self) -> u8 {
+        let hint = djb2(&self.bytes) | 1;
+        let hash = xor_byte(hint);
+        hash % TOTAL_NUMBER_OF_GROUPS
+    }
+}

src/account/mod.rs

@@ -0,0 +1,3 @@
+pub mod account_struct;
+pub mod address;
+pub mod signature;

src/account/signature.rs

@@ -0,0 +1,64 @@
+use anyhow::{Context, Result, anyhow, bail};
+use secp256k1::{Message, PublicKey, Secp256k1, SecretKey};
+
+#[allow(dead_code)]
+pub trait PrivateKey {
+    fn as_hex(&self) -> String;
+    fn get_public_key(&self) -> Result<String>;
+    fn sign(&self, tx_id: &str) -> Result<String>;
+}
+
+#[allow(dead_code)]
+pub struct GLSecp256k1PrivateKey {
+    pub hex_key: String,
+    pub key: SecretKey,
+}
+
+impl PrivateKey for GLSecp256k1PrivateKey {
+    fn as_hex(&self) -> String {
+        self.hex_key.clone()
+    }
+
+    fn get_public_key(&self) -> Result<String> {
+        let secp = Secp256k1::new();
+        let public_key = PublicKey::from_secret_key(&secp, &self.key);
+        Ok(public_key.to_string())
+    }
+
+    fn sign(&self, tx_id: &str) -> Result<String> {
+        let tx_id_bytes = hex::decode(tx_id)?;
+        let message = Message::from_digest(
+            tx_id_bytes
+                .try_into()
+                .map_err(|_| anyhow!("Invalid hash length"))?,
+        );
+
+        let secp = Secp256k1::new();
+        let signature = secp.sign_ecdsa(&message, &self.key);
+        let serialized = signature.serialize_compact();
+        let signature = hex::encode(serialized);
+
+        Ok(signature)
+    }
+}
+
+#[allow(dead_code)]
+impl GLSecp256k1PrivateKey {
+    pub fn new(key: &str) -> Result<Self> {
+        if !Self::is_valid(key) {
+            bail!("Invalid private key format");
+        }
+
+        let private_key = SecretKey::from_slice(&hex::decode(key).context("Invalid hex key")?)
+            .context("Failed to create secret key")?;
+
+        Ok(Self {
+            key: private_key,
+            hex_key: key.to_string(),
+        })
+    }
+
+    fn is_valid(hex_key: &str) -> bool {
+        hex_key.len() == 64 && hex_key.chars().all(|c| c.is_ascii_hexdigit())
+    }
+}

src/addresses.rs

@@ -1,11 +1,11 @@
 use anyhow::Result;
 use clap::Parser;
 
-use crate::common::{get, print_output};
+use crate::common::{check_network, get, print_output};
 
 /// CLI arguments for `kermit addresses`.
 #[derive(Parser)]
-pub(crate) enum AddressesSubcommands {
+pub enum AddressesSubcommands {
     /// Get the balance of an address.
     #[command(visible_alias = "b")]
     Balance {
@@ -28,7 +28,9 @@ pub(crate) enum AddressesSubcommands {
 }
 
 impl AddressesSubcommands {
-    pub(crate) async fn run(self, url: String) -> Result<()> {
+    pub async fn run(self, url: &str) -> Result<()> {
+        check_network(url).await?;
+
         let endpoint = match self {
             Self::Balance { address, mem_pool } => {
                 format!("/addresses/{address}/balance?mempool={mem_pool}")
@@ -47,7 +49,7 @@ impl AddressesSubcommands {
             },
         };
 
-        let output = get(&url, &endpoint).await?;
+        let output = get(url, &endpoint).await?;
         print_output(output)?;
 
         Ok(())

src/args.rs

@@ -1,14 +1,19 @@
 use clap::{Parser, Subcommand, ValueHint};
 
 use crate::{
-    addresses::AddressesSubcommands, blockflow::BlockflowSubcommands,
-    contracts::ContractsSubcommands, infos::InfosSubcommands, miners::MinersSubcommands,
-    transactions::TransactionsSubcommands, utils::UtilsSubcommands, wallets::WalletsSubcommands,
+    addresses::AddressesSubcommands,
+    blockflow::BlockflowSubcommands,
+    contracts::{ContractsSubcommands, NetworkType},
+    infos::InfosSubcommands,
+    miners::MinersSubcommands,
+    transactions::TransactionsSubcommands,
+    utils::UtilsSubcommands,
+    wallets::WalletsSubcommands,
 };
 
 #[derive(Parser)]
 #[command(version)]
-pub(crate) struct Kermit {
+pub struct Kermit {
     #[clap(long, short, env, value_hint = ValueHint::Url,
     default_value = "http://localhost:22973")]
     pub url: String,
@@ -18,7 +23,7 @@ pub(crate) struct Kermit {
 }
 
 #[derive(Subcommand)]
-pub(crate) enum KermitSubcommand {
+pub enum KermitSubcommand {
     /// Address management utilities.
     #[command(visible_alias = "a")]
     Addresses {
@@ -38,6 +43,19 @@ pub(crate) enum KermitSubcommand {
     Contracts {
         #[command(subcommand)]
         command: ContractsSubcommands,
+
+        /// Path to the config YAML file
+        #[arg(long, short, default_value = "./alephium.config.yaml")]
+        config_file_path: String,
+
+        /// Create the config file for contracts automatically if not set
+        #[arg(long, default_value_t = false)]
+        auto_create_config_file: bool,
+
+        /// Network type may trigger a different behavior in contract
+        /// operations. Choose accordingly
+        #[arg(long, short, value_enum, default_value_t = NetworkType::Dev)]
+        network: NetworkType,
     },
 
     /// Infos about node and hashrate.

src/blockflow.rs

@@ -1,11 +1,11 @@
 use anyhow::Result;
 use clap::Parser;
 
-use crate::common::{get, print_output};
+use crate::common::{check_network, get, print_output};
 
 /// CLI arguments for `kermit blockflow`.
 #[derive(Parser)]
-pub(crate) enum BlockflowSubcommands {
+pub enum BlockflowSubcommands {
     /// List blocks on the given time interval.
     #[command(visible_alias = "bs")]
     Blocks { from_ts: i64, to_ts: Option<i64> },
@@ -62,7 +62,9 @@ pub(crate) enum BlockflowSubcommands {
 }
 
 impl BlockflowSubcommands {
-    pub(crate) async fn run(self, url: &str) -> Result<()> {
+    pub async fn run(self, url: &str) -> Result<()> {
+        check_network(url).await?;
+
         let endpoint = match self {
             Self::Blocks { from_ts, to_ts } => {
                 let mut endpoint = format!("/blockflow/blocks?fromTs={from_ts}");

src/common/crypto.rs

@@ -0,0 +1,29 @@
+pub fn djb2(bytes: &[u8]) -> i32 {
+    let mut hash: i32 = 5381;
+    for &byte in bytes {
+        hash = (hash << 5).wrapping_add(hash).wrapping_add(byte.into());
+    }
+    hash
+}
+
+pub const fn xor_byte(int_value: i32) -> u8 {
+    let byte0 = ((int_value >> 24) & 0xff) as u8;
+    let byte1 = ((int_value >> 16) & 0xff) as u8;
+    let byte2 = ((int_value >> 8) & 0xff) as u8;
+    let byte3 = (int_value & 0xff) as u8;
+    byte0 ^ byte1 ^ byte2 ^ byte3
+}
+
+pub fn is_hex_string(input: &str) -> bool {
+    input.starts_with("0x")
+        && (input.len() - 2).is_multiple_of(2)
+        && input[2..].chars().all(|c| c.is_ascii_hexdigit())
+}
+
+pub fn is_b58(input: &str) -> bool {
+    input.starts_with("b58:")
+        && input[4..].chars().all(|c| {
+            c.is_ascii_alphanumeric()
+                && "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz".contains(c)
+        })
+}