MESH-1166/Scope of Claim refactor

pallets/compliance-manager/src/lib.rs

@@ -95,9 +95,10 @@ use polymesh_common_utilities::{
     Context,
 };
 use polymesh_primitives::{
-    proposition, Claim, ClaimType, Condition, ConditionType, IdentityId, Ticker,
+    proposition, Claim, ClaimType, Condition, ConditionType, IdentityId, Scope, Ticker,
 };
 use polymesh_primitives_derive::Migrate;
+
 #[cfg(feature = "std")]
 use sp_runtime::{Deserialize, Serialize};
 use sp_std::{
@@ -601,7 +602,7 @@ impl<T: Trait> Module<T> {
         issuers
             .iter()
             .flat_map(|issuer| {
-                <identity::Module<T>>::fetch_claim(target, claim_type, *issuer, scope)
+                <identity::Module<T>>::fetch_claim(target, claim_type, *issuer, scope.clone())
                     .map(|id_claim| id_claim.claim)
             })
             .collect::<Vec<_>>()
@@ -612,7 +613,7 @@ impl<T: Trait> Module<T> {
     fn fetch_confidential_claims(id: IdentityId, ticker: &Ticker) -> Vec<Claim> {
         let claim_type = ClaimType::InvestorZKProof;
         // NOTE: Ticker lenght is less by design that IdentityId.
-        let asset_scope = IdentityId::try_from(ticker.as_slice()).unwrap_or_default();
+        let asset_scope = Scope::from(*ticker);
 
         <identity::Module<T>>::fetch_claim(id, claim_type, id, Some(asset_scope))
             .into_iter()

pallets/identity/src/lib.rs

@@ -146,6 +146,12 @@ pub struct Claim2ndKey {
     pub scope: Option<Scope>,
 }
 
+#[derive(Encode, Decode, Clone, PartialEq, Eq, Debug, PartialOrd, Ord)]
+pub struct Claim2ndKeyOld {
+    pub issuer: IdentityId,
+    pub scope: Option<IdentityId>,
+}
+
 #[derive(Encode, Decode, Clone, PartialEq, Eq, Default, Debug)]
 pub struct BatchAddClaimItem<M> {
     pub target: IdentityId,
@@ -267,6 +273,15 @@ decl_module! {
         fn deposit_event() = default;
 
         fn on_runtime_upgrade() -> Weight {
+            use frame_support::migration::{StorageIterator, put_storage_value};
+            // Covert old scopes to new scopes
+            for (key, value) in StorageIterator::<Claim2ndKeyOld>::new(b"Identity", b"Claims").drain() {
+                let new = Claim2ndKey {
+                    issuer: value.issuer,
+                    scope: value.scope.map(|scope| Scope::Identity(scope)),
+                };
+                put_storage_value(b"Identity", b"Claims", &key, new);
+            }
             // Rename "master" to "primary".
             <CddAuthForPrimaryKeyRotation>::put(<CddAuthForMasterKeyRotation>::take());
 
@@ -1817,7 +1832,7 @@ impl<T: Trait> Module<T> {
         let claim_type = claim.claim_type();
         let scope = claim.as_scope().cloned();
         let last_update_date = <pallet_timestamp::Module<T>>::get().saturated_into::<u64>();
-        let issuance_date = Self::fetch_claim(target, claim_type, issuer, scope)
+        let issuance_date = Self::fetch_claim(target, claim_type, issuer, scope.clone())
             .map_or(last_update_date, |id_claim| id_claim.issuance_date);
 
         let expiry = expiry.into_iter().map(|m| m.saturated_into::<u64>()).next();

pallets/runtime/tests/src/asset_test.rs

@@ -2073,23 +2073,23 @@ fn test_weights_for_is_valid_transfer() {
                 ticker,
                 vec![
                     Condition {
-                        condition_type: ConditionType::IsPresent(Claim::Accredited(ticker_id)),
+                        condition_type: ConditionType::IsPresent(Claim::Accredited(ticker_id.into())),
                         issuers: vec![eve_did]
                     },
                     Condition {
-                        condition_type: ConditionType::IsAbsent(Claim::BuyLockup(ticker_id)),
+                        condition_type: ConditionType::IsAbsent(Claim::BuyLockup(ticker_id.into())),
                         issuers: vec![eve_did]
                     }
                 ],
                 vec![
                     Condition {
-                        condition_type: ConditionType::IsPresent(Claim::Accredited(ticker_id)),
+                        condition_type: ConditionType::IsPresent(Claim::Accredited(ticker_id.into())),
                         issuers: vec![eve_did]
                     },
                     Condition {
                         condition_type: ConditionType::IsAnyOf(vec![
-                            Claim::BuyLockup(ticker_id),
-                            Claim::KnowYourCustomer(ticker_id)
+                            Claim::BuyLockup(ticker_id.into()),
+                            Claim::KnowYourCustomer(ticker_id.into())
                         ]),
                         issuers: vec![eve_did]
                     }
@@ -2098,14 +2098,14 @@ fn test_weights_for_is_valid_transfer() {
 
             // Providing claim to sender and receiver
             // For Alice
-            assert_add_claim!(eve_signed.clone(), alice_did, Claim::Accredited(alice_did));
-            assert_add_claim!(eve_signed.clone(), alice_did, Claim::BuyLockup(ticker_id));
+            assert_add_claim!(eve_signed.clone(), alice_did, Claim::Accredited(alice_did.into()));
+            assert_add_claim!(eve_signed.clone(), alice_did, Claim::BuyLockup(ticker_id.into()));
             // For Bob
-            assert_add_claim!(eve_signed.clone(), bob_did, Claim::Accredited(ticker_id));
+            assert_add_claim!(eve_signed.clone(), bob_did, Claim::Accredited(ticker_id.into()));
             assert_add_claim!(
                 eve_signed.clone(),
                 bob_did,
-                Claim::KnowYourCustomer(ticker_id)
+                Claim::KnowYourCustomer(ticker_id.into())
             );
 
             // Add Tms
@@ -2147,8 +2147,8 @@ fn test_weights_for_is_valid_transfer() {
             .1;
             assert!(matches!(result, weight_from_verify_transfer)); // Only sender rules are processed.
 
-            assert_revoke_claim!(eve_signed.clone(), alice_did, Claim::BuyLockup(ticker_id));
-            assert_add_claim!(eve_signed.clone(), alice_did, Claim::Accredited(ticker_id));
+            assert_revoke_claim!(eve_signed.clone(), alice_did, Claim::BuyLockup(ticker_id.into()));
+            assert_add_claim!(eve_signed.clone(), alice_did, Claim::Accredited(ticker_id.into()));
 
             let result =
                 Asset::_is_valid_transfer(&ticker, alice, Some(alice_did), Some(bob_did), 100)
@@ -2172,11 +2172,11 @@ fn test_weights_for_is_valid_transfer() {
                 alice_signed.clone(),
                 ticker,
                 vec![Condition {
-                    condition_type: ConditionType::IsPresent(Claim::Exempted(ticker_id)),
+                    condition_type: ConditionType::IsPresent(Claim::Exempted(ticker_id.into())),
                     issuers: vec![eve_did]
                 }],
                 vec![Condition {
-                    condition_type: ConditionType::IsPresent(Claim::Blocked(ticker_id)),
+                    condition_type: ConditionType::IsPresent(Claim::Blocked(ticker_id.into())),
                     issuers: vec![eve_did]
                 }]
             ));