Merge pull request #427 from coblox/instantiate-state-406

Refactor State Machine and Events have correct types for Alice AND Bob

Author: LLFourn

application/comit_node/src/comit_client/mod.rs

@@ -7,7 +7,7 @@ use std::{io, net::SocketAddr, sync::Arc};
 use std::{fmt::Debug, panic::RefUnwindSafe};
 use swap_protocols::{bam_types, rfc003};
 
-pub trait Client: Send + Sync {
+pub trait Client: Send + Sync + 'static {
     fn send_swap_request<
         SL: rfc003::Ledger,
         TL: rfc003::Ledger,

application/comit_node/src/http_api/rfc003/swap.rs

@@ -13,8 +13,9 @@ use swap_protocols::{
     ledger::{Bitcoin, Ethereum},
     rfc003::{
         self, bitcoin,
+        roles::{Alice, Bob},
         state_store::{self, StateStore},
-        Ledger, Secret, SecretHash,
+        Ledger, Secret,
     },
     Assets, Ledgers, Metadata, MetadataStore, Roles,
 };
@@ -290,14 +291,16 @@ fn handle_state_for_get_swap<T: MetadataStore<SwapId>, S: state_store::StateStor
             target_asset: Assets::Ether,
             role,
         }) => match role {
-            Roles::Alice => match state_store
-                .get::<Bitcoin, Ethereum, BitcoinQuantity, EtherQuantity, Secret>(id)
-            {
-                Err(e) => error!("Could not retrieve state: {:?}", e),
-                Ok(state) => info!("Here is the state we have retrieved: {:?}", state),
-            },
+            Roles::Alice => {
+                match state_store
+                    .get::<Alice<Bitcoin, Ethereum, BitcoinQuantity, EtherQuantity>>(id)
+                {
+                    Err(e) => error!("Could not retrieve state: {:?}", e),
+                    Ok(state) => info!("Here is the state we have retrieved: {:?}", state),
+                }
+            }
             Roles::Bob => match state_store
-                .get::<Bitcoin, Ethereum, BitcoinQuantity, EtherQuantity, SecretHash>(id)
+                .get::<Bob<Bitcoin, Ethereum, BitcoinQuantity, EtherQuantity>>(id)
             {
                 Err(e) => error!("Could not retrieve state: {:?}", e),
                 Ok(state) => info!("Here is the state we have retrieved: {:?}", state),

application/comit_node/src/swap_protocols/rfc003/actions/alice/btc_eth.rs

@@ -8,13 +8,12 @@ use swap_protocols::{
             ethereum::EtherRedeem,
             Action, StateActions,
         },
-        bitcoin::{bitcoin_htlc, bitcoin_htlc_address},
+        roles::Alice,
         state_machine::*,
-        Secret,
     },
 };
 
-impl StateActions for SwapStates<Bitcoin, Ethereum, BitcoinQuantity, EtherQuantity, Secret> {
+impl StateActions for SwapStates<Alice<Bitcoin, Ethereum, BitcoinQuantity, EtherQuantity>> {
     type Accept = ();
     type Decline = ();
     type Fund = BitcoinFund;
@@ -26,7 +25,7 @@ impl StateActions for SwapStates<Bitcoin, Ethereum, BitcoinQuantity, EtherQuanti
         match *self {
             SS::Start { .. } => vec![],
             SS::Accepted(Accepted { ref swap, .. }) => vec![Action::Fund(BitcoinFund {
-                address: bitcoin_htlc_address(swap),
+                address: swap.source_htlc_params().compute_address(),
                 value: swap.source_asset,
             })],
             SS::SourceFunded { .. } => vec![],
@@ -44,7 +43,7 @@ impl StateActions for SwapStates<Bitcoin, Ethereum, BitcoinQuantity, EtherQuanti
                 }),
                 Action::Refund(BitcoinRefund {
                     outpoint: *source_htlc_location,
-                    htlc: bitcoin_htlc(swap),
+                    htlc: swap.source_htlc_params().into(),
                     value: swap.source_asset,
                     transient_keypair: swap.source_ledger_refund_identity,
                 }),
@@ -60,7 +59,7 @@ impl StateActions for SwapStates<Bitcoin, Ethereum, BitcoinQuantity, EtherQuanti
                 ..
             }) => vec![Action::Refund(BitcoinRefund {
                 outpoint: *source_htlc_location,
-                htlc: bitcoin_htlc(swap),
+                htlc: swap.source_htlc_params().into(),
                 value: swap.source_asset,
                 transient_keypair: swap.source_ledger_refund_identity,
             })],

application/comit_node/src/swap_protocols/rfc003/actions/bob/btc_eth.rs

@@ -8,14 +8,13 @@ use swap_protocols::{
             ethereum::{EtherDeploy, EtherRefund},
             Accept, Action, Decline, StateActions,
         },
-        bitcoin::bitcoin_htlc,
-        ethereum::ethereum_htlc,
+        ethereum::{EtherHtlc, Htlc},
+        roles::Bob,
         state_machine::*,
-        SecretHash,
     },
 };
 
-impl StateActions for SwapStates<Bitcoin, Ethereum, BitcoinQuantity, EtherQuantity, SecretHash> {
+impl StateActions for SwapStates<Bob<Bitcoin, Ethereum, BitcoinQuantity, EtherQuantity>> {
     type Accept = Accept;
     type Decline = Decline;
     type Fund = EtherDeploy;
@@ -28,7 +27,7 @@ impl StateActions for SwapStates<Bitcoin, Ethereum, BitcoinQuantity, EtherQuanti
             SS::Start { .. } => vec![Action::Accept(Accept), Action::Decline(Decline)],
             SS::Accepted { .. } => vec![],
             SS::SourceFunded(SourceFunded { ref swap, .. }) => {
-                let htlc = ethereum_htlc(swap);
+                let htlc: EtherHtlc = swap.target_htlc_params().into();
                 vec![Action::Fund(EtherDeploy {
                     data: htlc.compile_to_hex().into(),
                     value: swap.target_asset,
@@ -68,9 +67,9 @@ impl StateActions for SwapStates<Bitcoin, Ethereum, BitcoinQuantity, EtherQuanti
                 ..
             }) => vec![Action::Redeem(BitcoinRedeem {
                 outpoint: *source_htlc_location,
-                htlc: bitcoin_htlc(swap),
+                htlc: swap.source_htlc_params().into(),
                 value: swap.source_asset,
-                transient_keypair: swap.source_ledger_refund_identity,
+                transient_keypair: swap.source_ledger_success_identity,
                 secret: *secret,
             })],
             SS::Error(_) => vec![],
@@ -84,16 +83,14 @@ mod tests {
 
     use super::*;
     use bitcoin_support;
-    use hex;
-    use secp256k1_support;
-    use swap_protocols::rfc003::Secret;
+    use hex::FromHex;
+    use swap_protocols::rfc003::{roles::test::Bobisha, Secret};
 
     #[test]
     fn given_state_instance_when_calling_actions_should_not_need_to_specify_type_arguments() {
-        let swap_state = SwapStates::from(Start {
-            source_ledger_refund_identity: secp256k1_support::KeyPair::from_secret_key_slice(
-                &hex::decode("18e14a7b6a307f426a94f8114701e7c8e774e7f9a47e2c2035db29a206321725")
-                    .unwrap(),
+        let swap_state = SwapStates::from(Start::<Bobisha> {
+            source_ledger_refund_identity: bitcoin_support::PubkeyHash::from_hex(
+                "875638cac0b0ae9f826575e190f2788918c354c2",
             )
             .unwrap(),
             target_ledger_success_identity: "8457037fcd80a8650c4692d7fcfc1d0a96b92867"

application/comit_node/src/swap_protocols/rfc003/alice/handler.rs

@@ -15,9 +15,10 @@ use swap_protocols::{
         self,
         alice::SwapRequests,
         messages::Request,
+        roles::Alice,
         state_machine::{Start, SwapStates},
         state_store::StateStore,
-        ExtractSecret, Ledger, Secret,
+        Ledger, Secret,
     },
 };
 use swaps::{alice_events, common::SwapId};
@@ -123,11 +124,9 @@ impl<
 
 fn spawn_state_machine<SL: Ledger, TL: Ledger, SA: Asset, TA: Asset, S: StateStore<SwapId>>(
     id: SwapId,
-    start_state: Start<SL, TL, SA, TA, Secret>,
+    start_state: Start<Alice<SL, TL, SA, TA>>,
     state_store: &S,
-) where
-    TL::Transaction: ExtractSecret,
-{
+) {
     let state = SwapStates::Start(start_state);
 
     // TODO: spawn state machine from state here

application/comit_node/src/swap_protocols/rfc003/bitcoin/extract_secret.rs

@@ -1,9 +1,15 @@
 use bitcoin_support::Transaction;
-use swap_protocols::rfc003::secret::{ExtractSecret, Secret, SecretHash};
+use swap_protocols::{
+    ledger::Bitcoin,
+    rfc003::{
+        secret::{Secret, SecretHash},
+        ExtractSecret,
+    },
+};
 
-impl ExtractSecret for Transaction {
-    fn extract_secret(&self, secret_hash: &SecretHash) -> Option<Secret> {
-        self.input.iter().find_map(|txin| {
+impl ExtractSecret for Bitcoin {
+    fn extract_secret(transaction: &Transaction, secret_hash: &SecretHash) -> Option<Secret> {
+        transaction.input.iter().find_map(|txin| {
             txin.witness
                 .iter()
                 .find_map(|script_item| match Secret::from_vec(&script_item) {
@@ -50,7 +56,7 @@ mod test {
         let secret = Secret::from(*b"This is our favourite passphrase");
         let transaction = setup(&secret);
 
-        assert_that!(transaction.extract_secret(&secret.hash()))
+        assert_that!(Bitcoin::extract_secret(&transaction, &secret.hash()))
             .is_some()
             .is_equal_to(&secret);
     }
@@ -65,7 +71,7 @@ mod test {
              bfbfbfbfbfbfbfbfbfbfbfbfbfbfbfbf",
         )
         .unwrap();
-        assert_that!(transaction.extract_secret(&secret_hash)).is_none();
+        assert_that!(Bitcoin::extract_secret(&transaction, &secret_hash)).is_none();
     }
 
     #[test]
@@ -77,7 +83,7 @@ mod test {
                 .unwrap();
         let secret = Secret::from_vec(&hex_secret).unwrap();
 
-        assert_that!(transaction.extract_secret(&secret.hash()))
+        assert_that!(Bitcoin::extract_secret(&transaction, &secret.hash()))
             .is_some()
             .is_equal_to(&secret);
     }

application/comit_node/src/swap_protocols/rfc003/bitcoin/mod.rs

@@ -1,39 +1,39 @@
 use bitcoin_support::{Address, BitcoinQuantity, Blocks, OutPoint};
 use secp256k1_support::KeyPair;
-use swap_protocols::{ledger::Bitcoin, rfc003::Ledger};
+use swap_protocols::{
+    ledger::Bitcoin,
+    rfc003::{state_machine::HtlcParams, Ledger},
+};
 
 mod extract_secret;
 mod htlc;
 mod queries;
+mod validation;
 
 pub use self::{
     htlc::{Htlc, UnlockingError},
     queries::*,
 };
-use swap_protocols::{
-    asset::Asset,
-    rfc003::{state_machine::OngoingSwap, IntoSecretHash},
-};
 
 impl Ledger for Bitcoin {
     type LockDuration = Blocks;
     type HtlcLocation = OutPoint;
     type HtlcIdentity = KeyPair;
 }
 
-pub fn bitcoin_htlc<TL: Ledger, TA: Asset, S: IntoSecretHash>(
-    swap: &OngoingSwap<Bitcoin, TL, BitcoinQuantity, TA, S>,
-) -> Htlc {
-    Htlc::new(
-        swap.source_ledger_success_identity,
-        swap.source_ledger_refund_identity,
-        swap.secret.clone().into(),
-        swap.source_ledger_lock_duration.into(),
-    )
+impl From<HtlcParams<Bitcoin, BitcoinQuantity>> for Htlc {
+    fn from(htlc_params: HtlcParams<Bitcoin, BitcoinQuantity>) -> Self {
+        Htlc::new(
+            htlc_params.success_identity,
+            htlc_params.refund_identity,
+            htlc_params.secret_hash,
+            htlc_params.lock_duration.into(),
+        )
+    }
 }
 
-pub fn bitcoin_htlc_address<TL: Ledger, TA: Asset, S: IntoSecretHash>(
-    swap: &OngoingSwap<Bitcoin, TL, BitcoinQuantity, TA, S>,
-) -> Address {
-    bitcoin_htlc(swap).compute_address(swap.source_ledger.network)
+impl HtlcParams<Bitcoin, BitcoinQuantity> {
+    pub fn compute_address(&self) -> Address {
+        Htlc::from(self.clone()).compute_address(self.ledger.network)
+    }
 }

application/comit_node/src/swap_protocols/rfc003/bitcoin/queries.rs

@@ -1,73 +1,44 @@
 use bitcoin_support::{BitcoinQuantity, OutPoint};
 use ledger_query_service::BitcoinQuery;
 use swap_protocols::{
-    asset::Asset,
     ledger::Bitcoin,
     rfc003::{
-        bitcoin::bitcoin_htlc_address,
-        events::{
-            NewSourceHtlcFundedQuery, NewSourceHtlcRedeemedQuery, NewSourceHtlcRefundedQuery,
-        },
-        state_machine::OngoingSwap,
-        IntoSecretHash, Ledger,
+        events::{NewHtlcFundedQuery, NewHtlcRedeemedQuery, NewHtlcRefundedQuery},
+        state_machine::HtlcParams,
     },
 };
 
-impl<TL, TA, S> NewSourceHtlcFundedQuery<Bitcoin, TL, BitcoinQuantity, TA, S> for BitcoinQuery
-where
-    TL: Ledger,
-    TA: Asset,
-    S: IntoSecretHash,
-{
-    fn new_source_htlc_funded_query(
-        swap: &OngoingSwap<Bitcoin, TL, BitcoinQuantity, TA, S>,
-    ) -> Self {
+impl NewHtlcFundedQuery<Bitcoin, BitcoinQuantity> for BitcoinQuery {
+    fn new_htlc_funded_query(htlc_params: &HtlcParams<Bitcoin, BitcoinQuantity>) -> Self {
         BitcoinQuery::Transaction {
-            to_address: Some(bitcoin_htlc_address(swap)),
+            to_address: Some(htlc_params.compute_address()),
             from_outpoint: None,
             unlock_script: None,
         }
     }
 }
 
-impl<TL, TA, S> NewSourceHtlcRefundedQuery<Bitcoin, TL, BitcoinQuantity, TA, S> for BitcoinQuery
-where
-    TL: Ledger,
-    TA: Asset,
-    S: IntoSecretHash,
-{
-    fn new_source_htlc_refunded_query(
-        swap: &OngoingSwap<Bitcoin, TL, BitcoinQuantity, TA, S>,
-        source_htlc_location: &OutPoint,
+impl NewHtlcRefundedQuery<Bitcoin, BitcoinQuantity> for BitcoinQuery {
+    fn new_htlc_refunded_query(
+        _htlc_params: &HtlcParams<Bitcoin, BitcoinQuantity>,
+        htlc_location: &OutPoint,
     ) -> Self {
         BitcoinQuery::Transaction {
             to_address: None,
-            from_outpoint: Some(source_htlc_location.clone()),
-            unlock_script: Some(vec![
-                swap.source_ledger_refund_identity
-                    .public_key()
-                    .inner()
-                    .serialize()
-                    .to_vec(),
-                vec![0u8],
-            ]),
+            from_outpoint: Some(*htlc_location),
+            unlock_script: Some(vec![vec![0u8]]),
         }
     }
 }
 
-impl<TL, TA, S> NewSourceHtlcRedeemedQuery<Bitcoin, TL, BitcoinQuantity, TA, S> for BitcoinQuery
-where
-    TL: Ledger,
-    TA: Asset,
-    S: IntoSecretHash,
-{
-    fn new_source_htlc_redeemed_query(
-        _swap: &OngoingSwap<Bitcoin, TL, BitcoinQuantity, TA, S>,
-        source_htlc_location: &OutPoint,
+impl NewHtlcRedeemedQuery<Bitcoin, BitcoinQuantity> for BitcoinQuery {
+    fn new_htlc_redeemed_query(
+        _htlc_params: &HtlcParams<Bitcoin, BitcoinQuantity>,
+        htlc_location: &OutPoint,
     ) -> Self {
         BitcoinQuery::Transaction {
             to_address: None,
-            from_outpoint: Some(source_htlc_location.clone()),
+            from_outpoint: Some(*htlc_location),
             unlock_script: Some(vec![vec![1u8]]),
         }
     }