Implement pallet-currency-swap logic

crates/pallet-currency-swap/Cargo.toml

@@ -0,0 +1,51 @@
+[package]
+name = "pallet-currency-swap"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[dependencies]
+primitives-currency-swap = { version = "0.1", path = "../primitives-currency-swap", default-features = false }
+
+codec = { package = "parity-scale-codec", version = "3.2.2", default-features = false, features = ["derive"] }
+frame-benchmarking = { default-features = false, git = "https://github.com/humanode-network/substrate", branch = "locked/polkadot-v0.9.38", optional = true }
+frame-support = { default-features = false, git = "https://github.com/humanode-network/substrate", branch = "locked/polkadot-v0.9.38" }
+frame-system = { default-features = false, git = "https://github.com/humanode-network/substrate", branch = "locked/polkadot-v0.9.38" }
+scale-info = { version = "2.5.0", default-features = false, features = ["derive"] }
+sp-runtime = { default-features = false, git = "https://github.com/humanode-network/substrate", branch = "locked/polkadot-v0.9.38" }
+sp-std = { default-features = false, git = "https://github.com/humanode-network/substrate", branch = "locked/polkadot-v0.9.38" }
+
+[dev-dependencies]
+mockall = "0.11"
+pallet-balances = { git = "https://github.com/humanode-network/substrate", branch = "locked/polkadot-v0.9.38" }
+pallet-evm-balances = { git = "https://github.com/humanode-network/frontier", branch = "locked/polkadot-v0.9.38" }
+pallet-evm-system = { git = "https://github.com/humanode-network/frontier", branch = "locked/polkadot-v0.9.38" }
+sp-core = { git = "https://github.com/humanode-network/substrate", branch = "locked/polkadot-v0.9.38" }
+
+[features]
+default = ["std"]
+runtime-benchmarks = [
+  "frame-benchmarking/runtime-benchmarks",
+  "frame-support/runtime-benchmarks",
+  "frame-system/runtime-benchmarks",
+  "pallet-balances/runtime-benchmarks",
+  "sp-runtime/runtime-benchmarks",
+]
+std = [
+  "codec/std",
+  "frame-support/std",
+  "frame-system/std",
+  "primitives-currency-swap/std",
+  "scale-info/std",
+  "sp-runtime/std",
+  "sp-std/std",
+]
+try-runtime = [
+  "frame-support/try-runtime",
+  "frame-system/try-runtime",
+  "pallet-balances/try-runtime",
+  "pallet-evm-balances/try-runtime",
+  "pallet-evm-system/try-runtime",
+  "primitives-currency-swap/try-runtime",
+  "sp-runtime/try-runtime",
+]

crates/pallet-currency-swap/src/benchmarking.rs

@@ -0,0 +1,119 @@
+//! The benchmarks for the pallet.
+
+use frame_benchmarking::benchmarks;
+use frame_support::{assert_ok, dispatch::DispatchResult, traits::Currency};
+use frame_system::RawOrigin;
+
+use crate::*;
+
+/// The benchmark interface into the environment.
+pub trait Interface: super::Config {
+    /// The data to be passed from `prepare` to `verify`.
+    type Data;
+
+    /// Prepare currency swap environment.
+    fn prepare() -> Self::Data;
+
+    /// Verify currency swap environment,
+    fn verify(data: Self::Data) -> DispatchResult;
+
+    /// Obtain the Account ID the balance is swapped from.
+    fn from_account_id() -> <Self as frame_system::Config>::AccountId;
+
+    /// Obtain the amount of balance to withdraw from the swap source account.
+    fn from_balance() -> FromBalanceOf<Self>;
+
+    /// Obtain the Account ID the balance is swapped to.
+    fn to_account_id() -> <Self as Config>::AccountIdTo;
+
+    /// Obtain the amount of balance to deposit to the swap destination account.
+    fn to_balance() -> ToBalanceOf<Self>;
+}
+
+benchmarks! {
+    where_clause {
+        where
+            T: Interface,
+    }
+
+    swap {
+        let from = <T as Interface>::from_account_id();
+        let from_balance = <T as Interface>::from_balance();
+        let to = <T as Interface>::to_account_id();
+        let to_balance =  <T as Interface>::to_balance();
+        let init_balance: u32 = 1000;
+
+        let _ = <FromCurrencyOf<T>>::deposit_creating(&from, init_balance.into());
+
+        let from_balance_before = <FromCurrencyOf<T>>::total_balance(&from);
+        let to_balance_before = <ToCurrencyOf<T>>::total_balance(&to);
+
+        let currency_swap = <T as Interface>::prepare();
+
+        let origin = RawOrigin::Signed(from.clone());
+
+    }: _(origin, to.clone(), from_balance)
+    verify {
+        let from_balance_after = <FromCurrencyOf<T>>::total_balance(&from);
+        let to_balance_after = <ToCurrencyOf<T>>::total_balance(&to);
+
+        assert_eq!(from_balance_before - from_balance_after, from_balance);
+        assert_eq!(to_balance_after - to_balance_before, to_balance);
+
+        assert_ok!(<T as Interface>::verify(currency_swap));
+    }
+
+    impl_benchmark_test_suite!(
+        Pallet,
+        crate::mock::new_test_ext(),
+        crate::mock::Test,
+    );
+}
+
+#[cfg(test)]
+impl Interface for crate::mock::Test {
+    type Data = (
+        std::sync::MutexGuard<'static, ()>,
+        mock::__mock_MockCurrencySwap_CurrencySwap_9230394375286242749::__swap::Context,
+    );
+
+    fn prepare() -> Self::Data {
+        let mock_runtime_guard = mock::runtime_lock();
+
+        let swap_ctx = mock::MockCurrencySwap::swap_context();
+        swap_ctx.expect().times(1..).return_once(move |_| {
+            Ok(
+                <mock::EvmBalances as Currency<mock::EvmAccountId>>::NegativeImbalance::new(
+                    Self::to_balance().into(),
+                ),
+            )
+        });
+
+        (mock_runtime_guard, swap_ctx)
+    }
+
+    fn verify(data: Self::Data) -> DispatchResult {
+        let (mock_runtime_guard, swap_ctx) = data;
+        swap_ctx.checkpoint();
+        drop(mock_runtime_guard);
+        Ok(())
+    }
+
+    fn from_account_id() -> <Self as frame_system::Config>::AccountId {
+        42
+    }
+
+    fn from_balance() -> FromBalanceOf<Self> {
+        100
+    }
+
+    fn to_account_id() -> <Self as Config>::AccountIdTo {
+        use sp_std::str::FromStr;
+
+        mock::EvmAccountId::from_str("1000000000000000000000000000000000000001").unwrap()
+    }
+
+    fn to_balance() -> ToBalanceOf<Self> {
+        100
+    }
+}

crates/pallet-currency-swap/src/lib.rs

@@ -0,0 +1,140 @@
+//! A substrate pallet containing the currency swap integration.
+
+#![cfg_attr(not(feature = "std"), no_std)]
+
+use frame_support::traits::Currency;
+pub use pallet::*;
+use primitives_currency_swap::CurrencySwap as CurrencySwapT;
+pub use weights::*;
+
+pub mod weights;
+
+#[cfg(feature = "runtime-benchmarks")]
+pub mod benchmarking;
+#[cfg(test)]
+mod mock;
+#[cfg(test)]
+mod tests;
+
+/// Utility alias for easy access to [`primitives_currency_swap::CurrencySwap::From`] type from a given config.
+type FromCurrencyOf<T> = <<T as Config>::CurrencySwap as CurrencySwapT<
+    <T as frame_system::Config>::AccountId,
+    <T as Config>::AccountIdTo,
+>>::From;
+
+/// Utility alias for easy access to the [`Currency::Balance`] of
+/// the [`primitives_currency_swap::CurrencySwap::From`] type.
+type FromBalanceOf<T> =
+    <FromCurrencyOf<T> as Currency<<T as frame_system::Config>::AccountId>>::Balance;
+
+/// Utility alias for easy access to [`primitives_currency_swap::CurrencySwap::To`] type from a given config.
+type ToCurrencyOf<T> = <<T as Config>::CurrencySwap as CurrencySwapT<
+    <T as frame_system::Config>::AccountId,
+    <T as Config>::AccountIdTo,
+>>::To;
+
+/// Utility alias for easy access to the [`Currency::Balance`] of
+/// the [`primitives_currency_swap::CurrencySwap::To`] type.
+type ToBalanceOf<T> = <ToCurrencyOf<T> as Currency<<T as Config>::AccountIdTo>>::Balance;
+
+// We have to temporarily allow some clippy lints. Later on we'll send patches to substrate to
+// fix them at their end.
+#[allow(clippy::missing_docs_in_private_items)]
+#[frame_support::pallet]
+pub mod pallet {
+    use frame_support::{
+        pallet_prelude::*,
+        storage::with_storage_layer,
+        traits::{ExistenceRequirement, Imbalance, WithdrawReasons},
+    };
+    use frame_system::pallet_prelude::*;
+    use sp_runtime::traits::MaybeDisplay;
+    use sp_std::fmt::Debug;
+
+    use super::*;
+
+    #[pallet::pallet]
+    #[pallet::generate_store(pub(super) trait Store)]
+    pub struct Pallet<T>(_);
+
+    /// Configuration trait of this pallet.
+    #[pallet::config]
+    pub trait Config: frame_system::Config {
+        /// Overarching event type.
+        type RuntimeEvent: From<Event<Self>> + IsType<<Self as frame_system::Config>::RuntimeEvent>;
+
+        /// The user account identifier type to convert to.
+        type AccountIdTo: Parameter
+            + Member
+            + MaybeSerializeDeserialize
+            + Debug
+            + MaybeDisplay
+            + Ord
+            + MaxEncodedLen;
+
+        /// Interface into currency swap implementation.
+        type CurrencySwap: CurrencySwapT<Self::AccountId, Self::AccountIdTo>;
+
+        /// Weight information for extrinsics in this pallet.
+        type WeightInfo: WeightInfo;
+    }
+
+    #[pallet::event]
+    #[pallet::generate_deposit(pub(super) fn deposit_event)]
+    pub enum Event<T: Config> {
+        /// Balances were swapped.
+        BalancesSwapped {
+            /// The account id balances withdrawed from.
+            from: T::AccountId,
+            /// The withdrawed balances amount.
+            withdrawed_amount: FromBalanceOf<T>,
+            /// The account id balances deposited to.
+            to: T::AccountIdTo,
+            /// The deposited balances amount.
+            deposited_amount: ToBalanceOf<T>,
+        },
+    }
+
+    #[pallet::call]
+    impl<T: Config> Pallet<T> {
+        /// Swap balances.
+        #[pallet::call_index(0)]
+        #[pallet::weight(T::WeightInfo::swap())]
+        pub fn swap(
+            origin: OriginFor<T>,
+            to: T::AccountIdTo,
+            amount: FromBalanceOf<T>,
+        ) -> DispatchResult {
+            let who = ensure_signed(origin)?;
+
+            with_storage_layer(move || {
+                let withdrawed_imbalance = FromCurrencyOf::<T>::withdraw(
+                    &who,
+                    amount,
+                    WithdrawReasons::TRANSFER,
+                    ExistenceRequirement::AllowDeath,
+                )?;
+                let withdrawed_amount = withdrawed_imbalance.peek();
+
+                let deposited_imbalance =
+                    T::CurrencySwap::swap(withdrawed_imbalance).map_err(|error| {
+                        // Here we undo the withdrawl to avoid having a dangling imbalance.
+                        FromCurrencyOf::<T>::resolve_creating(&who, error.incoming_imbalance);
+                        error.cause.into()
+                    })?;
+                let deposited_amount = deposited_imbalance.peek();
+
+                ToCurrencyOf::<T>::resolve_creating(&to, deposited_imbalance);
+
+                Self::deposit_event(Event::BalancesSwapped {
+                    from: who,
+                    withdrawed_amount,
+                    to,
+                    deposited_amount,
+                });
+
+                Ok(())
+            })
+        }
+    }
+}