fix(claims): remove fields from claims

src/iam.ts

@@ -17,12 +17,12 @@
 
 import { providers, Signer, utils, Wallet } from "ethers";
 import {
-    IRoleDefinition,
+    DomainReader,
+    EncodedCall,
     IAppDefinition,
     IOrganizationDefinition,
+    IRoleDefinition,
     PreconditionType,
-    EncodedCall,
-    DomainReader,
 } from "@energyweb/iam-contracts";
 import {
     Algorithms,
@@ -72,6 +72,7 @@ import { isValidDID, parseDID } from "./utils/did";
 import { chainConfigs } from "./iam/chainConfig";
 import { canonizeSig } from "./utils/enrollment";
 import { JWT } from "@ew-did-registry/jwt";
+
 const { id, keccak256, defaultAbiCoder, solidityKeccak256, arrayify, namehash } = utils;
 
 export type InitializeData = {
@@ -521,11 +522,13 @@ export class IAM extends IAMBase {
      *
      */
     async createSelfSignedClaim({ data, subject }: { data: ClaimData; subject?: string }) {
-        if (this._userClaims) {
-            const token = await this.createPublicClaim({ data, subject });
-            return this.publishPublicClaim({ token });
+        if (!this._userClaims) {
+            throw new Error(ERROR_MESSAGES.CLAIMS_NOT_INITIALIZED);
         }
-        throw new Error(ERROR_MESSAGES.CLAIMS_NOT_INITIALIZED);
+
+        const token = await this.createPublicClaim({ data, subject });
+
+        return this.publishPublicClaim({ token });
     }
 
     /**
@@ -1391,6 +1394,7 @@ export class IAM extends IAMBase {
         const enroledRoles = new Set(
             (await this.getClaimsBySubject({ did: subject, isAccepted: true })).map(({ claimType }) => claimType),
         );
+
         const requiredRoles = new Set(
             enrolmentPreconditions
                 .filter(({ type }) => type === PreconditionType.Role)
@@ -1579,12 +1583,16 @@ export class IAM extends IAMBase {
             claimIssuer: [this._did],
             acceptedBy: this._did,
         };
+
+        const strippedClaimData = this.stripClaimData(claimData);
+
         if (registrationTypes.includes(RegistrationTypes.OffChain)) {
             const publicClaim: IPublicClaim = {
                 did: sub,
                 signer: this._did,
-                claimData,
+                claimData: strippedClaimData,
             };
+
             message.issuedToken = await this.issuePublicClaim({
                 publicClaim,
             });
@@ -1928,4 +1936,11 @@ export class IAM extends IAMBase {
         }
         throw new Error(ERROR_MESSAGES.CACHE_CLIENT_NOT_PROVIDED);
     }
+
+    private stripClaimData(data: ClaimData): ClaimData {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { fields, ...claimData } = data;
+
+        return claimData;
+    }
 }

src/iam/chainConfig.ts

@@ -1,11 +1,11 @@
 import { VoltaAddress1056 } from "@ew-did-registry/did-ethr-resolver";
 import {
+    VOLTA_CLAIM_MANAGER_ADDRESS,
     VOLTA_DOMAIN_NOTIFER_ADDRESS,
     VOLTA_ENS_REGISTRY_ADDRESS,
+    VOLTA_IDENTITY_MANAGER_ADDRESS,
     VOLTA_PUBLIC_RESOLVER_ADDRESS,
     VOLTA_RESOLVER_V1_ADDRESS,
-    VOLTA_IDENTITY_MANAGER_ADDRESS,
-    VOLTA_CLAIM_MANAGER_ADDRESS,
     VOLTA_STAKING_POOL_FACTORY_ADDRESS,
 } from "@energyweb/iam-contracts";
 import { CacheServerClientOptions } from "../cacheServerClient/cacheServerClient";

test/claimsTests/enrollmentClaimsTests.ts

@@ -1,9 +1,9 @@
 import { PreconditionType } from "@energyweb/iam-contracts";
 import { Methods } from "@ew-did-registry/did";
 import { addressOf } from "@ew-did-registry/did-ethr-resolver";
-import { Wallet, utils } from "ethers";
+import { utils, Wallet } from "ethers";
 import { Codec } from "nats.ws";
-import { IAM, RegistrationTypes, IRoleDefinition, NATS_EXCHANGE_TOPIC } from "../../src/iam-client-lib";
+import { IAM, IRoleDefinition, NATS_EXCHANGE_TOPIC, RegistrationTypes } from "../../src/iam-client-lib";
 import { createIam, root, rootOwner } from "../iam.test";
 import { claimManager, replenish } from "../setup_contracts";
 import {
@@ -28,6 +28,7 @@ export function enrollmentClaimsTests() {
     const roleName1 = "myrole1";
     const roleName2 = "myrole2";
     const roleName3 = "myrole3";
+    const roleName4 = "myrole4";
     const namespace = root;
     const version = 1;
     const baseRoleDef = {
@@ -50,6 +51,11 @@ export function enrollmentClaimsTests() {
             roleName: roleName3,
             enrolmentPreconditions: [{ type: PreconditionType.Role, conditions: [`${roleName1}.${root}`] }],
         },
+        [`${roleName4}.${root}`]: {
+            ...baseRoleDef,
+            roleName: roleName4,
+            issuer: { issuerType: "ROLE", roleName: `${roleName1}.${root}` },
+        },
     };
     let roleCreatorIam: IAM;
     let userIam: IAM;
@@ -88,11 +94,12 @@ export function enrollmentClaimsTests() {
     ) {
         const requesterDID = requesterIam.getDid();
         await requesterIam.createClaimRequest({
-            claim: { claimType, claimTypeVersion: version, fields: [] },
+            claim: { claimType, claimTypeVersion: version, fields: [{ key: "temperature", value: 36 }] },
             registrationTypes,
             subject: subjectDID,
         });
         expect(publish).toBeCalledTimes(1);
+
         const [, encodedMsg] = publish.mock.calls.pop();
         const message = mockedJsonCodec.decode(encodedMsg);
 
@@ -104,11 +111,34 @@ export function enrollmentClaimsTests() {
 
         const [requesterChannel, data] = publish.mock.calls.pop();
         expect(requesterChannel).toEqual(`${requesterIam.getDid()}.${NATS_EXCHANGE_TOPIC}`);
+        const { issuedToken, requester, claimIssuer, onChainProof, acceptedBy } = mockedJsonCodec.decode(data);
+
+        if (registrationTypes.includes(RegistrationTypes.OffChain)) {
+            expect(issuedToken).not.toBeUndefined();
+
+            const { claimData, signer, did } = (await issuerIam.decodeJWTToken({
+                token: issuedToken,
+            })) as { [key: string]: string };
+
+            expect(claimData).toEqual({
+                claimType,
+                claimTypeVersion: version,
+            });
+
+            expect(claimData).not.toContain({
+                fields: [{ key: "temperature", value: 36 }],
+            });
+
+            expect(signer).toBe(issuerIam.getDid());
+            expect(did).toBe(requesterIam.getDid());
+        }
 
-        const { claimIssuer, requester, onChainProof } = mockedJsonCodec.decode(data);
         expect(requester).toEqual(requesterDID);
         expect(claimIssuer).toEqual([issuerIam.getDid()]);
+
         registrationTypes.includes(RegistrationTypes.OnChain) && expect(onChainProof).toHaveLength(132);
+
+        expect(acceptedBy).toBe(issuerIam.getDid());
     }
 
     beforeEach(() => {
@@ -159,6 +189,31 @@ export function enrollmentClaimsTests() {
         expect(await claimManager.hasRole(addressOf(userDID), namehash(`${roleName2}.${root}`), version));
     });
 
+    test("should enroll off-chain when prerequisites are met", async () => {
+        await roleCreatorIam.createRole({
+            roleName: roleName4,
+            namespace,
+            data: roles[`${roleName4}.${root}`],
+            returnSteps: false,
+        });
+
+        const role4Claim = {
+            claimType: `${roleName4}.${root}`,
+            isAccepted: true,
+        };
+        cacheClaim(userDID, role4Claim);
+
+        await enrolAndIssue(userIam, staticIssuerIam, {
+            subjectDID: userDID,
+            claimType: `${roleName4}.${root}`,
+            registrationTypes: [RegistrationTypes.OffChain],
+        });
+
+        const hasRole = await claimManager.hasRole(addressOf(userDID), namehash(`${roleName4}.${root}`), version);
+
+        expect(hasRole).toBe(false);
+    });
+
     test("should enrol when prerequisites are met", async () => {
         await roleCreatorIam.createRole({
             roleName: roleName3,

test/iam.test.ts

@@ -1,19 +1,19 @@
 import { BigNumber, utils, Wallet } from "ethers";
-import { IAM, ENSNamespaceTypes } from "../src/iam";
+import { ENSNamespaceTypes, IAM } from "../src/iam";
 import {
-    deployDidRegistry,
-    ensRegistry,
-    ensResolver,
-    didContract,
-    rpcUrl,
     assetsManager,
-    domainNotifer,
     claimManager,
-    replenish,
+    deployClaimManager,
+    deployDidRegistry,
     deployEns,
-    provider,
     deployIdentityManager,
-    deployClaimManager,
+    didContract,
+    domainNotifer,
+    ensRegistry,
+    ensResolver,
+    provider,
+    replenish,
+    rpcUrl,
 } from "./setup_contracts";
 import { labelhash } from "../src/utils/ENS_hash";
 import { orgTests } from "./organization.testSuite";