Calculate clear signing messages correctly (#355)

* Calculate clear signing messages correctly

* New messages

* Bindings

Author: Rigidity

bindings/clear_signing.json

@@ -5,8 +5,7 @@
     "fields": {
       "launcher_id": "Bytes32",
       "custody_hash": "TreeHash",
-      "delegated_spend": "Spend",
-      "coin_id": "Option<Bytes32>"
+      "delegated_spend": "Spend"
     }
   },
   "VaultTransaction": {
@@ -22,8 +21,7 @@
       "total_fee": "u64",
       "reserved_fee": "u64",
       "p2_puzzle_hash": "Bytes32",
-      "coin_message_hash": "Option<Bytes32>",
-      "puzzle_message_hash": "Bytes32"
+      "delegated_puzzle_hash": "Bytes32"
     }
   },
   "ParsedPayment": {
@@ -80,5 +78,33 @@
       "puzzle_hash": "Bytes32",
       "amount": "u64"
     }
+  },
+  "calculate_vault_puzzle_message": {
+    "type": "function",
+    "args": {
+      "delegated_puzzle_hash": "Bytes32",
+      "vault_puzzle_hash": "Bytes32"
+    },
+    "return": "Bytes"
+  },
+  "calculate_vault_coin_message": {
+    "type": "function",
+    "args": {
+      "delegated_puzzle_hash": "Bytes32",
+      "vault_coin_id": "Bytes32",
+      "genesis_challenge": "Bytes32"
+    },
+    "return": "Bytes"
+  },
+  "calculate_vault_start_recovery_message": {
+    "type": "function",
+    "args": {
+      "delegated_puzzle_hash": "Bytes32",
+      "left_side_subtree_hash": "Bytes32",
+      "recovery_timelock": "u64",
+      "vault_coin_id": "Bytes32",
+      "genesis_challenge": "Bytes32"
+    },
+    "return": "Bytes"
   }
 }

crates/chia-sdk-bindings/src/clear_signing.rs

@@ -1,4 +1,5 @@
-use chia_protocol::Bytes32;
+use bindy::Result;
+use chia_protocol::{Bytes, Bytes32};
 use chia_sdk_driver::{self as sdk};
 use clvm_utils::TreeHash;
 
@@ -9,7 +10,6 @@ pub struct VaultSpendReveal {
     pub launcher_id: Bytes32,
     pub custody_hash: TreeHash,
     pub delegated_spend: Spend,
-    pub coin_id: Option<Bytes32>,
 }
 
 impl From<VaultSpendReveal> for sdk::VaultSpendReveal {
@@ -18,7 +18,44 @@ impl From<VaultSpendReveal> for sdk::VaultSpendReveal {
             launcher_id: value.launcher_id,
             custody_hash: value.custody_hash,
             delegated_spend: value.delegated_spend.into(),
-            coin_id: value.coin_id,
         }
     }
 }
+
+pub fn calculate_vault_puzzle_message(
+    delegated_puzzle_hash: Bytes32,
+    vault_puzzle_hash: Bytes32,
+) -> Result<Bytes> {
+    Ok(sdk::calculate_vault_puzzle_message(
+        delegated_puzzle_hash,
+        vault_puzzle_hash,
+    ))
+}
+
+pub fn calculate_vault_coin_message(
+    delegated_puzzle_hash: Bytes32,
+    vault_coin_id: Bytes32,
+    genesis_challenge: Bytes32,
+) -> Result<Bytes> {
+    Ok(sdk::calculate_vault_coin_message(
+        delegated_puzzle_hash,
+        vault_coin_id,
+        genesis_challenge,
+    ))
+}
+
+pub fn calculate_vault_start_recovery_message(
+    delegated_puzzle_hash: Bytes32,
+    left_side_subtree_hash: Bytes32,
+    recovery_timelock: u64,
+    vault_coin_id: Bytes32,
+    genesis_challenge: Bytes32,
+) -> Result<Bytes> {
+    Ok(sdk::calculate_vault_start_recovery_message(
+        delegated_puzzle_hash,
+        left_side_subtree_hash,
+        recovery_timelock,
+        vault_coin_id,
+        genesis_challenge,
+    ))
+}

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

@@ -1,20 +1,26 @@
 use std::collections::HashSet;
 
-use chia_protocol::{Bytes32, Coin, CoinSpend};
+use chia_consensus::opcodes::{
+    CREATE_COIN_ANNOUNCEMENT, CREATE_PUZZLE_ANNOUNCEMENT, RECEIVE_MESSAGE, SEND_MESSAGE,
+};
+use chia_protocol::{Bytes, Bytes32, Coin, CoinSpend};
 use chia_puzzle_types::{
     Memos,
     nft::NftMetadata,
     offer::{NotarizedPayment, SettlementPaymentsSolution},
-    singleton::SingletonArgs,
 };
 use chia_puzzles::SETTLEMENT_PAYMENT_HASH;
 use chia_sdk_types::{
-    Condition, MessageFlags, MessageSide, Mod, announcement_id, conditions::CreateCoin,
-    puzzles::SingletonMember, run_puzzle, tree_hash_notarized_payment,
+    Condition, MessageFlags, MessageSide, Mod, announcement_id,
+    conditions::CreateCoin,
+    puzzles::{
+        AddDelegatedPuzzleWrapper, Force1of2RestrictedVariable, PreventConditionOpcode,
+        PreventMultipleCreateCoinsMod, SingletonMember, Timelock,
+    },
+    run_puzzle, tree_hash_notarized_payment,
 };
-use chia_sha2::Sha256;
 use clvm_traits::{FromClvm, ToClvm};
-use clvm_utils::{TreeHash, tree_hash};
+use clvm_utils::{ToTreeHash, TreeHash, tree_hash};
 use clvmr::{Allocator, NodePtr};
 
 use crate::{BURN_PUZZLE_HASH, Cat, ClawbackV2, DriverError, Nft, Puzzle, Spend, mips_puzzle_hash};
@@ -31,8 +37,6 @@ pub struct VaultSpendReveal {
     /// The delegated puzzle we're signing and its solution.
     /// Its output is the non-custody related conditions that the vault spend will output.
     pub delegated_spend: Spend,
-    /// The coin id of the vault coin that is being spent (used for calculating the non-fast forwardable message hash).
-    pub coin_id: Option<Bytes32>,
 }
 
 /// The purpose of this is to provide sufficient information to verify what is happening to a vault and its assets
@@ -63,11 +67,8 @@ pub struct VaultTransaction {
     pub reserved_fee: u64,
     /// The p2 puzzle hash that the vault owns (analogous to a decoded XCH or TXCH address).
     pub p2_puzzle_hash: Bytes32,
-    /// The hash of the delegated puzzle hash and the vault coin id, used for non-fast forwardable spend signing.
-    /// This is only calculated if the vault coin id is provided.
-    pub coin_message_hash: Option<Bytes32>,
-    /// The hash of the delegated puzzle hash and the vault puzzle hash, used for fast forwardable spend signing.
-    pub puzzle_message_hash: Bytes32,
+    /// The original delegated puzzle hash that is being signed for.
+    pub delegated_puzzle_hash: Bytes32,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
@@ -444,24 +445,7 @@ impl VaultTransaction {
             }
         }
 
-        let delegated_puzzle_hash = tree_hash(allocator, vault.delegated_spend.puzzle);
-
-        let coin_message_hash = if let Some(vault_coin_id) = vault.coin_id {
-            let mut coin_message_hasher = Sha256::new();
-            coin_message_hasher.update(delegated_puzzle_hash);
-            coin_message_hasher.update(vault_coin_id);
-            Some(coin_message_hasher.finalize().into())
-        } else {
-            None
-        };
-
-        let vault_puzzle_hash =
-            SingletonArgs::curry_tree_hash(vault.launcher_id, vault.custody_hash);
-
-        let mut puzzle_message_hasher = Sha256::new();
-        puzzle_message_hasher.update(delegated_puzzle_hash);
-        puzzle_message_hasher.update(vault_puzzle_hash);
-        let puzzle_message_hash = puzzle_message_hasher.finalize().into();
+        let delegated_puzzle_hash = tree_hash(allocator, vault.delegated_spend.puzzle).into();
 
         Ok(Self {
             new_custody_hash,
@@ -472,8 +456,7 @@ impl VaultTransaction {
             total_fee: total_input.saturating_sub(total_output),
             reserved_fee,
             p2_puzzle_hash: our_p2_puzzle_hash,
-            coin_message_hash,
-            puzzle_message_hash,
+            delegated_puzzle_hash,
         })
     }
 }
@@ -767,14 +750,81 @@ fn calculate_transfer_type(
     }
 }
 
+pub fn calculate_vault_puzzle_message(
+    delegated_puzzle_hash: Bytes32,
+    vault_puzzle_hash: Bytes32,
+) -> Bytes {
+    [
+        delegated_puzzle_hash.to_bytes(),
+        vault_puzzle_hash.to_bytes(),
+    ]
+    .concat()
+    .into()
+}
+
+pub fn calculate_vault_coin_message(
+    delegated_puzzle_hash: Bytes32,
+    vault_coin_id: Bytes32,
+    genesis_challenge: Bytes32,
+) -> Bytes {
+    [
+        delegated_puzzle_hash.to_bytes(),
+        vault_coin_id.to_bytes(),
+        genesis_challenge.to_bytes(),
+    ]
+    .concat()
+    .into()
+}
+
+pub fn calculate_vault_start_recovery_message(
+    delegated_puzzle_hash: Bytes32,
+    left_side_subtree_hash: Bytes32,
+    recovery_timelock: u64,
+    vault_coin_id: Bytes32,
+    genesis_challenge: Bytes32,
+) -> Bytes {
+    let mut delegated_puzzle_hash: TreeHash = delegated_puzzle_hash.into();
+
+    let restrictions = vec![
+        Force1of2RestrictedVariable::new(
+            left_side_subtree_hash,
+            0,
+            vec![Timelock::new(recovery_timelock).curry_tree_hash()]
+                .tree_hash()
+                .into(),
+            ().tree_hash().into(),
+        )
+        .curry_tree_hash(),
+        PreventConditionOpcode::new(CREATE_COIN_ANNOUNCEMENT).curry_tree_hash(),
+        PreventConditionOpcode::new(CREATE_PUZZLE_ANNOUNCEMENT).curry_tree_hash(),
+        PreventConditionOpcode::new(SEND_MESSAGE).curry_tree_hash(),
+        PreventConditionOpcode::new(RECEIVE_MESSAGE).curry_tree_hash(),
+        PreventMultipleCreateCoinsMod::mod_hash(),
+    ];
+
+    for restriction in restrictions.into_iter().rev() {
+        delegated_puzzle_hash =
+            AddDelegatedPuzzleWrapper::new(restriction, delegated_puzzle_hash).curry_tree_hash();
+    }
+
+    [
+        delegated_puzzle_hash.to_bytes(),
+        vault_coin_id.to_bytes(),
+        genesis_challenge.to_bytes(),
+    ]
+    .concat()
+    .into()
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
 
     use anyhow::Result;
+    use chia_bls::verify;
     use chia_puzzles::SINGLETON_LAUNCHER_HASH;
     use chia_sdk_test::Simulator;
-    use chia_sdk_types::Conditions;
+    use chia_sdk_types::{Conditions, TESTNET11_CONSTANTS};
     use rstest::rstest;
 
     use crate::{Action, FeeAction, Id, SpendContext, Spends, TestVault};
@@ -831,7 +881,6 @@ mod tests {
             launcher_id: alice.launcher_id(),
             custody_hash: alice.custody_hash(),
             delegated_spend: result.delegated_spend,
-            coin_id: None,
         };
 
         let tx = VaultTransaction::parse(&mut ctx, &reveal, result.coin_spends)?;
@@ -897,7 +946,6 @@ mod tests {
             launcher_id: bob.launcher_id(),
             custody_hash: bob.custody_hash(),
             delegated_spend: result.delegated_spend,
-            coin_id: None,
         };
 
         let tx = VaultTransaction::parse(&mut ctx, &reveal, result.coin_spends)?;
@@ -933,7 +981,6 @@ mod tests {
             launcher_id: bob.launcher_id(),
             custody_hash: bob.custody_hash(),
             delegated_spend: result.delegated_spend,
-            coin_id: None,
         };
 
         let tx = VaultTransaction::parse(&mut ctx, &reveal, result.coin_spends)?;
@@ -973,7 +1020,6 @@ mod tests {
             launcher_id: alice.launcher_id(),
             custody_hash: alice.custody_hash(),
             delegated_spend: result.delegated_spend,
-            coin_id: None,
         };
 
         let tx = VaultTransaction::parse(&mut ctx, &reveal, result.coin_spends)?;
@@ -1024,7 +1070,6 @@ mod tests {
             launcher_id: alice.launcher_id(),
             custody_hash: alice.custody_hash(),
             delegated_spend: result.delegated_spend,
-            coin_id: None,
         };
 
         let tx = VaultTransaction::parse(&mut ctx, &reveal, result.coin_spends)?;
@@ -1090,7 +1135,6 @@ mod tests {
             launcher_id: alice.launcher_id(),
             custody_hash: alice.custody_hash(),
             delegated_spend: result.delegated_spend,
-            coin_id: None,
         };
 
         let tx = VaultTransaction::parse(&mut ctx, &reveal, result.coin_spends)?;
@@ -1117,7 +1161,6 @@ mod tests {
             launcher_id: alice.launcher_id(),
             custody_hash: alice.custody_hash(),
             delegated_spend: result.delegated_spend,
-            coin_id: None,
         };
 
         let tx = VaultTransaction::parse(&mut ctx, &reveal, result.coin_spends)?;
@@ -1160,7 +1203,6 @@ mod tests {
             launcher_id: alice.launcher_id(),
             custody_hash: alice.custody_hash(),
             delegated_spend: result.delegated_spend,
-            coin_id: None,
         };
 
         let tx = VaultTransaction::parse(&mut ctx, &reveal, result.coin_spends)?;
@@ -1178,4 +1220,41 @@ mod tests {
 
         Ok(())
     }
+
+    #[rstest]
+    fn test_clear_signing_coin_message() -> Result<()> {
+        let mut sim = Simulator::new();
+        let mut ctx = SpendContext::new();
+
+        let alice = TestVault::mint(&mut sim, &mut ctx, 1000)?;
+        let bob = TestVault::mint(&mut sim, &mut ctx, 0)?;
+
+        let vault = alice.fetch_vault(&sim)?;
+
+        let result = alice.spend(
+            &mut sim,
+            &mut ctx,
+            &[Action::send(Id::Xch, bob.puzzle_hash(), 1000, Memos::None)],
+        )?;
+
+        let reveal = VaultSpendReveal {
+            launcher_id: alice.launcher_id(),
+            custody_hash: alice.custody_hash(),
+            delegated_spend: result.delegated_spend,
+        };
+
+        let tx = VaultTransaction::parse(&mut ctx, &reveal, result.coin_spends)?;
+        assert_eq!(tx.new_custody_hash, Some(alice.custody_hash()));
+        assert_eq!(tx.payments.len(), 1);
+
+        let coin_message = calculate_vault_coin_message(
+            tx.delegated_puzzle_hash,
+            vault.coin.coin_id(),
+            TESTNET11_CONSTANTS.genesis_challenge,
+        );
+
+        assert!(verify(&result.signature, &alice.public_key, coin_message));
+
+        Ok(())
+    }
 }