clean: remove bounds / serde impls

Removed some additional bounds and cleaned up some structs and impls.

kit/src/behaviors/allocate/mod.rs

@@ -1,6 +1,6 @@
 use super::*;
 
-pub trait AllocateType<E>: Debug + Serialize + Clone
+pub trait AllocateType<E>
 where
     E: Send + 'static,
 {
@@ -44,9 +44,9 @@ where
 #[async_trait::async_trait]
 impl<A, P, E> Behavior<E> for Allocate<A, E, Config<P>>
 where
-    A: AllocateType<E> + Debug + Send + Sync + 'static + for<'a> Deserialize<'a>,
-    P: PoolType + Debug + Send + Sync + 'static,
-    E: Debug + Send + Sync + 'static,
+    A: AllocateType<E> + Send,
+    P: PoolType + Send,
+    E: Send + 'static,
 {
     type Processor = Allocate<A, E, Processing<P, E>>;
     async fn startup(
@@ -61,9 +61,9 @@ where
 #[async_trait::async_trait]
 impl<A, P, E> Processor<E> for Allocate<A, E, Processing<P, E>>
 where
-    A: AllocateType<E> + Debug + Send + Sync + 'static,
-    P: PoolType + Debug + Send + Sync + 'static,
-    E: Debug + Send + Sync + 'static,
+    A: AllocateType<E> + Send,
+    P: PoolType + Send,
+    E: Send + 'static,
 {
     async fn get_stream(&mut self) -> Result<Option<EventStream<E>>> {
         todo!("We have not implemented the 'get_stream' method yet for the 'Allocate' behavior.");

kit/src/behaviors/creator.rs

@@ -19,8 +19,6 @@ pub struct Config<P: PoolType> {
 impl<P> Behavior<()> for Create<Config<P>>
 where
     P: PoolType + Send + Sync + 'static,
-    P::StrategyContract: Send,
-    P::SolverContract: Send,
 {
     type Processor = ();
     async fn startup(
@@ -100,23 +98,19 @@ where
 
         debug!("Pool created!\n {:#?}", pool);
 
-        let pool_creation = (
-            pool.id,
-            pool.tokens.iter().map(|t| t.address()).collect::<Vec<_>>(),
-            pool.liquidity_token.address(),
-            params,
-            self.data.allocation_data.clone(),
-        );
-        messager.send(To::All, pool_creation).await.unwrap();
+        messager
+            .send(
+                To::All,
+                PoolCreation::<P> {
+                    id: pool.id,
+                    tokens: pool.tokens.iter().map(|t| t.address()).collect::<Vec<_>>(),
+                    liquidity_token: pool.liquidity_token.address(),
+                    params,
+                    allocation_data: self.data.allocation_data.clone(),
+                },
+            )
+            .await
+            .unwrap();
         Ok(())
     }
 }
-
-// TODO: We should be able to use this but it is currently hard to work with due
-// to `serde::Deserialize`
-#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq)]
-pub struct PoolCreation<P: PoolType> {
-    pub id: eU256,
-    pub params: P::Parameters,
-    pub allocation_data: P::AllocationData,
-}

kit/src/behaviors/mod.rs

@@ -12,17 +12,13 @@ pub use token::{MintRequest, TokenAdminQuery};
 use self::{
     creator::Create,
     deploy::{Deploy, DeploymentData},
-    pool::PoolType,
+    pool::{PoolCreation, PoolType},
     token::TokenAdmin,
 };
 use super::*;
 
 pub const MAX: eU256 = eU256::MAX;
 
-type PoolId = eU256;
-type TokenList = Vec<eAddress>;
-type LiquidityToken = eAddress;
-
 pub mod allocate;
 pub mod creator;
 pub mod deploy;
@@ -39,29 +35,65 @@ pub enum Behaviors<P: PoolType> {
 }
 
 #[derive(Debug, Deserialize, Serialize)]
+#[serde(bound = "P: PoolType")]
 pub enum MessageTypes<P>
 where
     P: PoolType,
 {
     #[serde(untagged)]
     Deploy(DeploymentData),
     #[serde(untagged)]
-    // TODO: This is super weird. The following commented out version with `PoolCreation<P>`
-    // doesn't compile. Create(creator::PoolCreation<P>),
-    // TODO: BUT, this line where the tuple struct has the exact same data as `PoolCreation<P>`
-    // DOES compile. I'm not sure how to go about making this work nicely, but at least this works
-    // for now.
-    Create(
-        (
-            eU256,         // Pool ID
-            Vec<eAddress>, // Token List
-            eAddress,      // Liquidity Token
-            P::Parameters,
-            P::AllocationData,
-        ),
-    ),
+    Create(PoolCreation<P>),
     #[serde(untagged)]
     TokenAdmin(token::Response),
     #[serde(untagged)]
     Update(P::Parameters),
 }
+
+#[derive(Debug)]
+struct GetPoolTodo<P: PoolType> {
+    deployment_data: Option<DeploymentData>,
+    pool_creation: Option<PoolCreation<P>>,
+}
+
+impl<P: PoolType> GetPoolTodo<P> {
+    async fn complete(messager: &mut Messager) -> Self {
+        // Make an undone "TODO" list.
+        let mut todo: GetPoolTodo<P> = GetPoolTodo {
+            deployment_data: None,
+            pool_creation: None,
+        };
+        let id = messager.id.clone();
+        // Loop through the messager until we check off the boxes for this TODO list.
+        debug!("{:#?} is looping through their TODO list.", id.clone());
+        loop {
+            if let Ok(msg) = messager.get_next::<MessageTypes<P>>().await {
+                match msg.data {
+                    MessageTypes::Deploy(deploy_data) => {
+                        debug!("Updater: Got deployment data: {:?}", deploy_data);
+                        todo.deployment_data = Some(deploy_data);
+                        if todo.pool_creation.is_some() {
+                            debug!("{:#?}: Got all the data.\n{:#?}", id.clone(), todo);
+                            break todo;
+                        }
+                    }
+                    MessageTypes::Create(pool_creation) => {
+                        debug!("Updater: Got pool creation data: {:?}", pool_creation);
+                        todo.pool_creation = Some(pool_creation);
+                        if todo.deployment_data.is_some() {
+                            debug!("{:#?}: Got all the data.\n{:#?}", id.clone(), todo);
+                            break todo;
+                        }
+                    }
+                    _ => continue,
+                }
+            } else {
+                debug!(
+                    "{:#?} got some other message variant it could ignore.",
+                    id.clone()
+                );
+                continue;
+            }
+        }
+    }
+}

kit/src/behaviors/swap/mod.rs

@@ -2,12 +2,16 @@ use self::{bindings::erc20::ERC20, pool::InputToken};
 use super::*;
 use crate::behaviors::token::Response;
 
-pub trait SwapType<E>: Debug + Serialize + Clone {
+pub trait SwapType<E> {
     fn compute_swap_amount(event: E) -> (eU256, InputToken);
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
-pub struct Swap<S: State, T: SwapType<E>, E> {
+pub struct Swap<S, T, E>
+where
+    S: State,
+    T: SwapType<E>,
+{
     // to get tokens on start up
     pub token_admin: String,
     pub update: String,
@@ -16,12 +20,20 @@ pub struct Swap<S: State, T: SwapType<E>, E> {
     pub _phantom: PhantomData<E>,
 }
 
+// TODO: This needs to be configurable in some way to make the `SwapType` become
+// transparent and useful.
+// Should also get some data necessary for mint amounts and what not.
 #[derive(Clone, Debug, Serialize, Deserialize, State)]
 pub struct Config<P: PoolType> {
-    pub base_config: BaseConfig,
-    pub params: P::Parameters,
-    pub allocation_data: P::AllocationData,
-    pub token_list: Vec<String>,
+    phantom: PhantomData<P>,
+}
+
+impl<P: PoolType> Default for Config<P> {
+    fn default() -> Self {
+        Self {
+            phantom: PhantomData,
+        }
+    }
 }
 
 #[derive(Debug, Clone, State)]
@@ -31,27 +43,12 @@ pub struct Processing<P: PoolType> {
     pub pool: Pool<P>,
 }
 
-#[derive(Debug)]
-struct SwapTodo<P: PoolType> {
-    deployment_data: Option<DeploymentData>,
-    #[allow(clippy::type_complexity)]
-    pool_creation: Option<(
-        PoolId,         // Pool ID
-        TokenList,      // Token List
-        LiquidityToken, // Liquidity Token
-        <P as PoolType>::Parameters,
-        <P as PoolType>::AllocationData,
-    )>,
-}
-
 #[async_trait::async_trait]
 impl<P, T, E> Behavior<()> for Swap<Config<P>, T, E>
 where
-    P: PoolType + Send + Sync + 'static,
-    P::StrategyContract: Send,
-    P::SolverContract: Send,
-    T: SwapType<E> + Send + Sync + 'static + for<'a> Deserialize<'a>,
-    E: Debug + Send + Sync + 'static,
+    P: PoolType + Send,
+    T: SwapType<E> + Send,
+    E: Send,
 {
     // type Processor = Swap<Processing<P>, T, E>;
     type Processor = ();
@@ -60,67 +57,28 @@ where
         client: Arc<ArbiterMiddleware>,
         mut messager: Messager,
     ) -> Result<Self::Processor> {
-        // Make a "TODO" list.
-        // This is the data I need to recieve to do my job
-        let mut todo: SwapTodo<P> = SwapTodo {
-            deployment_data: None,
-            pool_creation: None,
-        };
-
-        // Loop through the messager until we check off the boxes for this TODO list.
-        debug!("Updater is looping through their TODO list.");
-        loop {
-            if let Ok(msg) = messager.get_next::<MessageTypes<P>>().await {
-                match msg.data {
-                    MessageTypes::Deploy(deploy_data) => {
-                        debug!("Updater: Got deployment data: {:?}", deploy_data);
-                        todo.deployment_data = Some(deploy_data);
-                        if todo.pool_creation.is_some() {
-                            debug!("Updater: Got all the data.\n{:#?}", todo);
-                            break;
-                        }
-                    }
-                    MessageTypes::Create(pool_creation) => {
-                        debug!("Updater: Got pool creation data: {:?}", pool_creation);
-                        todo.pool_creation = Some(pool_creation);
-                        if todo.deployment_data.is_some() {
-                            debug!("Updater: Got all the data.\n{:#?}", todo);
-                            break;
-                        }
-                    }
-                    _ => continue,
-                }
-            } else {
-                debug!("Updater got some other message variant it could ignore.");
-                continue;
-            }
-        }
-        debug!("Updater has checked off their TODO list.");
+        // TODO: Here we probably need to filter on the `PoolCreation` so that we get
+        // the correct pool.
+        let completed_todo = GetPoolTodo::<P>::complete(&mut messager).await;
+        let (deployment_data, pool_creation) = (
+            completed_todo.deployment_data.unwrap(),
+            completed_todo.pool_creation.unwrap(),
+        );
 
         let (strategy_contract, solver_contract) =
-            P::get_contracts(todo.deployment_data.as_ref().unwrap(), client.clone());
-        let dfmm = DFMM::new(todo.deployment_data.unwrap().dfmm, client.clone());
-        debug!("Got DFMM and the strategy contracts.");
+            P::get_contracts(&deployment_data, client.clone());
+        let dfmm = DFMM::new(deployment_data.dfmm, client.clone());
 
         // Get the intended tokens for the pool and do approvals.
         let mut tokens: Vec<ArbiterToken<ArbiterMiddleware>> = Vec::new();
-        for tkn in self.data.token_list.drain(..) {
-            messager
-                .send(
-                    To::Agent(self.token_admin.clone()),
-                    TokenAdminQuery::AddressOf(tkn.clone()),
-                )
-                .await
-                .unwrap();
-            let token = ArbiterToken::new(
-                messager.get_next::<eAddress>().await.unwrap().data,
-                client.clone(),
-            );
+        for token_address in pool_creation.tokens.into_iter() {
+            let token = ArbiterToken::new(token_address, client.clone());
+            let name = token.name().call().await?;
             messager
                 .send(
                     To::Agent(self.token_admin.clone()),
                     TokenAdminQuery::MintRequest(MintRequest {
-                        token: tkn,
+                        token: name,
                         mint_to: client.address(),
                         mint_amount: 100_000_000_000,
                     }),
@@ -142,21 +100,13 @@ where
             tokens.push(token);
         }
 
-        let lp_address = todo.pool_creation.clone().unwrap().2;
-        let lp_token = ERC20::new(lp_address, client.clone());
-        let instance = P::create_instance(
-            strategy_contract,
-            solver_contract,
-            todo.pool_creation.clone().unwrap().3,
-        );
-
         // build pool for processor and stream
-        let pool = Pool::<P> {
-            id: todo.pool_creation.clone().unwrap().0,
+        let _pool = Pool::<P> {
+            id: pool_creation.id,
             dfmm,
-            instance,
+            instance: P::create_instance(strategy_contract, solver_contract, pool_creation.params),
             tokens,
-            liquidity_token: lp_token,
+            liquidity_token: ERC20::new(pool_creation.liquidity_token, client.clone()),
         };
         // TODO: We need to come back around and adjust this.
         // match self.swap_type.get_stream(messager.clone()) {
@@ -184,8 +134,8 @@ where
 impl<P, T, E> Processor<E> for Swap<Processing<P>, T, E>
 where
     P: PoolType + Send + Sync,
-    T: SwapType<E> + Send + Sync + 'static,
-    E: Send + Sync + 'static,
+    T: SwapType<E> + Send,
+    E: Send + 'static,
 {
     async fn get_stream(&mut self) -> Result<Option<EventStream<E>>> {
         todo!("We have not implemented the 'get_stream' method yet for the 'Swap' behavior.")