Added simplicity contracts support to the coin-store

Author: ikripaka

Cargo.toml

@@ -3,6 +3,9 @@ resolver = "3"
 members = [
     "crates/*"
 ]
+exclude = [
+    "crates/cli-client"
+]
 
 [workspace.package]
 version = "0.1.0"
@@ -19,8 +22,8 @@ anyhow = { version = "1.0.100" }
 
 tracing = { version = "0.1.41" }
 
-contracts = { git = "https://github.com/BlockstreamResearch/simplicity-contracts.git", rev = "6a53bf7", package = "contracts" }
-cli-helper = { git = "https://github.com/BlockstreamResearch/simplicity-contracts.git", rev = "6a53bf7", package = "cli" }
-simplicityhl-core = { version = "0.3.0", features = ["encoding"] }
+contracts = { git = "https://github.com/BlockstreamResearch/simplicity-contracts.git", rev = "b3d1ae9", package = "contracts" }
+cli-helper = { git = "https://github.com/BlockstreamResearch/simplicity-contracts.git", rev = "b3d1ae9", package = "cli" }
+simplicityhl-core = { version = "0.3.1", features = ["encoding"] }
 
 simplicityhl = { version = "0.4.0" }

crates/cli-client/Cargo.toml

@@ -37,7 +37,6 @@ tracing = { workspace = true }
 tracing-subscriber = { version = "0.3", features = ["env-filter"] }
 
 serde = { version = "1", features = ["derive"] }
-toml = "0.8"
-hex = "0.4"
-dotenvy = "0.15"
-
+toml = { version =  "0.8" }
+hex = { version =  "0.4" }
+dotenvy = { version =  "0.15" }

crates/cli-client/src/cli/basic.rs

@@ -1,5 +1,5 @@
 use clap::Subcommand;
-use simplicityhl::elements::OutPoint;
+use simplicityhl::elements::{Address, OutPoint};
 
 #[derive(Debug, Subcommand)]
 pub enum Command {
@@ -75,7 +75,7 @@ pub enum HelperCommand {
     /// Show wallet balance
     Balance,
 
-    /// List UTXOs
+    /// List all UTXOs stored in wallet
     Utxos,
 
     /// Import a UTXO into the wallet
@@ -96,7 +96,7 @@ pub enum BasicCommand {
     TransferNative {
         /// Recipient address
         #[arg(long)]
-        to: String,
+        to: Address,
         /// Amount to send in satoshis
         #[arg(long)]
         amount: u64,
@@ -128,7 +128,7 @@ pub enum BasicCommand {
         asset: String,
         /// Recipient address
         #[arg(long)]
-        to: String,
+        to: Address,
         /// Amount to send
         #[arg(long)]
         amount: u64,

crates/cli-client/src/cli/commands.rs

@@ -0,0 +1,32 @@
+use crate::error::Error;
+use simplicityhl::elements::Transaction;
+use simplicityhl::elements::pset::serialize::Serialize;
+use simplicityhl::simplicity::hex::DisplayHex;
+
+#[derive(Debug, Clone, Copy)]
+pub enum Broadcaster {
+    Offline,
+    Online,
+}
+
+impl From<bool> for Broadcaster {
+    fn from(b: bool) -> Self {
+        if b { Broadcaster::Online } else { Broadcaster::Offline }
+    }
+}
+
+impl Broadcaster {
+    pub async fn broadcast_tx(&self, tx: &Transaction) -> Result<(), Error> {
+        match self {
+            Broadcaster::Offline => {
+                println!("{}", tx.serialize().to_lower_hex_string());
+            }
+            Broadcaster::Online => {
+                cli_helper::explorer::broadcast_tx(tx).await?;
+                let txid = tx.txid();
+                println!("Broadcasted: {txid}");
+            }
+        }
+        Ok(())
+    }
+}

crates/cli-client/src/cli/common.rs

@@ -2,6 +2,8 @@ use crate::cli::{Cli, HelperCommand};
 use crate::config::Config;
 use crate::error::Error;
 use crate::wallet::Wallet;
+use coin_store::utxo_store::UtxoStore;
+use simplicityhl::elements::bitcoin::secp256k1;
 
 impl Cli {
     pub(crate) async fn run_helper(&self, config: Config, command: &HelperCommand) -> Result<(), Error> {
@@ -26,14 +28,14 @@ impl Cli {
             HelperCommand::Balance => {
                 let wallet = self.get_wallet(&config).await?;
 
-                let filter = coin_store::Filter::new()
+                let filter = coin_store::UtxoFilter::new()
                     .script_pubkey(wallet.signer().p2pk_address(config.address_params())?.script_pubkey());
-                let results = wallet.store().query(&[filter]).await?;
+                let results = <_ as UtxoStore>::query_utxos(wallet.store(), &[filter]).await?;
 
                 let mut balances: std::collections::HashMap<simplicityhl::elements::AssetId, u64> =
                     std::collections::HashMap::new();
 
-                if let Some(coin_store::QueryResult::Found(entries)) = results.into_iter().next() {
+                if let Some(coin_store::UtxoQueryResult::Found(entries)) = results.into_iter().next() {
                     for entry in entries {
                         let (asset, value) = match entry {
                             coin_store::UtxoEntry::Confidential { secrets, .. } => (secrets.asset, secrets.value),
@@ -59,10 +61,10 @@ impl Cli {
             HelperCommand::Utxos => {
                 let wallet = self.get_wallet(&config).await?;
 
-                let filter = coin_store::Filter::new();
-                let results = wallet.store().query(&[filter]).await?;
+                let filter = coin_store::UtxoFilter::new();
+                let results = wallet.store().query_utxos(&[filter]).await?;
 
-                if let Some(coin_store::QueryResult::Found(entries)) = results.into_iter().next() {
+                if let Some(coin_store::UtxoQueryResult::Found(entries)) = results.into_iter().next() {
                     for entry in &entries {
                         let outpoint = entry.outpoint();
                         let (asset, value) = match entry {
@@ -88,7 +90,7 @@ impl Cli {
 
                 let blinder = match blinding_key {
                     Some(key_hex) => {
-                        let bytes: [u8; 32] = hex::decode(key_hex)
+                        let bytes: [u8; secp256k1::constants::SECRET_KEY_SIZE] = hex::decode(key_hex)
                             .map_err(|e| Error::Config(format!("Invalid blinding key hex: {e}")))?
                             .try_into()
                             .map_err(|_| Error::Config("Blinding key must be 32 bytes".to_string()))?;

crates/cli-client/src/cli/helper.rs

@@ -0,0 +1,17 @@
+use crate::cli::{Cli, MakerCommand};
+use crate::config::Config;
+use crate::error::Error;
+
+impl Cli {
+    pub(crate) async fn run_maker(&self, config: Config, command: &MakerCommand) -> Result<(), Error> {
+        match command {
+            MakerCommand::Create => {}
+            MakerCommand::Fund => {}
+            MakerCommand::Exercise => {}
+            MakerCommand::Cancel => {}
+            MakerCommand::List => {}
+        }
+
+        Ok(())
+    }
+}

crates/cli-client/src/cli/maker.rs

@@ -1,16 +1,20 @@
 mod basic;
 mod commands;
+mod common;
 mod helper;
+mod maker;
+mod taker;
 
 use std::path::PathBuf;
 
 use clap::Parser;
 
 use crate::config::{Config, default_config_path};
 use crate::error::Error;
+pub use commands::{BasicCommand, Command, HelperCommand, MakerCommand, TakerCommand};
+use signer::Signer;
 
 use crate::wallet::Wallet;
-pub use commands::{BasicCommand, Command, HelperCommand, MakerCommand, TakerCommand};
 
 #[derive(Debug, Parser)]
 #[command(name = "simplicity-dex")]
@@ -32,17 +36,21 @@ impl Cli {
         Config::load_or_default(&self.config)
     }
 
-    fn parse_seed(&self) -> Result<[u8; 32], Error> {
+    fn parse_seed(&self) -> Result<[u8; Signer::SEED_LEN], Error> {
         let seed_hex = self
             .seed
             .as_ref()
             .ok_or_else(|| Error::Config("Seed is required. Use --seed or SIMPLICITY_DEX_SEED".to_string()))?;
 
         let bytes = hex::decode(seed_hex).map_err(|e| Error::Config(format!("Invalid seed hex: {e}")))?;
 
-        bytes
-            .try_into()
-            .map_err(|_| Error::Config("Seed must be exactly 32 bytes (64 hex chars)".to_string()))
+        bytes.try_into().map_err(|_| {
+            Error::Config(format!(
+                "Seed must be exactly {} bytes ({} hex chars)",
+                Signer::SEED_LEN,
+                Signer::SEED_LEN * 2
+            ))
+        })
     }
 
     async fn get_wallet(&self, config: &Config) -> Result<Wallet, Error> {
@@ -57,8 +65,8 @@ impl Cli {
 
         match &self.command {
             Command::Basic { command } => self.run_basic(config, command).await,
-            Command::Maker { command: _ } => todo!(),
-            Command::Taker { command: _ } => todo!(),
+            Command::Maker { command } => self.run_maker(config, command).await,
+            Command::Taker { command } => self.run_taker(config, command).await,
             Command::Helper { command } => self.run_helper(config, command).await,
             Command::Config => {
                 println!("{config:#?}");

crates/cli-client/src/cli/mod.rs

@@ -0,0 +1,16 @@
+use crate::cli::{Cli, TakerCommand};
+use crate::config::Config;
+use crate::error::Error;
+
+impl Cli {
+    pub(crate) async fn run_taker(&self, config: Config, command: &TakerCommand) -> Result<(), Error> {
+        match command {
+            TakerCommand::Browse => {}
+            TakerCommand::Take => {}
+            TakerCommand::Claim => {}
+            TakerCommand::List => {}
+        }
+
+        Ok(())
+    }
+}

crates/cli-client/src/cli/taker.rs

@@ -1,3 +1,5 @@
+use simplicityhl::simplicity::hex::HexToArrayError;
+
 #[derive(thiserror::Error, Debug)]
 pub enum Error {
     #[error("Configuration error: {0}")]
@@ -29,4 +31,7 @@ pub enum Error {
 
     #[error("Hex error: {0}")]
     Hex(#[from] hex::FromHexError),
+
+    #[error("Hex to array error: {0}")]
+    HexToArray(#[from] HexToArrayError),
 }