From 636c37450222cf8b23fe8c7451e1f3b3cc017a13 Mon Sep 17 00:00:00 2001 From: savi0ur <94991321+pratraut@users.noreply.github.com> Date: Wed, 13 Mar 2024 01:58:36 +0530 Subject: [PATCH] Fixed liquid exchange deployment and double serializing issue (#32) * Fixed liquid exchange deployment and double serializing issue * Fixed rustfmt --- configs/stable_pool.toml | 2 +- src/behaviors/deployer.rs | 88 +++++++++++++++++++++++++++++++----- src/behaviors/pool_admin.rs | 4 +- src/behaviors/token_admin.rs | 21 ++++++--- 4 files changed, 92 insertions(+), 23 deletions(-) diff --git a/configs/stable_pool.toml b/configs/stable_pool.toml index c3ec8a2..75d73ec 100644 --- a/configs/stable_pool.toml +++ b/configs/stable_pool.toml @@ -1,5 +1,5 @@ [[admin]] -Deployer = {} +Deployer = { liquid_exchange_parameters = { asset_token_parameters = { name = "Arbiter Token X", symbol = "ARBX", decimals = 18 }, quote_token_parameters = { name = "Arbiter Token Y", symbol = "ARBY", decimals = 18 }, initial_price = 1.0 }} [[admin]] PoolAdmin = {} diff --git a/src/behaviors/deployer.rs b/src/behaviors/deployer.rs index c3226cd..41b8bb5 100644 --- a/src/behaviors/deployer.rs +++ b/src/behaviors/deployer.rs @@ -2,14 +2,16 @@ use std::sync::Arc; use anyhow::{anyhow, Result}; -use arbiter_bindings::bindings::liquid_exchange::LiquidExchange; +use arbiter_bindings::bindings::{arbiter_token::ArbiterToken, liquid_exchange::LiquidExchange}; use arbiter_core::middleware::ArbiterMiddleware; use arbiter_engine::{ machine::{Behavior, EventStream}, messager::{Messager, To}, }; -use ethers::types::H160; +use ethers::types::{H160, U256}; +use tracing::info; +use self::token_admin::TokenData; use super::*; use crate::bindings::uniswap_v3_factory::UniswapV3Factory; @@ -28,8 +30,17 @@ impl DeploymentData { } } +#[derive(Debug, Deserialize, Serialize, Clone)] +pub struct LiquidExchangeParameters { + pub asset_token_parameters: TokenData, + pub quote_token_parameters: TokenData, + pub initial_price: f64, +} + #[derive(Debug, Deserialize, Serialize)] -pub struct Deployer {} +pub struct Deployer { + pub liquid_exchange_parameters: LiquidExchangeParameters, +} #[async_trait::async_trait] impl Behavior<()> for Deployer { @@ -39,16 +50,31 @@ impl Behavior<()> for Deployer { messager: Messager, ) -> Result>> { let factory = deploy_factory(&client).await?; - let liquid_exchange = deploy_liquid_exchange(&client).await?; + + let le_param = self.liquid_exchange_parameters.clone(); + let liquid_exchange = deploy_liquid_exchange( + &client, + &le_param.asset_token_parameters, + &le_param.quote_token_parameters, + le_param.initial_price, + ) + .await?; + info!("Factory deployed at {:?}", factory.address()); + info!( + "Liquid exchange deployed at {:?}", + liquid_exchange.address() + ); + info!( + "Liquid exchange initial price : {:?}", + liquid_exchange.price().call().await? + ); let deployment_data = DeploymentData { factory: factory.address(), liquid_exchange: liquid_exchange.address(), }; - messager - .send(To::All, serde_json::to_string(&deployment_data)?) - .await?; + messager.send(To::All, &deployment_data).await?; Ok(None) } @@ -66,10 +92,48 @@ pub async fn deploy_factory( pub async fn deploy_liquid_exchange( client: &Arc, + arbx_param: &TokenData, + arby_param: &TokenData, + initial_price: f64, ) -> Result> { - LiquidExchange::deploy(client.clone(), ()) - .map_err(|e| anyhow!("Failed to deploy liquid exchange: {}", e))? - .send() - .await - .map_err(|e| anyhow!("Failed to send liquid exchange: {}", e)) + let initial_liquid_exchange_price = U256::from((initial_price * 10f64.powf(18.0)) as u64); + + // Deploy an instance of the `ArbiterToken` contract using our predefined constants. + let arbx = ArbiterToken::deploy( + client.clone(), + ( + arbx_param.name.clone(), + arbx_param.symbol.clone(), + arbx_param.decimals, + ), + )? + .send() + .await?; + info!("Arbiter Token X contract deployed at {:?}", arbx.address()); + + // Deploy the second instance of the `ArbiterToken` contract using our predefined constants. + let arby = ArbiterToken::deploy( + client.clone(), + ( + arby_param.name.clone(), + arby_param.symbol.clone(), + arby_param.decimals, + ), + )? + .send() + .await?; + info!("Arbiter Token Y contract deployed at {:?}", arby.address()); + + LiquidExchange::deploy( + client.clone(), + ( + arbx.address(), + arby.address(), + initial_liquid_exchange_price, + ), + ) + .map_err(|e| anyhow!("Failed to deploy liquid exchange: {}", e))? + .send() + .await + .map_err(|e| anyhow!("Failed to send liquid exchange: {}", e)) } diff --git a/src/behaviors/pool_admin.rs b/src/behaviors/pool_admin.rs index 1d111d2..2aaf535 100644 --- a/src/behaviors/pool_admin.rs +++ b/src/behaviors/pool_admin.rs @@ -128,9 +128,7 @@ mod tests { fee: 100, }; - messager - .send(To::All, serde_json::to_string(&pool_creation_request)?) - .await?; + messager.send(To::All, &pool_creation_request).await?; Ok(None) } diff --git a/src/behaviors/token_admin.rs b/src/behaviors/token_admin.rs index 9bbb92c..846af84 100644 --- a/src/behaviors/token_admin.rs +++ b/src/behaviors/token_admin.rs @@ -22,7 +22,7 @@ pub struct TokenAdmin { pub client: Option>, } -#[derive(Debug, Serialize, Deserialize)] +#[derive(Debug, Serialize, Deserialize, Clone)] pub struct TokenData { pub name: String, pub symbol: String, @@ -84,9 +84,7 @@ impl Behavior for TokenAdmin { self.tokens = Some(deployed_tokens); self.client = Some(client.clone()); - let message_content = serde_json::to_string(&token_addresses)?; - - let _ = messager.send(To::All, &message_content).await; + let _ = messager.send(To::All, &token_addresses).await; Ok(Some(messager.clone().stream().unwrap())) } @@ -103,8 +101,11 @@ impl Behavior for TokenAdmin { match query { TokenAdminQuery::AddressOf(token_name) => { if let Some(token_data) = self.token_data.get(&token_name) { - let response = serde_json::to_string(&token_data.address) - .map_err(|_| anyhow::anyhow!("Failed to serialize token address"))?; + let response = if let Some(v) = token_data.address { + v + } else { + return Err(anyhow::anyhow!("Token address is not found.")); + }; if let Some(messager) = &self.messager { messager .send(To::Agent(event.from.clone()), response) @@ -141,7 +142,8 @@ impl Behavior for TokenAdmin { Ok(ControlFlow::Continue) } TokenAdminQuery::DeployRequest(deploy_request) => { - ArbiterToken::deploy( + let req = deploy_request.clone(); + let token = ArbiterToken::deploy( self.client.clone().unwrap(), ( deploy_request.name, @@ -152,6 +154,11 @@ impl Behavior for TokenAdmin { .send() .await?; + self.token_data.insert(req.name.clone(), req.clone()); + self.tokens + .as_mut() + .and_then(|token_obj| token_obj.insert(req.name, token)); + Ok(ControlFlow::Continue) } }