A0-1140: e2e tests for simple_dex (#723)

obrok · web-flow · commit 1fa4f3a42140 · 2022-11-14T16:48:25.000+01:00
* Add simple_dex to deploy.sh

* Expose out_given_in in simple_dex

* Add e2e test for simple_dex

* Fix clippy

* Test dex swap rejection due to slippage
diff --git a/aleph-client/src/contract/convertible_value.rs b/aleph-client/src/contract/convertible_value.rs
@@ -1,6 +1,6 @@
 use std::ops::Deref;
 
-use anyhow::{bail, Result};
+use anyhow::{anyhow, bail, Result};
 use contract_transcode::Value;
 use sp_core::crypto::Ss58Codec;
 
@@ -71,3 +71,36 @@ impl TryFrom<ConvertibleValue> for AccountId {
         }
     }
 }
+
+impl<T> TryFrom<ConvertibleValue> for Result<T>
+where
+    ConvertibleValue: TryInto<T, Error = anyhow::Error>,
+{
+    type Error = anyhow::Error;
+
+    fn try_from(value: ConvertibleValue) -> Result<Result<T>, Self::Error> {
+        if let Value::Tuple(tuple) = &value.0 {
+            match tuple.ident() {
+                Some(x) if x == "Ok" => {
+                    if tuple.values().count() == 1 {
+                        let item =
+                            ConvertibleValue(tuple.values().next().unwrap().clone()).try_into()?;
+                        return Ok(Ok(item));
+                    } else {
+                        bail!("Unexpected number of elements in Ok variant: {:?}", &value);
+                    }
+                }
+                Some(x) if x == "Err" => {
+                    if tuple.values().count() == 1 {
+                        return Ok(Err(anyhow!(value.to_string())));
+                    } else {
+                        bail!("Unexpected number of elements in Err variant: {:?}", &value);
+                    }
+                }
+                _ => (),
+            }
+        }
+
+        bail!("Expected {:?} to be an Ok(_) or Err(_) tuple.", value);
+    }
+}
diff --git a/aleph-client/src/contract/mod.rs b/aleph-client/src/contract/mod.rs
@@ -96,15 +96,15 @@ impl ContractInstance {
         conn: &C,
         message: &str,
     ) -> Result<ConvertibleValue> {
-        self.contract_read(conn, message, &[])
+        self.contract_read::<C, String>(conn, message, &[])
     }
 
     /// Reads the value of a read-only call via RPC.
-    pub fn contract_read<C: AnyConnection>(
+    pub fn contract_read<C: AnyConnection, S: AsRef<str> + Debug>(
         &self,
         conn: &C,
         message: &str,
-        args: &[&str],
+        args: &[S],
     ) -> Result<ConvertibleValue> {
         let payload = self.encode(message, args)?;
         let request = self.contract_read_request(&payload);
@@ -121,15 +121,15 @@ impl ContractInstance {
 
     /// Executes a 0-argument contract call.
     pub fn contract_exec0(&self, conn: &SignedConnection, message: &str) -> Result<()> {
-        self.contract_exec(conn, message, &[])
+        self.contract_exec::<String>(conn, message, &[])
     }
 
     /// Executes a contract call.
-    pub fn contract_exec(
+    pub fn contract_exec<S: AsRef<str> + Debug>(
         &self,
         conn: &SignedConnection,
         message: &str,
-        args: &[&str],
+        args: &[S],
     ) -> Result<()> {
         let data = self.encode(message, args)?;
         let xt = compose_extrinsic!(
@@ -164,7 +164,7 @@ impl ContractInstance {
         })
     }
 
-    fn encode(&self, message: &str, args: &[&str]) -> Result<Vec<u8>> {
+    fn encode<S: AsRef<str> + Debug>(&self, message: &str, args: &[S]) -> Result<Vec<u8>> {
         ContractMessageTranscoder::new(&self.ink_project).encode(message, args)
     }
 
diff --git a/contracts/scripts/test.sh b/contracts/scripts/test.sh
@@ -7,10 +7,12 @@ CONTRACTS_PATH=$(pwd)/contracts
 EARLY_BIRD_SPECIAL=$(jq --raw-output ".early_bird_special" < "$CONTRACTS_PATH"/addresses.json)
 THE_PRESSIAH_COMETH=$(jq --raw-output ".the_pressiah_cometh" < "$CONTRACTS_PATH"/addresses.json)
 BACK_TO_THE_FUTURE=$(jq --raw-output ".back_to_the_future" < "$CONTRACTS_PATH"/addresses.json)
+SIMPLE_DEX=$(jq --raw-output ".simple_dex" < "$CONTRACTS_PATH"/addresses.json)
 
 pushd "$E2E_PATH"
 
 RUST_LOG="aleph_e2e_client=info" cargo run --release -- \
+  --test-cases simple_dex \
   --test-cases marketplace \
   --test-cases button_game_reset \
   --test-cases early_bird_special \
@@ -19,9 +21,11 @@ RUST_LOG="aleph_e2e_client=info" cargo run --release -- \
   --early-bird-special "$EARLY_BIRD_SPECIAL" \
   --the-pressiah-cometh "$THE_PRESSIAH_COMETH" \
   --back-to-the-future "$BACK_TO_THE_FUTURE" \
+  --simple-dex "$SIMPLE_DEX" \
   --button-game-metadata ../contracts/button/target/ink/metadata.json \
   --ticket-token-metadata ../contracts/ticket_token/target/ink/metadata.json \
   --reward-token-metadata ../contracts/game_token/target/ink/metadata.json \
-  --marketplace-metadata ../contracts/marketplace/target/ink/metadata.json
+  --marketplace-metadata ../contracts/marketplace/target/ink/metadata.json \
+  --simple-dex-metadata ../contracts/simple_dex/target/ink/metadata.json
 
 exit $?
diff --git a/e2e-tests/src/cases.rs b/e2e-tests/src/cases.rs
@@ -15,7 +15,7 @@ use crate::{
         force_new_era as test_force_new_era, marketplace as test_marketplace,
         points_basic as test_points_basic, points_stake_change as test_points_stake_change,
         schedule_doomed_version_change_and_verify_finalization_stopped as test_schedule_doomed_version_change_and_verify_finalization_stopped,
-        schedule_version_change as test_schedule_version_change,
+        schedule_version_change as test_schedule_version_change, simple_dex as test_simple_dex,
         staking_era_payouts as test_staking_era_payouts,
         staking_new_validator as test_staking_new_validator,
         the_pressiah_cometh as test_the_pressiah_cometh, token_transfer as test_token_transfer,
@@ -72,6 +72,7 @@ pub fn possible_test_cases() -> PossibleTestCases {
         ("back_to_the_future", test_back_to_the_future as TestCase),
         ("the_pressiah_cometh", test_the_pressiah_cometh as TestCase),
         ("marketplace", test_marketplace as TestCase),
+        ("simple_dex", test_simple_dex as TestCase),
         ("ban_automatic", test_ban_automatic as TestCase),
         ("ban_manual", test_ban_manual as TestCase),
         (
diff --git a/e2e-tests/src/config.rs b/e2e-tests/src/config.rs
@@ -81,6 +81,10 @@ pub struct TestCaseParams {
     #[clap(long)]
     pub the_pressiah_cometh: Option<String>,
 
+    /// Address of the simple dex contract.
+    #[clap(long)]
+    pub simple_dex: Option<String>,
+
     /// Path to the button game metadata file. Only used by button tests.
     #[clap(long)]
     pub button_game_metadata: Option<String>,
@@ -97,6 +101,10 @@ pub struct TestCaseParams {
     #[clap(long)]
     pub marketplace_metadata: Option<String>,
 
+    /// Path to the simple_dex metadata file. Only used by button tests.
+    #[clap(long)]
+    pub simple_dex_metadata: Option<String>,
+
     /// Version for the VersionUpgrade test.
     #[clap(long)]
     pub upgrade_to_version: Option<u32>,
diff --git a/e2e-tests/src/test/button_game/contracts.rs b/e2e-tests/src/test/button_game/contracts.rs
@@ -6,6 +6,121 @@ use sp_core::crypto::{AccountId32 as AccountId, Ss58Codec};
 
 use crate::Config;
 
+/// A wrapper around the simple dex contract.
+///
+/// The methods on this type match contract methods.
+#[derive(Debug)]
+pub(super) struct SimpleDexInstance {
+    contract: ContractInstance,
+}
+
+impl<'a> From<&'a SimpleDexInstance> for &'a ContractInstance {
+    fn from(dex: &'a SimpleDexInstance) -> Self {
+        &dex.contract
+    }
+}
+
+impl<'a> From<&'a SimpleDexInstance> for AccountId {
+    fn from(dex: &'a SimpleDexInstance) -> Self {
+        dex.contract.address().clone()
+    }
+}
+
+impl SimpleDexInstance {
+    pub fn new(config: &Config) -> Result<Self> {
+        let dex_address = config
+            .test_case_params
+            .simple_dex
+            .clone()
+            .context("Simple dex address not set.")?;
+        let dex_address = AccountId::from_string(&dex_address)?;
+        let metadata_path = config
+            .test_case_params
+            .simple_dex_metadata
+            .clone()
+            .context("Simple dex metadata not set")?;
+
+        Ok(Self {
+            contract: ContractInstance::new(dex_address, &metadata_path)?,
+        })
+    }
+
+    pub fn add_swap_pair(
+        &self,
+        conn: &SignedConnection,
+        from: AccountId,
+        to: AccountId,
+    ) -> Result<()> {
+        self.contract
+            .contract_exec(conn, "add_swap_pair", &[&from.to_string(), &to.to_string()])
+    }
+
+    pub fn deposit(
+        &self,
+        conn: &SignedConnection,
+        amounts: &[(&PSP22TokenInstance, Balance)],
+    ) -> Result<()> {
+        let deposits = amounts
+            .iter()
+            .map(|(token, amount)| {
+                let address: AccountId = (*token).try_into()?;
+                Ok(format!("deposits ({:}, {:})", address, amount))
+            })
+            .collect::<Result<Vec<String>>>()?;
+
+        self.contract
+            .contract_exec(conn, "deposit", &[format!("[{:}]", deposits.join(","))])
+    }
+
+    pub fn out_given_in<C: AnyConnection>(
+        &self,
+        conn: &C,
+        token_in: &PSP22TokenInstance,
+        token_out: &PSP22TokenInstance,
+        amount_token_in: Balance,
+        min_amount_token_out: Option<Balance>,
+    ) -> Result<Balance> {
+        let token_in: AccountId = token_in.into();
+        let token_out: AccountId = token_out.into();
+
+        self.contract
+            .contract_read(
+                conn,
+                "out_given_in",
+                &[
+                    token_in.to_string(),
+                    token_out.to_string(),
+                    amount_token_in.to_string(),
+                    min_amount_token_out.map_or("None".to_string(), |x| format!("Some({:})", x)),
+                ],
+            )?
+            .try_into()?
+    }
+
+    pub fn swap(
+        &self,
+        conn: &SignedConnection,
+        token_in: &PSP22TokenInstance,
+        amount_token_in: Balance,
+        token_out: &PSP22TokenInstance,
+        min_amount_token_out: Balance,
+    ) -> Result<()> {
+        let token_in: AccountId = token_in.into();
+        let token_out: AccountId = token_out.into();
+
+        self.contract.contract_exec(
+            conn,
+            "swap",
+            &[
+                token_in.to_string(),
+                token_out.to_string(),
+                amount_token_in.to_string(),
+                min_amount_token_out.to_string(),
+            ],
+        )
+    }
+}
+
 /// A wrapper around a button game contract.
 ///
 /// The methods on this type match contract methods.
@@ -99,15 +214,15 @@ impl PSP22TokenInstance {
         self.contract.contract_exec(
             conn,
             "PSP22::transfer",
-            &[to.to_string().as_str(), amount.to_string().as_str(), "0x00"],
+            &[to.to_string(), amount.to_string(), "0x00".to_string()],
         )
     }
 
     pub fn mint(&self, conn: &SignedConnection, to: &AccountId, amount: Balance) -> Result<()> {
         self.contract.contract_exec(
             conn,
             "PSP22Mintable::mint",
-            &[to.to_string().as_str(), amount.to_string().as_str()],
+            &[to.to_string(), amount.to_string()],
         )
     }
 
@@ -120,13 +235,13 @@ impl PSP22TokenInstance {
         self.contract.contract_exec(
             conn,
             "PSP22::approve",
-            &[spender.to_string().as_str(), value.to_string().as_str()],
+            &[spender.to_string(), value.to_string()],
         )
     }
 
     pub fn balance_of(&self, conn: &Connection, account: &AccountId) -> Result<Balance> {
         self.contract
-            .contract_read(conn, "PSP22::balance_of", &[account.to_string().as_str()])?
+            .contract_read(conn, "PSP22::balance_of", &[account.to_string()])?
             .try_into()
     }
 }
diff --git a/e2e-tests/src/test/button_game/helpers.rs b/e2e-tests/src/test/button_game/helpers.rs
diff --git a/e2e-tests/src/test/button_game/mod.rs b/e2e-tests/src/test/button_game/mod.rs
diff --git a/e2e-tests/src/test/mod.rs b/e2e-tests/src/test/mod.rs
