Merge pull request #59 from Rigidity/test-cov

Improve CAT issuance and CAT tests

Author: Rigidity

crates/chia-sdk-driver/src/conditions.rs

@@ -8,34 +8,48 @@ use chia_sdk_types::{
     Condition, CreateCoin, CreateCoinAnnouncement, CreatePuzzleAnnouncement, ReserveFee,
 };
 
-use clvm_traits::{ClvmEncoder, ToClvm, ToClvmError};
+use clvm_traits::{FromClvm, ToClvm};
 use clvm_utils::CurriedProgram;
-use clvmr::{sha2::Sha256, NodePtr};
+use clvmr::{sha2::Sha256, Allocator, NodePtr};
 
 use crate::{Spend, SpendContext, SpendError};
 
-#[derive(Debug, Default, Clone, PartialEq, Eq)]
 #[must_use]
-pub struct Conditions {
-    conditions: Vec<Condition>,
+#[derive(Debug, Clone, PartialEq, Eq, ToClvm, FromClvm)]
+#[clvm(transparent)]
+pub struct Conditions<T = NodePtr> {
+    conditions: Vec<Condition<T>>,
 }
 
-impl Conditions {
+impl<T> Default for Conditions<T> {
+    fn default() -> Self {
+        Self {
+            conditions: Vec::new(),
+        }
+    }
+}
+
+impl Conditions<NodePtr> {
     pub fn new() -> Self {
         Self::default()
     }
+}
 
-    pub fn condition(mut self, condition: Condition) -> Self {
+impl<T> Conditions<T> {
+    pub fn condition(mut self, condition: Condition<T>) -> Self {
         self.conditions.push(condition);
         self
     }
 
-    pub fn conditions(mut self, conditions: &[Condition]) -> Self {
+    pub fn conditions(mut self, conditions: &[Condition<T>]) -> Self
+    where
+        T: Clone,
+    {
         self.conditions.extend_from_slice(conditions);
         self
     }
 
-    pub fn extend(mut self, conditions: impl IntoIterator<Item = Condition>) -> Self {
+    pub fn extend(mut self, conditions: impl IntoIterator<Item = Condition<T>>) -> Self {
         self.conditions.extend(conditions);
         self
     }
@@ -150,7 +164,10 @@ impl Conditions {
         self,
         ctx: &mut SpendContext,
         synthetic_key: PublicKey,
-    ) -> Result<Spend, SpendError> {
+    ) -> Result<Spend, SpendError>
+    where
+        T: ToClvm<Allocator>,
+    {
         let standard_puzzle = ctx.standard_puzzle()?;
 
         let puzzle = ctx.alloc(&CurriedProgram {
@@ -164,31 +181,21 @@ impl Conditions {
     }
 }
 
-impl AsRef<[Condition]> for Conditions {
-    fn as_ref(&self) -> &[Condition] {
+impl<T> AsRef<[Condition<T>]> for Conditions<T> {
+    fn as_ref(&self) -> &[Condition<T>] {
         &self.conditions
     }
 }
 
-impl IntoIterator for Conditions {
-    type Item = Condition;
-    type IntoIter = std::vec::IntoIter<Condition>;
+impl<T> IntoIterator for Conditions<T> {
+    type Item = Condition<T>;
+    type IntoIter = std::vec::IntoIter<Condition<T>>;
 
     fn into_iter(self) -> Self::IntoIter {
         self.conditions.into_iter()
     }
 }
 
-impl<E> ToClvm<E> for Conditions
-where
-    E: ClvmEncoder<Node = NodePtr>,
-    NodePtr: ToClvm<E>,
-{
-    fn to_clvm(&self, encoder: &mut E) -> Result<NodePtr, ToClvmError> {
-        self.conditions.to_clvm(encoder)
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use chia_sdk_test::{secret_key, test_transaction, Simulator};

crates/chia-sdk-driver/src/layer.rs

@@ -1,6 +1,8 @@
+use chia_protocol::{Coin, CoinSpend};
+use clvm_traits::{FromClvm, ToClvm};
 use clvmr::{Allocator, NodePtr};
 
-use crate::{DriverError, Puzzle, SpendContext};
+use crate::{DriverError, Puzzle, Spend, SpendContext};
 
 /// An individual layer in a puzzle's hierarchy.
 pub trait Layer {
@@ -32,13 +34,43 @@ pub trait Layer {
         ctx: &mut SpendContext,
         solution: Self::Solution,
     ) -> Result<NodePtr, DriverError>;
+
+    /// Creates a spend for this layer.
+    fn construct_spend(
+        &self,
+        ctx: &mut SpendContext,
+        solution: Self::Solution,
+    ) -> Result<Spend, DriverError> {
+        let solution = self.construct_solution(ctx, solution)?;
+        let puzzle = self.construct_puzzle(ctx)?;
+        Ok(Spend::new(puzzle, solution))
+    }
+
+    /// Creates a coin spend for this layer.
+    fn construct_coin_spend(
+        &self,
+        ctx: &mut SpendContext,
+        coin: Coin,
+        solution: Self::Solution,
+    ) -> Result<CoinSpend, DriverError> {
+        let solution = self.construct_solution(ctx, solution)?;
+        let puzzle = self.construct_puzzle(ctx)?;
+        Ok(CoinSpend::new(
+            coin,
+            ctx.serialize(&puzzle)?,
+            ctx.serialize(&solution)?,
+        ))
+    }
 }
 
-impl Layer for NodePtr {
+impl<T> Layer for T
+where
+    T: ToClvm<Allocator> + FromClvm<Allocator>,
+{
     type Solution = NodePtr;
 
-    fn parse_puzzle(_allocator: &Allocator, puzzle: Puzzle) -> Result<Option<Self>, DriverError> {
-        Ok(Some(puzzle.ptr()))
+    fn parse_puzzle(allocator: &Allocator, puzzle: Puzzle) -> Result<Option<Self>, DriverError> {
+        Ok(Some(T::from_clvm(allocator, puzzle.ptr())?))
     }
 
     fn parse_solution(
@@ -48,8 +80,8 @@ impl Layer for NodePtr {
         Ok(solution)
     }
 
-    fn construct_puzzle(&self, _ctx: &mut SpendContext) -> Result<NodePtr, DriverError> {
-        Ok(*self)
+    fn construct_puzzle(&self, ctx: &mut SpendContext) -> Result<NodePtr, DriverError> {
+        Ok(ctx.alloc(self)?)
     }
 
     fn construct_solution(

crates/chia-sdk-driver/src/layers/cat_layer.rs

@@ -8,7 +8,7 @@ use crate::{DriverError, Layer, Puzzle, SpendContext};
 
 /// The CAT [`Layer`] enforces restrictions on the supply of a token.
 /// Specifically, unless the TAIL program is run, the supply cannot change.
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub struct CatLayer<I> {
     /// The asset id of the CAT token. This is the tree hash of the TAIL program.
     pub asset_id: Bytes32,
@@ -112,3 +112,66 @@ where
         CatArgs::curry_tree_hash(self.asset_id, inner_puzzle_hash)
     }
 }
+
+#[cfg(test)]
+mod tests {
+
+    use chia_protocol::Coin;
+    use chia_puzzles::CoinProof;
+
+    use super::*;
+
+    #[test]
+    fn test_cat_layer() -> anyhow::Result<()> {
+        let mut ctx = SpendContext::new();
+        let asset_id = Bytes32::new([1; 32]);
+
+        let layer = CatLayer::new(asset_id, "Hello, world!".to_string());
+
+        let ptr = layer.construct_puzzle(&mut ctx)?;
+        let puzzle = Puzzle::parse(ctx.allocator(), ptr);
+        let roundtrip =
+            CatLayer::<String>::parse_puzzle(ctx.allocator(), puzzle)?.expect("invalid CAT layer");
+
+        assert_eq!(roundtrip.asset_id, layer.asset_id);
+        assert_eq!(roundtrip.inner_puzzle, layer.inner_puzzle);
+
+        let expected = CatArgs::curry_tree_hash(asset_id, layer.inner_puzzle.tree_hash());
+        assert_eq!(hex::encode(ctx.tree_hash(ptr)), hex::encode(expected));
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_cat_solution() -> anyhow::Result<()> {
+        let mut ctx = SpendContext::new();
+
+        let layer = CatLayer::new(Bytes32::default(), NodePtr::NIL);
+
+        let solution = CatSolution {
+            inner_puzzle_solution: NodePtr::NIL,
+            lineage_proof: None,
+            prev_coin_id: Bytes32::default(),
+            this_coin_info: Coin::new(Bytes32::default(), Bytes32::default(), 42),
+            next_coin_proof: CoinProof {
+                parent_coin_info: Bytes32::default(),
+                inner_puzzle_hash: Bytes32::default(),
+                amount: 34,
+            },
+            prev_subtotal: 0,
+            extra_delta: 0,
+        };
+        let expected_ptr = ctx.alloc(&solution)?;
+        let expected_hash = ctx.tree_hash(expected_ptr);
+
+        let actual_ptr = layer.construct_solution(&mut ctx, solution)?;
+        let actual_hash = ctx.tree_hash(actual_ptr);
+
+        assert_eq!(hex::encode(actual_hash), hex::encode(expected_hash));
+
+        let roundtrip = CatLayer::<NodePtr>::parse_solution(ctx.allocator(), actual_ptr)?;
+        assert_eq!(roundtrip, solution);
+
+        Ok(())
+    }
+}

crates/chia-sdk-driver/src/primitives.rs

@@ -5,7 +5,6 @@ mod did;
 mod did_info;
 mod did_launcher;
 mod intermediate_launcher;
-mod issue_cat;
 mod launcher;
 mod nft;
 mod nft_info;
@@ -17,7 +16,6 @@ pub use debug::*;
 pub use did::*;
 pub use did_info::*;
 pub use intermediate_launcher::*;
-pub use issue_cat::*;
 pub use launcher::*;
 pub use nft::*;
 pub use nft_info::*;