Implement HtlcEvents directly on the Facade

Co-authored-by: Tobin Harding <tobin.harding@tenx.tech>

Author: 2 people

cnd/src/http_api/route_factory.rs

@@ -1,11 +1,18 @@
 use crate::{
     config::settings::AllowedOrigins,
     db::{DetermineTypes, Retrieve, Saver},
+    ethereum::{Erc20Token, EtherQuantity},
     http_api,
     network::Network,
     seed::SwapSeed,
-    swap_protocols::{self, rfc003::state_store::StateStore, LedgerEventsCreator, SwapId},
+    swap_protocols::{
+        self,
+        ledger::{Bitcoin, Ethereum},
+        rfc003::{events::HtlcEvents, state_store::StateStore},
+        SwapId,
+    },
 };
+use bitcoin::Amount;
 use libp2p::PeerId;
 use tokio::executor::Executor;
 use warp::{self, filters::BoxedFilter, Filter, Reply};
@@ -28,7 +35,9 @@ pub fn create<
         + SwapSeed
         + DetermineTypes
         + Retrieve
-        + LedgerEventsCreator
+        + HtlcEvents<Bitcoin, Amount>
+        + HtlcEvents<Ethereum, EtherQuantity>
+        + HtlcEvents<Ethereum, Erc20Token>
         + Saver,
 >(
     peer_id: PeerId,

cnd/src/http_api/routes/rfc003/handlers/action.rs

@@ -1,5 +1,6 @@
 use crate::{
     db::{DetermineTypes, Save, Saver},
+    ethereum::{Erc20Token, EtherQuantity},
     http_api::{
         action::{
             ActionExecutionParameters, ActionResponseBody, IntoResponsePayload, ListRequiredFields,
@@ -14,17 +15,20 @@ use crate::{
     swap_protocols::{
         self,
         actions::Actions,
+        ledger::{Bitcoin, Ethereum},
         rfc003::{
             self,
             actions::{Action, ActionKind},
             bob::State,
+            events::HtlcEvents,
             messages::{Decision, IntoAcceptMessage},
             state_store::StateStore,
         },
-        LedgerEventsCreator, SwapId,
+        SwapId,
     },
 };
 use anyhow::Context;
+use bitcoin::Amount;
 use libp2p_comit::frame::Response;
 use std::fmt::Debug;
 use tokio::executor::Executor;
@@ -37,7 +41,9 @@ pub async fn handle_action<
         + SwapSeed
         + Saver
         + DetermineTypes
-        + LedgerEventsCreator
+        + HtlcEvents<Bitcoin, Amount>
+        + HtlcEvents<Ethereum, EtherQuantity>
+        + HtlcEvents<Ethereum, Erc20Token>
         + Executor
         + Clone,
 >(

cnd/src/http_api/routes/rfc003/handlers/post_swap.rs

@@ -1,23 +1,23 @@
 use crate::{
     db::{Save, Saver, Swap},
-    ethereum,
+    ethereum::{self, Erc20Token, EtherQuantity},
     http_api::{HttpAsset, HttpLedger},
     network::{DialInformation, Network},
     seed::SwapSeed,
     swap_protocols::{
         self,
         asset::Asset,
-        ledger,
+        ledger::{self, Bitcoin, Ethereum},
         rfc003::{
-            self, alice::State, state_store::StateStore, Accept, Decline, Ledger, Request,
-            SecretHash, SecretSource,
+            self, alice::State, events::HtlcEvents, state_store::StateStore, Accept, Decline,
+            Ledger, Request, SecretHash, SecretSource,
         },
-        HashFunction, LedgerEventsCreator, Role, SwapId,
+        HashFunction, Role, SwapId,
     },
     timestamp::Timestamp,
-    CreateLedgerEvents,
 };
 use anyhow::Context;
+use bitcoin::Amount;
 use futures::Future;
 use futures_core::{
     compat::Future01CompatExt,
@@ -36,7 +36,9 @@ pub async fn handle_post_swap<
         + Saver
         + Network
         + Clone
-        + LedgerEventsCreator,
+        + HtlcEvents<Bitcoin, Amount>
+        + HtlcEvents<Ethereum, EtherQuantity>
+        + HtlcEvents<Ethereum, Erc20Token>,
 >(
     dependencies: D,
     body: serde_json::Value,
@@ -216,9 +218,8 @@ where
         + Save<Swap>
         + Save<Decline>
         + Network
-        + LedgerEventsCreator
-        + CreateLedgerEvents<AL, AA>
-        + CreateLedgerEvents<BL, BA>
+        + HtlcEvents<AL, AA>
+        + HtlcEvents<BL, BA>
         + Clone,
     AL: Ledger,
     BL: Ledger,

cnd/src/http_api/routes/rfc003/mod.rs

@@ -5,6 +5,7 @@ mod swap_state;
 
 use crate::{
     db::{DetermineTypes, Retrieve, Save, Swap},
+    ethereum::{Erc20Token, EtherQuantity},
     http_api::{
         action::ActionExecutionParameters,
         route_factory::swap_path,
@@ -16,10 +17,12 @@ use crate::{
     network::Network,
     seed::SwapSeed,
     swap_protocols::{
-        rfc003::{actions::ActionKind, state_store::StateStore},
-        LedgerEventsCreator, SwapId,
+        ledger::{Bitcoin, Ethereum},
+        rfc003::{actions::ActionKind, events::HtlcEvents, state_store::StateStore},
+        SwapId,
     },
 };
+use bitcoin::Amount;
 use futures::Future;
 use futures_core::future::{FutureExt, TryFutureExt};
 use warp::{
@@ -33,7 +36,16 @@ use tokio::executor::Executor;
 
 #[allow(clippy::needless_pass_by_value)]
 pub fn post_swap<
-    D: Clone + Network + StateStore + Executor + Save<Swap> + SwapSeed + Saver + LedgerEventsCreator,
+    D: Clone
+        + Network
+        + StateStore
+        + Executor
+        + Save<Swap>
+        + SwapSeed
+        + Saver
+        + HtlcEvents<Bitcoin, Amount>
+        + HtlcEvents<Ethereum, EtherQuantity>
+        + HtlcEvents<Ethereum, Erc20Token>,
 >(
     dependencies: D,
     body: serde_json::Value,
@@ -74,7 +86,9 @@ pub fn action<
         + Network
         + SwapSeed
         + Saver
-        + LedgerEventsCreator,
+        + HtlcEvents<Bitcoin, Amount>
+        + HtlcEvents<Ethereum, EtherQuantity>
+        + HtlcEvents<Ethereum, Erc20Token>,
 >(
     method: http::Method,
     id: SwapId,

cnd/src/load_swaps.rs

@@ -6,10 +6,10 @@ use crate::{
     swap_protocols::{
         self,
         ledger::{Bitcoin, Ethereum},
-        rfc003::state_store::StateStore,
-        LedgerEventsCreator,
+        rfc003::{events::HtlcEvents, state_store::StateStore},
     },
 };
+use bitcoin::Amount;
 use tokio::executor::Executor;
 
 #[allow(clippy::cognitive_complexity)]
@@ -19,9 +19,11 @@ where
         + Executor
         + Clone
         + SwapSeed
-        + LedgerEventsCreator
         + Retrieve
         + DetermineTypes
+        + HtlcEvents<Bitcoin, Amount>
+        + HtlcEvents<Ethereum, EtherQuantity>
+        + HtlcEvents<Ethereum, Erc20Token>
         + LoadAcceptedSwap<Bitcoin, Ethereum, bitcoin::Amount, EtherQuantity>
         + LoadAcceptedSwap<Ethereum, Bitcoin, EtherQuantity, bitcoin::Amount>
         + LoadAcceptedSwap<Bitcoin, Ethereum, bitcoin::Amount, Erc20Token>

cnd/src/main.rs

@@ -5,15 +5,12 @@ use anyhow::Context;
 use cnd::{
     btsieve::{bitcoin::BitcoindConnector, ethereum::Web3Connector},
     config::{self, Settings},
-    db::{DetermineTypes, Retrieve, Saver, Sqlite},
+    db::Sqlite,
     http_api::route_factory,
     load_swaps,
     network::{self, transport, Network},
-    seed::{Seed, SwapSeed},
-    swap_protocols::{
-        rfc003::state_store::{InMemoryStateStore, StateStore},
-        Facade, LedgerEventsCreator,
-    },
+    seed::Seed,
+    swap_protocols::{rfc003::state_store::InMemoryStateStore, Facade},
 };
 use futures::{stream, Future, Stream};
 use futures_core::{FutureExt, TryFutureExt};
@@ -28,7 +25,6 @@ use std::{
     sync::{Arc, Mutex},
 };
 use structopt::StructOpt;
-use tokio::executor::Executor;
 
 mod cli;
 mod logging;
@@ -121,21 +117,11 @@ fn derive_key_pair(seed: &Seed) -> identity::Keypair {
     identity::Keypair::Ed25519(key.into())
 }
 
-fn spawn_warp_instance<
-    D: Clone
-        + StateStore
-        + Executor
-        + Network
-        + SwapSeed
-        + DetermineTypes
-        + Retrieve
-        + LedgerEventsCreator
-        + Saver,
->(
+fn spawn_warp_instance<S: Network>(
     settings: &Settings,
     peer_id: PeerId,
     runtime: &mut tokio::runtime::Runtime,
-    dependencies: D,
+    dependencies: Facade<S>,
 ) {
     let routes = route_factory::create(
         peer_id,

cnd/src/swap_protocols/facade.rs

@@ -4,22 +4,23 @@ use crate::{
         AcceptedSwap, DetermineTypes, LoadAcceptedSwap, Retrieve, Save, Saver, Sqlite, Swap,
         SwapTypes,
     },
-    ethereum::{Erc20Token, EtherQuantity},
     network::{DialInformation, Network, RequestError},
     seed::{Seed, SwapSeed},
     swap_protocols::{
         asset::Asset,
         ledger::{Bitcoin, Ethereum},
         rfc003::{
             self,
-            events::HtlcEvents,
-            state_machine::SwapStates,
+            events::{
+                Deployed, DeployedFuture, Funded, FundedFuture, HtlcEvents,
+                RedeemedOrRefundedFuture,
+            },
+            state_machine::{HtlcParams, SwapStates},
             state_store::{self, InMemoryStateStore, StateStore},
             ActorState, Ledger,
         },
         SwapId,
     },
-    CreateLedgerEvents,
 };
 use async_trait::async_trait;
 use bitcoin::Amount;
@@ -168,32 +169,67 @@ where
     }
 }
 
-pub trait LedgerEventsCreator:
-    CreateLedgerEvents<Bitcoin, Amount>
-    + CreateLedgerEvents<Ethereum, EtherQuantity>
-    + CreateLedgerEvents<Ethereum, Erc20Token>
-{
-}
-
-impl<S> LedgerEventsCreator for Facade<S> where S: Send + Sync + 'static {}
-
-impl<S> CreateLedgerEvents<Bitcoin, Amount> for Facade<S>
+impl<S> HtlcEvents<Bitcoin, Amount> for Facade<S>
 where
     S: Send + Sync + 'static,
 {
-    fn create_ledger_events(&self) -> Box<dyn HtlcEvents<Bitcoin, Amount>> {
-        Box::new(self.bitcoin_connector.clone())
+    fn htlc_deployed(
+        &self,
+        htlc_params: HtlcParams<Bitcoin, Amount>,
+    ) -> Box<DeployedFuture<Bitcoin>> {
+        self.bitcoin_connector.htlc_deployed(htlc_params)
+    }
+
+    fn htlc_funded(
+        &self,
+        htlc_params: HtlcParams<Bitcoin, Amount>,
+        htlc_deployment: &Deployed<Bitcoin>,
+    ) -> Box<FundedFuture<Bitcoin, Amount>> {
+        self.bitcoin_connector
+            .htlc_funded(htlc_params, htlc_deployment)
+    }
+
+    fn htlc_redeemed_or_refunded(
+        &self,
+        htlc_params: HtlcParams<Bitcoin, Amount>,
+        htlc_deployment: &Deployed<Bitcoin>,
+        htlc_funding: &Funded<Bitcoin, Amount>,
+    ) -> Box<RedeemedOrRefundedFuture<Bitcoin>> {
+        self.bitcoin_connector
+            .htlc_redeemed_or_refunded(htlc_params, htlc_deployment, htlc_funding)
     }
 }
 
-impl<S, A> CreateLedgerEvents<Ethereum, A> for Facade<S>
+impl<A, S> HtlcEvents<Ethereum, A> for Facade<S>
 where
     S: Send + Sync + 'static,
     A: Asset + Send + Sync + 'static,
     Web3Connector: HtlcEvents<Ethereum, A>,
 {
-    fn create_ledger_events(&self) -> Box<dyn HtlcEvents<Ethereum, A>> {
-        Box::new(self.ethereum_connector.clone())
+    fn htlc_deployed(&self, htlc_params: HtlcParams<Ethereum, A>) -> Box<DeployedFuture<Ethereum>> {
+        self.ethereum_connector.htlc_deployed(htlc_params)
+    }
+
+    fn htlc_funded(
+        &self,
+        htlc_params: HtlcParams<Ethereum, A>,
+        htlc_deployment: &Deployed<Ethereum>,
+    ) -> Box<FundedFuture<Ethereum, A>> {
+        self.ethereum_connector
+            .htlc_funded(htlc_params, htlc_deployment)
+    }
+
+    fn htlc_redeemed_or_refunded(
+        &self,
+        htlc_params: HtlcParams<Ethereum, A>,
+        htlc_deployment: &Deployed<Ethereum>,
+        htlc_funding: &Funded<Ethereum, A>,
+    ) -> Box<RedeemedOrRefundedFuture<Ethereum>> {
+        self.ethereum_connector.htlc_redeemed_or_refunded(
+            htlc_params,
+            htlc_deployment,
+            htlc_funding,
+        )
     }
 }