Working again

crates/dip/src/lib.rs

@@ -16,9 +16,43 @@
 
 // If you feel like getting in touch with us, you can do so at [email protected]
 
-pub mod location_conversion;
-pub mod v1;
+// Export v1 behind a namespace and also as the latest
+
+use codec::{Decode, Encode, MaxEncodedLen};
+use frame_support::RuntimeDebug;
+use scale_info::TypeInfo;
 
+pub mod v1;
 pub mod latest {
 	pub use crate::v1::*;
 }
+
+// Export utility modules without namespacing.
+mod location_conversion;
+pub use location_conversion::*;
+
+#[derive(Clone, Eq, PartialEq, Debug, Encode, Decode, TypeInfo, MaxEncodedLen)]
+pub enum VersionedIdentityProofAction<Identifier, Proof, Details = ()> {
+	#[codec(index = 1)]
+	V1(v1::IdentityProofAction<Identifier, Proof, Details>),
+}
+
+impl<Identifier, Proof> From<v1::IdentityProofAction<Identifier, Proof>>
+	for VersionedIdentityProofAction<Identifier, Proof>
+{
+	fn from(value: v1::IdentityProofAction<Identifier, Proof>) -> Self {
+		Self::V1(value)
+	}
+}
+
+#[derive(Encode, Decode, RuntimeDebug, Clone, Eq, PartialEq, TypeInfo)]
+pub enum VersionedIdentityProof<LeafKey, LeafValue> {
+	#[codec(index = 1)]
+	V1(v1::Proof<LeafKey, LeafValue>),
+}
+
+impl<LeafKey, LeafValue> From<v1::Proof<LeafKey, LeafValue>> for VersionedIdentityProof<LeafKey, LeafValue> {
+	fn from(value: v1::Proof<LeafKey, LeafValue>) -> Self {
+		Self::V1(value)
+	}
+}

crates/dip/src/location_conversion.rs

@@ -18,10 +18,8 @@
 
 // From Polkadot open PR https://github.com/paritytech/polkadot/pull/6662
 
-use codec::{Decode, Encode};
-use frame_support::traits::Get;
+use codec::Encode;
 use sp_io::hashing::blake2_256;
-use sp_runtime::traits::{AccountIdConversion, TrailingZeroInput};
 use sp_std::{borrow::Borrow, marker::PhantomData};
 use xcm::latest::prelude::*;
 use xcm_executor::traits::Convert;
@@ -104,146 +102,3 @@ impl<AccountId> ForeignChainAliasAccount<AccountId> {
 		(FOREIGN_CHAIN_PREFIX_RELAY, id).using_encoded(blake2_256)
 	}
 }
-
-pub struct Account32Hash<Network, AccountId>(PhantomData<(Network, AccountId)>);
-impl<Network: Get<Option<NetworkId>>, AccountId: From<[u8; 32]> + Into<[u8; 32]> + Clone>
-	Convert<MultiLocation, AccountId> for Account32Hash<Network, AccountId>
-{
-	fn convert_ref(location: impl Borrow<MultiLocation>) -> Result<AccountId, ()> {
-		Ok(("multiloc", location.borrow()).using_encoded(blake2_256).into())
-	}
-
-	fn reverse_ref(_: impl Borrow<AccountId>) -> Result<MultiLocation, ()> {
-		Err(())
-	}
-}
-
-/// A [`MultiLocation`] consisting of a single `Parent` [`Junction`] will be
-/// converted to the parent `AccountId`.
-pub struct ParentIsPreset<AccountId>(PhantomData<AccountId>);
-impl<AccountId: Decode + Eq + Clone> Convert<MultiLocation, AccountId> for ParentIsPreset<AccountId> {
-	fn convert_ref(location: impl Borrow<MultiLocation>) -> Result<AccountId, ()> {
-		if location.borrow().contains_parents_only(1) {
-			Ok(b"Parent"
-				.using_encoded(|b| AccountId::decode(&mut TrailingZeroInput::new(b)))
-				.expect("infinite length input; no invalid inputs for type; qed"))
-		} else {
-			Err(())
-		}
-	}
-
-	fn reverse_ref(who: impl Borrow<AccountId>) -> Result<MultiLocation, ()> {
-		let parent_account = b"Parent"
-			.using_encoded(|b| AccountId::decode(&mut TrailingZeroInput::new(b)))
-			.expect("infinite length input; no invalid inputs for type; qed");
-		if who.borrow() == &parent_account {
-			Ok(Parent.into())
-		} else {
-			Err(())
-		}
-	}
-}
-
-pub struct ChildParachainConvertsVia<ParaId, AccountId>(PhantomData<(ParaId, AccountId)>);
-impl<ParaId: From<u32> + Into<u32> + AccountIdConversion<AccountId>, AccountId: Clone> Convert<MultiLocation, AccountId>
-	for ChildParachainConvertsVia<ParaId, AccountId>
-{
-	fn convert_ref(location: impl Borrow<MultiLocation>) -> Result<AccountId, ()> {
-		match location.borrow() {
-			MultiLocation {
-				parents: 0,
-				interior: X1(Parachain(id)),
-			} => Ok(ParaId::from(*id).into_account_truncating()),
-			_ => Err(()),
-		}
-	}
-
-	fn reverse_ref(who: impl Borrow<AccountId>) -> Result<MultiLocation, ()> {
-		if let Some(id) = ParaId::try_from_account(who.borrow()) {
-			Ok(Parachain(id.into()).into())
-		} else {
-			Err(())
-		}
-	}
-}
-
-pub struct SiblingParachainConvertsVia<ParaId, AccountId>(PhantomData<(ParaId, AccountId)>);
-impl<ParaId: From<u32> + Into<u32> + AccountIdConversion<AccountId>, AccountId: Clone> Convert<MultiLocation, AccountId>
-	for SiblingParachainConvertsVia<ParaId, AccountId>
-{
-	fn convert_ref(location: impl Borrow<MultiLocation>) -> Result<AccountId, ()> {
-		match location.borrow() {
-			MultiLocation {
-				parents: 1,
-				interior: X1(Parachain(id)),
-			} => Ok(ParaId::from(*id).into_account_truncating()),
-			_ => Err(()),
-		}
-	}
-
-	fn reverse_ref(who: impl Borrow<AccountId>) -> Result<MultiLocation, ()> {
-		if let Some(id) = ParaId::try_from_account(who.borrow()) {
-			Ok(MultiLocation::new(1, X1(Parachain(id.into()))))
-		} else {
-			Err(())
-		}
-	}
-}
-
-/// Extracts the `AccountId32` from the passed `location` if the network
-/// matches.
-pub struct AccountId32Aliases<Network, AccountId>(PhantomData<(Network, AccountId)>);
-impl<Network: Get<Option<NetworkId>>, AccountId: From<[u8; 32]> + Into<[u8; 32]> + Clone>
-	Convert<MultiLocation, AccountId> for AccountId32Aliases<Network, AccountId>
-{
-	fn convert(location: MultiLocation) -> Result<AccountId, MultiLocation> {
-		let id = match location {
-			MultiLocation {
-				parents: 0,
-				interior: X1(AccountId32 { id, network: None }),
-			} => id,
-			MultiLocation {
-				parents: 0,
-				interior: X1(AccountId32 { id, network }),
-			} if network == Network::get() => id,
-			_ => return Err(location),
-		};
-		Ok(id.into())
-	}
-
-	fn reverse(who: AccountId) -> Result<MultiLocation, AccountId> {
-		Ok(AccountId32 {
-			id: who.into(),
-			network: Network::get(),
-		}
-		.into())
-	}
-}
-
-pub struct AccountKey20Aliases<Network, AccountId>(PhantomData<(Network, AccountId)>);
-impl<Network: Get<Option<NetworkId>>, AccountId: From<[u8; 20]> + Into<[u8; 20]> + Clone>
-	Convert<MultiLocation, AccountId> for AccountKey20Aliases<Network, AccountId>
-{
-	fn convert(location: MultiLocation) -> Result<AccountId, MultiLocation> {
-		let key = match location {
-			MultiLocation {
-				parents: 0,
-				interior: X1(AccountKey20 { key, network: None }),
-			} => key,
-			MultiLocation {
-				parents: 0,
-				interior: X1(AccountKey20 { key, network }),
-			} if network == Network::get() => key,
-			_ => return Err(location),
-		};
-		Ok(key.into())
-	}
-
-	fn reverse(who: AccountId) -> Result<MultiLocation, AccountId> {
-		let j = AccountKey20 {
-			key: who.into(),
-			network: Network::get(),
-		};
-		Ok(j.into())
-	}
-}

crates/dip/src/v1.rs

@@ -17,10 +17,14 @@
 // If you feel like getting in touch with us, you can do so at [email protected]
 
 use codec::{Decode, Encode, MaxEncodedLen};
+use frame_support::RuntimeDebug;
 use scale_info::TypeInfo;
 
 #[derive(Clone, Eq, PartialEq, Debug, Encode, Decode, TypeInfo, MaxEncodedLen)]
-pub enum IdentityProofAction<Identifier, Proof> {
-	Updated(Identifier, Proof),
+pub enum IdentityProofAction<Identifier, Proof, Details = ()> {
+	Updated(Identifier, Proof, Details),
 	Deleted(Identifier),
 }
+
+#[derive(Encode, Decode, RuntimeDebug, Clone, Eq, PartialEq, TypeInfo, Default)]
+pub struct Proof<LeafKey, LeafValue>(Vec<(LeafKey, LeafValue)>);

pallets/dip-receiver/src/lib.rs

@@ -23,9 +23,6 @@
 mod origin;
 pub mod traits;
 
-#[cfg(tests)]
-mod tests;
-
 pub use crate::{origin::*, pallet::*};
 
 #[frame_support::pallet]
@@ -35,13 +32,14 @@ pub mod pallet {
 	use frame_support::{dispatch::Dispatchable, pallet_prelude::*, traits::EnsureOrigin, Twox64Concat};
 	use frame_system::pallet_prelude::*;
 
-	use dip_support::latest::IdentityProofAction;
+	use dip_support::{latest::IdentityProofAction, VersionedIdentityProof, VersionedIdentityProofAction};
 
-	use crate::traits::{IdentityProofVerifier, Proof};
+	use crate::traits::IdentityProofVerifier;
 
 	/// The current storage version.
 	const STORAGE_VERSION: StorageVersion = StorageVersion::new(0);
 
+	// TODO: Store also additional details received by the provider
 	#[pallet::storage]
 	#[pallet::getter(fn identity_proofs)]
 	pub(crate) type IdentityProofs<T> =
@@ -84,25 +82,25 @@ pub mod pallet {
 	}
 
 	#[pallet::origin]
-	pub type Origin<T> = KiltDidOrigin<<T as Config>::Identifier, <T as frame_system::Config>::AccountId>;
+	pub type Origin<T> = DipOrigin<<T as Config>::Identifier, <T as frame_system::Config>::AccountId>;
 
 	#[pallet::call]
 	impl<T: Config> Pallet<T> {
 		#[pallet::call_index(0)]
 		#[pallet::weight(0)]
 		pub fn process_identity_action(
 			origin: OriginFor<T>,
-			action: IdentityProofAction<T::Identifier, T::ProofDigest>,
+			action: VersionedIdentityProofAction<T::Identifier, T::ProofDigest>,
 		) -> DispatchResult {
 			T::EnsureSourceXcmOrigin::ensure_origin(origin)?;
 
 			let event = match action {
-				IdentityProofAction::Updated(identifier, proof) => {
+				VersionedIdentityProofAction::V1(IdentityProofAction::Updated(identifier, proof, _)) => {
 					println!("DipReceiver::process_identity_action - Action was to update. Writing...");
 					IdentityProofs::<T>::mutate(&identifier, |entry| *entry = Some(proof.clone()));
 					Event::<T>::IdentityInfoUpdated(identifier, proof)
 				}
-				IdentityProofAction::Deleted(identifier) => {
+				VersionedIdentityProofAction::V1(IdentityProofAction::Deleted(identifier)) => {
 					println!("DipReceiver::process_identity_action - Action was to delete. Deleting...");
 					IdentityProofs::<T>::remove(&identifier);
 					Event::<T>::IdentityInfoDeleted(identifier)
@@ -119,15 +117,15 @@ pub mod pallet {
 		pub fn dispatch_as(
 			origin: OriginFor<T>,
 			identifier: T::Identifier,
-			proof: Proof<T::ProofLeafKey, T::ProofLeafValue>,
+			proof: VersionedIdentityProof<T::ProofLeafKey, T::ProofLeafValue>,
 			call: Box<<T as Config>::RuntimeCall>,
 		) -> DispatchResult {
 			let submitter = ensure_signed(origin)?;
 			let proof_digest = IdentityProofs::<T>::get(&identifier).ok_or(Error::<T>::IdentityNotFound)?;
 			let _ = T::ProofVerifier::verify_proof_against_digest(proof, proof_digest)
 				.map_err(|_| Error::<T>::InvalidProof)?;
-			let did_origin = KiltDidOrigin {
-				did_subject: identifier,
+			let did_origin = DipOrigin {
+				did_identifier: identifier,
 				account_address: submitter,
 			};
 			let _ = call

pallets/dip-receiver/src/origin.rs

@@ -22,18 +22,18 @@ use scale_info::TypeInfo;
 use sp_std::marker::PhantomData;
 
 #[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, TypeInfo, MaxEncodedLen)]
-pub struct KiltDidOrigin<DidIdentifier, AccountId> {
-	pub did_subject: DidIdentifier,
+pub struct DipOrigin<DidIdentifier, AccountId> {
+	pub did_identifier: DidIdentifier,
 	pub account_address: AccountId,
 }
 
-pub struct EnsureKiltDidOrigin<DidIdentifier, AccountId>(PhantomData<(DidIdentifier, AccountId)>);
+pub struct EnsureDipOrigin<DidIdentifier, AccountId>(PhantomData<(DidIdentifier, AccountId)>);
 
-impl<OuterOrigin, DidIdentifier, AccountId> EnsureOrigin<OuterOrigin> for EnsureKiltDidOrigin<DidIdentifier, AccountId>
+impl<OuterOrigin, DidIdentifier, AccountId> EnsureOrigin<OuterOrigin> for EnsureDipOrigin<DidIdentifier, AccountId>
 where
-	OuterOrigin: Into<Result<KiltDidOrigin<DidIdentifier, AccountId>, OuterOrigin>>,
+	OuterOrigin: Into<Result<DipOrigin<DidIdentifier, AccountId>, OuterOrigin>>,
 {
-	type Success = KiltDidOrigin<DidIdentifier, AccountId>;
+	type Success = DipOrigin<DidIdentifier, AccountId>;
 
 	fn try_origin(o: OuterOrigin) -> Result<Self::Success, OuterOrigin> {
 		o.into()

pallets/dip-receiver/src/traits.rs

@@ -16,14 +16,9 @@
 
 // If you feel like getting in touch with us, you can do so at [email protected]
 
-use codec::{Decode, Encode};
-use frame_support::RuntimeDebug;
-use scale_info::TypeInfo;
+use dip_support::VersionedIdentityProof;
 use sp_std::marker::PhantomData;
 
-#[derive(Encode, Decode, RuntimeDebug, Clone, Eq, PartialEq, TypeInfo, Default)]
-pub struct Proof<LeafKey, LeafValue>(Vec<(LeafKey, LeafValue)>);
-
 pub trait IdentityProofVerifier {
 	type ProofDigest;
 	type LeafKey;
@@ -32,7 +27,7 @@ pub trait IdentityProofVerifier {
 	type Error;
 
 	fn verify_proof_against_digest(
-		proof: Proof<Self::LeafKey, Self::LeafValue>,
+		proof: VersionedIdentityProof<Self::LeafKey, Self::LeafValue>,
 		digest: Self::ProofDigest,
 	) -> Result<Self::VerificationResult, Self::Error>;
 }
@@ -48,7 +43,7 @@ impl<ProofDigest, LeafKey, LeafValue> IdentityProofVerifier
 	type VerificationResult = ();
 
 	fn verify_proof_against_digest(
-		_proof: Proof<Self::LeafKey, Self::LeafValue>,
+		_proof: VersionedIdentityProof<Self::LeafKey, Self::LeafValue>,
 		_digest: Self::ProofDigest,
 	) -> Result<Self::VerificationResult, Self::Error> {
 		Ok(())