Merge pull request #90 from 0xPolygonID/bump

Fix for queries of string values

Author: vmidyllic

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xpolygonid/js-sdk",
-  "version": "1.0.0-beta.11",
+  "version": "1.0.0-beta.12",
   "description": "SDK to work with Polygon ID",
   "main": "dist/cjs/index.js",
   "module": "dist/esm_esbuild/index.js",
@@ -22,8 +22,8 @@
     "doc:build": "npm run doc:extract && npm run doc:documenter",
     "doc:watch:website": "ts-node ./scripts/doc-watch.ts",
     "tsc:declaration:watch": "tsc --watch --module commonjs --emitDeclarationOnly",
-    "test": "mocha --require ts-node/register tests/**/*.ts -t 60000",
-    "test:watch": "mocha -p --require ts-node/register tests/**/*.ts -t 60000 --watch",
+    "test": "mocha --require ts-node/register tests/**/*.ts -t 120000",
+    "test:watch": "mocha -p --require ts-node/register tests/**/*.ts -t 120000 --watch",
     "lint": "eslint --fix --ext .js,.ts src/**",
     "format": "prettier --write \"src/**/*.ts\" \"tests/**/*.ts\"",
     "deps:check": "madge --circular --extensions ts ./"

package.json

@@ -269,7 +269,9 @@ export class IdentityWallet implements IIdentityWallet {
   async createIdentity(
     opts: IdentityCreationOptions
   ): Promise<{ did: DID; credential: W3CCredential }> {
-    const tmpIdentifier = opts.seed ? uuid.v5(new sha256js().update(opts.seed).digest('hex'), uuid.NIL) : uuid.v4();
+    const tmpIdentifier = opts.seed
+      ? uuid.v5(new sha256js().update(opts.seed).digest('hex'), uuid.NIL)
+      : uuid.v4();
 
     opts.method = opts.method ?? DidMethod.Iden3;
     opts.blockchain = opts.blockchain ?? Blockchain.Polygon;

src/identity/identity-wallet.ts

@@ -39,7 +39,13 @@ import {
 import { toClaimNonRevStatus, toGISTProof } from './common';
 import { NativeProver } from './prover';
 
-import { DocumentLoader, Options, Path, getDocumentLoader } from '@iden3/js-jsonld-merklization';
+import {
+  DocumentLoader,
+  Merklizer,
+  Options,
+  Path,
+  getDocumentLoader
+} from '@iden3/js-jsonld-merklization';
 import { ZKProof } from '@iden3/js-jwz';
 import { Signer } from 'ethers';
 import { ZeroKnowledgeProofRequest, ZeroKnowledgeProofResponse } from '../iden3comm';
@@ -62,6 +68,7 @@ interface PreparedCredential {
 export interface QueryWithFieldName {
   query: Query;
   fieldName: string;
+  rawValue?: unknown;
   isSelectiveDisclosure?: boolean;
 }
 
@@ -639,7 +646,7 @@ export class ProofService implements IProofService {
     }
 
     let path: Path = new Path();
-    if (!!parsedQuery.fieldName) {
+    if (parsedQuery.fieldName) {
       path = await Path.getContextPathKey(
         JSON.stringify(schema),
         credential.type[1],
@@ -650,6 +657,7 @@ export class ProofService implements IProofService {
     path.prepend(['https://www.w3.org/2018/credentials#credentialSubject']);
 
     const mk = await credential.merklize(opts);
+
     const { proof, value: mtValue } = await mk.proof(path);
 
     const pathKey = await path.mtEntry();
@@ -665,7 +673,7 @@ export class ProofService implements IProofService {
     } else {
       parsedQuery.query.slotIndex = 5; // value data slot b
     }
-    if (!parsedQuery.fieldName){
+    if (!parsedQuery.fieldName) {
       const resultQuery = parsedQuery.query;
       resultQuery.operator = QueryOperators.$eq;
       resultQuery.values = [mtEntry];
@@ -684,6 +692,14 @@ export class ProofService implements IProofService {
       resultQuery.values = [mtEntry];
       return { query: resultQuery, vp };
     }
+    if (parsedQuery.rawValue === null || parsedQuery.rawValue === undefined) {
+      throw new Error('value is not presented in the query');
+    }
+    const ldType = await mk.jsonLDType(path);
+    parsedQuery.query.values = await this.transformQueryValueToBigInts(
+      parsedQuery.rawValue,
+      ldType
+    );
 
     return { query: parsedQuery.query };
   }
@@ -711,19 +727,27 @@ export class ProofService implements IProofService {
       parsedQuery.fieldName,
       byteEncoder.encode(JSON.stringify(schema))
     );
+    const { vp, mzValue, dataType } = await verifiablePresentationFromCred(
+      credential,
+      query,
+      parsedQuery.fieldName,
+      opts
+    );
 
     if (parsedQuery.isSelectiveDisclosure) {
-      const { vp, mzValue } = await verifiablePresentationFromCred(
-        credential,
-        query,
-        parsedQuery.fieldName,
-        opts
-      );
       const resultQuery = parsedQuery.query;
       resultQuery.operator = QueryOperators.$eq;
       resultQuery.values = [await mzValue.mtEntry()];
       return { query: resultQuery, vp };
     }
+    if (parsedQuery.rawValue === null || parsedQuery.rawValue === undefined) {
+      throw new Error('value is not presented in the query');
+    }
+
+    parsedQuery.query.values = await this.transformQueryValueToBigInts(
+      parsedQuery.rawValue,
+      dataType
+    );
 
     return { query: parsedQuery.query };
   }
@@ -756,24 +780,28 @@ export class ProofService implements IProofService {
     }
 
     let operator = 0;
-    const values: bigint[] = new Array<bigint>(64).fill(BigInt(0));
     const [key, value] = fieldReqEntries[0];
     if (!QueryOperators[key]) {
       throw new Error(`operator is not supported by lib`);
     }
     operator = QueryOperators[key];
+
+    query.operator = operator;
+
+    return { query, fieldName, rawValue: value };
+  }
+
+  async transformQueryValueToBigInts(value: unknown, ldType: string): Promise<bigint[]> {
+    const values: bigint[] = new Array<bigint>(64).fill(BigInt(0));
+
     if (Array.isArray(value)) {
       for (let index = 0; index < value.length; index++) {
-        values[index] = BigInt(value[index]);
+        values[index] = await Merklizer.hashValue(ldType, value);
       }
     } else {
-      values[0] = BigInt(value);
+      values[0] = await Merklizer.hashValue(ldType, value);
     }
-
-    query.operator = operator;
-    query.values = values;
-
-    return { query, fieldName };
+    return values;
   }
 
   /** {@inheritdoc IProofService.generateAuthV2Inputs} */

src/proof/proof-service.ts

@@ -55,7 +55,9 @@ export class MerkleTreeIndexedDBStorage implements IMerkleTreeStorage {
     };
     const meta = await get(identifier, this._merkleTreeMetaStore);
     if (meta) {
-      throw new Error(`Present merkle tree meta information in the store for current identifier ${identifier}`);
+      throw new Error(
+        `Present merkle tree meta information in the store for current identifier ${identifier}`
+      );
     }
     const treesMeta = createMetaInfo();
     await set(identifier, treesMeta, this._merkleTreeMetaStore);

src/storage/indexed-db/merkletree.ts

@@ -49,8 +49,10 @@ export class MerkleTreeLocalStorage implements IMerkleTreeStorage {
     if (meta) {
       const metaInfo: IdentityMerkleTreeMetaInformation[] = JSON.parse(meta);
       const presentMetaForIdentifier = metaInfo.find((m) => m.treeId === `${identifier}+${m.type}`);
-      if(presentMetaForIdentifier) {
-        throw new Error(`Present merkle tree meta information in the store for current identifier ${identifier}`);
+      if (presentMetaForIdentifier) {
+        throw new Error(
+          `Present merkle tree meta information in the store for current identifier ${identifier}`
+        );
       }
       const identityMetaInfo = metaInfo.filter((m) => m.identifier === identifier);
       if (identityMetaInfo.length > 0) {

src/storage/local-storage/merkletree.ts

@@ -52,8 +52,10 @@ export class InMemoryMerkleTreeStorage implements IMerkleTreeStorage {
     if (!identifier) {
       identifier = `${uuid.v4()}`;
     }
-    if(this._data[identifier]) {
-      throw new Error(`Present merkle tree meta information in the store for current identifier ${identifier}`);
+    if (this._data[identifier]) {
+      throw new Error(
+        `Present merkle tree meta information in the store for current identifier ${identifier}`
+      );
     }
     this._data[identifier] = [];
 

src/storage/memory/merkletree.ts

@@ -172,7 +172,9 @@ describe('auth', () => {
     credWallet = new CredentialWallet(dataStorage, resolvers);
     idWallet = new IdentityWallet(kms, dataStorage, credWallet);
 
-    proofService = new ProofService(idWallet, credWallet, circuitStorage, mockStateStorage,{ipfsGatewayURL:"https://ipfs.io"});
+    proofService = new ProofService(idWallet, credWallet, circuitStorage, mockStateStorage, {
+      ipfsGatewayURL: 'https://ipfs.io'
+    });
     packageMgr = await getPackageMgr(
       await circuitStorage.loadCircuitData(CircuitId.AuthV2),
       proofService.generateAuthV2Inputs.bind(proofService),
@@ -200,7 +202,7 @@ describe('auth', () => {
       method: DidMethod.Iden3,
       blockchain: Blockchain.Polygon,
       networkId: NetworkId.Mumbai,
-      seed: seedPhrase,
+      seed: seedPhraseIssuer,
       revocationOpts: {
         type: CredentialStatusType.Iden3ReverseSparseMerkleTreeProof,
         id: rhsUrl
@@ -261,9 +263,11 @@ describe('auth', () => {
       from: issuerDID.id.string()
     };
 
+    console.log(JSON.stringify(issuerCred));
     const msgBytes = byteEncoder.encode(JSON.stringify(authReq));
     const authRes = await authHandler.handleAuthorizationRequestForGenesisDID(userDID, msgBytes);
 
+    
     const tokenStr = authRes.token;
     console.log(tokenStr);
     expect(tokenStr).to.be.a('string');

tests/handlers/auth.test.ts

@@ -119,7 +119,7 @@ describe('sig proofs', () => {
     idWallet = new IdentityWallet(kms, dataStorage, credWallet);
 
     proofService = new ProofService(idWallet, credWallet, circuitStorage, mockStateStorage, {
-      ipfsGatewayURL: 'ipfs.io'
+      ipfsGatewayURL: 'https://ipfs.io'
     });
   });
 
@@ -284,4 +284,92 @@ describe('sig proofs', () => {
       CircuitId.AtomicQuerySigV2
     );
   });
+
+  it('sigv2-ipfs-string-eq', async () => {
+    const req = {
+      id: '0d8e91e5-5686-49b5-85e3-2b35538c6a03',
+      typ: 'application/iden3comm-plain-json',
+      type: 'https://iden3-communication.io/authorization/1.0/request',
+      thid: '0d8e91e5-5686-49b5-85e3-2b35538c6a03',
+      body: {
+        callbackUrl: 'https://verifier-v2.polygonid.me/api/callback?sessionId=25269',
+        reason: 'test flow',
+        scope: [
+          {
+            id: 1,
+            circuitId: 'credentialAtomicQuerySigV2',
+            query: {
+              allowedIssuers: ['*'],
+              context: 'ipfs://QmZ1zsLspwnjifxsncqDkB7EHb2pnaRnBPc5kqQcVxW5rV',
+              credentialSubject: {
+                stringTest: {
+                  $eq: 'test'
+                }
+              },
+              type: 'TestString'
+            }
+          }
+        ]
+      },
+      from: 'did:polygonid:polygon:mumbai:2qLPqvayNQz9TA2r5VPxUugoF18teGU583zJ859wfy'
+    };
+
+    const seedPhraseIssuer: Uint8Array = byteEncoder.encode('seedseedseedseedseedseedseedseed');
+    const seedPhrase: Uint8Array = byteEncoder.encode('seedseedseedseedseedseedseeduser');
+
+    const { did: userDID } = await idWallet.createIdentity({
+      method: DidMethod.Iden3,
+      blockchain: Blockchain.Polygon,
+      networkId: NetworkId.Mumbai,
+      seed: seedPhrase,
+      revocationOpts: {
+        type: CredentialStatusType.Iden3ReverseSparseMerkleTreeProof,
+        id: rhsUrl
+      }
+    });
+
+    const { did: issuerDID } = await idWallet.createIdentity({
+      method: DidMethod.Iden3,
+      blockchain: Blockchain.Polygon,
+      networkId: NetworkId.Mumbai,
+      seed: seedPhraseIssuer,
+      revocationOpts: {
+        type: CredentialStatusType.Iden3ReverseSparseMerkleTreeProof,
+        id: rhsUrl
+      }
+    });
+    const claimReq: CredentialRequest = {
+      credentialSchema: 'ipfs://Qmb1Q5jLETkUkhswCVX52ntTCNQnRm3NyyGf1NZG98u5cv',
+      type: 'TestString',
+      credentialSubject: {
+        id: userDID.toString(),
+        stringTest: 'test'
+      },
+      expiration: 1693526400,
+      revocationOpts: {
+        type: CredentialStatusType.Iden3ReverseSparseMerkleTreeProof,
+        id: rhsUrl
+      }
+    };
+    const issuerCred = await idWallet.issueCredential(issuerDID, claimReq, {
+      ipfsGatewayURL: 'https://ipfs.io'
+    });
+
+    await credWallet.save(issuerCred);
+
+    const creds = await credWallet.findByQuery(req.body.scope[0].query);
+    expect(creds.length).to.not.equal(0);
+
+    const credsForMyUserDID = await credWallet.filterByCredentialSubject(creds, userDID);
+    expect(creds.length).to.equal(1);
+
+    const { proof, vp } = await proofService.generateProof(
+      req.body.scope[0],
+      userDID,
+      credsForMyUserDID[0]
+    );
+    console.log(proof);
+
+    expect(vp).to.be.undefined;
+  });
 });