Merge pull request #281 from xch-dev/quex

Slot Update

Author: Yakuhito

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

@@ -11,7 +11,7 @@ use crate::{
     DelegatedStateAction, DriverError, Layer, Puzzle, SingletonAction, Spend, SpendContext,
 };
 
-use super::{CatalogRegistryConstants, CatalogRegistryInfo, CatalogRegistryState, Slot, SlotProof};
+use super::{CatalogRegistryConstants, CatalogRegistryInfo, CatalogRegistryState, Slot};
 
 #[derive(Debug, Clone)]
 pub struct CatalogPendingSpendInfo {
@@ -295,13 +295,12 @@ impl CatalogRegistry {
         &self,
         slot_value: CatalogSlotValue,
     ) -> Slot<CatalogSlotValue> {
-        let proof = SlotProof {
-            parent_parent_info: self.coin.parent_coin_info,
-            parent_inner_puzzle_hash: self.info.inner_puzzle_hash().into(),
-        };
-
         Slot::new(
-            proof,
+            LineageProof {
+                parent_parent_coin_info: self.coin.parent_coin_info,
+                parent_inner_puzzle_hash: self.info.inner_puzzle_hash().into(),
+                parent_amount: self.coin.amount,
+            },
             SlotInfo::from_value(self.info.constants.launcher_id, 0, slot_value),
         )
     }

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

@@ -26,9 +26,9 @@ use clvmr::{Allocator, NodePtr};
 use crate::{
     Cat, CatSpend, CatalogRegistry, CatalogRegistryConstants, CatalogRegistryInfo,
     CatalogRegistryState, DriverError, Launcher, Layer, Nft, Offer, Reserve, RewardDistributor,
-    RewardDistributorConstants, RewardDistributorInfo, RewardDistributorState, Slot, SlotProof,
-    Spend, SpendContext, StandardLayer, XchandlesConstants, XchandlesRegistry,
-    XchandlesRegistryInfo, XchandlesRegistryState,
+    RewardDistributorConstants, RewardDistributorInfo, RewardDistributorState, Slot, Spend,
+    SpendContext, StandardLayer, XchandlesConstants, XchandlesRegistry, XchandlesRegistryInfo,
+    XchandlesRegistryState,
 };
 
 #[allow(clippy::needless_pass_by_value)]
@@ -207,9 +207,10 @@ where
         parent_amount: 1,
     });
 
-    let slot_proof = SlotProof {
-        parent_parent_info: eve_coin.parent_coin_info,
+    let slot_proof = LineageProof {
+        parent_parent_coin_info: eve_coin.parent_coin_info,
         parent_inner_puzzle_hash: eve_singleton_inner_puzzle_hash.into(),
+        parent_amount: 1,
     };
     let left_slot = Slot::new(
         slot_proof,
@@ -703,17 +704,12 @@ pub fn launch_dig_reward_distributor(
         SingletonArgs::curry_tree_hash(launcher_id, target_inner_puzzle_hash).into(),
         1,
     );
-    let new_proof = Proof::Lineage(LineageProof {
+    let new_proof = LineageProof {
         parent_parent_coin_info: eve_coin.parent_coin_info,
         parent_inner_puzzle_hash: eve_singleton_inner_puzzle_hash.into(),
-        parent_amount: 1,
-    });
-
-    let slot_proof = SlotProof {
-        parent_parent_info: eve_coin.parent_coin_info,
-        parent_inner_puzzle_hash: eve_singleton_inner_puzzle_hash.into(),
+        parent_amount: eve_coin.amount,
     };
-    let slot = Slot::new(slot_proof, slot_info);
+    let slot = Slot::new(new_proof, slot_info);
 
     // this creates the launcher & secures the spend
     let security_coin_conditions =
@@ -729,7 +725,12 @@ pub fn launch_dig_reward_distributor(
         0,
         reserve_cat.coin.amount,
     );
-    let registry = RewardDistributor::new(new_registry_coin, new_proof, target_info, reserve);
+    let registry = RewardDistributor::new(
+        new_registry_coin,
+        Proof::Lineage(new_proof),
+        target_info,
+        reserve,
+    );
 
     // Spend security coin
     let security_coin_sig = spend_security_coin(
@@ -1640,6 +1641,7 @@ mod tests {
                     payment_cat.info.asset_id,
                 ),
             )?;
+        println!("launched"); // todo: debug
 
         // Check XCHandlesRegistry::from_launcher_solution
         let spends = ctx.take();

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

@@ -21,8 +21,8 @@ use crate::{
     RewardDistributorCommitIncentivesAction, RewardDistributorInitiatePayoutAction,
     RewardDistributorNewEpochAction, RewardDistributorRemoveEntryAction,
     RewardDistributorStakeAction, RewardDistributorSyncAction, RewardDistributorUnstakeAction,
-    RewardDistributorWithdrawIncentivesAction, SingletonAction, SingletonLayer, Slot, SlotProof,
-    Spend, SpendContext,
+    RewardDistributorWithdrawIncentivesAction, SingletonAction, SingletonLayer, Slot, Spend,
+    SpendContext,
 };
 
 use super::{Reserve, RewardDistributorConstants, RewardDistributorInfo, RewardDistributorState};
@@ -487,18 +487,14 @@ impl RewardDistributor {
             ));
         }
 
-        let slot_proof = SlotProof {
-            parent_parent_info: lineage_proof.parent_parent_coin_info,
-            parent_inner_puzzle_hash: lineage_proof.parent_inner_puzzle_hash,
-        };
         let slot_value = RewardDistributorRewardSlotValue {
             epoch_start: initial_state.round_time_info.epoch_end,
             next_epoch_initialized: false,
             rewards: 0,
         };
 
         let slot = Slot::new(
-            slot_proof,
+            lineage_proof,
             SlotInfo::from_value(
                 constants.launcher_id,
                 RewardDistributorSlotNonce::REWARD.to_u64(),
@@ -599,13 +595,12 @@ impl RewardDistributor {
     where
         SlotValue: Copy + ToTreeHash,
     {
-        let proof = SlotProof {
-            parent_parent_info: self.coin.parent_coin_info,
-            parent_inner_puzzle_hash: self.info.inner_puzzle_hash().into(),
-        };
-
         Slot::new(
-            proof,
+            LineageProof {
+                parent_parent_coin_info: self.coin.parent_coin_info,
+                parent_inner_puzzle_hash: self.info.inner_puzzle_hash().into(),
+                parent_amount: self.coin.amount,
+            },
             SlotInfo::from_value(self.info.constants.launcher_id, nonce.to_u64(), slot_value),
         )
     }

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

@@ -1,5 +1,5 @@
 use chia_protocol::{Bytes32, Coin, CoinSpend};
-use chia_puzzle_types::singleton::{SingletonArgs, SingletonStruct};
+use chia_puzzle_types::{singleton::SingletonArgs, LineageProof};
 use chia_sdk_types::{
     puzzles::{Slot1stCurryArgs, Slot2ndCurryArgs, SlotInfo, SlotSolution},
     Mod,
@@ -9,36 +9,24 @@ use clvmr::NodePtr;
 
 use crate::{DriverError, SpendContext};
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub struct SlotProof {
-    pub parent_parent_info: Bytes32,
-    pub parent_inner_puzzle_hash: Bytes32,
-}
-
-impl SlotProof {
-    pub fn slot_parent_id(&self, launcher_id: Bytes32) -> Bytes32 {
-        Coin::new(
-            self.parent_parent_info,
-            SingletonArgs::curry_tree_hash(launcher_id, self.parent_inner_puzzle_hash.into())
-                .into(),
-            1,
-        )
-        .coin_id()
-    }
-}
-
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[must_use]
 pub struct Slot<V> {
     pub coin: Coin,
-    pub proof: SlotProof,
+    pub proof: LineageProof,
 
     pub info: SlotInfo<V>,
 }
 
 impl<V> Slot<V> {
-    pub fn new(proof: SlotProof, info: SlotInfo<V>) -> Self {
-        let parent_coin_id = proof.slot_parent_id(info.launcher_id);
+    pub fn new(proof: LineageProof, info: SlotInfo<V>) -> Self {
+        let parent_coin_id = Coin::new(
+            proof.parent_parent_coin_info,
+            SingletonArgs::curry_tree_hash(info.launcher_id, proof.parent_inner_puzzle_hash.into())
+                .into(),
+            proof.parent_amount,
+        )
+        .coin_id();
 
         Self {
             coin: Coin::new(parent_coin_id, Slot::<V>::puzzle_hash(&info).into(), 0),
@@ -48,11 +36,7 @@ impl<V> Slot<V> {
     }
 
     pub fn first_curry_hash(launcher_id: Bytes32, nonce: u64) -> TreeHash {
-        Slot1stCurryArgs {
-            singleton_struct: SingletonStruct::new(launcher_id),
-            nonce,
-        }
-        .curry_tree_hash()
+        Slot1stCurryArgs::new(launcher_id, nonce).curry_tree_hash()
     }
 
     pub fn puzzle_hash(info: &SlotInfo<V>) -> TreeHash {
@@ -66,10 +50,10 @@ impl<V> Slot<V> {
     }
 
     pub fn construct_puzzle(&self, ctx: &mut SpendContext) -> Result<NodePtr, DriverError> {
-        let self_program = ctx.curry(Slot1stCurryArgs {
-            singleton_struct: SingletonStruct::new(self.info.launcher_id),
-            nonce: self.info.nonce,
-        })?;
+        let self_program = ctx.curry(Slot1stCurryArgs::new(
+            self.info.launcher_id,
+            self.info.nonce,
+        ))?;
 
         ctx.alloc(&CurriedProgram {
             program: self_program,
@@ -88,8 +72,7 @@ impl<V> Slot<V> {
         let puzzle_reveal = ctx.serialize(&puzzle_reveal)?;
 
         let solution = ctx.serialize(&SlotSolution {
-            parent_parent_info: self.proof.parent_parent_info,
-            parent_inner_puzzle_hash: self.proof.parent_inner_puzzle_hash,
+            lineage_proof: self.proof,
             spender_inner_puzzle_hash,
         })?;
 

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

@@ -14,7 +14,7 @@ use crate::{
     XchandlesRegisterAction, XchandlesUpdateAction,
 };
 
-use super::{Slot, SlotProof, XchandlesConstants, XchandlesRegistryInfo, XchandlesRegistryState};
+use super::{Slot, XchandlesConstants, XchandlesRegistryInfo, XchandlesRegistryState};
 
 #[derive(Debug, Clone)]
 pub struct XchandlesPendingSpendInfo {
@@ -367,9 +367,10 @@ impl XchandlesRegistry {
             parent_amount: eve_coin.amount,
         });
 
-        let slot_proof = SlotProof {
-            parent_parent_info: eve_coin.parent_coin_info,
+        let slot_proof = LineageProof {
+            parent_parent_coin_info: eve_coin.parent_coin_info,
             parent_inner_puzzle_hash: eve_singleton_inner_puzzle_hash.into(),
+            parent_amount: 1,
         };
         let slots = [
             Slot::new(
@@ -448,9 +449,10 @@ impl XchandlesRegistry {
         &self,
         slot_value: XchandlesSlotValue,
     ) -> Slot<XchandlesSlotValue> {
-        let proof = SlotProof {
-            parent_parent_info: self.coin.parent_coin_info,
+        let proof = LineageProof {
+            parent_parent_coin_info: self.coin.parent_coin_info,
             parent_inner_puzzle_hash: self.info.inner_puzzle_hash().into(),
+            parent_amount: 1,
         };
 
         Slot::new(

crates/chia-sdk-types/src/puzzles/action_layer/slot.rs

@@ -1,46 +1,69 @@
 use std::borrow::Cow;
 
 use chia_protocol::Bytes32;
-use chia_puzzle_types::singleton::SingletonStruct;
+use chia_puzzle_types::{singleton::SingletonStruct, LineageProof};
+use chia_puzzles::SINGLETON_TOP_LAYER_V1_1_HASH;
 use clvm_traits::{FromClvm, ToClvm};
-use clvm_utils::TreeHash;
+use clvm_utils::{ToTreeHash, TreeHash};
 use hex_literal::hex;
 
 use crate::Mod;
 
-pub const SLOT_PUZZLE: [u8; 456] = hex!(
+pub const SLOT_PUZZLE: [u8; 360] = hex!(
     "
-    ff02ffff01ff04ffff04ff08ffff04ffff30ff2fffff02ff1effff04ff02ffff
-    04ff05ffff04ff5fff8080808080ffff010180ff808080ffff04ffff04ff14ff
-    ff04ffff0112ffff04ff80ffff04ffff02ff1effff04ff02ffff04ff05ffff04
-    ff81bfff8080808080ff8080808080ff808080ffff04ffff01ffff47ff4302ff
+    ff02ffff01ff04ffff04ff08ffff04ffff30ff4fffff02ff1effff04ff02ffff
+    04ff05ffff04ff81afff8080808080ff82016f80ff808080ffff04ffff04ff0c
+    ffff04ffff0112ffff04ff80ffff04ffff02ff1effff04ff02ffff04ff05ffff
+    04ff3fff8080808080ff8080808080ff808080ffff04ffff01ffff4743ff02ff
     ffffa04bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c77
     85459aa09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596
     718ba7b2ffa102a12871fee210fb8619291eaea194581cbd2531e4b23759d225
     f6806923f63222a102a8d5dd63fba471ebcb1f3e8f7c1e1879b7152a6e7298a9
-    1ce119a63400ade7c5ffff02ffff03ffff07ff0580ffff01ff0bffff0102ffff
-    02ff16ffff04ff02ffff04ff09ff80808080ffff02ff16ffff04ff02ffff04ff
-    0dff8080808080ffff01ff0bffff0101ff058080ff0180ff0bff2affff0bff1c
-    ffff0bff1cff32ff0980ffff0bff1cffff0bff3affff0bff1cffff0bff1cff32
-    ffff02ff16ffff04ff02ffff04ff05ff8080808080ffff0bff1cffff0bff3aff
-    ff0bff1cffff0bff1cff32ff0b80ffff0bff1cff32ff22808080ff22808080ff
-    22808080ff018080
+    1ce119a63400ade7c5ff0bff56ffff0bff0affff0bff0aff66ff0980ffff0bff
+    0affff0bff76ffff0bff0affff0bff0aff66ff0d80ffff0bff0affff0bff76ff
+    ff0bff0affff0bff0aff66ff0b80ffff0bff0aff66ff46808080ff46808080ff
+    46808080ff018080
     "
 );
 
 pub const SLOT_PUZZLE_HASH: TreeHash = TreeHash::new(hex!(
     "
-    66460af4bd504bc5e26f05698530a46fceb764b354727faf620e3a49065fa513
+    2d55c0904da19dfb06ccdfb9b6ee3e4117e5856b573c9e5f495a5cdeab35ab51
     "
 ));
 
+#[derive(ToClvm, FromClvm, Debug, Clone, Copy, PartialEq, Eq)]
+#[clvm(list)]
+pub struct PackedSingletonStruct {
+    pub singleton_mod_hash: Bytes32,
+    #[clvm(rest)]
+    pub singleton_struct_hash: Bytes32,
+}
+
+impl PackedSingletonStruct {
+    pub fn new(launcher_id: Bytes32) -> Self {
+        Self {
+            singleton_mod_hash: SINGLETON_TOP_LAYER_V1_1_HASH.into(),
+            singleton_struct_hash: SingletonStruct::new(launcher_id).tree_hash().into(),
+        }
+    }
+}
 #[derive(ToClvm, FromClvm, Debug, Clone, Copy, PartialEq, Eq)]
 #[clvm(curry)]
 pub struct Slot1stCurryArgs {
-    pub singleton_struct: SingletonStruct,
+    pub controller_singleton_info: PackedSingletonStruct,
     pub nonce: u64,
 }
 
+impl Slot1stCurryArgs {
+    pub fn new(launcher_id: Bytes32, nonce: u64) -> Self {
+        Self {
+            controller_singleton_info: PackedSingletonStruct::new(launcher_id),
+            nonce,
+        }
+    }
+}
+
 #[derive(ToClvm, FromClvm, Debug, Clone, Copy, PartialEq, Eq)]
 #[clvm(curry)]
 pub struct Slot2ndCurryArgs {
@@ -50,8 +73,8 @@ pub struct Slot2ndCurryArgs {
 #[derive(ToClvm, FromClvm, Debug, Clone, Copy, PartialEq, Eq)]
 #[clvm(list)]
 pub struct SlotSolution {
-    pub parent_parent_info: Bytes32,
-    pub parent_inner_puzzle_hash: Bytes32,
+    pub lineage_proof: LineageProof,
+    #[clvm(rest)]
     pub spender_inner_puzzle_hash: Bytes32,
 }