@credo-ts/anoncreds 0.5.0-alpha.144 → 0.5.0-alpha.146

package/build/anoncreds-rs/AnonCredsRsHolderService.js

@@ -15,7 +15,33 @@ const models_1 = require("../models");
 const repository_1 = require("../repository");
 const services_1 = require("../services");
 const utils_1 = require("../utils");
+const indyIdentifiers_1 = require("../utils/indyIdentifiers");
+const linkSecret_1 = require("../utils/linkSecret");
+const metadata_1 = require("../utils/metadata");
+const w3cAnonCredsUtils_1 = require("../utils/w3cAnonCredsUtils");
+const utils_2 = require("./utils");
 let AnonCredsRsHolderService = class AnonCredsRsHolderService {
+    constructor() {
+        this.getPresentationMetadata = async (agentContext, options) => {
+            const { credentialsWithMetadata, credentialsProve } = options;
+            const credentials = await Promise.all(credentialsWithMetadata.map(async ({ credential, nonRevoked }) => {
+                const credentialJson = core_1.JsonTransformer.toJSON(credential);
+                const { revocationRegistryIndex, revocationRegistryId, timestamp } = anoncreds_shared_1.W3cCredential.fromJson(credentialJson);
+                if (!nonRevoked)
+                    return { credential: credentialJson, revocationState: undefined, timestamp: undefined };
+                if (!revocationRegistryId || !revocationRegistryIndex)
+                    throw new core_1.CredoError('Missing revocation metadata');
+                const { revocationState, updatedTimestamp } = await (0, utils_2.getRevocationMetadata)(agentContext, {
+                    nonRevokedInterval: nonRevoked,
+                    timestamp,
+                    revocationRegistryIndex,
+                    revocationRegistryId,
+                });
+                return { credential: credentialJson, revocationState, timestamp: updatedTimestamp };
+            }));
+            return { credentialsProve, credentials };
+        };
+    }
     async createLinkSecret(agentContext, options) {
         var _a;
         return {
@@ -35,45 +61,60 @@ let AnonCredsRsHolderService = class AnonCredsRsHolderService {
             for (const schemaId in schemas) {
                 rsSchemas[schemaId] = schemas[schemaId];
             }
-            const credentialRepository = agentContext.dependencyManager.resolve(repository_1.AnonCredsCredentialRepository);
+            const w3cCredentialRepository = agentContext.dependencyManager.resolve(core_1.W3cCredentialRepository);
+            const anoncredsCredentialRepository = agentContext.dependencyManager.resolve(repository_1.AnonCredsCredentialRepository);
             // Cache retrieved credentials in order to minimize storage calls
             const retrievedCredentials = new Map();
             const credentialEntryFromAttribute = async (attribute) => {
                 let credentialRecord = retrievedCredentials.get(attribute.credentialId);
                 if (!credentialRecord) {
-                    credentialRecord = await credentialRepository.getByCredentialId(agentContext, attribute.credentialId);
-                    retrievedCredentials.set(attribute.credentialId, credentialRecord);
+                    const w3cCredentialRecord = await w3cCredentialRepository.findById(agentContext, attribute.credentialId);
+                    if (w3cCredentialRecord) {
+                        credentialRecord = w3cCredentialRecord;
+                        retrievedCredentials.set(attribute.credentialId, w3cCredentialRecord);
+                    }
+                    else {
+                        credentialRecord = await anoncredsCredentialRepository.getByCredentialId(agentContext, attribute.credentialId);
+                        agentContext.config.logger.warn([
+                            `Creating AnonCreds proof with legacy credential ${attribute.credentialId}.`,
+                            `Please run the migration script to migrate credentials to the new w3c format. See https://credo.js.org/guides/updating/versions/0.4-to-0.5 for information on how to migrate.`,
+                        ].join('\n'));
+                    }
                 }
-                const revocationRegistryDefinitionId = credentialRecord.credential.rev_reg_id;
-                const revocationRegistryIndex = credentialRecord.credentialRevocationId;
+                const { linkSecretId, revocationRegistryId, credentialRevocationId } = (0, w3cAnonCredsUtils_1.getAnoncredsCredentialInfoFromRecord)(credentialRecord);
                 // TODO: Check if credential has a revocation registry id (check response from anoncreds-rs API, as it is
                 // sending back a mandatory string in Credential.revocationRegistryId)
                 const timestamp = attribute.timestamp;
                 let revocationState;
                 let revocationRegistryDefinition;
                 try {
-                    if (timestamp && revocationRegistryIndex && revocationRegistryDefinitionId) {
-                        if (!options.revocationRegistries[revocationRegistryDefinitionId]) {
-                            throw new error_1.AnonCredsRsError(`Revocation Registry ${revocationRegistryDefinitionId} not found`);
+                    if (timestamp && credentialRevocationId && revocationRegistryId) {
+                        if (!options.revocationRegistries[revocationRegistryId]) {
+                            throw new error_1.AnonCredsRsError(`Revocation Registry ${revocationRegistryId} not found`);
                         }
-                        const { definition, revocationStatusLists, tailsFilePath } = options.revocationRegistries[revocationRegistryDefinitionId];
+                        const { definition, revocationStatusLists, tailsFilePath } = options.revocationRegistries[revocationRegistryId];
                         // Extract revocation status list for the given timestamp
                         const revocationStatusList = revocationStatusLists[timestamp];
                         if (!revocationStatusList) {
-                            throw new core_1.CredoError(`Revocation status list for revocation registry ${revocationRegistryDefinitionId} and timestamp ${timestamp} not found in revocation status lists. All revocation status lists must be present.`);
+                            throw new core_1.CredoError(`Revocation status list for revocation registry ${revocationRegistryId} and timestamp ${timestamp} not found in revocation status lists. All revocation status lists must be present.`);
                         }
                         revocationRegistryDefinition = anoncreds_shared_1.RevocationRegistryDefinition.fromJson(definition);
                         revocationState = anoncreds_shared_1.CredentialRevocationState.create({
-                            revocationRegistryIndex: Number(revocationRegistryIndex),
+                            revocationRegistryIndex: Number(credentialRevocationId),
                             revocationRegistryDefinition,
                             tailsPath: tailsFilePath,
                             revocationStatusList: anoncreds_shared_1.RevocationStatusList.fromJson(revocationStatusList),
                         });
                     }
+                    const credential = credentialRecord instanceof core_1.W3cCredentialRecord
+                        ? await this.w3cToLegacyCredential(agentContext, {
+                            credential: credentialRecord.credential,
+                        })
+                        : credentialRecord.credential;
                     return {
-                        linkSecretId: credentialRecord.linkSecretId,
+                        linkSecretId,
                         credentialEntry: {
-                            credential: credentialRecord.credential,
+                            credential: credential,
                             revocationState: revocationState === null || revocationState === void 0 ? void 0 : revocationState.toJson(),
                             timestamp,
                         },
@@ -99,17 +140,9 @@ let AnonCredsRsHolderService = class AnonCredsRsHolderService {
                 credentialsProve.push({ entryIndex, isPredicate: true, referent, reveal: true });
                 entryIndex = entryIndex + 1;
             }
-            // Get all requested credentials and take linkSecret. If it's not the same for every credential, throw error
-            const linkSecretsMatch = credentials.every((item) => item.linkSecretId === credentials[0].linkSecretId);
-            if (!linkSecretsMatch) {
-                throw new error_1.AnonCredsRsError('All credentials in a Proof should have been issued using the same Link Secret');
-            }
-            const linkSecretRecord = await agentContext.dependencyManager
-                .resolve(repository_1.AnonCredsLinkSecretRepository)
-                .getByLinkSecretId(agentContext, credentials[0].linkSecretId);
-            if (!linkSecretRecord.value) {
-                throw new error_1.AnonCredsRsError('Link Secret value not stored');
-            }
+            const linkSecretIds = credentials.map((item) => item.linkSecretId);
+            const linkSecretId = (0, linkSecret_1.assertLinkSecretsMatch)(agentContext, linkSecretIds);
+            const linkSecret = await (0, linkSecret_1.getLinkSecret)(agentContext, linkSecretId);
             presentation = anoncreds_shared_1.Presentation.create({
                 credentialDefinitions: rsCredentialDefinitions,
                 schemas: rsSchemas,
@@ -117,7 +150,7 @@ let AnonCredsRsHolderService = class AnonCredsRsHolderService {
                 credentials: credentials.map((entry) => entry.credentialEntry),
                 credentialsProve,
                 selfAttest: selectedCredentials.selfAttestedAttributes,
-                linkSecret: linkSecretRecord.value,
+                linkSecret,
             });
             return presentation.toJson();
         }
@@ -170,69 +203,116 @@ let AnonCredsRsHolderService = class AnonCredsRsHolderService {
             createReturnObj === null || createReturnObj === void 0 ? void 0 : createReturnObj.credentialRequestMetadata.handle.clear();
         }
     }
-    async storeCredential(agentContext, options) {
+    async w3cToLegacyCredential(agentContext, options) {
+        const credentialJson = core_1.JsonTransformer.toJSON(options.credential);
+        const w3cAnonCredsCredentialObj = anoncreds_shared_1.W3cCredential.fromJson(credentialJson);
+        const w3cCredentialObj = w3cAnonCredsCredentialObj.toLegacy();
+        const legacyCredential = w3cCredentialObj.toJson();
+        return legacyCredential;
+    }
+    async processW3cCredential(agentContext, credential, processOptions) {
+        const { credentialRequestMetadata, revocationRegistryDefinition, credentialDefinition } = processOptions;
+        const processCredentialOptions = {
+            credentialRequestMetadata: credentialRequestMetadata,
+            linkSecret: await (0, linkSecret_1.getLinkSecret)(agentContext, credentialRequestMetadata.link_secret_name),
+            revocationRegistryDefinition: revocationRegistryDefinition,
+            credentialDefinition: credentialDefinition,
+        };
+        const credentialJson = core_1.JsonTransformer.toJSON(credential);
+        const w3cAnonCredsCredential = anoncreds_shared_1.W3cCredential.fromJson(credentialJson);
+        const processedW3cAnonCredsCredential = w3cAnonCredsCredential.process(processCredentialOptions);
+        const processedW3cJsonLdVerifiableCredential = core_1.JsonTransformer.fromJSON(processedW3cAnonCredsCredential.toJson(), core_1.W3cJsonLdVerifiableCredential);
+        return processedW3cJsonLdVerifiableCredential;
+    }
+    async legacyToW3cCredential(agentContext, options) {
         var _a, _b;
-        const { credential, credentialDefinition, credentialRequestMetadata, revocationRegistry, schema } = options;
-        const linkSecretRecord = await agentContext.dependencyManager
-            .resolve(repository_1.AnonCredsLinkSecretRepository)
-            .getByLinkSecretId(agentContext, credentialRequestMetadata.link_secret_name);
-        if (!linkSecretRecord.value) {
-            throw new error_1.AnonCredsRsError('Link Secret value not stored');
-        }
-        const revocationRegistryDefinition = revocationRegistry === null || revocationRegistry === void 0 ? void 0 : revocationRegistry.definition;
-        const credentialId = (_a = options.credentialId) !== null && _a !== void 0 ? _a : core_1.utils.uuid();
-        let credentialObj;
-        let processedCredential;
+        const { credential, issuerId, processOptions } = options;
+        let w3cCredential;
+        let anonCredsCredential;
+        let w3cCredentialObj;
         try {
-            credentialObj = anoncreds_shared_1.Credential.fromJson(credential);
-            processedCredential = credentialObj.process({
-                credentialDefinition: credentialDefinition,
-                credentialRequestMetadata: credentialRequestMetadata,
-                linkSecret: linkSecretRecord.value,
-                revocationRegistryDefinition,
-            });
-            const credentialRepository = agentContext.dependencyManager.resolve(repository_1.AnonCredsCredentialRepository);
-            const methodName = agentContext.dependencyManager
-                .resolve(services_1.AnonCredsRegistryService)
-                .getRegistryForIdentifier(agentContext, credential.cred_def_id).methodName;
-            await credentialRepository.save(agentContext, new repository_1.AnonCredsCredentialRecord({
-                credential: processedCredential.toJson(),
-                credentialId,
-                linkSecretId: linkSecretRecord.linkSecretId,
-                issuerId: options.credentialDefinition.issuerId,
-                schemaName: schema.name,
-                schemaIssuerId: schema.issuerId,
-                schemaVersion: schema.version,
-                credentialRevocationId: (_b = processedCredential.revocationRegistryIndex) === null || _b === void 0 ? void 0 : _b.toString(),
-                methodName,
-            }));
-            return credentialId;
+            anonCredsCredential = anoncreds_shared_1.Credential.fromJson(credential);
+            w3cCredentialObj = anonCredsCredential.toW3c({ issuerId, w3cVersion: '1.1' });
+            const w3cJsonLdVerifiableCredential = core_1.JsonTransformer.fromJSON(w3cCredentialObj.toJson(), core_1.W3cJsonLdVerifiableCredential);
+            w3cCredential = processOptions
+                ? await this.processW3cCredential(agentContext, w3cJsonLdVerifiableCredential, processOptions)
+                : w3cJsonLdVerifiableCredential;
         }
         finally {
-            credentialObj === null || credentialObj === void 0 ? void 0 : credentialObj.handle.clear();
-            processedCredential === null || processedCredential === void 0 ? void 0 : processedCredential.handle.clear();
+            (_a = anonCredsCredential === null || anonCredsCredential === void 0 ? void 0 : anonCredsCredential.handle) === null || _a === void 0 ? void 0 : _a.clear();
+            (_b = w3cCredentialObj === null || w3cCredentialObj === void 0 ? void 0 : w3cCredentialObj.handle) === null || _b === void 0 ? void 0 : _b.clear();
         }
+        return w3cCredential;
     }
-    async getCredential(agentContext, options) {
-        var _a, _b;
-        const credentialRecord = await agentContext.dependencyManager
-            .resolve(repository_1.AnonCredsCredentialRepository)
-            .getByCredentialId(agentContext, options.credentialId);
-        const attributes = {};
-        for (const attribute in credentialRecord.credential.values) {
-            attributes[attribute] = credentialRecord.credential.values[attribute].raw;
-        }
-        return {
-            attributes,
-            credentialDefinitionId: credentialRecord.credential.cred_def_id,
-            credentialId: credentialRecord.credentialId,
-            schemaId: credentialRecord.credential.schema_id,
-            credentialRevocationId: (_a = credentialRecord.credentialRevocationId) !== null && _a !== void 0 ? _a : null,
-            revocationRegistryId: (_b = credentialRecord.credential.rev_reg_id) !== null && _b !== void 0 ? _b : null,
-            methodName: credentialRecord.methodName,
+    async storeW3cCredential(agentContext, options) {
+        const { credential, credentialRequestMetadata, schema, credentialDefinition, credentialDefinitionId } = options;
+        const methodName = agentContext.dependencyManager
+            .resolve(services_1.AnonCredsRegistryService)
+            .getRegistryForIdentifier(agentContext, credential.issuerId).methodName;
+        // this thows an error if the link secret is not found
+        await (0, linkSecret_1.getLinkSecret)(agentContext, credentialRequestMetadata.link_secret_name);
+        const { revocationRegistryId, revocationRegistryIndex } = anoncreds_shared_1.W3cCredential.fromJson(core_1.JsonTransformer.toJSON(credential));
+        const w3cCredentialService = agentContext.dependencyManager.resolve(core_1.W3cCredentialService);
+        const w3cCredentialRecord = await w3cCredentialService.storeCredential(agentContext, { credential });
+        const anonCredsTags = (0, w3cAnonCredsUtils_1.getW3cRecordAnonCredsTags)({
+            w3cCredentialRecord,
+            schema,
+            schemaId: credentialDefinition.schemaId,
+            credentialDefinitionId,
+            revocationRegistryId,
+            credentialRevocationId: revocationRegistryIndex === null || revocationRegistryIndex === void 0 ? void 0 : revocationRegistryIndex.toString(),
+            linkSecretId: credentialRequestMetadata.link_secret_name,
+            methodName,
+        });
+        const anonCredsCredentialMetadata = {
+            credentialId: w3cCredentialRecord.id,
+            credentialRevocationId: anonCredsTags.anonCredsCredentialRevocationId,
+            linkSecretId: anonCredsTags.anonCredsLinkSecretId,
+            methodName: anonCredsTags.anonCredsMethodName,
         };
+        w3cCredentialRecord.setTags(anonCredsTags);
+        w3cCredentialRecord.metadata.set(metadata_1.W3cAnonCredsCredentialMetadataKey, anonCredsCredentialMetadata);
+        const w3cCredentialRepository = agentContext.dependencyManager.resolve(core_1.W3cCredentialRepository);
+        await w3cCredentialRepository.update(agentContext, w3cCredentialRecord);
+        return w3cCredentialRecord;
     }
-    async getCredentials(agentContext, options) {
+    async storeCredential(agentContext, options) {
+        const { credential, credentialDefinition, credentialDefinitionId, credentialRequestMetadata, schema, revocationRegistry, } = options;
+        const w3cJsonLdCredential = credential instanceof core_1.W3cJsonLdVerifiableCredential
+            ? credential
+            : await this.legacyToW3cCredential(agentContext, {
+                credential,
+                issuerId: credentialDefinition.issuerId,
+                processOptions: {
+                    credentialRequestMetadata,
+                    credentialDefinition,
+                    revocationRegistryDefinition: revocationRegistry === null || revocationRegistry === void 0 ? void 0 : revocationRegistry.definition,
+                },
+            });
+        const w3cCredentialRecord = await this.storeW3cCredential(agentContext, {
+            credentialRequestMetadata,
+            credential: w3cJsonLdCredential,
+            credentialDefinitionId,
+            schema,
+            credentialDefinition,
+            revocationRegistryDefinition: revocationRegistry === null || revocationRegistry === void 0 ? void 0 : revocationRegistry.definition,
+        });
+        return w3cCredentialRecord.id;
+    }
+    async getCredential(agentContext, options) {
+        const w3cCredentialRepository = agentContext.dependencyManager.resolve(core_1.W3cCredentialRepository);
+        const w3cCredentialRecord = await w3cCredentialRepository.findById(agentContext, options.id);
+        if (w3cCredentialRecord)
+            return (0, w3cAnonCredsUtils_1.getAnoncredsCredentialInfoFromRecord)(w3cCredentialRecord);
+        const anonCredsCredentialRepository = agentContext.dependencyManager.resolve(repository_1.AnonCredsCredentialRepository);
+        const anonCredsCredentialRecord = await anonCredsCredentialRepository.getByCredentialId(agentContext, options.id);
+        agentContext.config.logger.warn([
+            `Querying legacy credential repository for credential with id ${options.id}.`,
+            `Please run the migration script to migrate credentials to the new w3c format.`,
+        ].join('\n'));
+        return (0, w3cAnonCredsUtils_1.getAnoncredsCredentialInfoFromRecord)(anonCredsCredentialRecord);
+    }
+    async getLegacyCredentials(agentContext, options) {
         const credentialRecords = await agentContext.dependencyManager
             .resolve(repository_1.AnonCredsCredentialRepository)
             .findByQuery(agentContext, {
@@ -244,25 +324,47 @@ let AnonCredsRsHolderService = class AnonCredsRsHolderService {
             schemaIssuerId: options.schemaIssuerId,
             methodName: options.methodName,
         });
-        return credentialRecords.map((credentialRecord) => {
-            var _a, _b;
-            return ({
-                attributes: Object.fromEntries(Object.entries(credentialRecord.credential.values).map(([key, value]) => [key, value.raw])),
-                credentialDefinitionId: credentialRecord.credential.cred_def_id,
-                credentialId: credentialRecord.credentialId,
-                schemaId: credentialRecord.credential.schema_id,
-                credentialRevocationId: (_a = credentialRecord.credentialRevocationId) !== null && _a !== void 0 ? _a : null,
-                revocationRegistryId: (_b = credentialRecord.credential.rev_reg_id) !== null && _b !== void 0 ? _b : null,
-                methodName: credentialRecord.methodName,
-            });
+        return credentialRecords.map((credentialRecord) => (0, w3cAnonCredsUtils_1.getAnoncredsCredentialInfoFromRecord)(credentialRecord));
+    }
+    async getCredentials(agentContext, options) {
+        const credentialRecords = await agentContext.dependencyManager
+            .resolve(core_1.W3cCredentialRepository)
+            .findByQuery(agentContext, {
+            anonCredsCredentialDefinitionId: !options.credentialDefinitionId || (0, indyIdentifiers_1.isUnqualifiedCredentialDefinitionId)(options.credentialDefinitionId)
+                ? undefined
+                : options.credentialDefinitionId,
+            anonCredsSchemaId: !options.schemaId || (0, indyIdentifiers_1.isUnqualifiedSchemaId)(options.schemaId) ? undefined : options.schemaId,
+            anonCredsIssuerId: !options.issuerId || (0, indyIdentifiers_1.isUnqualifiedIndyDid)(options.issuerId) ? undefined : options.issuerId,
+            anonCredsSchemaName: options.schemaName,
+            anonCredsSchemaVersion: options.schemaVersion,
+            anonCredsSchemaIssuerId: !options.schemaIssuerId || (0, indyIdentifiers_1.isUnqualifiedIndyDid)(options.schemaIssuerId) ? undefined : options.schemaIssuerId,
+            anonCredsMethodName: options.methodName,
+            anonCredsUnqualifiedSchemaId: options.schemaId && (0, indyIdentifiers_1.isUnqualifiedSchemaId)(options.schemaId) ? options.schemaId : undefined,
+            anonCredsUnqualifiedIssuerId: options.issuerId && (0, indyIdentifiers_1.isUnqualifiedIndyDid)(options.issuerId) ? options.issuerId : undefined,
+            anonCredsUnqualifiedSchemaIssuerId: options.schemaIssuerId && (0, indyIdentifiers_1.isUnqualifiedIndyDid)(options.schemaIssuerId) ? options.schemaIssuerId : undefined,
+            anonCredsUnqualifiedCredentialDefinitionId: options.credentialDefinitionId && (0, indyIdentifiers_1.isUnqualifiedCredentialDefinitionId)(options.credentialDefinitionId)
+                ? options.credentialDefinitionId
+                : undefined,
         });
+        const credentials = credentialRecords.map((credentialRecord) => (0, w3cAnonCredsUtils_1.getAnoncredsCredentialInfoFromRecord)(credentialRecord));
+        const legacyCredentials = await this.getLegacyCredentials(agentContext, options);
+        if (legacyCredentials.length > 0) {
+            agentContext.config.logger.warn(`Queried credentials include legacy credentials. Please run the migration script to migrate credentials to the new w3c format.`);
+        }
+        return [...legacyCredentials, ...credentials];
     }
-    async deleteCredential(agentContext, credentialId) {
-        const credentialRepository = agentContext.dependencyManager.resolve(repository_1.AnonCredsCredentialRepository);
-        const credentialRecord = await credentialRepository.getByCredentialId(agentContext, credentialId);
-        await credentialRepository.delete(agentContext, credentialRecord);
+    async deleteCredential(agentContext, id) {
+        const w3cCredentialRepository = agentContext.dependencyManager.resolve(core_1.W3cCredentialRepository);
+        const w3cCredentialRecord = await w3cCredentialRepository.findById(agentContext, id);
+        if (w3cCredentialRecord) {
+            await w3cCredentialRepository.delete(agentContext, w3cCredentialRecord);
+            return;
+        }
+        const anoncredsCredentialRepository = agentContext.dependencyManager.resolve(repository_1.AnonCredsCredentialRepository);
+        const anoncredsCredentialRecord = await anoncredsCredentialRepository.getByCredentialId(agentContext, id);
+        await anoncredsCredentialRepository.delete(agentContext, anoncredsCredentialRecord);
     }
-    async getCredentialsForProofRequest(agentContext, options) {
+    async getLegacyCredentialsForProofRequest(agentContext, options) {
         var _a, _b;
         const proofRequest = options.proofRequest;
         const referent = options.attributeReferent;
@@ -275,12 +377,12 @@ let AnonCredsRsHolderService = class AnonCredsRsHolderService {
         const attributes = (_b = requestedAttribute.names) !== null && _b !== void 0 ? _b : [requestedAttribute.name];
         const attributeQuery = {};
         for (const attribute of attributes) {
-            attributeQuery[`attr::${attribute}::marker`] = true;
+            attributeQuery[`anonCredsAttr::${attribute}::marker`] = true;
         }
         $and.push(attributeQuery);
         // Add query for proof request restrictions
         if (requestedAttribute.restrictions) {
-            const restrictionQuery = this.queryFromRestrictions(requestedAttribute.restrictions);
+            const restrictionQuery = this.queryLegacyFromRestrictions(requestedAttribute.restrictions);
             $and.push(restrictionQuery);
         }
         // Add extra query
@@ -295,42 +397,146 @@ let AnonCredsRsHolderService = class AnonCredsRsHolderService {
             $and,
         });
         return credentials.map((credentialRecord) => {
-            var _a, _b;
-            const attributes = {};
-            for (const attribute in credentialRecord.credential.values) {
-                attributes[attribute] = credentialRecord.credential.values[attribute].raw;
-            }
             return {
-                credentialInfo: {
-                    attributes,
-                    credentialDefinitionId: credentialRecord.credential.cred_def_id,
-                    credentialId: credentialRecord.credentialId,
-                    schemaId: credentialRecord.credential.schema_id,
-                    credentialRevocationId: (_a = credentialRecord.credentialRevocationId) !== null && _a !== void 0 ? _a : null,
-                    revocationRegistryId: (_b = credentialRecord.credential.rev_reg_id) !== null && _b !== void 0 ? _b : null,
-                    methodName: credentialRecord.methodName,
-                },
+                credentialInfo: (0, w3cAnonCredsUtils_1.getAnoncredsCredentialInfoFromRecord)(credentialRecord),
                 interval: proofRequest.non_revoked,
             };
         });
     }
+    async getCredentialsForProofRequest(agentContext, options) {
+        var _a, _b;
+        const proofRequest = options.proofRequest;
+        const referent = options.attributeReferent;
+        const requestedAttribute = (_a = proofRequest.requested_attributes[referent]) !== null && _a !== void 0 ? _a : proofRequest.requested_predicates[referent];
+        if (!requestedAttribute) {
+            throw new error_1.AnonCredsRsError(`Referent not found in proof request`);
+        }
+        const $and = [];
+        // Make sure the attribute(s) that are requested are present using the marker tag
+        const attributes = (_b = requestedAttribute.names) !== null && _b !== void 0 ? _b : [requestedAttribute.name];
+        const attributeQuery = {};
+        for (const attribute of attributes) {
+            attributeQuery[`anonCredsAttr::${attribute}::marker`] = true;
+        }
+        $and.push(attributeQuery);
+        // Add query for proof request restrictions
+        if (requestedAttribute.restrictions) {
+            const restrictionQuery = this.queryFromRestrictions(requestedAttribute.restrictions);
+            $and.push(restrictionQuery);
+        }
+        // Add extra query
+        // TODO: we're not really typing the extraQuery, and it will work differently based on the anoncreds implmentation
+        // We should make the allowed properties more strict
+        if (options.extraQuery) {
+            $and.push(options.extraQuery);
+        }
+        const w3cCredentialRepository = agentContext.dependencyManager.resolve(core_1.W3cCredentialRepository);
+        const credentials = await w3cCredentialRepository.findByQuery(agentContext, { $and });
+        const legacyCredentialWithMetadata = await this.getLegacyCredentialsForProofRequest(agentContext, options);
+        if (legacyCredentialWithMetadata.length > 0) {
+            agentContext.config.logger.warn([
+                `Including legacy credentials in proof request.`,
+                `Please run the migration script to migrate credentials to the new w3c format.`,
+            ].join('\n'));
+        }
+        const credentialWithMetadata = credentials.map((credentialRecord) => {
+            return {
+                credentialInfo: (0, w3cAnonCredsUtils_1.getAnoncredsCredentialInfoFromRecord)(credentialRecord),
+                interval: proofRequest.non_revoked,
+            };
+        });
+        return [...credentialWithMetadata, ...legacyCredentialWithMetadata];
+    }
     queryFromRestrictions(restrictions) {
         var _a, _b;
         const query = [];
         const { restrictions: parsedRestrictions } = core_1.JsonTransformer.fromJSON({ restrictions }, models_1.AnonCredsRestrictionWrapper);
         for (const restriction of parsedRestrictions) {
             const queryElements = {};
+            if (restriction.credentialDefinitionId) {
+                if ((0, indyIdentifiers_1.isUnqualifiedCredentialDefinitionId)(restriction.credentialDefinitionId)) {
+                    queryElements.anonCredsUnqualifiedCredentialDefinitionId = restriction.credentialDefinitionId;
+                }
+                else {
+                    queryElements.anonCredsCredentialDefinitionId = restriction.credentialDefinitionId;
+                }
+            }
+            if (restriction.issuerId || restriction.issuerDid) {
+                const issuerId = ((_a = restriction.issuerId) !== null && _a !== void 0 ? _a : restriction.issuerDid);
+                if ((0, indyIdentifiers_1.isUnqualifiedIndyDid)(issuerId)) {
+                    queryElements.anonCredsUnqualifiedIssuerId = issuerId;
+                }
+                else {
+                    queryElements.anonCredsIssuerId = issuerId;
+                }
+            }
+            if (restriction.schemaId) {
+                if ((0, indyIdentifiers_1.isUnqualifiedSchemaId)(restriction.schemaId)) {
+                    queryElements.anonCredsUnqualifiedSchemaId = restriction.schemaId;
+                }
+                else {
+                    queryElements.anonCredsSchemaId = restriction.schemaId;
+                }
+            }
+            if (restriction.schemaIssuerId || restriction.schemaIssuerDid) {
+                const schemaIssuerId = ((_b = restriction.schemaIssuerId) !== null && _b !== void 0 ? _b : restriction.schemaIssuerDid);
+                if ((0, indyIdentifiers_1.isUnqualifiedIndyDid)(schemaIssuerId)) {
+                    queryElements.anonCredsUnqualifiedSchemaIssuerId = schemaIssuerId;
+                }
+                else {
+                    queryElements.anonCredsSchemaIssuerId = schemaIssuerId;
+                }
+            }
+            if (restriction.schemaName) {
+                queryElements.anonCredsSchemaName = restriction.schemaName;
+            }
+            if (restriction.schemaVersion) {
+                queryElements.anonCredsSchemaVersion = restriction.schemaVersion;
+            }
+            for (const [attributeName, attributeValue] of Object.entries(restriction.attributeValues)) {
+                queryElements[`anonCredsAttr::${attributeName}::value`] = attributeValue;
+            }
+            for (const [attributeName, isAvailable] of Object.entries(restriction.attributeMarkers)) {
+                if (isAvailable) {
+                    queryElements[`anonCredsAttr::${attributeName}::marker`] = isAvailable;
+                }
+            }
+            query.push(queryElements);
+        }
+        return query.length === 1 ? query[0] : { $or: query };
+    }
+    queryLegacyFromRestrictions(restrictions) {
+        var _a, _b;
+        const query = [];
+        const { restrictions: parsedRestrictions } = core_1.JsonTransformer.fromJSON({ restrictions }, models_1.AnonCredsRestrictionWrapper);
+        for (const restriction of parsedRestrictions) {
+            const queryElements = {};
+            const additionalQueryElements = {};
             if (restriction.credentialDefinitionId) {
                 queryElements.credentialDefinitionId = restriction.credentialDefinitionId;
+                if ((0, indyIdentifiers_1.isUnqualifiedCredentialDefinitionId)(restriction.credentialDefinitionId)) {
+                    additionalQueryElements.credentialDefinitionId = restriction.credentialDefinitionId;
+                }
             }
             if (restriction.issuerId || restriction.issuerDid) {
-                queryElements.issuerId = (_a = restriction.issuerId) !== null && _a !== void 0 ? _a : restriction.issuerDid;
+                const issuerId = ((_a = restriction.issuerId) !== null && _a !== void 0 ? _a : restriction.issuerDid);
+                queryElements.issuerId = issuerId;
+                if ((0, indyIdentifiers_1.isUnqualifiedIndyDid)(issuerId)) {
+                    additionalQueryElements.issuerId = issuerId;
+                }
             }
             if (restriction.schemaId) {
                 queryElements.schemaId = restriction.schemaId;
+                if ((0, indyIdentifiers_1.isUnqualifiedSchemaId)(restriction.schemaId)) {
+                    additionalQueryElements.schemaId = restriction.schemaId;
+                }
             }
             if (restriction.schemaIssuerId || restriction.schemaIssuerDid) {
-                queryElements.schemaIssuerId = (_b = restriction.schemaIssuerId) !== null && _b !== void 0 ? _b : restriction.issuerDid;
+                const issuerId = ((_b = restriction.schemaIssuerId) !== null && _b !== void 0 ? _b : restriction.schemaIssuerDid);
+                queryElements.schemaIssuerId = issuerId;
+                if ((0, indyIdentifiers_1.isUnqualifiedIndyDid)(issuerId)) {
+                    additionalQueryElements.schemaIssuerId = issuerId;
+                }
             }
             if (restriction.schemaName) {
                 queryElements.schemaName = restriction.schemaName;
@@ -347,9 +553,36 @@ let AnonCredsRsHolderService = class AnonCredsRsHolderService {
                 }
             }
             query.push(queryElements);
+            if (Object.keys(additionalQueryElements).length > 0) {
+                query.push(additionalQueryElements);
+            }
         }
         return query.length === 1 ? query[0] : { $or: query };
     }
+    async createW3cPresentation(agentContext, options) {
+        const { credentialsProve, credentials } = await this.getPresentationMetadata(agentContext, {
+            credentialsWithMetadata: options.credentialsWithRevocationMetadata,
+            credentialsProve: options.credentialsProve,
+        });
+        let w3cAnonCredsPresentation;
+        let w3cPresentation;
+        try {
+            w3cAnonCredsPresentation = anoncreds_shared_1.W3cPresentation.create({
+                credentials,
+                credentialsProve,
+                schemas: options.schemas,
+                credentialDefinitions: options.credentialDefinitions,
+                presentationRequest: options.proofRequest,
+                linkSecret: await (0, linkSecret_1.getLinkSecret)(agentContext, options.linkSecretId),
+            });
+            const presentationJson = w3cAnonCredsPresentation.toJson();
+            w3cPresentation = core_1.JsonTransformer.fromJSON(presentationJson, core_1.W3cJsonLdVerifiablePresentation);
+        }
+        finally {
+            w3cAnonCredsPresentation === null || w3cAnonCredsPresentation === void 0 ? void 0 : w3cAnonCredsPresentation.handle.clear();
+        }
+        return w3cPresentation;
+    }
 };
 AnonCredsRsHolderService = __decorate([
     (0, core_1.injectable)()