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

@@ -41,6 +41,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 +219,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/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,92 @@
+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> {
+	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,));
+		let intent_id = pallet_ice::Pallet::<hydradx_runtime::Runtime>::get_intent_id(deadline, increment_id);
+		intent_ids.push(intent_id);
+	}
+
+	intent_ids
+}
+
+/*
+
+fn print_json_str(assets: &[OmnipoolAssetInfo<AssetId>]) {
+	// dump assets info in json format
+	let mut json = String::from("[");
+	for asset in assets {
+		json.push_str(&format!(
+			r#"{{"asset_id": {}, "reserve": {}, "hub_reserve": {}, "decimals": {}, "fee": {}, "hub_fee": {}, "symbol": "{}"}}"#,
+			asset.asset_id,
+			asset.reserve,
+			asset.hub_reserve,
+			asset.decimals,
+			asset.fee.deconstruct(),
+			asset.hub_fee.deconstruct(),
+			asset.symbol
+		));
+		json.push_str(",");
+	}
+	json.pop();
+	json.push_str("]");
+	println!("{}", json);
+}
+
+ */

integration-tests/src/ice/omni.rs

@@ -0,0 +1,128 @@
+use crate::ice::{solve_intents_with, submit_intents, PATH_TO_SNAPSHOT};
+use crate::polkadot_test_net::*;
+use frame_support::assert_ok;
+use frame_support::traits::fungible::Mutate;
+use hydradx_adapters::ice::{IceRoutingSupport, OmnipoolDataProvider};
+use hydradx_adapters::price::OraclePriceProviderUsingRoute;
+use hydradx_adapters::OraclePriceProvider;
+use hydradx_runtime::{
+	Currencies, EmaOracle, Omnipool, ReferralsOraclePeriod, Router, RuntimeOrigin, System, Timestamp, ICE,
+	LRNA as LRNAT,
+};
+use hydradx_traits::router::{PoolType, Trade};
+use pallet_ice::types::{BoundedResolvedIntents, BoundedTrades, Intent, IntentId, Swap};
+use pallet_ice::Call::submit_intent;
+use pallet_omnipool::types::Tradability;
+use primitives::{AccountId, AssetId, Moment};
+use sp_runtime::traits::BlockNumberProvider;
+
+type PriceP =
+	OraclePriceProviderUsingRoute<Router, OraclePriceProvider<AssetId, EmaOracle, LRNAT>, ReferralsOraclePeriod>;
+
+type OmniSolverWithOmnipool =
+	ice_solver::omni::OmniSolver<AccountId, AssetId, OmnipoolDataProvider<hydradx_runtime::Runtime>>;
+
+#[test]
+fn solver_should_find_solution_with_one_intent() {
+	hydra_live_ext(PATH_TO_SNAPSHOT).execute_with(|| {
+		hydradx_runtime::Balances::set_balance(&BOB.into(), 200_000_000_000_000);
+
+		let deadline: Moment = Timestamp::now() + 43_200_000;
+		let intent_ids = submit_intents(vec![Intent {
+			who: BOB.into(),
+			swap: Swap {
+				asset_in: 0,
+				asset_out: 27,
+				amount_in: 100_000_000_000_000,
+				amount_out: 1149711278057,
+				swap_type: pallet_ice::types::SwapType::ExactIn,
+			},
+			deadline,
+			partial: true,
+			on_success: None,
+			on_failure: None,
+		}]);
+
+		let intents = vec![(
+			intent_ids[0],
+			pallet_ice::Pallet::<hydradx_runtime::Runtime>::get_intent(intent_ids[0]).unwrap(),
+		)];
+
+		let resolved = solve_intents_with::<OmniSolverWithOmnipool>(intents).unwrap();
+
+		let (trades, score) =
+			pallet_ice::Pallet::<hydradx_runtime::Runtime>::calculate_trades_and_score(&resolved.to_vec()).unwrap();
+
+		assert_eq!(
+			resolved.to_vec(),
+			vec![pallet_ice::types::ResolvedIntent {
+				intent_id: 796899343984252629811200000,
+				amount_in: 99853645824127,
+				amount_out: 1148028627591,
+			},]
+		);
+
+		assert_eq!(
+			trades,
+			vec![pallet_ice::types::TradeInstruction::SwapExactIn {
+				asset_in: 0,
+				asset_out: 27,
+				amount_in: 99853645824127,
+				amount_out: 1148028627591,
+				route: pallet_ice::types::BoundedRoute::try_from(vec![Trade {
+					pool: PoolType::Omnipool,
+					asset_in: 0,
+					asset_out: 27,
+				}])
+				.unwrap()
+			},]
+		);
+
+		assert_eq!(score, 1000000);
+	});
+}
+
+#[test]
+fn execute_solution_should_work_with_solved_intents() {
+	hydra_live_ext(PATH_TO_SNAPSHOT).execute_with(|| {
+		hydradx_runtime::Balances::set_balance(&BOB.into(), 200_000_000_000_000);
+		assert_ok!(hydradx_runtime::Omnipool::set_asset_tradable_state(
+			hydradx_runtime::RuntimeOrigin::root(),
+			LRNA,
+			Tradability::SELL | Tradability::BUY
+		));
+
+		let deadline: Moment = Timestamp::now() + 43_200_000;
+		let intent_ids = submit_intents(vec![Intent {
+			who: BOB.into(),
+			swap: Swap {
+				asset_in: 0,
+				asset_out: 27,
+				amount_in: 100_000_000_000_000,
+				amount_out: 1149711278057,
+				swap_type: pallet_ice::types::SwapType::ExactIn,
+			},
+			deadline,
+			partial: true,
+			on_success: None,
+			on_failure: None,
+		}]);
+
+		let intents = vec![(
+			intent_ids[0],
+			pallet_ice::Pallet::<hydradx_runtime::Runtime>::get_intent(intent_ids[0]).unwrap(),
+		)];
+		let resolved = solve_intents_with::<OmniSolverWithOmnipool>(intents).unwrap();
+
+		let (trades, score) =
+			pallet_ice::Pallet::<hydradx_runtime::Runtime>::calculate_trades_and_score(&resolved.to_vec()).unwrap();
+
+		assert_ok!(ICE::submit_solution(
+			RuntimeOrigin::signed(BOB.into()),
+			resolved,
+			BoundedTrades::try_from(trades).unwrap(),
+			score,
+			System::current_block_number()
+		));
+	});
+}

integration-tests/src/lib.rs

@@ -17,6 +17,7 @@ mod evm_permit;
 mod exchange_asset;
 mod fee_calculation;
 mod global_account_derivation;
+mod ice;
 mod insufficient_assets_ed;
 mod multi_payment;
 mod non_native_fee;

integration-tests/src/utils/mod.rs

@@ -1,2 +1,3 @@
 pub(crate) mod accounts;
 pub(crate) mod contracts;
+pub(crate) mod pools;