A mess but we're properly connected to the simulator

Author: prozacchiwawa

src/channel_handler/mod.rs

@@ -19,7 +19,7 @@ use crate::channel_handler::types::{
 use crate::common::constants::{CREATE_COIN, REM};
 use crate::common::standard_coin::{
     ChiaIdentity, agg_sig_me_message, aggregate_public_keys, partial_signer, private_to_public_key,
-    puzzle_for_pk, puzzle_hash_for_pk, sign_agg_sig_me, standard_solution,
+    puzzle_for_pk, puzzle_hash_for_pk, sign_agg_sig_me, standard_solution_unsafe,
     standard_solution_partial, unsafe_sign_partial,
 };
 use crate::common::types::{
@@ -303,6 +303,7 @@ impl ChannelHandler {
             create_conditions_with_rem,
             &aggregated_key_for_unroll_create,
             &env.agg_sig_me_additional_data,
+            true
         )
     }
 
@@ -944,6 +945,7 @@ impl ChannelHandler {
             conditions,
             &aggregate_public_key,
             &env.agg_sig_me_additional_data,
+            true
         )?;
         Ok(TransactionBundle {
             solution,
@@ -973,6 +975,7 @@ impl ChannelHandler {
             conditions,
             &aggregate_public_key,
             &env.agg_sig_me_additional_data,
+            false
         )?;
 
         Ok((state_channel_coin.clone(), solution, signature))
@@ -1475,7 +1478,7 @@ impl ChannelHandler {
 
             coins_with_solutions.push(TransactionBundle {
                 puzzle: spend_coin_puzzle.clone(),
-                solution: standard_solution(
+                solution: standard_solution_unsafe(
                     env.allocator,
                     &self.referee_private_key(),
                     conditions,

src/common/standard_coin.rs

@@ -7,7 +7,7 @@ use chia_bls;
 use clvm_traits::{clvm_curried_args, ToClvm};
 
 use clvmr::allocator::NodePtr;
-use clvm_tools_rs::util::number_from_u8;
+use clvm_tools_rs::util::{number_from_u8, u8_from_number};
 
 use clvm_tools_rs::classic::clvm::__type_compatibility__::{
     Bytes, Stream, UnvalidatedBytesFromType,
@@ -87,6 +87,23 @@ fn test_calculate_synthetic_offset() {
     assert_eq!(offset, want_offset);
 }
 
+pub fn calculate_synthetic_secret_key(secret_key: &PrivateKey, hidden_puzzle_hash: &Hash) -> Result<PrivateKey, types::Error> {
+    let secret_exponent_bytes = secret_key.bytes();
+    let secret_exponent = number_from_u8(&secret_exponent_bytes);
+    let public_key = private_to_public_key(secret_key);
+    let synthetic_secret_offset = calculate_synthetic_offset(&public_key, &PuzzleHash::from_hash(hidden_puzzle_hash.clone()));
+    let synthetic_secret_exponent = (secret_exponent + synthetic_secret_offset) % group_order_int();
+    let private_key_bytes_right = u8_from_number(synthetic_secret_exponent);
+    let mut private_key_bytes: [u8; 32] = [0; 32];
+    for (i, b) in private_key_bytes_right.iter().enumerate() {
+        private_key_bytes[i + 32 - private_key_bytes.len()] = *b;
+    }
+    PrivateKey::from_bytes(&private_key_bytes)
+        .map(Ok)
+        .unwrap_or_else(|e| Err(format!("calculate_synthetic_public_key: {e:?}")))
+        .into_gen()
+}
+
 pub fn calculate_synthetic_public_key(
     public_key: &PublicKey,
     hidden_puzzle_hash: &PuzzleHash,
@@ -369,7 +386,7 @@ pub fn sign_agg_sig_me(
     signed
 }
 
-pub fn standard_solution(
+pub fn standard_solution_unsafe(
     allocator: &mut AllocEncoder,
     private_key: &PrivateKey,
     conditions: NodePtr,
@@ -384,10 +401,11 @@ pub fn standard_solution(
 pub fn standard_solution_partial(
     allocator: &mut AllocEncoder,
     private_key: &PrivateKey,
-    unroll_coin_parent: &CoinID,
+    parent_coin: &CoinID,
     conditions: NodePtr,
     aggregate_public_key: &PublicKey,
     agg_sig_me_additional_data: &Hash,
+    partial: bool,
 ) -> Result<(NodePtr, Aggsig), types::Error> {
     // Fairly certain i understand that because of the property that
     // (SK1 + SK2).sign((PK1 + PK2) || msg) ==
@@ -423,20 +441,24 @@ pub fn standard_solution_partial(
             CoinCondition::CreateCoin(_ph) => {
                 let agg_sig_me_message = agg_sig_me_message(
                     &quoted_conds_hash.bytes(),
-                    unroll_coin_parent,
+                    parent_coin,
                     agg_sig_me_additional_data,
                 );
                 eprintln!("public_key {aggregate_public_key:?} {agg_sig_me_message:?}");
                 add_signature(
                     &mut aggregated_signature,
-                    partial_signer(private_key, aggregate_public_key, &agg_sig_me_message),
+                    if partial {
+                        partial_signer(private_key, &aggregate_public_key, &agg_sig_me_message)
+                    } else {
+                        private_key.sign(&agg_sig_me_message)
+                    }
                 );
             }
             CoinCondition::AggSigMe(pubkey, data) => {
                 let mut message = pubkey.bytes().to_vec();
                 message.extend_from_slice(&data);
                 let agg_sig_me_message =
-                    agg_sig_me_message(&message, unroll_coin_parent, agg_sig_me_additional_data);
+                    agg_sig_me_message(&message, parent_coin, agg_sig_me_additional_data);
                 add_signature(
                     &mut aggregated_signature,
                     partial_signer(private_key, &pubkey, &agg_sig_me_message),

src/common/types.rs

@@ -28,7 +28,7 @@ use clvm_traits::{ClvmEncoder, ToClvm, ToClvmError};
 use clvm_tools_rs::compiler::runtypes::RunFailure;
 
 /// CoinID
-#[derive(Default, Clone)]
+#[derive(Default, Clone, Debug)]
 pub struct CoinID(Hash);
 
 impl CoinID {
@@ -58,6 +58,9 @@ impl CoinString {
         let mut allocator = AllocEncoder::new();
         let amount_clvm = amount.to_clvm(&mut allocator).unwrap();
         let mut res = Vec::new();
+        eprintln!("parent {parent:?}");
+        eprintln!("puzzle_hash {puzzle_hash:?}");
+        eprintln!("amount {amount:?}");
         res.append(&mut parent.bytes().to_vec());
         res.append(&mut puzzle_hash.bytes().to_vec());
         res.append(&mut allocator.allocator().atom(amount_clvm).to_vec());
@@ -380,7 +383,7 @@ impl Hash {
     }
     pub fn from_slice(by: &[u8]) -> Hash {
         let mut fixed: [u8; 32] = [0; 32];
-        for (i, b) in by.iter().enumerate() {
+        for (i, b) in by.iter().enumerate().take(32) {
             fixed[i % 32] = *b;
         }
         Hash::from_bytes(fixed)

src/referee.rs

@@ -15,7 +15,7 @@ use crate::channel_handler::types::{GameStartInfo, ReadableMove, ReadableUX};
 use crate::common::constants::CREATE_COIN;
 use crate::common::standard_coin::{
     curry_and_treehash, private_to_public_key, puzzle_for_pk, puzzle_hash_for_pk, sign_agg_sig_me,
-    standard_solution, ChiaIdentity,
+    standard_solution_unsafe, ChiaIdentity,
 };
 use crate::common::types::{
     u64_from_atom, usize_from_atom, Aggsig, AllocEncoder, Amount, CoinCondition, CoinString, Error,
@@ -672,7 +672,7 @@ impl RefereeMaker {
             // XXX puzzle_reveal
                 (CREATE_COIN, (puzzle_hash.clone(), (self.amount.clone(), ()))).to_clvm(allocator).into_gen()?;
             let (solution, sig) =
-                standard_solution(allocator, &self.my_identity.private_key, inner_conditions)?;
+                standard_solution_unsafe(allocator, &self.my_identity.private_key, inner_conditions)?;
             let args_list: Vec<Node> = [
                 previous_state.game_move.move_made.to_clvm(allocator).into_gen()?,
                 previous_state
@@ -733,7 +733,11 @@ impl RefereeMaker {
                 .to_clvm(allocator)
                 .into_gen()?;
             let (solution, sig) =
-                standard_solution(allocator, &self.my_identity.private_key, inner_conditions)?;
+                standard_solution_unsafe(
+                    allocator,
+                    &self.my_identity.private_key,
+                    inner_conditions
+                )?;
             let args_list: Vec<Node> = [
                 current_state.game_move.move_made.to_clvm(allocator).into_gen()?,
                 current_state
@@ -1117,7 +1121,11 @@ impl RefereeMaker {
             .into_gen()?;
 
         let (slash_solution, slash_aggsig) =
-            standard_solution(allocator, &self.my_identity.private_key, slash_conditions)?;
+            standard_solution_unsafe(
+                allocator,
+                &self.my_identity.private_key,
+                slash_conditions
+            )?;
 
         let (state, validation_program) = {
             let current_state = self.current_state();

src/tests/simulator.rs

@@ -1,6 +1,8 @@
 use clvmr::allocator::NodePtr;
 use clvm_traits::ToClvm;
 
+use clvm_tools_rs::classic::clvm_tools::binutils::disassemble;
+
 use pyo3::prelude::*;
 use pyo3::types::{PyNone, PyBytes, PyTuple};
 use rand::prelude::*;
@@ -9,10 +11,9 @@ use rand_chacha::ChaCha8Rng;
 
 use indoc::indoc;
 
-use crate::common::constants::CREATE_COIN;
-use crate::common::standard_coin::standard_solution;
-use crate::common::types::{ErrToError, Error, Puzzle, Amount, Hash, CoinString, CoinID, PuzzleHash, PrivateKey, Aggsig, Node, SpecificTransactionBundle, AllocEncoder, TransactionBundle};
-use crate::common::standard_coin::ChiaIdentity;
+use crate::common::constants::{AGG_SIG_ME_ADDITIONAL_DATA, CREATE_COIN, DEFAULT_HIDDEN_PUZZLE_HASH};
+use crate::common::standard_coin::{sign_agg_sig_me, standard_solution_partial, ChiaIdentity, calculate_synthetic_secret_key, private_to_public_key, calculate_synthetic_public_key, agg_sig_me_message};
+use crate::common::types::{ErrToError, Error, Puzzle, Amount, Hash, CoinString, CoinID, PuzzleHash, PrivateKey, Aggsig, Node, SpecificTransactionBundle, AllocEncoder, TransactionBundle, ToQuotedProgram, Sha256tree};
 
 // Allow simulator from rust.
 struct Simulator {
@@ -127,6 +128,8 @@ impl Simulator {
             let mut result_coins = Vec::new();
             for i in items.iter() {
                 let coin_of_item: PyObject = i.getattr(py, "coin")?.extract(py)?;
+                let as_list_str: String = coin_of_item.call_method0(py, "__repr__")?.extract(py)?;
+                eprintln!("as_list_str {as_list_str}");
                 let as_list: Vec<PyObject> = self.coin_as_list.call1(py, (coin_of_item,))?.extract(py)?;
                 let parent_coin_info: &PyBytes = as_list[0].downcast(py)?;
                 let parent_coin_info_slice: &[u8] = parent_coin_info.extract()?;
@@ -231,6 +234,8 @@ impl Simulator {
             let (inclusion_status, err): (PyObject, PyObject) = spend_res.extract(py)?;
             eprintln!("inclusion_status {inclusion_status}");
             let status: u32 = inclusion_status.extract(py)?;
+            let e: String = err.call_method0(py, "__repr__")?.extract(py)?;
+            eprintln!("err {e:?}");
             Ok(status)
         })
     }
@@ -241,13 +246,16 @@ fn test_sim() {
     let seed: [u8; 32] = [0; 32];
     let mut rng = ChaCha8Rng::from_seed(seed);
     let mut allocator = AllocEncoder::new();
+    let agg_sig_me_additional_data = Hash::from_slice(&AGG_SIG_ME_ADDITIONAL_DATA);
     let s = Simulator::new();
     let private_key: PrivateKey = rng.gen();
     let identity = ChiaIdentity::new(&mut allocator, private_key.clone()).expect("should create");
+    eprintln!("identity public key {:?}", identity.public_key);
     s.farm_block(&identity.puzzle_hash);
 
     let coins = s.get_my_coins(&identity.puzzle_hash).expect("got coins");
-    eprintln!("coins {coins:?}");
+    eprintln!("coin 0 {:?}", coins[0].to_parts());
+    eprintln!("coin 0 id {:?}", coins[0].to_coin_id());
 
     let (first_coin_parent, first_coin_ph, first_coin_amt) = coins[0].to_parts().unwrap();
     assert_eq!(first_coin_ph, identity.puzzle_hash);
@@ -258,38 +266,56 @@ fn test_sim() {
           (Amount::new(1), ())
          )
         ),
-        (CREATE_COIN,
-         (identity.puzzle_hash.clone(),
-          (first_coin_amt - Amount::new(1), ())
-         )
-        )
+        // (CREATE_COIN,
+        //  (identity.puzzle_hash.clone(),
+        //   (first_coin_amt - Amount::new(1), ())
+        //  )
+        // )
     ].to_clvm(&mut allocator).expect("should create conditions");
 
-    let (solution, signature) = standard_solution(
+    let default_hidden_puzzle_hash = Hash::from_bytes(DEFAULT_HIDDEN_PUZZLE_HASH.clone());
+    let synthetic_secret_key = calculate_synthetic_secret_key(
+        &identity.private_key,
+        &default_hidden_puzzle_hash
+    ).expect("should be ok");
+    let synthetic_public_key = private_to_public_key(&synthetic_secret_key);
+    assert_eq!(
+        synthetic_public_key,
+        calculate_synthetic_public_key(
+            &identity.public_key,
+            &PuzzleHash::from_hash(default_hidden_puzzle_hash.clone())
+        ).expect("should be ok")
+    );
+    let (solution, signature1) = standard_solution_partial(
         &mut allocator,
-        &private_key,
-        conditions
+        &synthetic_secret_key,
+        &coins[0].to_coin_id(),
+        conditions,
+        &synthetic_public_key,
+        &agg_sig_me_additional_data,
+        false
     ).expect("should build");
 
-    let spend =
-        Python::with_gil(|py| {
-            s.make_coin_spend(
-                py,
-                &mut allocator,
-                &CoinString::from_parts(&CoinID::default(), &PuzzleHash::default(), &Amount::default()),
-                identity.puzzle.clone(),
-                solution
-            )
-        }).expect("should get a spend");
+    let quoted_conds = conditions.to_quoted_program(&mut allocator).expect("should work");
+    let hashed_conds = quoted_conds.sha256tree(&mut allocator);
+    let agg_sig_me_message = agg_sig_me_message(
+        &hashed_conds.bytes(),
+        &coins[0].to_coin_id(),
+        &agg_sig_me_additional_data
+    );
+    eprintln!("our message {agg_sig_me_message:?}");
+    let signature2 = synthetic_secret_key.sign(&agg_sig_me_message);
+    assert_eq!(signature1, signature2);
 
-    eprintln!("spend {spend:?}");
+    eprintln!("our cond hash {hashed_conds:?}");
+    eprintln!("our signature {signature1:?}");
 
     let specific = SpecificTransactionBundle {
         coin: coins[0].clone(),
         bundle: TransactionBundle {
             puzzle: identity.puzzle.clone(),
             solution,
-            signature,
+            signature: signature1,
         }
     };
 

src/tests/standard_coin.rs

@@ -11,7 +11,7 @@ use crate::common::constants::{DEFAULT_HIDDEN_PUZZLE_HASH, ONE, TWO};
 use crate::common::standard_coin::{
     calculate_hash_of_quoted_mod_hash, calculate_synthetic_public_key, curry_and_treehash,
     get_standard_coin_puzzle, hex_to_sexp, partial_signer, private_to_public_key, puzzle_for_pk,
-    puzzle_hash_for_pk, standard_solution, unsafe_sign_partial,
+    puzzle_hash_for_pk, standard_solution_unsafe, unsafe_sign_partial,
 };
 use crate::common::types::{
     Aggsig, AllocEncoder, Node, PrivateKey, PublicKey, PuzzleHash, Sha256Input, Sha256tree,
@@ -182,7 +182,11 @@ fn test_standard_puzzle_solution_maker() {
         (synthetic_public_key, (quoted_conditions_hash.clone(), ())),
     );
     let (solution, signature) =
-        standard_solution(&mut allocator, &mut &private_key, conditions).expect("should work");
+        standard_solution_unsafe(
+            &mut allocator,
+            &mut &private_key,
+            conditions
+        ).expect("should work");
     let expected_full_conditions = (expected_added_condition, Node(conditions))
         .to_clvm(&mut allocator)
         .expect("should work");