Merge pull request #79 from richardkiss/channel_handler_types

Fragment channel handler types into multiple small files

Author: prozacchiwawa

src/channel_handler/types.rs

@@ -0,0 +1,8 @@
+use crate::referee::RefereeOnChainTransaction;
+
+#[derive(Debug)]
+pub enum AcceptTransactionState {
+    Determined(Box<RefereeOnChainTransaction>),
+    Waiting,
+    Finished,
+}

src/channel_handler/types/accept_transaction_state.rs

@@ -0,0 +1,113 @@
+use std::rc::Rc;
+
+use clvm_traits::ToClvm;
+
+use log::debug;
+
+use rand::prelude::*;
+
+use crate::channel_handler::types::{prepend_rem_conditions, ChannelHandlerEnv, UnrollCoin};
+use crate::common::constants::CREATE_COIN;
+use crate::common::standard_coin::standard_solution_partial;
+use crate::common::types::{
+    Aggsig, Amount, BrokenOutCoinSpendInfo, CoinID, CoinString, Error, GameID, IntoErr, Node,
+    PrivateKey, Program, PublicKey, Sha256tree, Spend,
+};
+
+/// Describes all aspects of the channel coin spend.
+/// Allows the user to get the solution, conditions, quoted condition program
+/// and signature for the channel coin spend.
+pub struct ChannelCoin {
+    state_channel_coin: CoinString,
+}
+
+impl ChannelCoin {
+    pub fn new(state_channel_coin: CoinString) -> Self {
+        ChannelCoin { state_channel_coin }
+    }
+
+    pub fn coin_string(&self) -> &CoinString {
+        &self.state_channel_coin
+    }
+    pub fn to_coin_id(&self) -> CoinID {
+        self.state_channel_coin.to_coin_id()
+    }
+
+    pub fn get_solution_and_signature_from_conditions<R: Rng>(
+        &self,
+        env: &mut ChannelHandlerEnv<R>,
+        private_key: &PrivateKey,
+        aggregate_public_key: &PublicKey,
+        conditions: Rc<Program>,
+    ) -> Result<BrokenOutCoinSpendInfo, Error> {
+        debug!("STATE CONDITONS: {conditions:?}");
+        let conditions_nodeptr = conditions.to_nodeptr(env.allocator)?;
+        let spend = standard_solution_partial(
+            env.allocator,
+            private_key,
+            &self.state_channel_coin.to_coin_id(),
+            conditions_nodeptr,
+            aggregate_public_key,
+            &env.agg_sig_me_additional_data,
+            true,
+        )?;
+        Ok(spend)
+    }
+
+    pub fn get_solution_and_signature<R: Rng>(
+        &self,
+        env: &mut ChannelHandlerEnv<R>,
+        private_key: &PrivateKey,
+        aggregate_channel_public_key: &PublicKey,
+        aggregate_unroll_public_key: &PublicKey,
+        amount: &Amount,
+        unroll_coin: &UnrollCoin,
+    ) -> Result<BrokenOutCoinSpendInfo, Error> {
+        debug!(
+            "making solution for channel coin with unroll state {}",
+            unroll_coin.state_number
+        );
+        let unroll_puzzle =
+            unroll_coin.make_curried_unroll_puzzle(env, aggregate_unroll_public_key)?;
+        let unroll_puzzle_hash = Node(unroll_puzzle).sha256tree(env.allocator);
+        let create_conditions = vec![Node(
+            (
+                CREATE_COIN,
+                (unroll_puzzle_hash.clone(), (amount.clone(), ())),
+            )
+                .to_clvm(env.allocator)
+                .into_gen()?,
+        )];
+        let create_conditions_obj = create_conditions.to_clvm(env.allocator).into_gen()?;
+        let create_conditions_with_rem =
+            prepend_rem_conditions(env, unroll_coin.state_number, create_conditions_obj)?;
+        let ccrem_program = Program::from_nodeptr(env.allocator, create_conditions_with_rem)?;
+        self.get_solution_and_signature_from_conditions(
+            env,
+            private_key,
+            aggregate_channel_public_key,
+            Rc::new(ccrem_program),
+        )
+    }
+}
+
+#[derive(Clone, Debug)]
+pub struct ChannelCoinSpentResult {
+    pub transaction: Spend,
+    pub timeout: bool,
+    pub games_canceled: Vec<GameID>,
+}
+
+#[derive(Clone, Debug)]
+pub struct ChannelCoinSpendInfo {
+    pub solution: Rc<Program>,
+    pub conditions: Rc<Program>,
+    pub aggsig: Aggsig,
+}
+
+pub struct ChannelCoinInfo {
+    pub coin: ChannelCoin,
+    pub amount: Amount,
+    // Used in unrolling.
+    pub spend: Spend,
+}

src/channel_handler/types/channel_coin.rs

@@ -0,0 +1,90 @@
+use rand::prelude::*;
+
+use rand::distributions::Standard;
+
+use crate::channel_handler::types::{PotatoSignatures, UnrollCoin};
+use crate::common::types::{
+    Aggsig, AllocEncoder, Amount, CoinID, Hash, PrivateKey, PublicKey, Puzzle, PuzzleHash,
+    Sha256tree, Timeout,
+};
+
+#[derive(Clone)]
+pub struct ChannelHandlerPrivateKeys {
+    pub my_channel_coin_private_key: PrivateKey,
+    pub my_unroll_coin_private_key: PrivateKey,
+    pub my_referee_private_key: PrivateKey,
+}
+
+impl Distribution<ChannelHandlerPrivateKeys> for Standard {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> ChannelHandlerPrivateKeys {
+        ChannelHandlerPrivateKeys {
+            my_channel_coin_private_key: rng.gen(),
+            my_unroll_coin_private_key: rng.gen(),
+            my_referee_private_key: rng.gen(),
+        }
+    }
+}
+
+pub struct ChannelHandlerInitiationData {
+    pub launcher_coin_id: CoinID,
+    pub we_start_with_potato: bool,
+    pub their_channel_pubkey: PublicKey,
+    pub their_unroll_pubkey: PublicKey,
+    pub their_referee_puzzle_hash: PuzzleHash,
+    pub my_contribution: Amount,
+    pub their_contribution: Amount,
+    pub unroll_advance_timeout: Timeout,
+}
+
+#[derive(Clone)]
+pub struct ChannelHandlerInitiationResult {
+    pub channel_puzzle_hash_up: PuzzleHash,
+    pub my_initial_channel_half_signature_peer: Aggsig,
+}
+
+/// The channel handler can use these two items to produce a spend on chain.
+#[derive(Default, Clone)]
+pub struct ChannelHandlerUnrollSpendInfo {
+    /// Contains the half signature, puzzle and conditions needed to spend.
+    pub coin: UnrollCoin,
+    /// Contains the other half of the signature.
+    pub signatures: PotatoSignatures,
+}
+
+pub struct ChannelHandlerEnv<'a, R: Rng> {
+    pub allocator: &'a mut AllocEncoder,
+    pub rng: &'a mut R,
+    pub unroll_metapuzzle: Puzzle,
+    pub unroll_puzzle: Puzzle,
+
+    pub referee_coin_puzzle: Puzzle,
+    pub referee_coin_puzzle_hash: PuzzleHash,
+
+    pub standard_puzzle: Puzzle,
+
+    pub agg_sig_me_additional_data: Hash,
+}
+
+impl<'a, R: Rng> ChannelHandlerEnv<'a, R> {
+    pub fn new(
+        allocator: &'a mut AllocEncoder,
+        rng: &'a mut R,
+        unroll_metapuzzle: Puzzle,
+        unroll_puzzle: Puzzle,
+        referee_coin_puzzle: Puzzle,
+        standard_puzzle: Puzzle,
+        agg_sig_me_additional_data: Hash,
+    ) -> ChannelHandlerEnv<'a, R> {
+        let referee_coin_puzzle_hash = referee_coin_puzzle.sha256tree(allocator);
+        ChannelHandlerEnv {
+            allocator,
+            rng,
+            referee_coin_puzzle,
+            referee_coin_puzzle_hash,
+            unroll_metapuzzle,
+            unroll_puzzle,
+            standard_puzzle,
+            agg_sig_me_additional_data,
+        }
+    }
+}

src/channel_handler/types/channel_handler.rs

@@ -0,0 +1,8 @@
+use crate::common::types::CoinString;
+
+pub struct CoinDataForReward {
+    pub coin_string: CoinString,
+    // parent: CoinID,
+    // puzzle_hash: PuzzleHash,
+    // amount: Amount,
+}

src/channel_handler/types/coin_data_for_reward.rs

@@ -0,0 +1,7 @@
+use crate::common::types::{Amount, PuzzleHash};
+
+#[derive(Debug)]
+pub enum CoinIdentificationByPuzzleHash {
+    Reward(PuzzleHash, Amount),
+    Game(PuzzleHash, Amount),
+}

src/channel_handler/types/coin_identification_by_puzzle_hash.rs

@@ -0,0 +1,41 @@
+use crate::channel_handler::types::OnChainGameCoin;
+use crate::common::types::{Amount, CoinSpend, CoinString, GameID, PuzzleHash};
+use crate::referee::TheirTurnCoinSpentResult;
+
+#[derive(Debug)]
+pub enum CoinSpentInformation {
+    OurReward(PuzzleHash, Amount),
+    OurSpend(PuzzleHash, Amount),
+    TheirSpend(TheirTurnCoinSpentResult),
+    Expected(PuzzleHash, Amount),
+}
+
+#[derive(Debug, Clone)]
+pub struct CoinSpentMoveUp {
+    pub game_id: GameID,
+    pub spend_before_game_coin: CoinSpend,
+    pub after_update_game_coin: CoinString,
+}
+
+#[derive(Debug, Clone)]
+pub struct CoinSpentAccept {
+    pub game_id: GameID,
+    pub spend: CoinSpend,
+    pub reward_coin: CoinString,
+}
+
+// Disposition
+#[derive(Debug, Clone)]
+pub enum CoinSpentDisposition {
+    CancelledUX(Vec<GameID>),
+    Move(CoinSpentMoveUp),
+    Accept(CoinSpentAccept),
+}
+
+#[derive(Debug, Clone)]
+pub struct CoinSpentResult {
+    pub my_clean_reward_coin_string_up: CoinString,
+    // New coins that now exist.
+    pub new_game_coins_on_chain: Vec<OnChainGameCoin>,
+    pub disposition: Option<CoinSpentDisposition>,
+}

src/channel_handler/types/coin_spent.rs

@@ -0,0 +1,27 @@
+use clvm_traits::{ClvmEncoder, ToClvm, ToClvmError};
+use clvmr::allocator::NodePtr;
+
+use crate::common::types::AllocEncoder;
+
+#[derive(Debug, Clone)]
+pub struct Evidence(NodePtr);
+
+impl Evidence {
+    pub fn from_nodeptr(n: NodePtr) -> Evidence {
+        Evidence(n)
+    }
+
+    pub fn nil(allocator: &mut AllocEncoder) -> Evidence {
+        Evidence(allocator.allocator().nil())
+    }
+
+    pub fn to_nodeptr(&self) -> NodePtr {
+        self.0
+    }
+}
+
+impl<E: ClvmEncoder<Node = NodePtr>> ToClvm<E> for Evidence {
+    fn to_clvm(&self, _encoder: &mut E) -> Result<NodePtr, ToClvmError> {
+        Ok(self.0)
+    }
+}