feat: ICE

Cargo.toml

@@ -43,15 +43,17 @@ members = [
     'pallets/dynamic-evm-fee',
     'pallets/xyk-liquidity-mining',
     'precompiles/call-permit',
-    'runtime-mock'
+    'runtime-mock',
+    'pallets/ice',
+    'pallets/ice/solver'
 ]
 
 resolver = "2"
 
 [workspace.dependencies]
 codec = { package = "parity-scale-codec", version = "3.6.1", default-features = false, features = ["derive"] }
 scale-info = { version = "2.11.1", default-features = false, features = ["derive"] }
-serde = { version = "1.0.197", default-features = false }
+serde = { version = "=1.0.197", default-features = false }
 primitive-types = { version = "0.12.0", default-features = false }
 
 affix = "0.1.2"
@@ -90,7 +92,7 @@ rand_xoshiro = "0.6.0"
 rug = { version = "1.17.0", features = ["num-traits"] }
 rustc-hex = { version = '2.1.0', default-features = false }
 sha3 = { version = "0.10.6", default-features = false }
-serde_json = { version = "1.0.117", default-features = false }
+serde_json = { version = "=1.0.117", default-features = false }
 slices = "0.2.0"
 smallvec = "1.9.0"
 similar-asserts = "1.1.0"
@@ -102,6 +104,8 @@ toml = "0.5"
 trie-db = "0.28.0"
 trybuild = "1.0"
 
+clarabel = { git = "https://github.com/enthusiastmartin/Clarabel.rs" ,  branch = "feat/sp-support", default-features = false }
+
 hydra-dx-math = { path = "math", default-features = false }
 hydradx = { path = "node", default-features = false }
 hydradx-traits = { path = "traits", default-features = false }
@@ -143,6 +147,8 @@ pallet-xyk-liquidity-mining = { path = "pallets/xyk-liquidity-mining", default-f
 pallet-referrals = { path = "pallets/referrals", default-features = false }
 pallet-evm-accounts = { path = "pallets/evm-accounts", default-features = false }
 pallet-evm-accounts-rpc-runtime-api = { path = "pallets/evm-accounts/rpc/runtime-api", default-features = false }
+pallet-ice = { path = "pallets/ice", default-features = false}
+ice-solver = { path = "pallets/ice/solver", default-features = false}
 
 hydra-dx-build-script-utils = { path = "utils/build-script-utils", default-features = false }
 scraper = { path = "scraper", default-features = false }

integration-tests/Cargo.toml

@@ -9,6 +9,7 @@ license = "Apache 2.0"
 repository = "https://github.com/galacticcouncil/HydraDX-node"
 
 [dependencies]
+rand = { version = "0.8.5", default-features = false }
 hex-literal = { workspace = true }
 frame-remote-externalities = { workspace = true }
 tokio = { workspace = true }
@@ -41,6 +42,8 @@ pallet-staking = { workspace = true }
 pallet-lbp = { workspace = true }
 pallet-xyk = { workspace = true }
 pallet-evm-accounts = { workspace = true }
+pallet-ice = { workspace = true}
+ice-solver = { workspace = true}
 
 pallet-treasury = { workspace = true }
 pallet-democracy = { workspace = true }
@@ -217,6 +220,8 @@ std = [
     "pallet-dynamic-evm-fee/std",
     "precompile-utils/std",
     "pallet-transaction-pause/std",
+    "pallet-ice/std",
+    "ice-solver/std",
 ]
 
 # we don't include integration tests when benchmarking feature is enabled

integration-tests/src/ice/generator.rs

@@ -0,0 +1,51 @@
+use pallet_ice::traits::{OmnipoolAssetInfo, OmnipoolInfo};
+use pallet_ice::types::{Intent, Swap, SwapType};
+use primitives::{AccountId, AssetId, Moment};
+use rand::Rng;
+use sp_core::crypto::AccountId32;
+use sp_runtime::{FixedPointNumber, FixedU128};
+
+pub(crate) fn generate_random_intents(
+	c: u32,
+	data: Vec<OmnipoolAssetInfo<AssetId>>,
+	deadline: Moment,
+) -> Vec<Intent<AccountId, AssetId>> {
+	let random_pair = || {
+		let mut rng = rand::thread_rng();
+		loop {
+			let idx_in = rng.gen_range(0..data.len());
+			let idx_out = rng.gen_range(0..data.len());
+			let reserve_in = data[idx_in].reserve;
+			let reserve_out = data[idx_out].reserve;
+			let amount_in = rng.gen_range(1..reserve_in / 4);
+			let lrna_in = FixedU128::from_rational(amount_in, reserve_in)
+				.checked_mul_int(data[idx_in].hub_reserve)
+				.unwrap();
+			let amount_out = FixedU128::from_rational(reserve_out, data[idx_out].hub_reserve)
+				.checked_mul_int(lrna_in)
+				.unwrap();
+			return (data[idx_in].asset_id, data[idx_out].asset_id, amount_in, amount_out);
+		}
+	};
+
+	let mut intents = Vec::new();
+	for i in 0..c {
+		let who: [u8; 32] = [i as u8; 32];
+		let (asset_in, asset_out, amount_in, amount_out) = random_pair();
+		intents.push(Intent {
+			who: who.into(),
+			swap: Swap {
+				asset_in,
+				asset_out,
+				amount_in,
+				amount_out,
+				swap_type: SwapType::ExactIn,
+			},
+			deadline,
+			partial: true,
+			on_success: None,
+			on_failure: None,
+		});
+	}
+	intents
+}

integration-tests/src/ice/intents.rs

@@ -0,0 +1,44 @@
+use super::*;
+
+#[test]
+fn submit_intent_should_work() {
+	Hydra::execute_with(|| {
+		crate::utils::pools::setup_omnipool();
+
+		let deadline: Moment = NOW + 43_200_000;
+
+		let swap = Swap {
+			asset_in: HDX,
+			asset_out: DAI,
+			amount_in: 1_000_000_000_000,
+			amount_out: 2_000_000_000_000,
+			swap_type: pallet_ice::types::SwapType::ExactIn,
+		};
+		assert_ok!(ICE::submit_intent(
+			RuntimeOrigin::signed(BOB.into()),
+			Intent {
+				who: BOB.into(),
+				swap: swap.clone(),
+				deadline,
+				partial: false,
+				on_success: None,
+				on_failure: None,
+			}
+		));
+
+		let intent_id = pallet_ice::Pallet::<hydradx_runtime::Runtime>::get_intent_id(deadline, 0);
+
+		let expected_entry = pallet_ice::types::Intent {
+			who: BOB.into(),
+			swap,
+			deadline,
+			partial: false,
+			on_success: None,
+			on_failure: None,
+		};
+		assert_eq!(
+			pallet_ice::Pallet::<hydradx_runtime::Runtime>::get_intent(intent_id),
+			Some(expected_entry)
+		);
+	});
+}

integration-tests/src/ice/mod.rs

@@ -0,0 +1,71 @@
+pub(crate) mod generator;
+mod intents;
+mod omni;
+
+use crate::polkadot_test_net::*;
+use frame_support::assert_ok;
+use frame_support::traits::fungible::Mutate;
+use hydra_dx_math::ratio::Ratio;
+use hydradx_adapters::price::OraclePriceProviderUsingRoute;
+use hydradx_adapters::OraclePriceProvider;
+use hydradx_runtime::{
+	Currencies, EmaOracle, Omnipool, ReferralsOraclePeriod, Router, RuntimeOrigin, ICE, LRNA as LRNAT,
+};
+use hydradx_traits::price::PriceProvider;
+use hydradx_traits::router::AssetPair;
+use orml_traits::MultiCurrency;
+use pallet_ice::traits::Solver;
+use pallet_ice::types::{Balance, BoundedResolvedIntents, BoundedTrades, Intent, IntentId, ResolvedIntent as RI, Swap};
+use primitives::{AccountId, AssetId, Moment};
+use sp_core::crypto::AccountId32;
+use xcm_emulator::TestExt;
+
+const PATH_TO_SNAPSHOT: &str = "omnipool-snapshot/2024-10-18";
+
+pub(crate) fn solve_intents_with<S: Solver<(IntentId, Intent<sp_runtime::AccountId32, AssetId>)>>(
+	intents: Vec<(IntentId, Intent<sp_runtime::AccountId32, AssetId>)>,
+) -> Result<BoundedResolvedIntents, ()> {
+	let (result, metadata) = S::solve(intents).map_err(|_| ())?;
+	let resolved_intents = BoundedResolvedIntents::try_from(result).unwrap();
+	//let trades = BoundedTrades::try_from(solution.trades()).unwrap();
+	//let score = solution.score();
+	Ok(resolved_intents)
+}
+
+#[test]
+fn test_omnipool_snapshot() {
+	hydra_live_ext(PATH_TO_SNAPSHOT).execute_with(|| {
+		//let omnipool_account = hydradx_runtime::Omnipool::protocol_account();
+		let buy_asset = 27;
+		let initial_balance20 = Currencies::free_balance(buy_asset, &AccountId32::from(BOB));
+		hydradx_runtime::Balances::set_balance(&BOB.into(), 200_000_000_000_000_000);
+
+		assert_ok!(Router::sell(
+			RuntimeOrigin::signed(BOB.into()),
+			0,
+			buy_asset,
+			100_000_000_000_000,
+			0,
+			vec![]
+		));
+		let balance20 = Currencies::free_balance(buy_asset, &AccountId32::from(BOB));
+
+		assert_eq!(balance20 - initial_balance20, 1249711278057);
+	});
+}
+
+pub(crate) fn submit_intents(intents: Vec<Intent<AccountId, AssetId>>) -> Vec<(IntentId, Intent<AccountId, AssetId>)> {
+	let mut intent_ids = Vec::new();
+	for intent in intents {
+		let deadline = intent.deadline;
+		let increment_id = pallet_ice::Pallet::<hydradx_runtime::Runtime>::next_incremental_id();
+		assert_ok!(ICE::submit_intent(
+			RuntimeOrigin::signed(intent.who.clone()),
+			intent.clone()
+		));
+		let intent_id = pallet_ice::Pallet::<hydradx_runtime::Runtime>::get_intent_id(deadline, increment_id);
+		intent_ids.push((intent_id, intent));
+	}
+
+	intent_ids
+}