[MOON-1737] adds IdentityJudgement Proxy type support

runtime/moonbase/src/lib.rs

@@ -790,6 +790,8 @@ pub enum ProxyType {
 	Balances = 5,
 	/// Allow extrinsic related to AuthorMapping.
 	AuthorMapping = 6,
+	/// Allow extrinsic related to IdentityJudgement.
+	IdentityJudgement = 7,
 }
 
 impl Default for ProxyType {
@@ -833,6 +835,10 @@ impl InstanceFilter<Call> for ProxyType {
 			),
 			ProxyType::Balances => matches!(c, Call::Balances(..) | Call::Utility(..)),
 			ProxyType::AuthorMapping => matches!(c, Call::AuthorMapping(..)),
+			ProxyType::IdentityJudgement => matches!(
+				c,
+				Call::Identity(pallet_identity::Call::provide_judgement { .. }) | Call::Utility(..)
+			),
 		}
 	}
 

runtime/moonbase/tests/integration_test.rs

@@ -273,6 +273,7 @@ fn verify_proxy_type_indices() {
 	assert_eq!(moonbase_runtime::ProxyType::CancelProxy as u8, 4);
 	assert_eq!(moonbase_runtime::ProxyType::Balances as u8, 5);
 	assert_eq!(moonbase_runtime::ProxyType::AuthorMapping as u8, 6);
+	assert_eq!(moonbase_runtime::ProxyType::IdentityJudgement as u8, 7);
 }
 
 #[test]

runtime/moonbeam/src/lib.rs

@@ -801,6 +801,8 @@ pub enum ProxyType {
 	Balances = 5,
 	/// Allow extrinsic related to AuthorMapping.
 	AuthorMapping = 6,
+	/// Allow extrinsic related to IdentityJudgement.
+	IdentityJudgement = 7,
 }
 
 impl Default for ProxyType {
@@ -844,6 +846,10 @@ impl InstanceFilter<Call> for ProxyType {
 			),
 			ProxyType::Balances => matches!(c, Call::Balances(..) | Call::Utility(..)),
 			ProxyType::AuthorMapping => matches!(c, Call::AuthorMapping(..)),
+			ProxyType::IdentityJudgement => matches!(
+				c,
+				Call::Identity(pallet_identity::Call::provide_judgement { .. }) | Call::Utility(..)
+			),
 		}
 	}
 

runtime/moonbeam/tests/integration_test.rs

@@ -274,6 +274,7 @@ fn verify_proxy_type_indices() {
 	assert_eq!(moonbeam_runtime::ProxyType::CancelProxy as u8, 4);
 	assert_eq!(moonbeam_runtime::ProxyType::Balances as u8, 5);
 	assert_eq!(moonbeam_runtime::ProxyType::AuthorMapping as u8, 6);
+	assert_eq!(moonbeam_runtime::ProxyType::IdentityJudgement as u8, 7);
 }
 
 #[test]

runtime/moonriver/src/lib.rs

@@ -807,6 +807,8 @@ pub enum ProxyType {
 	Balances = 5,
 	/// Allow extrinsic related to AuthorMapping.
 	AuthorMapping = 6,
+	/// Allow extrinsic related to IdentityJudgement.
+	IdentityJudgement = 7,
 }
 
 impl Default for ProxyType {
@@ -850,6 +852,10 @@ impl InstanceFilter<Call> for ProxyType {
 			),
 			ProxyType::Balances => matches!(c, Call::Balances(..) | Call::Utility(..)),
 			ProxyType::AuthorMapping => matches!(c, Call::AuthorMapping(..)),
+			ProxyType::IdentityJudgement => matches!(
+				c,
+				Call::Identity(pallet_identity::Call::provide_judgement { .. }) | Call::Utility(..)
+			),
 		}
 	}
 

runtime/moonriver/tests/integration_test.rs

@@ -273,6 +273,7 @@ fn verify_proxy_type_indices() {
 	assert_eq!(moonriver_runtime::ProxyType::CancelProxy as u8, 4);
 	assert_eq!(moonriver_runtime::ProxyType::Balances as u8, 5);
 	assert_eq!(moonriver_runtime::ProxyType::AuthorMapping as u8, 6);
+	assert_eq!(moonriver_runtime::ProxyType::IdentityJudgement as u8, 7);
 }
 
 #[test]

tests/tests/test-proxy/test-proxy-identity.ts

@@ -0,0 +1,115 @@
+import "@polkadot/api-augment";
+import "@moonbeam-network/api-augment";
+import { expect } from "chai";
+import { alith, baltathar } from "../../util/accounts";
+
+import { describeDevMoonbeam } from "../../util/setup-dev-tests";
+
+describeDevMoonbeam("Proxy : IdentityJudgement fails without proxy", (context) => {
+  before("setup one identity and registrar", async () => {
+    const block = await context.createBlock([
+      context.polkadotApi.tx.sudo.sudo(context.polkadotApi.tx.identity.addRegistrar(alith.address)),
+      context.polkadotApi.tx.identity
+        .setIdentity({
+          display: { Raw: "foobar" },
+        })
+        .signAsync(baltathar),
+    ]);
+
+    block.result.forEach((r, idx) => {
+      expect(r.successful, `tx[${idx}] - ${r.error?.name}`).to.be.true;
+    });
+  });
+
+  it("should fail providing judgement", async () => {
+    const blockExecute = await context.createBlock(
+      context.polkadotApi.tx.proxy
+        .proxy(
+          alith.address,
+          null,
+          context.polkadotApi.tx.identity.provideJudgement(0, baltathar.address, {
+            Reasonable: true,
+          })
+        )
+        .signAsync(baltathar)
+    );
+
+    expect(blockExecute.result.successful).to.be.false;
+    expect(blockExecute.result.error.name).to.equal("NotProxy");
+  });
+});
+
+describeDevMoonbeam("Proxy : IdentityJudgement succeeds with proxy", (context) => {
+  before("setup one identity and registrar", async () => {
+    const block = await context.createBlock([
+      context.polkadotApi.tx.sudo.sudo(context.polkadotApi.tx.identity.addRegistrar(alith.address)),
+      context.polkadotApi.tx.identity
+        .setIdentity({
+          display: { Raw: "foobar" },
+        })
+        .signAsync(baltathar),
+    ]);
+
+    block.result.forEach((r, idx) => {
+      expect(r.successful, `tx[${idx}] - ${r.error?.name}`).to.be.true;
+    });
+  });
+
+  it("should succeed providing judgement", async () => {
+    const blockAdd = await context.createBlock(
+      context.polkadotApi.tx.proxy
+        .addProxy(baltathar.address, "IdentityJudgement" as any, 0)
+        .signAsync(alith)
+    );
+
+    expect(blockAdd.result.successful).to.be.true;
+    const proxyAddEvent = blockAdd.result.events.reduce((acc, e) => {
+      if (context.polkadotApi.events.proxy.ProxyAdded.is(e.event)) {
+        acc.push({
+          proxyType: e.event.data[2].toString(),
+        });
+      }
+      return acc;
+    }, []);
+    expect(proxyAddEvent).to.deep.equal([
+      {
+        proxyType: "IdentityJudgement",
+      },
+    ]);
+
+    const blockExecute = await context.createBlock(
+      context.polkadotApi.tx.proxy
+        .proxy(
+          alith.address,
+          null,
+          context.polkadotApi.tx.identity.provideJudgement(0, baltathar.address, {
+            Reasonable: true,
+          })
+        )
+        .signAsync(baltathar)
+    );
+
+    expect(blockExecute.result.successful).to.be.true;
+    const proxyExecuteEvent = blockExecute.result.events.reduce(
+      (acc, e) => {
+        if (context.polkadotApi.events.proxy.ProxyExecuted.is(e.event)) {
+          acc.proxyExecuted = e.event.data[0].toString();
+        } else if (context.polkadotApi.events.identity.JudgementGiven.is(e.event)) {
+          acc.judgementGiven = {
+            address: e.event.data[0].toString(),
+            decision: e.event.data[1].toString(),
+          };
+        }
+        return acc;
+      },
+      { proxyExecuted: null, judgementGiven: null }
+    );
+    expect(proxyExecuteEvent).to.deep.equal({
+      proxyExecuted: "Ok",
+      judgementGiven: {
+        address: baltathar.address,
+        decision: "0",
+      },
+    });
+  });
+});