Merge pull request #57 from Rigidity/move-cat-spend

Consolidate CAT spends into the Cat primitive

Author: Rigidity

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

@@ -1,3 +1,5 @@
+use std::num::TryFromIntError;
+
 use chia_sdk_types::ConditionError;
 use clvm_traits::{FromClvmError, ToClvmError};
 use clvmr::reduction::EvalErr;
@@ -40,11 +42,6 @@ pub enum DriverError {
     #[error("invalid singleton struct")]
     InvalidSingletonStruct,
 
-    #[error("mismatched singleton output (maybe no spend revealed the new singleton state)")]
-    MismatchedOutput,
-
-    #[error(
-        "missing puzzle (required to build innermost puzzle - usually fixed by using .with_puzzle)"
-    )]
-    MissingPuzzle,
+    #[error("try from int error")]
+    TryFromInt(#[from] TryFromIntError),
 }

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

@@ -43,7 +43,6 @@ mod layers;
 mod primitive;
 mod primitives;
 mod puzzle;
-mod puzzles;
 mod spend;
 mod spend_context;
 mod spend_error;
@@ -55,7 +54,6 @@ pub use layers::*;
 pub use primitive::*;
 pub use primitives::*;
 pub use puzzle::*;
-pub use puzzles::*;
 pub use spend::*;
 pub use spend_context::*;
 pub use spend_error::*;

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

@@ -1,19 +1,23 @@
 mod cat;
+mod cat_spend;
 mod debug;
 mod did;
 mod did_info;
 mod did_launcher;
 mod intermediate_launcher;
+mod issue_cat;
 mod launcher;
 mod nft;
 mod nft_info;
 mod nft_launcher;
 
 pub use cat::*;
+pub use cat_spend::*;
 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::*;

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

@@ -3,11 +3,14 @@ use chia_puzzles::{
     cat::{CatArgs, CatSolution},
     CoinProof, LineageProof,
 };
-use chia_sdk_types::{run_puzzle, Condition};
+use chia_sdk_types::{run_puzzle, Condition, CreateCoin};
 use clvm_traits::FromClvm;
+use clvm_utils::CurriedProgram;
 use clvmr::{Allocator, NodePtr};
 
-use crate::{CatLayer, DriverError, Layer, Primitive, Puzzle, Spend, SpendContext};
+use crate::{CatLayer, DriverError, Layer, Primitive, Puzzle, SpendContext};
+
+use super::{CatSpend, RawCatSpend};
 
 #[derive(Debug, Clone, Copy)]
 pub struct Cat {
@@ -32,31 +35,92 @@ impl Cat {
         }
     }
 
+    /// Creates coin spends for one or more CATs in a ring.
+    /// Without the ring announcements, CAT spends cannot share inputs and outputs.
+    ///
+    /// Each item is a CAT and the inner spend for that CAT.
+    pub fn spend_all(
+        ctx: &mut SpendContext,
+        cat_spends: &[CatSpend],
+    ) -> Result<Vec<CoinSpend>, DriverError> {
+        let mut coin_spends = Vec::new();
+
+        let cat_puzzle_ptr = ctx.cat_puzzle()?;
+        let len = cat_spends.len();
+
+        let mut total_delta = 0;
+
+        for (index, cat_spend) in cat_spends.iter().enumerate() {
+            let CatSpend {
+                cat,
+                inner_spend,
+                extra_delta,
+            } = cat_spend;
+
+            // Calculate the delta and add it to the subtotal.
+            let output = ctx.run(inner_spend.puzzle, inner_spend.solution)?;
+            let conditions: Vec<NodePtr> = ctx.extract(output)?;
+
+            let create_coins = conditions
+                .into_iter()
+                .filter_map(|ptr| ctx.extract::<CreateCoin>(ptr).ok());
+
+            let delta = create_coins.fold(
+                i128::from(cat.coin.amount) - i128::from(*extra_delta),
+                |delta, create_coin| delta - i128::from(create_coin.amount),
+            );
+
+            let prev_subtotal = total_delta;
+            total_delta += delta;
+
+            // Find information of neighboring coins on the ring.
+            let prev = &cat_spends[if index == 0 { len - 1 } else { index - 1 }];
+            let next = &cat_spends[if index == len - 1 { 0 } else { index + 1 }];
+
+            let puzzle_reveal = ctx.serialize(&CurriedProgram {
+                program: cat_puzzle_ptr,
+                args: CatArgs::new(cat.asset_id, cat_spend.inner_spend.puzzle),
+            })?;
+
+            let solution = ctx.serialize(&CatSolution {
+                inner_puzzle_solution: inner_spend.solution,
+                lineage_proof: cat.lineage_proof,
+                prev_coin_id: prev.cat.coin.coin_id(),
+                this_coin_info: cat.coin,
+                next_coin_proof: CoinProof {
+                    parent_coin_info: next.cat.coin.parent_coin_info,
+                    inner_puzzle_hash: ctx.tree_hash(inner_spend.puzzle).into(),
+                    amount: next.cat.coin.amount,
+                },
+                prev_subtotal: prev_subtotal.try_into()?,
+                extra_delta: *extra_delta,
+            })?;
+
+            coin_spends.push(CoinSpend::new(cat.coin, puzzle_reveal, solution));
+        }
+
+        Ok(coin_spends)
+    }
+
     /// Creates a coin spend for this CAT.
-    #[allow(clippy::too_many_arguments)]
     pub fn spend(
         &self,
         ctx: &mut SpendContext,
-        prev_coin_id: Bytes32,
-        this_coin_info: Coin,
-        next_coin_proof: CoinProof,
-        prev_subtotal: i64,
-        extra_delta: i64,
-        inner_spend: Spend,
+        spend: RawCatSpend,
     ) -> Result<CoinSpend, DriverError> {
-        let cat_layer = CatLayer::new(self.asset_id, inner_spend.puzzle);
+        let cat_layer = CatLayer::new(self.asset_id, spend.inner_spend.puzzle);
 
         let puzzle_ptr = cat_layer.construct_puzzle(ctx)?;
         let solution_ptr = cat_layer.construct_solution(
             ctx,
             CatSolution {
                 lineage_proof: self.lineage_proof,
-                prev_coin_id,
-                this_coin_info,
-                next_coin_proof,
-                prev_subtotal,
-                extra_delta,
-                inner_puzzle_solution: inner_spend.solution,
+                prev_coin_id: spend.prev_coin_id,
+                this_coin_info: self.coin,
+                next_coin_proof: spend.next_coin_proof,
+                prev_subtotal: spend.prev_subtotal,
+                extra_delta: spend.extra_delta,
+                inner_puzzle_solution: spend.inner_spend.solution,
             },
         )?;
 
@@ -150,3 +214,178 @@ impl Primitive for Cat {
         }))
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use chia_puzzles::{cat::EverythingWithSignatureTailArgs, standard::StandardArgs};
+    use chia_sdk_test::{secret_key, test_transaction, Simulator};
+    use chia_sdk_types::{Condition, RunTail};
+
+    use crate::{issue_cat_from_coin, issue_cat_from_key, Conditions};
+
+    use super::*;
+
+    #[tokio::test]
+    async fn test_cat_spend_multi() -> anyhow::Result<()> {
+        let sim = Simulator::new().await?;
+        let peer = sim.connect().await?;
+        let ctx = &mut SpendContext::new();
+
+        let sk = secret_key()?;
+        let pk = sk.public_key();
+
+        let puzzle_hash = StandardArgs::curry_tree_hash(pk).into();
+        let coin = sim.mint_coin(puzzle_hash, 6).await;
+
+        let (issue_cat, issuance) = issue_cat_from_coin(
+            ctx,
+            coin.coin_id(),
+            6,
+            Conditions::new()
+                .create_hinted_coin(puzzle_hash, 1, puzzle_hash)
+                .create_hinted_coin(puzzle_hash, 2, puzzle_hash)
+                .create_hinted_coin(puzzle_hash, 3, puzzle_hash),
+        )?;
+
+        ctx.spend_p2_coin(coin, pk, issue_cat)?;
+
+        let cat_puzzle_hash =
+            CatArgs::curry_tree_hash(issuance.asset_id, puzzle_hash.into()).into();
+
+        let cat_spends = [
+            CatSpend::new(
+                Cat::new(
+                    Coin::new(issuance.eve_coin.coin_id(), cat_puzzle_hash, 1),
+                    Some(issuance.lineage_proof),
+                    issuance.asset_id,
+                    puzzle_hash,
+                ),
+                Conditions::new()
+                    .create_hinted_coin(puzzle_hash, 1, puzzle_hash)
+                    .p2_spend(ctx, pk)?,
+            ),
+            CatSpend::new(
+                Cat::new(
+                    Coin::new(issuance.eve_coin.coin_id(), cat_puzzle_hash, 2),
+                    Some(issuance.lineage_proof),
+                    issuance.asset_id,
+                    puzzle_hash,
+                ),
+                Conditions::new()
+                    .create_hinted_coin(puzzle_hash, 2, puzzle_hash)
+                    .p2_spend(ctx, pk)?,
+            ),
+            CatSpend::new(
+                Cat::new(
+                    Coin::new(issuance.eve_coin.coin_id(), cat_puzzle_hash, 3),
+                    Some(issuance.lineage_proof),
+                    issuance.asset_id,
+                    puzzle_hash,
+                ),
+                Conditions::new()
+                    .create_hinted_coin(puzzle_hash, 3, puzzle_hash)
+                    .p2_spend(ctx, pk)?,
+            ),
+        ];
+        for coin_spend in Cat::spend_all(ctx, &cat_spends)? {
+            ctx.insert_coin_spend(coin_spend);
+        }
+
+        test_transaction(&peer, ctx.take_spends(), &[sk], &sim.config().constants).await;
+
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn test_cat_spend() -> anyhow::Result<()> {
+        let sim = Simulator::new().await?;
+        let peer = sim.connect().await?;
+        let ctx = &mut SpendContext::new();
+
+        let sk = secret_key()?;
+        let pk = sk.public_key();
+
+        let puzzle_hash = StandardArgs::curry_tree_hash(pk).into();
+        let coin = sim.mint_coin(puzzle_hash, 1).await;
+
+        let conditions = Conditions::new().create_hinted_coin(puzzle_hash, 1, puzzle_hash);
+        let (issue_cat, issuance) = issue_cat_from_coin(ctx, coin.coin_id(), 1, conditions)?;
+
+        ctx.spend_p2_coin(coin, pk, issue_cat)?;
+
+        let cat_puzzle_hash =
+            CatArgs::curry_tree_hash(issuance.asset_id, puzzle_hash.into()).into();
+        let cat_coin = Coin::new(issuance.eve_coin.coin_id(), cat_puzzle_hash, 1);
+
+        let cat_spends = [CatSpend::new(
+            Cat::new(
+                cat_coin,
+                Some(issuance.lineage_proof),
+                issuance.asset_id,
+                puzzle_hash,
+            ),
+            Conditions::new()
+                .create_hinted_coin(puzzle_hash, 1, puzzle_hash)
+                .p2_spend(ctx, pk)?,
+        )];
+
+        for coin_spend in Cat::spend_all(ctx, &cat_spends)? {
+            ctx.insert_coin_spend(coin_spend);
+        }
+
+        test_transaction(&peer, ctx.take_spends(), &[sk], &sim.config().constants).await;
+
+        Ok(())
+    }
+
+    #[tokio::test]
+    async fn test_cat_melt() -> anyhow::Result<()> {
+        let sim = Simulator::new().await?;
+        let peer = sim.connect().await?;
+        let ctx = &mut SpendContext::new();
+
+        let sk = secret_key()?;
+        let pk = sk.public_key();
+
+        let puzzle_hash = StandardArgs::curry_tree_hash(pk).into();
+        let coin = sim.mint_coin(puzzle_hash, 10000).await;
+
+        let conditions = Conditions::new().create_hinted_coin(puzzle_hash, 10000, puzzle_hash);
+        let (issue_cat, issuance) = issue_cat_from_key(ctx, coin.coin_id(), pk, 10000, conditions)?;
+
+        ctx.spend_p2_coin(coin, pk, issue_cat)?;
+
+        let tail = ctx.everything_with_signature_tail_puzzle()?;
+        let tail_program = ctx.alloc(&CurriedProgram {
+            program: tail,
+            args: EverythingWithSignatureTailArgs::new(pk),
+        })?;
+        let run_tail = Condition::Other(ctx.alloc(&RunTail::new(tail_program, ()))?);
+
+        let cat_puzzle_hash =
+            CatArgs::curry_tree_hash(issuance.asset_id, puzzle_hash.into()).into();
+        let cat_coin = Coin::new(issuance.eve_coin.coin_id(), cat_puzzle_hash, 10000);
+
+        let cat_spend = CatSpend::with_extra_delta(
+            Cat::new(
+                cat_coin,
+                Some(issuance.lineage_proof),
+                issuance.asset_id,
+                puzzle_hash,
+            ),
+            Conditions::new()
+                .create_hinted_coin(puzzle_hash, 7000, puzzle_hash)
+                .condition(run_tail)
+                .p2_spend(ctx, pk)?,
+            -3000,
+        );
+
+        for coin_spend in Cat::spend_all(ctx, &[cat_spend])? {
+            ctx.insert_coin_spend(coin_spend);
+        }
+
+        test_transaction(&peer, ctx.take_spends(), &[sk], &sim.config().constants).await;
+
+        Ok(())
+    }
+}