NUT-XX: Cairo Spending Conditions implementation

Cargo.toml

@@ -100,8 +100,12 @@ tonic-build = "0.13.1"
 strum = "0.27.1"
 strum_macros = "0.27.1"
 rustls = { version = "0.23.28", default-features = false, features = ["ring"] }
-
-
+starknet-types-core = "0.1.9"
+cairo-air = { git = "https://github.com/starkware-libs/stwo-cairo", rev = "62c3c4a" }
+stwo_cairo_prover = { git = "https://github.com/starkware-libs/stwo-cairo", rev = "62c3c4a" }
+cairo-lang-runner = { git = "https://github.com/starkware-libs/cairo.git", rev = "5cc466a" }
+cairo-prove = { git = "https://github.com/starkware-libs/stwo-cairo", rev = "335de15"}
+cairo-lang-executable = { git = "https://github.com/starkware-libs/cairo.git", rev = "5cc466a" }
 
 [workspace.metadata]
 authors = ["CDK Developers"]

crates/cashu/Cargo.toml

@@ -36,10 +36,13 @@ serde_with.workspace = true
 regex = { workspace = true, optional = true }
 strum = { workspace = true, optional = true }
 strum_macros = { workspace = true, optional = true }
+cairo-air = { workspace = true }
+stwo_cairo_prover = { workspace = true }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 instant = { workspace = true, features = ["wasm-bindgen", "inaccurate"] }
 
 [dev-dependencies]
 bip39.workspace = true
 uuid.workspace = true
+starknet-types-core = { workspace = true }

crates/cashu/src/nuts/mod.rs

@@ -25,6 +25,7 @@ pub mod nut19;
 pub mod nut20;
 pub mod nut23;
 pub mod nut24;
+pub mod nutxx;
 
 #[cfg(feature = "auth")]
 mod auth;
@@ -69,3 +70,4 @@ pub use nut23::{
     MintQuoteBolt11Response, QuoteState as MintQuoteState,
 };
 pub use nut24::{MeltQuoteBolt12Request, MintQuoteBolt12Request, MintQuoteBolt12Response};
+pub use nutxx::{CairoWitness, Conditions as NutXXConditions};

crates/cashu/src/nuts/nut00/mod.rs

@@ -28,6 +28,7 @@ use crate::nuts::nut01::SecretKey;
 use crate::nuts::nut11::{serde_p2pk_witness, P2PKWitness};
 use crate::nuts::nut12::BlindSignatureDleq;
 use crate::nuts::nut14::{serde_htlc_witness, HTLCWitness};
+use crate::nuts::nutxx::{serde_cairo_witness, CairoWitness};
 use crate::nuts::{Id, ProofDleq};
 use crate::secret::Secret;
 use crate::Amount;
@@ -285,6 +286,9 @@ pub enum Witness {
     /// HTLC Witness
     #[serde(with = "serde_htlc_witness")]
     HTLCWitness(HTLCWitness),
+    /// Cairo Witness
+    #[serde(with = "serde_cairo_witness")]
+    CairoWitness(CairoWitness),
 }
 
 impl From<P2PKWitness> for Witness {
@@ -299,6 +303,12 @@ impl From<HTLCWitness> for Witness {
     }
 }
 
+impl From<CairoWitness> for Witness {
+    fn from(witness: CairoWitness) -> Self {
+        Self::CairoWitness(witness)
+    }
+}
+
 impl Witness {
     /// Add signatures to [`Witness`]
     pub fn add_signatures(&mut self, signatues: Vec<String>) {
@@ -311,6 +321,7 @@ impl Witness {
                     sigs
                 });
             }
+            Self::CairoWitness(_cairo_witness) => {} // unused
         }
     }
 
@@ -319,6 +330,7 @@ impl Witness {
         match self {
             Self::P2PKWitness(witness) => Some(witness.signatures.clone()),
             Self::HTLCWitness(witness) => witness.signatures.clone(),
+            Self::CairoWitness(_witness) => None,
         }
     }
 
@@ -327,6 +339,7 @@ impl Witness {
         match self {
             Self::P2PKWitness(_witness) => None,
             Self::HTLCWitness(witness) => Some(witness.preimage.clone()),
+            Self::CairoWitness(_witness) => None,
         }
     }
 }

crates/cashu/src/nuts/nut06.rs

@@ -14,6 +14,7 @@ use super::nut19::CachedEndpoint;
 use super::{nut04, nut05, nut15, nut19, MppMethodSettings};
 #[cfg(feature = "auth")]
 use super::{AuthRequired, BlindAuthSettings, ClearAuthSettings, ProtectedEndpoint};
+use crate::nutxx::NutXXSettings;
 use crate::CurrencyUnit;
 
 /// Mint Version
@@ -336,6 +337,10 @@ pub struct Nuts {
     #[serde(skip_serializing_if = "Option::is_none")]
     #[cfg(feature = "auth")]
     pub nut22: Option<BlindAuthSettings>,
+    /// NUTXX Settings
+    #[serde(default)]
+    #[serde(rename = "xx")]
+    pub nutxx: NutXXSettings,
 }
 
 impl Nuts {
@@ -453,6 +458,17 @@ impl Nuts {
         }
     }
 
+    /// NutXX settings
+    pub fn nutxx(self, supported: bool) -> Self {
+        Self {
+            nutxx: NutXXSettings {
+                supported,
+                ..NutXXSettings::default()
+            },
+            ..self
+        }
+    }
+
     /// Units where minting is supported
     pub fn supported_mint_units(&self) -> Vec<&CurrencyUnit> {
         self.nut04

crates/cashu/src/nuts/nut10.rs

@@ -28,6 +28,8 @@ pub enum Kind {
     P2PK,
     /// NUT-14 HTLC
     HTLC,
+    /// NUT-XX Cairo
+    Cairo,
 }
 
 /// Secert Date

crates/cashu/src/nuts/nut11/mod.rs

@@ -2,6 +2,7 @@
 //!
 //! <https://github.com/cashubtc/nuts/blob/main/11.md>
 
+use std::array::TryFromSliceError;
 use std::collections::{HashMap, HashSet};
 use std::str::FromStr;
 use std::{fmt, vec};
@@ -17,10 +18,10 @@ use thiserror::Error;
 use super::nut00::Witness;
 use super::nut01::PublicKey;
 use super::{Kind, Nut10Secret, Proof, Proofs, SecretKey};
-use crate::ensure_cdk;
 use crate::nuts::nut00::BlindedMessage;
 use crate::secret::Secret;
 use crate::util::{hex, unix_time};
+use crate::{ensure_cdk, NutXXConditions};
 
 pub mod serde_p2pk_witness;
 
@@ -72,6 +73,9 @@ pub enum Error {
     /// From hex error
     #[error(transparent)]
     HexError(#[from] hex::Error),
+    /// Slice Error
+    #[error(transparent)]
+    Slice(#[from] TryFromSliceError),
     /// Serde Json error
     #[error(transparent)]
     SerdeJsonError(#[from] serde_json::Error),
@@ -312,6 +316,14 @@ pub enum SpendingConditions {
         /// Additional Optional Spending [`Conditions`]
         conditions: Option<Conditions>,
     },
+    /// NUTXX Spending conditions
+    /// Defined in [NUTXX](https://github.com/cashubtc/nuts/blob/main/xx.md)
+    CairoConditions {
+        /// Blake2s program hash
+        data: [u8; 32],
+        /// Additional Optional Spending [`NutXXConditions`]
+        conditions: Option<NutXXConditions>,
+    },
 }
 
 impl SpendingConditions {
@@ -343,11 +355,17 @@ impl SpendingConditions {
         }
     }
 
+    /// New Cairo [SpendingConditions]
+    pub fn new_cairo(data: [u8; 32], conditions: Option<NutXXConditions>) -> Self {
+        Self::CairoConditions { data, conditions }
+    }
+
     /// Kind of [SpendingConditions]
     pub fn kind(&self) -> Kind {
         match self {
             Self::P2PKConditions { .. } => Kind::P2PK,
             Self::HTLCConditions { .. } => Kind::HTLC,
+            Self::CairoConditions { .. } => Kind::Cairo,
         }
     }
 
@@ -356,6 +374,7 @@ impl SpendingConditions {
         match self {
             Self::P2PKConditions { conditions, .. } => conditions.as_ref().and_then(|c| c.num_sigs),
             Self::HTLCConditions { conditions, .. } => conditions.as_ref().and_then(|c| c.num_sigs),
+            Self::CairoConditions { .. } => None,
         }
     }
 
@@ -371,6 +390,7 @@ impl SpendingConditions {
                 Some(pubkeys)
             }
             Self::HTLCConditions { conditions, .. } => conditions.clone().and_then(|c| c.pubkeys),
+            Self::CairoConditions { .. } => None,
         }
     }
 
@@ -379,6 +399,7 @@ impl SpendingConditions {
         match self {
             Self::P2PKConditions { conditions, .. } => conditions.as_ref().and_then(|c| c.locktime),
             Self::HTLCConditions { conditions, .. } => conditions.as_ref().and_then(|c| c.locktime),
+            Self::CairoConditions { .. } => None,
         }
     }
 
@@ -391,6 +412,16 @@ impl SpendingConditions {
             Self::HTLCConditions { conditions, .. } => {
                 conditions.clone().and_then(|c| c.refund_keys)
             }
+            Self::CairoConditions { .. } => None,
+        }
+    }
+
+    /// Cairo program output hash
+    pub fn output(&self) -> Option<[u8; 32]> {
+        match self {
+            Self::P2PKConditions { .. } => None,
+            Self::HTLCConditions { .. } => None,
+            Self::CairoConditions { conditions, .. } => conditions.clone().and_then(|c| c.output),
         }
     }
 }
@@ -423,6 +454,15 @@ impl TryFrom<Nut10Secret> for SpendingConditions {
                     .tags()
                     .and_then(|t| t.clone().try_into().ok()),
             }),
+            Kind::Cairo => Ok(Self::CairoConditions {
+                data: hex::decode(secret.secret_data().data())?
+                    .as_slice()
+                    .try_into()?,
+                conditions: secret
+                    .secret_data()
+                    .tags()
+                    .and_then(|t| t.clone().try_into().ok()),
+            }),
         }
     }
 }
@@ -436,6 +476,9 @@ impl From<SpendingConditions> for super::nut10::Secret {
             SpendingConditions::HTLCConditions { data, conditions } => {
                 super::nut10::Secret::new(Kind::HTLC, data.to_string(), conditions)
             }
+            SpendingConditions::CairoConditions { data, conditions } => {
+                super::nut10::Secret::new(Kind::Cairo, hex::encode(data), conditions)
+            }
         }
     }
 }
@@ -530,7 +573,7 @@ impl TryFrom<Vec<Vec<String>>> for Conditions {
     fn try_from(tags: Vec<Vec<String>>) -> Result<Conditions, Self::Error> {
         let tags: HashMap<TagKind, Tag> = tags
             .into_iter()
-            .map(|t| Tag::try_from(t).unwrap())
+            .filter_map(|t| Tag::try_from(t).ok())
             .map(|t| (t.kind(), t))
             .collect();
 

crates/cashu/src/nuts/nut18/secret.rs

@@ -3,6 +3,7 @@ use serde::{Deserialize, Serialize};
 
 use crate::nuts::nut10::Kind;
 use crate::nuts::{Nut10Secret, SpendingConditions};
+use crate::util::hex;
 
 /// Nut10Secret without nonce for payment requests
 #[derive(Debug, Clone, Hash, PartialEq, Eq, Serialize, Deserialize)]
@@ -58,6 +59,9 @@ impl From<SpendingConditions> for Nut10SecretRequest {
             SpendingConditions::HTLCConditions { data, conditions } => {
                 Self::new(Kind::HTLC, data.to_string(), conditions)
             }
+            SpendingConditions::CairoConditions { data, conditions } => {
+                Self::new(Kind::Cairo, hex::encode(data), conditions)
+            }
         }
     }
 }