[intent-coprocessor]: Price Discovery Protocol

modules/pallets/intents-coprocessor/Cargo.toml

@@ -28,7 +28,9 @@ anyhow = { workspace = true }
 alloy-primitives = { workspace = true }
 alloy-sol-macro = { workspace = true }
 alloy-sol-types = { workspace = true }
+hex-literal = { workspace = true }
 
+crypto-utils = { workspace = true }
 ismp = { workspace = true }
 pallet-ismp = { workspace = true }
 
@@ -49,6 +51,7 @@ std = [
     "scale-info/std",
     "anyhow/std",
     "alloy-primitives/std",
+    "crypto-utils/std",
     "sp-io/std",
     "pallet-ismp/std",
 ]

modules/pallets/intents-coprocessor/rpc/Cargo.toml

@@ -13,6 +13,7 @@ log = { workspace = true, default-features = true }
 tokio = { workspace = true, features = ["sync", "time"] }
 futures = { workspace = true }
 hex = { workspace = true, default-features = true }
+primitive-types = { workspace = true, default-features = true }
 pallet-intents-coprocessor = { workspace = true, default-features = true }
 
 [dependencies.polkadot-sdk]

modules/pallets/intents-coprocessor/rpc/src/lib.rs

@@ -53,6 +53,27 @@ pub struct RpcBidInfo {
 	pub user_op: Vec<u8>,
 }
 
+/// A single price entry returned by the RPC
+#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq)]
+pub struct RpcPriceEntry {
+	/// The submitter's encoded account
+	#[serde(with = "hex_bytes")]
+	pub submitter: Vec<u8>,
+	/// The submitted price as a hex-encoded U256
+	pub price: String,
+	/// Timestamp of submission (seconds)
+	pub timestamp: u64,
+}
+
+/// Response for the `intents_getPairPrices` RPC method
+#[derive(Clone, Debug, Serialize, Deserialize, Eq, PartialEq)]
+pub struct RpcPairPrices {
+	/// High confidence prices (from verified fillers with proofs)
+	pub verified: Vec<RpcPriceEntry>,
+	/// Low confidence prices (from unverified submitters)
+	pub unverified: Vec<RpcPriceEntry>,
+}
+
 impl Ord for RpcBidInfo {
 	fn cmp(&self, other: &Self) -> std::cmp::Ordering {
 		self.filler.cmp(&other.filler)
@@ -158,6 +179,17 @@ fn runtime_error_into_rpc_error(e: impl std::fmt::Display) -> ErrorObjectOwned {
 	ErrorObject::owned(9877, format!("{e}"), None::<String>)
 }
 
+/// Construct the full storage key for a `StorageMap` entry with `Blake2_128Concat` hasher.
+fn storage_map_key(pallet: &[u8], storage: &[u8], map_key: &H256) -> Vec<u8> {
+	let mut key = Vec::new();
+	key.extend_from_slice(&sp_core::hashing::twox_128(pallet));
+	key.extend_from_slice(&sp_core::hashing::twox_128(storage));
+	let map_key_bytes = map_key.as_bytes();
+	key.extend_from_slice(&sp_core::hashing::blake2_128(map_key_bytes));
+	key.extend_from_slice(map_key_bytes);
+	key
+}
+
 /// Construct the storage key prefix for iterating all fillers in the on-chain
 /// `Bids` double-map for a given order commitment.
 fn bids_storage_prefix(commitment: &H256) -> Vec<u8> {
@@ -176,6 +208,10 @@ pub trait IntentsApi {
 	#[method(name = "intents_getBidsForOrder")]
 	fn get_bids_for_order(&self, commitment: H256) -> RpcResult<Vec<RpcBidInfo>>;
 
+	/// Get all prices for a token pair, separated by confidence level
+	#[method(name = "intents_getPairPrices")]
+	fn get_pair_prices(&self, pair_id: H256) -> RpcResult<RpcPairPrices>;
+
 	#[subscription(name = "intents_subscribeBids" => "intents_bidNotification", unsubscribe = "intents_unsubscribeBids", item = RpcBidInfo)]
 	async fn subscribe_bids(&self, commitment: Option<H256>) -> SubscriptionResult;
 }
@@ -259,6 +295,40 @@ where
 		Ok(bids.into_iter().collect())
 	}
 
+	fn get_pair_prices(&self, pair_id: H256) -> RpcResult<RpcPairPrices> {
+		let best_hash = self.client.info().best_hash;
+
+		let decode_entries = |storage_name: &[u8]| -> Vec<RpcPriceEntry> {
+			let key = storage_map_key(b"IntentsCoprocessor", storage_name, &pair_id);
+			let storage_key = sp_core::storage::StorageKey(key);
+
+			let data = match self.client.storage(best_hash, &storage_key) {
+				Ok(Some(data)) => data.0,
+				_ => return Vec::new(),
+			};
+
+			// Decode Vec<PriceEntry<AccountId32>>
+			// PriceEntry SCALE-encodes as (AccountId32(32 bytes), U256(32 bytes), u64(8 bytes))
+			type Entry = (sp_runtime::AccountId32, primitive_types::U256, u64);
+			match Vec::<Entry>::decode(&mut &data[..]) {
+				Ok(entries) => entries
+					.into_iter()
+					.map(|(submitter, price, timestamp)| RpcPriceEntry {
+						submitter: submitter.encode(),
+						price: format!("0x{price:x}"),
+						timestamp,
+					})
+					.collect(),
+				Err(_) => Vec::new(),
+			}
+		};
+
+		Ok(RpcPairPrices {
+			verified: decode_entries(b"VerifiedPrices"),
+			unverified: decode_entries(b"UnverifiedPrices"),
+		})
+	}
+
 	async fn subscribe_bids(
 		&self,
 		pending: PendingSubscriptionSink,