@cheqd/studio 3.7.0 → 3.8.0-develop.1

package/dist/services/identity/agent.js

@@ -5,13 +5,13 @@ import { DIDManager } from '@veramo/did-manager';
 import { DIDResolverPlugin, getUniversalResolver as UniversalResolver } from '@veramo/did-resolver';
 import { CredentialPlugin } from '@veramo/credential-w3c';
 import { CredentialIssuerLD, LdDefaultContexts, VeramoEd25519Signature2018, VeramoEd25519Signature2020, VeramoJsonWebSignature2020, } from '@veramo/credential-ld';
-import { Cheqd, getResolver as CheqdDidResolver, DefaultResolverUrl, DefaultStatusList2021ResourceTypes, DefaultStatusList2021StatusPurposeTypes, DefaultStatusList2021Encodings, } from '@cheqd/did-provider-cheqd';
+import { Cheqd, getResolver as CheqdDidResolver, DefaultResolverUrl, BitstringStatusListResourceType, DefaultStatusList2021StatusPurposeTypes, DefaultStatusListEncodings, BitstringStatusPurposeTypes, DefaultStatusList2021ResourceTypes, } from '@cheqd/did-provider-cheqd';
 import { ResourceModule } from '@cheqd/sdk';
 import { getDidKeyResolver as KeyDidResolver } from '@veramo/did-provider-key';
 import { Resolver } from 'did-resolver';
 import { DefaultDidUrlPattern } from '../../types/shared.js';
-import { DefaultStatusActions } from '../../types/credential-status.js';
-import { MINIMAL_DENOM, VC_PROOF_FORMAT, VC_REMOVE_ORIGINAL_FIELDS } from '../../types/constants.js';
+import { BitstringStatusActions, DefaultStatusActions, StatusListType } from '../../types/credential-status.js';
+import { BitstringStatusListEntry, MINIMAL_DENOM, VC_PROOF_FORMAT, VC_REMOVE_ORIGINAL_FIELDS, } from '../../types/constants.js';
 import { toCoin, toDefaultDkg, toMinimalDenom } from '../../helpers/helpers.js';
 import { jwtDecode } from 'jwt-decode';
 import { SupportedKeyTypes } from '@veramo/utils';
@@ -195,16 +195,26 @@ export class Veramo {
         try {
             let verifiable_credential;
             if (statusListOptions) {
-                verifiable_credential =
-                    statusListOptions.statusPurpose == 'revocation'
-                        ? await agent.cheqdIssueRevocableCredentialWithStatusList2021({
-                            issuanceOptions,
-                            statusOptions: statusListOptions,
-                        })
-                        : await agent.cheqdIssueSuspendableCredentialWithStatusList2021({
-                            issuanceOptions,
-                            statusOptions: statusListOptions,
-                        });
+                const { statusListType, ...statusOptions } = statusListOptions;
+                if (statusListType == StatusListType.StatusList2021) {
+                    // TODO: remove this check when we remove StatusList2021
+                    verifiable_credential =
+                        statusListOptions.statusPurpose == DefaultStatusList2021StatusPurposeTypes.revocation
+                            ? await agent.cheqdIssueRevocableCredentialWithStatusList2021({
+                                issuanceOptions,
+                                statusOptions: statusOptions,
+                            })
+                            : await agent.cheqdIssueSuspendableCredentialWithStatusList2021({
+                                issuanceOptions,
+                                statusOptions: statusOptions,
+                            });
+                }
+                else {
+                    verifiable_credential = await agent.cheqdIssueCredentialWithStatusList({
+                        issuanceOptions,
+                        statusOptions: statusOptions,
+                    });
+                }
             }
             else {
                 verifiable_credential = await agent.createVerifiableCredential(issuanceOptions);
@@ -218,13 +228,25 @@ export class Veramo {
     async verifyCredential(agent, credential, verificationOptions = {}) {
         let result;
         if (verificationOptions.verifyStatus) {
-            result = await agent.cheqdVerifyCredential({
-                credential: credential,
-                fetchList: true,
-                verificationArgs: {
-                    ...verificationOptions,
-                },
-            });
+            const cred = credential;
+            if (cred.credentialStatus?.type === BitstringStatusListEntry) {
+                result = await agent.cheqdVerifyCredentialWithStatusList({
+                    credential: cred,
+                    fetchList: true,
+                    verificationArgs: {
+                        ...verificationOptions,
+                    },
+                });
+            }
+            else {
+                result = await agent.cheqdVerifyCredential({
+                    credential: cred,
+                    fetchList: true,
+                    verificationArgs: {
+                        ...verificationOptions,
+                    },
+                });
+            }
         }
         else {
             result = await agent.verifyCredential({
@@ -277,13 +299,27 @@ export class Veramo {
             });
         }
         if (verificationOptions.verifyStatus) {
-            result = await agent.cheqdVerifyPresentation({
-                presentation: presentation,
-                fetchList: true,
-                verificationArgs: {
-                    ...verificationOptions,
-                },
-            });
+            const firstCredential = typeof presentation.verifiableCredential?.[0] === 'string'
+                ? jwtDecode(presentation.verifiableCredential[0])
+                : presentation.verifiableCredential?.[0];
+            if (firstCredential?.credentialStatus?.type === BitstringStatusListEntry) {
+                result = await agent.cheqdVerifyPresentationWithStatusList({
+                    presentation: presentation,
+                    fetchList: true,
+                    verificationArgs: {
+                        ...verificationOptions,
+                    },
+                });
+            }
+            else {
+                result = await agent.cheqdVerifyPresentation({
+                    presentation: presentation,
+                    fetchList: true,
+                    verificationArgs: {
+                        ...verificationOptions,
+                    },
+                });
+            }
         }
         else {
             result = await agent.verifyPresentation({
@@ -319,9 +355,29 @@ export class Veramo {
             issuerDid: did,
             statusListName: resourceOptions.name,
             statusPurpose: statusOptions.statusPurpose || DefaultStatusList2021StatusPurposeTypes.revocation,
-            statusListEncoding: statusOptions.encoding || DefaultStatusList2021Encodings.base64url,
+            statusListEncoding: statusOptions.encoding || DefaultStatusListEncodings.base64url,
+            statusListLength: statusOptions.length,
+            resourceVersion: resourceOptions.version,
+            encrypted: false,
+        });
+    }
+    async createUnencryptedBitstringStatusList(agent, did, resourceOptions, statusOptions) {
+        const [kms] = await agent.keyManagerGetKeyManagementSystems();
+        if (!resourceOptions.name) {
+            throw new Error(`createUnencryptedBitstringStatusList: status list name is required`);
+        }
+        return await agent.cheqdCreateStatusList({
+            kms,
+            issuerDid: did,
+            statusListName: resourceOptions.name,
+            statusPurpose: statusOptions.statusPurpose || BitstringStatusPurposeTypes.message,
+            statusSize: statusOptions.size || 1,
+            statusMessages: statusOptions.statusMessages,
+            ttl: statusOptions.ttl,
+            statusListEncoding: statusOptions.encoding || DefaultStatusListEncodings.base64url,
             statusListLength: statusOptions.length,
             resourceVersion: resourceOptions.version,
+            alsoKnownAs: resourceOptions.alsoKnownAs,
             encrypted: false,
         });
     }
@@ -364,7 +420,7 @@ export class Veramo {
             issuerDid: did,
             statusListName: resourceOptions.name,
             statusPurpose: statusOptions.statusPurpose || DefaultStatusList2021StatusPurposeTypes.revocation,
-            statusListEncoding: statusOptions.encoding || DefaultStatusList2021Encodings.base64url,
+            statusListEncoding: statusOptions.encoding || DefaultStatusListEncodings.base64url,
             statusListLength: statusOptions.length,
             resourceVersion: resourceOptions.version,
             encrypted: true,
@@ -373,6 +429,58 @@ export class Veramo {
             dkgOptions: toDefaultDkg(did),
         });
     }
+    async createEncryptedBitstringStatusList(agent, did, resourceOptions, statusOptions) {
+        const [kms] = await agent.keyManagerGetKeyManagementSystems();
+        if (!resourceOptions.name) {
+            throw new Error(`createEncryptedBitstringStatusList: status list name is required`);
+        }
+        // construct payment conditions
+        const paymentConditions = (statusOptions?.paymentConditions
+            ? statusOptions.paymentConditions.map((condition) => {
+                return {
+                    type: 'timelockPayment',
+                    feePaymentAddress: condition.feePaymentAddress,
+                    feePaymentAmount: `${toMinimalDenom(condition.feePaymentAmount)}${MINIMAL_DENOM}`,
+                    intervalInSeconds: condition.feePaymentWindow * 60,
+                };
+            })
+            : (function () {
+                // validate relevant components - case: feePaymentAddress
+                if (!statusOptions.feePaymentAddress)
+                    throw new Error('createEncryptedBitstringStatusList: feePaymentAddress is required');
+                // validate relevant components - case: feePaymentAmount
+                if (!statusOptions.feePaymentAmount)
+                    throw new Error('createEncryptedBitstringStatusList: feePaymentAmount is required');
+                // validate relevant components - case: feePaymentWindow
+                if (!statusOptions.feePaymentWindow)
+                    throw new Error('createEncryptedBitstringStatusList: feePaymentWindow is required');
+                return [
+                    {
+                        type: 'timelockPayment',
+                        feePaymentAddress: statusOptions.feePaymentAddress,
+                        feePaymentAmount: `${toMinimalDenom(statusOptions.feePaymentAmount)}${MINIMAL_DENOM}`,
+                        intervalInSeconds: statusOptions.feePaymentWindow * 60,
+                    },
+                ];
+            })());
+        return await agent.cheqdCreateStatusList({
+            kms,
+            issuerDid: did,
+            statusListName: resourceOptions.name,
+            statusPurpose: statusOptions.statusPurpose || BitstringStatusPurposeTypes.message,
+            statusSize: statusOptions.size || 1,
+            statusMessages: statusOptions.statusMessages,
+            ttl: statusOptions.ttl,
+            statusListEncoding: statusOptions.encoding || DefaultStatusListEncodings.base64url,
+            statusListLength: statusOptions.length,
+            resourceVersion: resourceOptions.version,
+            alsoKnownAs: resourceOptions.alsoKnownAs,
+            encrypted: true,
+            paymentConditions,
+            returnSymmetricKey: true,
+            dkgOptions: toDefaultDkg(did),
+        });
+    }
     async broadcastStatusList2021(agent, did, resourceOptions, statusOptions) {
         const [kms] = await agent.keyManagerGetKeyManagementSystems();
         if (!resourceOptions.data) {
@@ -384,13 +492,29 @@ export class Veramo {
                 ...resourceOptions,
                 collectionId: did.split(':')[3],
                 data: resourceOptions.data,
-                resourceType: statusOptions.statusPurpose === 'revocation'
+                resourceType: statusOptions.statusPurpose === DefaultStatusList2021StatusPurposeTypes.revocation
                     ? DefaultStatusList2021ResourceTypes.revocation
                     : DefaultStatusList2021ResourceTypes.suspension,
             },
             network: did.split(':')[2],
         });
     }
+    async broadcastBitstringStatusList(agent, did, resourceOptions) {
+        const [kms] = await agent.keyManagerGetKeyManagementSystems();
+        if (!resourceOptions.data) {
+            throw new Error(`StatusList data is required`);
+        }
+        return await agent.cheqdBroadcastStatusList({
+            kms,
+            payload: {
+                ...resourceOptions,
+                collectionId: did.split(':')[3],
+                data: resourceOptions.data,
+                resourceType: BitstringStatusListResourceType,
+            },
+            network: did.split(':')[2],
+        });
+    }
     async remunerateStatusList2021(agent, feePaymentOptions) {
         return await agent.cheqdTransactSendTokens({
             recipientAddress: feePaymentOptions.feePaymentAddress,
@@ -400,7 +524,27 @@ export class Veramo {
             returnTxResponse: true,
         });
     }
-    async revokeCredentials(agent, credentials, publish = true, symmetricKey = '') {
+    async revokeCredentials(agent, credentials, listType, publish = true, symmetricKey = '') {
+        if (listType === StatusListType.Bitstring) {
+            if (Array.isArray(credentials)) {
+                return await agent.cheqdBulkUpdateCredentialsWithStatusList({
+                    credentials,
+                    newStatus: BitstringStatusActions.revoke,
+                    fetchList: true,
+                    publish,
+                });
+            }
+            return await agent.cheqdUpdateCredentialWithStatusList({
+                credential: credentials,
+                newStatus: BitstringStatusActions.revoke,
+                fetchList: true,
+                publish,
+                symmetricKey,
+                returnStatusListMetadata: true,
+                returnUpdatedStatusList: true,
+            });
+        }
+        // default to StatusList2021
         if (Array.isArray(credentials))
             return await agent.cheqdRevokeCredentials({
                 credentials,
@@ -416,7 +560,27 @@ export class Veramo {
             returnUpdatedStatusList: true,
         });
     }
-    async suspendCredentials(agent, credentials, publish = true, symmetricKey = '') {
+    async suspendCredentials(agent, credentials, listType, publish = true, symmetricKey = '') {
+        if (listType === StatusListType.Bitstring) {
+            if (Array.isArray(credentials)) {
+                return await agent.cheqdBulkUpdateCredentialsWithStatusList({
+                    credentials,
+                    newStatus: BitstringStatusActions.suspend,
+                    fetchList: true,
+                    publish,
+                });
+            }
+            return await agent.cheqdUpdateCredentialWithStatusList({
+                credential: credentials,
+                newStatus: BitstringStatusActions.suspend,
+                fetchList: true,
+                publish,
+                symmetricKey,
+                returnStatusListMetadata: true,
+                returnUpdatedStatusList: true,
+            });
+        }
+        // default to StatusList2021
         if (Array.isArray(credentials))
             return await agent.cheqdSuspendCredentials({ credentials, fetchList: true, publish });
         return await agent.cheqdSuspendCredential({
@@ -428,7 +592,27 @@ export class Veramo {
             returnUpdatedStatusList: true,
         });
     }
-    async unsuspendCredentials(agent, credentials, publish = true, symmetricKey = '') {
+    async unsuspendCredentials(agent, credentials, listType, publish = true, symmetricKey = '') {
+        if (listType === StatusListType.Bitstring) {
+            if (Array.isArray(credentials)) {
+                return await agent.cheqdBulkUpdateCredentialsWithStatusList({
+                    credentials,
+                    newStatus: BitstringStatusActions.reinstate,
+                    fetchList: true,
+                    publish,
+                });
+            }
+            return await agent.cheqdUpdateCredentialWithStatusList({
+                credential: credentials,
+                newStatus: BitstringStatusActions.reinstate,
+                fetchList: true,
+                publish,
+                symmetricKey,
+                returnStatusListMetadata: true,
+                returnUpdatedStatusList: true,
+            });
+        }
+        // default to StatusList2021
         if (Array.isArray(credentials))
             return await agent.cheqdUnsuspendCredentials({ credentials, fetchList: true, publish });
         return await agent.cheqdUnsuspendCredential({
@@ -440,53 +624,71 @@ export class Veramo {
             returnUpdatedStatusList: true,
         });
     }
-    async updateUnencryptedStatusList2021(agent, did, statusOptions) {
-        switch (statusOptions.statusAction) {
-            case DefaultStatusActions.revoke:
-                return await agent.cheqdRevokeCredentials({
-                    revocationOptions: {
-                        issuerDid: did,
-                        statusListIndices: statusOptions.indices,
-                        statusListName: statusOptions.statusListName,
-                        statusListVersion: statusOptions.statusListVersion,
-                    },
-                    fetchList: true,
-                    publish: true,
-                    publishEncrypted: false,
-                    returnUpdatedStatusList: true,
-                    returnStatusListMetadata: true,
-                });
-            case DefaultStatusActions.suspend:
-                return await agent.cheqdSuspendCredentials({
-                    suspensionOptions: {
-                        issuerDid: did,
-                        statusListIndices: statusOptions.indices,
-                        statusListName: statusOptions.statusListName,
-                        statusListVersion: statusOptions.statusListVersion,
-                    },
-                    fetchList: true,
-                    publish: true,
-                    publishEncrypted: false,
-                    returnUpdatedStatusList: true,
-                    returnStatusListMetadata: true,
-                });
-            case DefaultStatusActions.reinstate:
-                return await agent.cheqdUnsuspendCredentials({
-                    unsuspensionOptions: {
-                        issuerDid: did,
-                        statusListIndices: statusOptions.indices,
-                        statusListName: statusOptions.statusListName,
-                        statusListVersion: statusOptions.statusListVersion,
-                    },
-                    fetchList: true,
-                    publish: true,
-                    publishEncrypted: false,
-                    returnUpdatedStatusList: true,
-                    returnStatusListMetadata: true,
-                });
+    async updateUnencryptedStatusList(agent, did, listType, statusOptions) {
+        if (listType === StatusListType.Bitstring) {
+            return await agent.cheqdBulkUpdateCredentialsWithStatusList({
+                newStatus: BitstringStatusActions[statusOptions.statusAction],
+                updateOptions: {
+                    issuerDid: did,
+                    statusListIndices: statusOptions.indices,
+                    statusListName: statusOptions.statusListName,
+                    statusListVersion: statusOptions.statusListVersion,
+                },
+                fetchList: true,
+                publish: true,
+                publishEncrypted: false,
+                returnUpdatedStatusList: true,
+                returnStatusListMetadata: true,
+            });
+        }
+        else {
+            switch (statusOptions.statusAction) {
+                case DefaultStatusActions.revoke:
+                    return await agent.cheqdRevokeCredentials({
+                        revocationOptions: {
+                            issuerDid: did,
+                            statusListIndices: statusOptions.indices,
+                            statusListName: statusOptions.statusListName,
+                            statusListVersion: statusOptions.statusListVersion,
+                        },
+                        fetchList: true,
+                        publish: true,
+                        publishEncrypted: false,
+                        returnUpdatedStatusList: true,
+                        returnStatusListMetadata: true,
+                    });
+                case DefaultStatusActions.suspend:
+                    return await agent.cheqdSuspendCredentials({
+                        suspensionOptions: {
+                            issuerDid: did,
+                            statusListIndices: statusOptions.indices,
+                            statusListName: statusOptions.statusListName,
+                            statusListVersion: statusOptions.statusListVersion,
+                        },
+                        fetchList: true,
+                        publish: true,
+                        publishEncrypted: false,
+                        returnUpdatedStatusList: true,
+                        returnStatusListMetadata: true,
+                    });
+                case DefaultStatusActions.reinstate:
+                    return await agent.cheqdUnsuspendCredentials({
+                        unsuspensionOptions: {
+                            issuerDid: did,
+                            statusListIndices: statusOptions.indices,
+                            statusListName: statusOptions.statusListName,
+                            statusListVersion: statusOptions.statusListVersion,
+                        },
+                        fetchList: true,
+                        publish: true,
+                        publishEncrypted: false,
+                        returnUpdatedStatusList: true,
+                        returnStatusListMetadata: true,
+                    });
+            }
         }
     }
-    async updateEncryptedStatusList2021(agent, did, statusOptions) {
+    async updateEncryptedStatusList(agent, did, listType, statusOptions) {
         // construct payment conditions
         const paymentConditions = (statusOptions?.paymentConditions
             ? statusOptions.paymentConditions.map((condition) => {
@@ -505,13 +707,13 @@ export class Veramo {
                     return undefined;
                 // validate relevant components - case: feePaymentAddress
                 if (!statusOptions.feePaymentAddress)
-                    throw new Error('updateEncryptedStatusList2021: feePaymentAddress is required');
+                    throw new Error('updateEncryptedStatusList: feePaymentAddress is required');
                 // validate relevant components - case: feePaymentAmount
                 if (!statusOptions.feePaymentAmount)
-                    throw new Error('updateEncryptedStatusList2021: feePaymentAmount is required');
+                    throw new Error('updateEncryptedStatusList: feePaymentAmount is required');
                 // validate relevant components - case: feePaymentWindow
                 if (!statusOptions.feePaymentWindow)
-                    throw new Error('updateEncryptedStatusList2021: feePaymentWindow is required');
+                    throw new Error('updateEncryptedStatusList: feePaymentWindow is required');
                 return [
                     {
                         feePaymentAddress: statusOptions.feePaymentAddress,
@@ -521,61 +723,83 @@ export class Veramo {
                     },
                 ];
             })());
-        switch (statusOptions.statusAction) {
-            case DefaultStatusActions.revoke:
-                return await agent.cheqdRevokeCredentials({
-                    revocationOptions: {
-                        issuerDid: did,
-                        statusListIndices: statusOptions.indices,
-                        statusListName: statusOptions.statusListName,
-                        statusListVersion: statusOptions.statusListVersion,
-                    },
-                    symmetricKey: statusOptions.symmetricKey,
-                    paymentConditions,
-                    fetchList: true,
-                    publish: true,
-                    publishEncrypted: true,
-                    returnSymmetricKey: true,
-                    returnUpdatedStatusList: true,
-                    returnStatusListMetadata: true,
-                    dkgOptions: toDefaultDkg(did),
-                });
-            case DefaultStatusActions.suspend:
-                return await agent.cheqdSuspendCredentials({
-                    suspensionOptions: {
-                        issuerDid: did,
-                        statusListIndices: statusOptions.indices,
-                        statusListName: statusOptions.statusListName,
-                        statusListVersion: statusOptions.statusListVersion,
-                    },
-                    symmetricKey: statusOptions.symmetricKey,
-                    paymentConditions,
-                    fetchList: true,
-                    publish: true,
-                    publishEncrypted: true,
-                    returnSymmetricKey: true,
-                    returnUpdatedStatusList: true,
-                    returnStatusListMetadata: true,
-                    dkgOptions: toDefaultDkg(did),
-                });
-            case DefaultStatusActions.reinstate:
-                return await agent.cheqdUnsuspendCredentials({
-                    unsuspensionOptions: {
-                        issuerDid: did,
-                        statusListIndices: statusOptions.indices,
-                        statusListName: statusOptions.statusListName,
-                        statusListVersion: statusOptions.statusListVersion,
-                    },
-                    symmetricKey: statusOptions.symmetricKey,
-                    paymentConditions,
-                    fetchList: true,
-                    publish: true,
-                    publishEncrypted: true,
-                    returnSymmetricKey: true,
-                    returnUpdatedStatusList: true,
-                    returnStatusListMetadata: true,
-                    dkgOptions: toDefaultDkg(did),
-                });
+        if (listType === StatusListType.Bitstring) {
+            return await agent.cheqdBulkUpdateCredentialsWithStatusList({
+                newStatus: BitstringStatusActions[statusOptions.statusAction],
+                updateOptions: {
+                    issuerDid: did,
+                    statusListIndices: statusOptions.indices,
+                    statusListName: statusOptions.statusListName,
+                    statusListVersion: statusOptions.statusListVersion,
+                },
+                symmetricKey: statusOptions.symmetricKey,
+                paymentConditions,
+                fetchList: true,
+                publish: true,
+                publishEncrypted: true,
+                returnSymmetricKey: true,
+                returnUpdatedStatusList: true,
+                returnStatusListMetadata: true,
+                dkgOptions: toDefaultDkg(did),
+            });
+        }
+        else {
+            switch (statusOptions.statusAction) {
+                case DefaultStatusActions.revoke:
+                    return await agent.cheqdRevokeCredentials({
+                        revocationOptions: {
+                            issuerDid: did,
+                            statusListIndices: statusOptions.indices,
+                            statusListName: statusOptions.statusListName,
+                            statusListVersion: statusOptions.statusListVersion,
+                        },
+                        symmetricKey: statusOptions.symmetricKey,
+                        paymentConditions,
+                        fetchList: true,
+                        publish: true,
+                        publishEncrypted: true,
+                        returnSymmetricKey: true,
+                        returnUpdatedStatusList: true,
+                        returnStatusListMetadata: true,
+                        dkgOptions: toDefaultDkg(did),
+                    });
+                case DefaultStatusActions.suspend:
+                    return await agent.cheqdSuspendCredentials({
+                        suspensionOptions: {
+                            issuerDid: did,
+                            statusListIndices: statusOptions.indices,
+                            statusListName: statusOptions.statusListName,
+                            statusListVersion: statusOptions.statusListVersion,
+                        },
+                        symmetricKey: statusOptions.symmetricKey,
+                        paymentConditions,
+                        fetchList: true,
+                        publish: true,
+                        publishEncrypted: true,
+                        returnSymmetricKey: true,
+                        returnUpdatedStatusList: true,
+                        returnStatusListMetadata: true,
+                        dkgOptions: toDefaultDkg(did),
+                    });
+                case DefaultStatusActions.reinstate:
+                    return await agent.cheqdUnsuspendCredentials({
+                        unsuspensionOptions: {
+                            issuerDid: did,
+                            statusListIndices: statusOptions.indices,
+                            statusListName: statusOptions.statusListName,
+                            statusListVersion: statusOptions.statusListVersion,
+                        },
+                        symmetricKey: statusOptions.symmetricKey,
+                        paymentConditions,
+                        fetchList: true,
+                        publish: true,
+                        publishEncrypted: true,
+                        returnSymmetricKey: true,
+                        returnUpdatedStatusList: true,
+                        returnStatusListMetadata: true,
+                        dkgOptions: toDefaultDkg(did),
+                    });
+            }
         }
     }
     async checkStatusList2021(agent, did, statusOptions) {
@@ -588,9 +812,16 @@ export class Veramo {
             dkgOptions: toDefaultDkg(did),
         });
     }
-    async searchStatusList2021(did, statusListName, statusPurpose) {
+    async searchStatusList(did, statusListName, listType, statusPurpose) {
+        let resourceType;
+        if (listType === StatusListType.Bitstring) {
+            resourceType = BitstringStatusListResourceType;
+        }
+        else {
+            resourceType = DefaultStatusList2021ResourceTypes[statusPurpose];
+        }
         // construct url
-        const url = new URL(`${process.env.RESOLVER_URL || DefaultResolverUrl}${did}?resourceName=${statusListName}&resourceType=${DefaultStatusList2021ResourceTypes[statusPurpose]}`);
+        const url = new URL(`${process.env.RESOLVER_URL || DefaultResolverUrl}${did}?resourceName=${statusListName}&resourceType=${resourceType}`);
         try {
             // fetch resource metadata
             const resourceMetadataVersioned = (await (await fetch(url, {
@@ -626,7 +857,7 @@ export class Veramo {
         }
         catch (error) {
             // silent fail
-            console.error(`searchStatusList2021: fetch: failed: ${error}`);
+            console.error(`searchStatusList: fetch: failed: ${error}`);
             // return result
             return {
                 found: false,