@cheqd/did-provider-cheqd 4.5.4 → 4.6.0-develop.1

package/build/esm/agent/ICheqd.js

@@ -3,15 +3,16 @@
 // unused vars are kept by convention
 // non-null assertion is used when we know better than the compiler that the value is not null or undefined
 import { CheqdNetwork, ResourceModule, createDidPayload, createDidVerificationMethod, createKeyPairBase64, createKeyPairHex, createVerificationKeys, } from '@cheqd/sdk';
-import { DefaultRESTUrls, DefaultStatusList2021Encodings, DefaultStatusList2021ResourceTypes, DefaultStatusList2021StatusPurposeTypes, } from '../did-manager/cheqd-did-provider.js';
+import { DefaultRESTUrls, DefaultStatusListEncodings, DefaultStatusList2021ResourceTypes, DefaultStatusList2021StatusPurposeTypes, BitstringStatusPurposeTypes, BitstringStatusListResourceType, } from '../did-manager/cheqd-did-provider.js';
 import { fromString, toString } from 'uint8arrays';
 import { decodeJWT } from 'did-jwt';
 import { StatusList } from '@digitalbazaar/vc-status-list';
+import { Bitstring as DBBitstring } from '@digitalbazaar/bitstring';
 import { v4 } from 'uuid';
 import fs from 'fs';
 import Debug from 'debug';
 import { LitCompatibleCosmosChains, LitProtocol, } from '../dkg-threshold/lit-protocol/v6.js';
-import { blobToHexString, getEncodedList, isEncodedList, randomFromRange, safeDeserialise, toBlob, } from '../utils/helpers.js';
+import { blobToHexString, decodeWithMetadata, encodeWithMetadata, generateRandomStatusListIndex, getEncodedList, isEncodedList, isValidEncodedBitstring, randomFromRange, safeDeserialise, toBlob, } from '../utils/helpers.js';
 import { DefaultResolverUrl } from '../did-manager/cheqd-did-resolver.js';
 import { LitNetworksV2, LitProtocolV2 } from '../dkg-threshold/lit-protocol/v2.js';
 const debug = Debug('veramo:did-provider-cheqd');
@@ -41,6 +42,16 @@ export const GenerateVersionIdMethodName = 'cheqdGenerateVersionId';
 export const GenerateStatusList2021MethodName = 'cheqdGenerateStatusList2021';
 export const IssueRevocableCredentialWithStatusList2021MethodName = 'cheqdIssueRevocableCredentialWithStatusList2021';
 export const IssueSuspendableCredentialWithStatusList2021MethodName = 'cheqdIssueSuspendableCredentialWithStatusList2021';
+export const CreateStatusListMethodName = 'cheqdCreateStatusList';
+export const BroadcastStatusListMethodName = 'cheqdBroadcastStatusList';
+export const GenerateStatusListMethodName = 'cheqdGenerateStatusList';
+export const VerifyStatusListCredentialMethodName = 'cheqdVerifyStatusListCredential';
+export const IssueCredentialWithStatusListMethodName = 'cheqdIssueCredentialWithStatusList';
+export const VerifyCredentialWithStatusListMethodName = 'cheqdVerifyCredentialWithStatusList';
+export const UpdateCredentialWithStatusListMethodName = 'cheqdUpdateCredentialWithStatusList';
+export const BulkUpdateCredentialsWithStatusListMethodName = 'cheqdBulkUpdateCredentialsWithStatusList';
+export const VerifyPresentationWithStatusListMethodName = 'cheqdVerifyPresentationWithStatusList';
+// END: TODO, start Remove or update with status list 2021
 export const VerifyCredentialMethodName = 'cheqdVerifyCredential';
 export const VerifyPresentationMethodName = 'cheqdVerifyPresentation';
 export const CheckCredentialStatusMethodName = 'cheqdCheckCredentialStatus';
@@ -50,12 +61,20 @@ export const SuspendCredentialMethodName = 'cheqdSuspendCredential';
 export const SuspendCredentialsMethodName = 'cheqdSuspendCredentials';
 export const UnsuspendCredentialMethodName = 'cheqdUnsuspendCredential';
 export const UnsuspendCredentialsMethodName = 'cheqdUnsuspendCredentials';
+// END: Remove or update with status list 2021
 export const TransactSendTokensMethodName = 'cheqdTransactSendTokens';
 export const ObservePaymentConditionMethodName = 'cheqdObservePaymentCondition';
 export const MintCapacityCreditMethodName = 'cheqdMintCapacityCredit';
 export const DelegateCapacityCreditMethodName = 'cheqdDelegateCapacityCredit';
 export const DidPrefix = 'did';
 export const CheqdDidMethod = 'cheqd';
+export var BitstringStatusValue;
+(function (BitstringStatusValue) {
+    BitstringStatusValue[BitstringStatusValue["VALID"] = 0] = "VALID";
+    BitstringStatusValue[BitstringStatusValue["REVOKED"] = 1] = "REVOKED";
+    BitstringStatusValue[BitstringStatusValue["SUSPENDED"] = 2] = "SUSPENDED";
+    BitstringStatusValue[BitstringStatusValue["UNKNOWN"] = 3] = "UNKNOWN";
+})(BitstringStatusValue || (BitstringStatusValue = {}));
 export class Cheqd {
     methods;
     schema = {
@@ -142,6 +161,22 @@ export class Cheqd {
                         type: 'object',
                     },
                 },
+                cheqdCreateStatusList: {
+                    description: 'Create a new Bitstring Status List',
+                    arguments: {
+                        type: 'object',
+                        properties: {
+                            args: {
+                                type: 'object',
+                                description: 'A cheqdCreateBitstringStatusListArgs object as any for extensibility',
+                            },
+                        },
+                        required: ['args'],
+                    },
+                    returnType: {
+                        type: 'object',
+                    },
+                },
                 cheqdBroadcastStatusList2021: {
                     description: 'Broadcast a Status List 2021 to cheqd ledger',
                     arguments: {
@@ -149,7 +184,23 @@ export class Cheqd {
                         properties: {
                             args: {
                                 type: 'object',
-                                description: 'A cheqdBroadcastStatusList2021Args object as any for extensibility',
+                                description: 'A cheqdBroadcastStatusListArgs object as any for extensibility',
+                            },
+                        },
+                        required: ['args'],
+                    },
+                    returnType: {
+                        type: 'object',
+                    },
+                },
+                cheqdBroadcastStatusList: {
+                    description: 'Broadcast a Bitstring Status List to cheqd ledger',
+                    arguments: {
+                        type: 'object',
+                        properties: {
+                            args: {
+                                type: 'object',
+                                description: 'A cheqdBroadcastStatusListArgs object as any for extensibility',
                             },
                         },
                         required: ['args'],
@@ -235,6 +286,37 @@ export class Cheqd {
                         type: 'string',
                     },
                 },
+                cheqdGenerateStatusList: {
+                    description: 'Generate a new Bitstring Status List',
+                    arguments: {
+                        type: 'object',
+                        properties: {
+                            args: {
+                                type: 'object',
+                                description: 'A cheqdGenerateStatusListArgs object as any for extensibility',
+                            },
+                        },
+                    },
+                    returnType: {
+                        type: 'string',
+                    },
+                },
+                cheqdIssueCredentialWithStatusList: {
+                    description: 'Issue a revocable or suspendable credential with a Bitstring Status List as credential status registry',
+                    arguments: {
+                        type: 'object',
+                        properties: {
+                            args: {
+                                type: 'object',
+                                description: 'A cheqdIssueCredentialWithStatusListArgs object as any for extensibility',
+                            },
+                        },
+                        required: ['args'],
+                    },
+                    returnType: {
+                        type: 'object',
+                    },
+                },
                 cheqdIssueRevocableCredentialWithStatusList2021: {
                     description: 'Issue a revocable credential with a Status List 2021 as credential status registry',
                     arguments: {
@@ -242,7 +324,7 @@ export class Cheqd {
                         properties: {
                             args: {
                                 type: 'object',
-                                description: 'A cheqdIssueCredentialWithStatusList2021Args object as any for extensibility',
+                                description: 'A cheqdIssueRevocableCredentialWithStatusList2021Args object as any for extensibility',
                             },
                         },
                         required: ['args'],
@@ -258,7 +340,7 @@ export class Cheqd {
                         properties: {
                             args: {
                                 type: 'object',
-                                description: 'A cheqdIssueCredentialWithStatusList2021Args object as any for extensibility',
+                                description: 'A cheqdIssueSuspendableCredentialWithStatusList2021Args object as any for extensibility',
                             },
                         },
                         required: ['args'],
@@ -274,7 +356,23 @@ export class Cheqd {
                         properties: {
                             args: {
                                 type: 'object',
-                                description: 'A cheqdVerifyCredentialWithStatusList2021Args object as any for extensibility',
+                                description: 'A cheqdVerifyCredentialWithStatusListArgs object as any for extensibility',
+                            },
+                        },
+                        required: ['args'],
+                    },
+                    returnType: {
+                        type: 'object',
+                    },
+                },
+                cheqdVerifyCredentialWithStatusList: {
+                    description: 'Verify a credential, enhanced by revocation / suspension check with a Bitstring Status List as credential status registry',
+                    arguments: {
+                        type: 'object',
+                        properties: {
+                            args: {
+                                type: 'object',
+                                description: 'A cheqdVerifyCredentialWithStatusListArgs object as any for extensibility',
                             },
                         },
                         required: ['args'],
@@ -290,7 +388,7 @@ export class Cheqd {
                         properties: {
                             args: {
                                 type: 'object',
-                                description: 'A cheqdVerifyPresentationWithStatusList2021Args object as any for extensibility',
+                                description: 'A cheqdVerifyPresentationWithStatusListArgs object as any for extensibility',
                             },
                         },
                         required: ['args'],
@@ -306,7 +404,7 @@ export class Cheqd {
                         properties: {
                             args: {
                                 type: 'object',
-                                description: 'A cheqdCheckCredentialStatusWithStatusList2021Args object as any for extensibility',
+                                description: 'A cheqdCheckCredentialStatusWithStatusListArgs object as any for extensibility',
                             },
                         },
                         required: ['args'],
@@ -322,7 +420,7 @@ export class Cheqd {
                         properties: {
                             args: {
                                 type: 'object',
-                                description: 'A cheqdRevokeCredentialWithStatusList2021Args object as any for extensibility',
+                                description: 'A cheqdRevokeCredentialWithStatusListArgs object as any for extensibility',
                             },
                         },
                         required: ['args'],
@@ -338,7 +436,7 @@ export class Cheqd {
                         properties: {
                             args: {
                                 type: 'object',
-                                description: 'A cheqdRevokeBulkCredentialsWithStatusList2021Args object as any for extensibility',
+                                description: 'A cheqdRevokeBulkCredentialsWithStatusListArgs object as any for extensibility',
                             },
                         },
                         required: ['args'],
@@ -354,7 +452,7 @@ export class Cheqd {
                         properties: {
                             args: {
                                 type: 'object',
-                                description: 'A cheqdSuspendCredentialWithStatusList2021Args object as any for extensibility',
+                                description: 'A cheqdSuspendCredentialWithStatusListArgs object as any for extensibility',
                             },
                         },
                         required: ['args'],
@@ -370,7 +468,7 @@ export class Cheqd {
                         properties: {
                             args: {
                                 type: 'object',
-                                description: 'A cheqdSuspendBulkCredentialsWithStatusList2021Args object as any for extensibility',
+                                description: 'A cheqdSuspendBulkCredentialsWithStatusListArgs object as any for extensibility',
                             },
                         },
                         required: ['args'],
@@ -386,7 +484,7 @@ export class Cheqd {
                         properties: {
                             args: {
                                 type: 'object',
-                                description: 'cheqdUnsuspendCredentialWithStatusList2021Args object as any for extensibility',
+                                description: 'cheqdUnsuspendCredentialWithStatusListArgs object as any for extensibility',
                             },
                         },
                         required: ['args'],
@@ -402,7 +500,7 @@ export class Cheqd {
                         properties: {
                             args: {
                                 type: 'object',
-                                description: 'A cheqdUnsuspendBulkCredentialsWithStatusList2021Args object as any for extensibility',
+                                description: 'A cheqdUnsuspendBulkCredentialsWithStatusListArgs object as any for extensibility',
                             },
                         },
                         required: ['args'],
@@ -449,9 +547,19 @@ export class Cheqd {
     supportedDidProviders;
     didProvider;
     providerId;
+    // Deprecate below constants in future versions
     static defaultStatusList2021Length = 16 * 1024 * 8; // 16KB in bits or 131072 bits / entries
     static defaultContextV1 = 'https://www.w3.org/2018/credentials/v1';
     static statusList2021Context = 'https://w3id.org/vc-status-list-2021/v1';
+    // END: Deprecate
+    static DefaultBitstringContexts = {
+        v2: 'https://www.w3.org/ns/credentials/v2',
+        statusList: 'https://www.w3.org/ns/credentials/status/v1',
+    };
+    // Default bitstring status list size in bits
+    static DefaultBitstringStatusSize = 2; // 2 bits per credential (0, 1, 2, 3)
+    // Minimum bitstring length for compliance
+    static DefaultBitstringLength = 16 * 1024 * 8; // 16KB in bits or 131072 bits (spec minimum)
     constructor(args) {
         if (typeof args.providers !== 'object') {
             throw new Error('[did-provider-cheqd]: at least one did provider is required');
@@ -466,16 +574,25 @@ export class Cheqd {
             [CreateResourceMethodName]: this.CreateResource.bind(this),
             [CreateStatusList2021MethodName]: this.CreateStatusList2021.bind(this),
             [BroadcastStatusList2021MethodName]: this.BroadcastStatusList2021.bind(this),
+            [CreateStatusListMethodName]: this.CreateBitstringStatusList.bind(this),
+            [BroadcastStatusListMethodName]: this.BroadcastBitstringStatusList.bind(this),
             [GenerateDidDocMethodName]: this.GenerateDidDoc.bind(this),
             [GenerateDidDocWithLinkedResourceMethodName]: this.GenerateDidDocWithLinkedResource.bind(this),
             [GenerateKeyPairMethodName]: this.GenerateIdentityKeys.bind(this),
             [GenerateVersionIdMethodName]: this.GenerateVersionId.bind(this),
             [GenerateStatusList2021MethodName]: this.GenerateStatusList2021.bind(this),
+            [GenerateStatusListMethodName]: this.GenerateBitstringStatusList.bind(this),
+            [VerifyStatusListCredentialMethodName]: this.VerifyStatusListCredential.bind(this),
+            [IssueCredentialWithStatusListMethodName]: this.IssueCredentialWithBitstringStatusList.bind(this),
             [IssueRevocableCredentialWithStatusList2021MethodName]: this.IssueRevocableCredentialWithStatusList2021.bind(this),
             [IssueSuspendableCredentialWithStatusList2021MethodName]: this.IssueSuspendableCredentialWithStatusList2021.bind(this),
             [VerifyCredentialMethodName]: this.VerifyCredentialWithStatusList2021.bind(this),
+            [VerifyCredentialWithStatusListMethodName]: this.VerifyCredentialWithBitstringStatusList.bind(this),
             [VerifyPresentationMethodName]: this.VerifyPresentationWithStatusList2021.bind(this),
             [CheckCredentialStatusMethodName]: this.CheckCredentialStatusWithStatusList2021.bind(this),
+            [VerifyPresentationWithStatusListMethodName]: this.VerifyPresentationWithBitstringStatusList.bind(this),
+            [UpdateCredentialWithStatusListMethodName]: this.UpdateCredentialWithStatusList.bind(this),
+            [BulkUpdateCredentialsWithStatusListMethodName]: this.BulkUpdateCredentialsWithStatusList.bind(this),
             [RevokeCredentialMethodName]: this.RevokeCredentialWithStatusList2021.bind(this),
             [RevokeCredentialsMethodName]: this.RevokeBulkCredentialsWithStatusList2021.bind(this),
             [SuspendCredentialMethodName]: this.SuspendCredentialWithStatusList2021.bind(this),
@@ -614,8 +731,8 @@ export class Cheqd {
             if (typeof args.statusListEncoding !== 'string') {
                 throw new Error('[did-provider-cheqd]: statusListEncoding must be string');
             }
-            if (!Object.values(DefaultStatusList2021Encodings).includes(args.statusListEncoding)) {
-                throw new Error(`[did-provider-cheqd]: statusListEncoding must be one of ${Object.values(DefaultStatusList2021Encodings).join(', ')}`);
+            if (!Object.values(DefaultStatusListEncodings).includes(args.statusListEncoding)) {
+                throw new Error(`[did-provider-cheqd]: statusListEncoding must be one of ${Object.values(DefaultStatusListEncodings).join(', ')}`);
             }
         }
         // validate validUntil
@@ -661,13 +778,13 @@ export class Cheqd {
         // generate bitstring
         const bitstring = await context.agent[GenerateStatusList2021MethodName]({
             length: args?.statusListLength || Cheqd.defaultStatusList2021Length,
-            bitstringEncoding: args?.statusListEncoding || DefaultStatusList2021Encodings.base64url,
+            bitstringEncoding: args?.statusListEncoding || DefaultStatusListEncodings.base64url,
         });
         // construct data and metadata tuple
         const data = args.encrypted
             ? await (async function (that) {
                 // encrypt bitstring - case: symmetric
-                const { encryptedString: symmetricEncryptionCiphertext, symmetricKey } = await LitProtocol.encryptDirect(fromString(bitstring, args?.statusListEncoding || DefaultStatusList2021Encodings.base64url));
+                const { encryptedString: symmetricEncryptionCiphertext, symmetricKey } = await LitProtocol.encryptDirect(fromString(bitstring, args?.statusListEncoding || DefaultStatusListEncodings.base64url));
                 // instantiate dkg-threshold client, in which case lit-protocol is used
                 const lit = await provider.instantiateDkgThresholdProtocolClient({});
                 // construct access control conditions
@@ -684,7 +801,7 @@ export class Cheqd {
                     }
                 }));
                 // encrypt bitstring - case: threshold
-                const { encryptedString: thresholdEncryptionCiphertext, stringHash } = await lit.encrypt(fromString(bitstring, args?.statusListEncoding || DefaultStatusList2021Encodings.base64url), unifiedAccessControlConditions);
+                const { encryptedString: thresholdEncryptionCiphertext, stringHash } = await lit.encrypt(fromString(bitstring, args?.statusListEncoding || DefaultStatusListEncodings.base64url), unifiedAccessControlConditions);
                 // construct encoded list
                 const encodedList = `${await blobToHexString(symmetricEncryptionCiphertext)}-${toString(thresholdEncryptionCiphertext, 'hex')}`;
                 // return result tuple
@@ -701,7 +818,7 @@ export class Cheqd {
                                 metadata: {
                                     type: DefaultStatusList2021ResourceTypes.revocation,
                                     encrypted: true,
-                                    encoding: args?.statusListEncoding || DefaultStatusList2021Encodings.base64url,
+                                    encoding: args?.statusListEncoding || DefaultStatusListEncodings.base64url,
                                     statusListHash: stringHash,
                                     paymentConditions: args.paymentConditions,
                                 },
@@ -725,7 +842,7 @@ export class Cheqd {
                                 metadata: {
                                     type: DefaultStatusList2021ResourceTypes.suspension,
                                     encrypted: true,
-                                    encoding: args?.statusListEncoding || DefaultStatusList2021Encodings.base64url,
+                                    encoding: args?.statusListEncoding || DefaultStatusListEncodings.base64url,
                                     statusListHash: stringHash,
                                     paymentConditions: args.paymentConditions,
                                 },
@@ -755,7 +872,7 @@ export class Cheqd {
                                 metadata: {
                                     type: DefaultStatusList2021ResourceTypes.revocation,
                                     encrypted: false,
-                                    encoding: args?.statusListEncoding || DefaultStatusList2021Encodings.base64url,
+                                    encoding: args?.statusListEncoding || DefaultStatusListEncodings.base64url,
                                 },
                             },
                             undefined,
@@ -772,7 +889,7 @@ export class Cheqd {
                                 metadata: {
                                     type: DefaultStatusList2021ResourceTypes.suspension,
                                     encrypted: false,
-                                    encoding: args?.statusListEncoding || DefaultStatusList2021Encodings.base64url,
+                                    encoding: args?.statusListEncoding || DefaultStatusListEncodings.base64url,
                                 },
                             },
                             undefined,
@@ -799,7 +916,7 @@ export class Cheqd {
                 network: network,
             }),
             resource: data[0],
-            resourceMetadata: await Cheqd.fetchStatusList2021Metadata({
+            resourceMetadata: await Cheqd.fetchStatusListMetadata({
                 credentialStatus: {
                     id: `${DefaultResolverUrl}${args.issuerDid}?resourceName=${args.statusListName}&resourceType=${DefaultStatusList2021ResourceTypes[args.statusPurpose]}`,
                     type: 'StatusList2021Entry',
@@ -827,8 +944,250 @@ export class Cheqd {
         }
         // TODO: validate data as per bitstring
         // validate resource type
-        if (!Object.values(DefaultStatusList2021ResourceTypes).includes(args?.payload?.resourceType)) {
-            throw new Error(`[did-provider-cheqd]: resourceType must be one of ${Object.values(DefaultStatusList2021ResourceTypes).join(', ')}`);
+        const allowedTypes = [...Object.values(DefaultStatusList2021ResourceTypes), 'BitstringStatusListCredential'];
+        if (!Object.values(allowedTypes).includes(args?.payload?.resourceType)) {
+            throw new Error(`[did-provider-cheqd]: resourceType must be one of ${Object.values(allowedTypes).join(', ')}`);
+        }
+        this.providerId = Cheqd.generateProviderId(args.network);
+        this.didProvider = await Cheqd.getProviderFromNetwork(args.network, this.supportedDidProviders);
+        return await this.didProvider.createResource({
+            options: {
+                kms: args.kms,
+                payload: args.payload,
+                signInputs: args.signInputs,
+                fee: args?.fee ||
+                    (await ResourceModule.generateCreateResourceJsonFees((await this.didProvider.getWalletAccounts())[0].address)),
+            },
+        }, context);
+    }
+    async CreateBitstringStatusList(args, context) {
+        if (typeof args.kms !== 'string') {
+            throw new Error('[did-provider-cheqd]: kms is required');
+        }
+        if (typeof args.issuerDid !== 'string' || !args.issuerDid) {
+            throw new Error('[did-provider-cheqd]: issuerDid is required');
+        }
+        if (typeof args.statusListName !== 'string' || !args.statusListName) {
+            throw new Error('[did-provider-cheqd]: statusListName is required');
+        }
+        if (!args.statusPurpose) {
+            throw new Error('[did-provider-cheqd]: statusPurpose is required');
+        }
+        if (typeof args.encrypted === 'undefined') {
+            throw new Error('[did-provider-cheqd]: encrypted is required');
+        }
+        // validate statusPurpose
+        const statusPurpose = Array.isArray(args.statusPurpose) ? args.statusPurpose[0] : args.statusPurpose;
+        if (!Object.values(BitstringStatusPurposeTypes).includes(statusPurpose)) {
+            throw new Error(`[did-provider-cheqd]: statusPurpose must be in ${Object.values(BitstringStatusPurposeTypes).join(', ')}`);
+        }
+        // validate statusListLength
+        if (args?.statusListLength) {
+            if (typeof args.statusListLength !== 'number') {
+                throw new Error('[did-provider-cheqd]: statusListLength must be number');
+            }
+            if (args.statusListLength < Cheqd.DefaultBitstringLength) {
+                throw new Error(`[did-provider-cheqd]: statusListLength must be greater than or equal to ${Cheqd.DefaultBitstringLength} number of entries`);
+            }
+        }
+        // validate statusListEncoding, W3C spec only supports base64url encoding
+        if (args?.statusListEncoding) {
+            if (typeof args.statusListEncoding !== 'string') {
+                throw new Error('[did-provider-cheqd]: statusListEncoding must be string');
+            }
+            if (args.statusListEncoding !== DefaultStatusListEncodings.base64url) {
+                throw new Error(`[did-provider-cheqd]: statusListEncoding must be ${DefaultStatusListEncodings.base64url}`);
+            }
+        }
+        // validate validUntil
+        if (args?.validUntil) {
+            if (typeof args.validUntil !== 'string') {
+                throw new Error('[did-provider-cheqd]: validUntil must be string');
+            }
+            if (new Date() <= new Date(args.validUntil)) {
+                throw new Error('[did-provider-cheqd]: validUntil must be greater than current date');
+            }
+        }
+        // validate args in pairs - case: encrypted
+        if (args.encrypted) {
+            // validate paymentConditions
+            if (!args?.paymentConditions ||
+                !args?.paymentConditions?.length ||
+                !Array.isArray(args?.paymentConditions) ||
+                args?.paymentConditions.length === 0) {
+                throw new Error('[did-provider-cheqd]: paymentConditions is required');
+            }
+            if (!args?.paymentConditions?.every((condition) => condition.feePaymentAddress && condition.feePaymentAmount && condition.intervalInSeconds)) {
+                throw new Error('[did-provider-cheqd]: paymentConditions must contain feePaymentAddress and feeAmount and intervalInSeconds');
+            }
+            if (!args?.paymentConditions?.every((condition) => typeof condition.feePaymentAddress === 'string' &&
+                typeof condition.feePaymentAmount === 'string' &&
+                typeof condition.intervalInSeconds === 'number')) {
+                throw new Error('[did-provider-cheqd]: feePaymentAddress and feePaymentAmount must be string and intervalInSeconds must be number');
+            }
+            if (!args?.paymentConditions?.every((condition) => condition.type === AccessControlConditionTypes.timelockPayment)) {
+                throw new Error('[did-provider-cheqd]: paymentConditions must be of type timelockPayment');
+            }
+        }
+        // get network
+        const network = args.issuerDid.split(':')[2];
+        // define provider
+        const provider = (function (that) {
+            // switch on network
+            return (that.supportedDidProviders.find((provider) => provider.network === network) ||
+                (function () {
+                    throw new Error(`[did-provider-cheqd]: no relevant providers found`);
+                })());
+        })(this);
+        // generate bitstring
+        const bitstring = await context.agent[GenerateStatusListMethodName]({
+            statusSize: args?.statusSize,
+            length: args?.statusListLength,
+            bitstringEncoding: args?.statusListEncoding || DefaultStatusListEncodings.base64url,
+        });
+        // Generate proof without credentialSubject.encodedList property
+        const issuanceOptions = {
+            credential: {
+                '@context': [Cheqd.defaultContextV1], // TODO: use v2 context when v2 credential support enabled
+                type: ['VerifiableCredential', BitstringStatusListResourceType],
+                issuer: args.issuerDid,
+                issuanceDate: new Date().toISOString(),
+                expirationDate: args?.validUntil,
+                credentialSubject: {
+                    type: 'BitstringStatusList',
+                    statusPurpose: args.statusPurpose,
+                    ttl: args?.ttl,
+                },
+            },
+            proofFormat: 'jwt',
+        };
+        const issued = await context.agent.createVerifiableCredential(issuanceOptions);
+        // construct data and metadata tuple
+        const data = args.encrypted
+            ? await (async function (that) {
+                // encrypt bitstring - case: symmetric
+                const { encryptedString: symmetricEncryptionCiphertext, symmetricKey } = await LitProtocol.encryptDirect(fromString(bitstring, args?.statusListEncoding || DefaultStatusListEncodings.base64url));
+                // instantiate dkg-threshold client, in which case lit-protocol is used
+                const lit = await provider.instantiateDkgThresholdProtocolClient({});
+                // construct access control conditions
+                const unifiedAccessControlConditions = await Promise.all(args.paymentConditions.map(async (condition) => {
+                    switch (condition.type) {
+                        case AccessControlConditionTypes.timelockPayment:
+                            return await LitProtocol.generateCosmosAccessControlConditionInverseTimelock({
+                                key: '$.tx_responses.*.timestamp',
+                                comparator: '<=',
+                                value: `${condition.intervalInSeconds}`,
+                            }, condition.feePaymentAmount, condition.feePaymentAddress, condition?.blockHeight, args?.dkgOptions?.chain || that.didProvider.dkgOptions.chain);
+                        default:
+                            throw new Error(`[did-provider-cheqd]: unsupported access control condition type ${condition.type}`);
+                    }
+                }));
+                // encrypt bitstring - case: threshold
+                const { encryptedString: thresholdEncryptionCiphertext, stringHash } = await lit.encrypt(fromString(bitstring, args?.statusListEncoding || DefaultStatusListEncodings.base64url), unifiedAccessControlConditions);
+                // construct encoded list
+                const { encodedList, symmetricLength } = await encodeWithMetadata(symmetricEncryptionCiphertext, thresholdEncryptionCiphertext);
+                issued.credentialSubject = {
+                    type: 'BitstringStatusList',
+                    statusPurpose: args.statusPurpose,
+                    encodedList,
+                    ttl: args?.ttl,
+                };
+                // return result tuple
+                return [
+                    {
+                        bitstringStatusListCredential: issued,
+                        metadata: {
+                            encrypted: true,
+                            encoding: args?.statusListEncoding || DefaultStatusListEncodings.base64url,
+                            length: args?.statusListLength || Cheqd.DefaultBitstringLength,
+                            statusSize: args?.statusSize,
+                            statusMessages: args?.statusMessages || [],
+                            statusListHash: stringHash,
+                            symmetricLength,
+                            paymentConditions: args.paymentConditions,
+                        },
+                    },
+                    {
+                        symmetricEncryptionCiphertext: await blobToHexString(symmetricEncryptionCiphertext),
+                        thresholdEncryptionCiphertext: toString(thresholdEncryptionCiphertext, 'hex'),
+                        stringHash,
+                        symmetricKey: toString(symmetricKey, 'hex'),
+                    },
+                ];
+            })(this)
+            : await (async function () {
+                issued.credentialSubject = {
+                    type: 'BitstringStatusList',
+                    statusPurpose: args.statusPurpose,
+                    encodedList: bitstring,
+                    ttl: args?.ttl,
+                };
+                return [
+                    {
+                        bitstringStatusListCredential: issued,
+                        metadata: {
+                            encrypted: false,
+                            encoding: args?.statusListEncoding || DefaultStatusListEncodings.base64url,
+                            length: args?.statusListLength || Cheqd.DefaultBitstringLength,
+                            statusSize: args?.statusSize,
+                            statusMessages: args?.statusMessages || [],
+                        },
+                    },
+                    undefined,
+                ];
+            })();
+        // construct payload
+        const payload = {
+            id: v4(),
+            collectionId: args.issuerDid.split(':').reverse()[0],
+            name: args.statusListName,
+            resourceType: BitstringStatusListResourceType,
+            version: args?.resourceVersion || new Date().toISOString(),
+            alsoKnownAs: args?.alsoKnownAs || [],
+            data: fromString(JSON.stringify(data[0]), 'utf-8'),
+        };
+        // return result
+        return {
+            created: await context.agent[BroadcastStatusListMethodName]({
+                kms: args.kms,
+                payload,
+                network: network,
+            }),
+            resource: data[0],
+            resourceMetadata: await Cheqd.fetchStatusListMetadata({
+                credentialStatus: {
+                    id: `${DefaultResolverUrl}${args.issuerDid}?resourceName=${args.statusListName}&resourceType=${BitstringStatusListResourceType}`,
+                },
+            }),
+            encrypted: args.encrypted,
+            symmetricKey: args.encrypted && args.returnSymmetricKey ? data[1]?.symmetricKey : undefined,
+        };
+    }
+    async BroadcastBitstringStatusList(args, context) {
+        if (typeof args.kms !== 'string') {
+            throw new Error('[did-provider-cheqd]: kms is required');
+        }
+        if (typeof args.payload !== 'object') {
+            throw new Error('[did-provider-cheqd]: payload object is required');
+        }
+        if (typeof args.network !== 'string') {
+            throw new Error('[did-provider-cheqd]: network is required');
+        }
+        if (args?.file) {
+            args.payload.data = await Cheqd.getFile(args.file);
+        }
+        if (typeof args?.payload?.data === 'string') {
+            args.payload.data = fromString(args.payload.data, 'base64');
+        }
+        // Validate that data is present
+        if (!args.payload.data) {
+            throw new Error('[did-provider-cheqd]: payload.data is required for Bitstring Status List');
+        }
+        // Validate and parse the Bitstring Status List data
+        await this.validateBitstringStatusListPayload(args.payload);
+        // Validate against resource type
+        if (args?.payload?.resourceType !== BitstringStatusListResourceType) {
+            throw new Error(`[did-provider-cheqd]: resourceType must be ${BitstringStatusListResourceType}`);
         }
         this.providerId = Cheqd.generateProviderId(args.network);
         this.didProvider = await Cheqd.getProviderFromNetwork(args.network, this.supportedDidProviders);
@@ -842,6 +1201,115 @@ export class Cheqd {
             },
         }, context);
     }
+    /**
+     * Validate Bitstring Status List payload structure and content
+     */
+    async validateBitstringStatusListPayload(payload) {
+        if (!payload.data) {
+            throw new Error('[did-provider-cheqd]: payload.data is required');
+        }
+        let bitstringData;
+        try {
+            // Parse the data as BitstringStatusList
+            const dataString = typeof payload.data === 'string' ? payload.data : toString(payload.data, 'utf-8');
+            bitstringData = JSON.parse(dataString);
+        }
+        catch (error) {
+            throw new Error(`[did-provider-cheqd]: Invalid BitstringStatusList data format: ${error.message}`);
+        }
+        const metadata = bitstringData.metadata;
+        const bitstringCredential = bitstringData.bitstringStatusListCredential;
+        // Validate required properties
+        if (!bitstringCredential.credentialSubject.statusPurpose) {
+            throw new Error('[did-provider-cheqd]: statusPurpose is required');
+        }
+        if (!bitstringCredential.credentialSubject.encodedList) {
+            throw new Error('[did-provider-cheqd]: encodedList is required');
+        }
+        if (!bitstringCredential.issuanceDate) {
+            throw new Error('[did-provider-cheqd]: issuanceDate is required');
+        }
+        // Validate status purpose
+        const statusPurpose = Array.isArray(bitstringCredential.credentialSubject.statusPurpose)
+            ? bitstringCredential.credentialSubject.statusPurpose[0]
+            : bitstringCredential.credentialSubject.statusPurpose;
+        if (!Object.values(BitstringStatusPurposeTypes).includes(statusPurpose)) {
+            throw new Error(`[did-provider-cheqd]: Invalid statusPurpose. Must be in: ${Object.values(BitstringStatusPurposeTypes).join(', ')}`);
+        }
+        // Validate encoded list format (should be base64url encoded)
+        if (!isValidEncodedBitstring(bitstringCredential.credentialSubject.encodedList)) {
+            throw new Error('[did-provider-cheqd]: Invalid encodedList format. Must be base64url encoded GZIP compressed bitstring');
+        }
+        // Validate dates
+        try {
+            new Date(bitstringCredential.issuanceDate);
+            if (bitstringCredential.expirationDate) {
+                const validUntil = new Date(bitstringCredential.expirationDate);
+                const validFrom = new Date(bitstringCredential.issuanceDate);
+                if (validUntil <= validFrom) {
+                    throw new Error('[did-provider-cheqd]: expirationDate must be after issuanceDate');
+                }
+            }
+        }
+        catch (error) {
+            throw new Error(`[did-provider-cheqd]: Invalid date format: ${error.message}`);
+        }
+        // Validate status size if present
+        if (metadata.statusSize !== undefined) {
+            if (![1, 2, 4, 8].includes(metadata.statusSize)) {
+                throw new Error('[did-provider-cheqd]: statusSize must be 1, 2, 4, or 8 bits');
+            }
+            // Validate status messages for multi-bit status
+            if (metadata.statusSize > 1) {
+                await this.validateStatusMessagesInPayload(metadata.statusMessages, metadata.statusSize);
+            }
+        }
+        // Validate TTL if present
+        if (bitstringCredential.credentialSubject.ttl !== undefined) {
+            if (typeof bitstringCredential.credentialSubject.ttl !== 'number' ||
+                bitstringCredential.credentialSubject.ttl < 0) {
+                throw new Error('[did-provider-cheqd]: ttl must be a non-negative number');
+            }
+        }
+    }
+    /**
+     * Validate status messages for multi-bit status
+     */
+    async validateStatusMessagesInPayload(statusMessages, statusSize) {
+        if (statusSize <= 1) {
+            return; // No validation needed for single-bit status
+        }
+        const expectedMessageCount = Math.pow(2, statusSize);
+        if (!statusMessages || statusMessages.length === 0) {
+            throw new Error(`[did-provider-cheqd]: statusMessages is required for ${statusSize}-bit status (expected ${expectedMessageCount} messages)`);
+        }
+        if (statusMessages.length !== expectedMessageCount) {
+            throw new Error(`[did-provider-cheqd]: statusMessages must have exactly ${expectedMessageCount} entries for ${statusSize}-bit status`);
+        }
+        // Validate each status message
+        const expectedStatuses = new Set();
+        for (let i = 0; i < expectedMessageCount; i++) {
+            expectedStatuses.add(`0x${i.toString(16).toLowerCase()}`);
+        }
+        const actualStatuses = new Set(statusMessages.map((msg) => msg.status));
+        for (const expected of expectedStatuses) {
+            if (!actualStatuses.has(expected)) {
+                throw new Error(`[did-provider-cheqd]: Missing status message for value ${expected}`);
+            }
+        }
+        // Validate message format
+        for (const statusMsg of statusMessages) {
+            if (!statusMsg.status || !statusMsg.message) {
+                throw new Error('[did-provider-cheqd]: Each status message must have both status and message properties');
+            }
+            if (typeof statusMsg.status !== 'string' || typeof statusMsg.message !== 'string') {
+                throw new Error('[did-provider-cheqd]: status and message must be strings');
+            }
+            if (!statusMsg.status.match(/^0x[0-9a-f]+$/i)) {
+                throw new Error(`[did-provider-cheqd]: Invalid status format ${statusMsg.status}. Must be hex prefixed with 0x`);
+            }
+        }
+    }
     async GenerateDidDoc(args, context) {
         if (typeof args.verificationMethod !== 'string') {
             throw new Error('[did-provider-cheqd]: verificationMethod is required');
@@ -938,6 +1406,158 @@ export class Cheqd {
                 return encoded;
         }
     }
+    async GenerateBitstringStatusList(args, context) {
+        const statusSize = args?.statusSize || 1; // default to 1 bit per entry // TODO change to 2 bits per entry after StatusList2021 is removed
+        const length = args?.length || Cheqd.DefaultBitstringLength; // default to 131072
+        // Total number of bits = entries * bits per entry
+        const totalBits = length * statusSize;
+        // Ensure bitstring is byte-aligned (i.e., multiple of 8 bits)
+        const alignedLength = Math.ceil(totalBits / 8) * 8;
+        const bitstring = args?.buffer
+            ? new DBBitstring({ buffer: args.buffer })
+            : new DBBitstring({ length: alignedLength });
+        // get compressed bits
+        const compressed = await bitstring.compressBits();
+        switch (args?.bitstringEncoding) {
+            case 'hex':
+                return toString(compressed, 'hex');
+            case 'base64url':
+            default:
+                return toString(compressed, 'base64url');
+        }
+    }
+    async VerifyStatusListCredential(args, context) {
+        // if jwt credential, decode it
+        const credentialObj = typeof args.credential === 'string' ? await Cheqd.decodeCredentialJWT(args.credential) : args.credential;
+        // Validate required fields
+        if (!credentialObj || typeof credentialObj !== 'object') {
+            return {
+                verified: false,
+                error: { message: 'Invalid credential format' },
+            };
+        }
+        const { credentialSubject, ...rest } = credentialObj;
+        // Validate credentialSubject and encodedList
+        if (!credentialSubject?.encodedList) {
+            return {
+                verified: false,
+                error: { message: 'Missing encodedList in credentialSubject' },
+            };
+        }
+        // Validate that this is indeed a status list credential
+        if (!credentialObj.type || !credentialObj.type.includes('BitstringStatusListCredential')) {
+            return {
+                verified: false,
+                error: { message: 'Credential is not a BitstringStatusListCredential' },
+            };
+        }
+        // Extract encodedList and create credential without it for verification
+        const { encodedList, ...restCredentialSubject } = credentialSubject || {};
+        // Create formatted credential for verification without encodedList
+        const formattedCredential = {
+            credentialSubject: restCredentialSubject,
+            ...rest,
+        };
+        // verify default policies
+        const verificationResult = await context.agent.verifyCredential({
+            ...args?.verificationArgs,
+            credential: formattedCredential,
+            policies: {
+                ...args?.verificationArgs?.policies,
+                // Disable credentialStatus check for status list credentials to avoid circular dependency
+                credentialStatus: false,
+            },
+        });
+        // Additional validation for BitstringStatusListCredential
+        if (verificationResult.verified) {
+            // Basic validation that encodedList is properly formatted
+            if (typeof encodedList !== 'string' || !encodedList) {
+                return {
+                    verified: false,
+                    error: { message: 'Invalid encodedList format' },
+                };
+            }
+            // Validate encodedList format (should be base64url encoded)
+            if (!isValidEncodedBitstring(encodedList)) {
+                return {
+                    verified: false,
+                    error: { message: 'EncodedList validation failed' },
+                };
+            }
+            // Validate statusPurpose is a valid value
+            const statusPurpose = Array.isArray(credentialObj.credentialSubject.statusPurpose)
+                ? credentialObj.credentialSubject.statusPurpose[0]
+                : credentialObj.credentialSubject.statusPurpose;
+            if (!Object.values(BitstringStatusPurposeTypes).includes(statusPurpose)) {
+                return {
+                    verified: false,
+                    error: { message: `Invalid statusPurpose: ${credentialObj.credentialSubject.statusPurpose}` },
+                };
+            }
+            // If ttl is provided, validate it's a positive number
+            if (restCredentialSubject.ttl !== undefined &&
+                (typeof restCredentialSubject.ttl !== 'number' || restCredentialSubject.ttl <= 0)) {
+                return {
+                    verified: false,
+                    error: { message: 'Invalid ttl value' },
+                };
+            }
+        }
+        return { verified: verificationResult.verified, error: verificationResult.error };
+    }
+    async IssueCredentialWithBitstringStatusList(args, context) {
+        // validate resource type
+        const allowedTypes = ['refresh', 'message'];
+        if (!allowedTypes.includes(args.statusOptions.statusPurpose)) {
+            throw new Error(`[did-provider-cheqd]: statusPurpose while issuance must be one of ${allowedTypes.join(', ')}`);
+        }
+        // construct issuer
+        const issuer = args.issuanceOptions.credential.issuer.id
+            ? args.issuanceOptions.credential.issuer.id
+            : args.issuanceOptions.credential.issuer;
+        // generate status list credential
+        const statusListCredential = `${DefaultResolverUrl}${issuer}?resourceName=${args.statusOptions.statusListName}&resourceType=${BitstringStatusListResourceType}`;
+        // get latest status list
+        const statuslist = await Cheqd.fetchBitstringStatusList({
+            credentialStatus: {
+                id: statusListCredential,
+            },
+        });
+        // Validate statusPurpose with statusList.statusPurpose
+        const sl_statusPurpose = statuslist.bitstringStatusListCredential.credentialSubject.statusPurpose;
+        if (!Object.values(sl_statusPurpose).includes(args.statusOptions.statusPurpose)) {
+            throw new Error(`[did-provider-cheqd]: statusPurpose must be one of ${Object.values(sl_statusPurpose).join(', ')}`);
+        }
+        // If statusPurpose is 'message', statusMessages and statusSize MUST be present in Credential
+        if (args.statusOptions.statusPurpose === BitstringStatusPurposeTypes.message) {
+            if (!statuslist.metadata.statusSize || !statuslist.metadata.statusMessages) {
+                throw new Error('[did-provider-cheqd]: statusMessages and statusSize must be present for statusPurpose="message"');
+            }
+        }
+        // generate index
+        const statusListIndex = await generateRandomStatusListIndex(args.statusOptions, {
+            statusSize: statuslist.metadata.statusSize,
+            length: statuslist.metadata.length,
+        });
+        // construct credential status
+        const credentialStatus = {
+            id: `${statusListCredential}#${statusListIndex}`,
+            type: 'BitstringStatusListEntry',
+            statusPurpose: args.statusOptions.statusPurpose || BitstringStatusPurposeTypes.message,
+            statusListIndex: `${statusListIndex}`,
+            statusListCredential,
+            statusSize: statuslist.metadata.statusSize || 1,
+            statusMessage: statuslist.metadata.statusMessages || [],
+        };
+        // add credential status to credential
+        args.issuanceOptions.credential.credentialStatus = credentialStatus;
+        // add relevant context
+        args.issuanceOptions.credential['@context'] = this.addBitstringStatusListContexts(args.issuanceOptions.credential);
+        // TODO: update Veramo so that default "https://www.w3.org/2018/credentials/v1" is not added in context
+        // create a credential
+        const credential = await context.agent.createVerifiableCredential(args.issuanceOptions);
+        return credential;
+    }
     async IssueRevocableCredentialWithStatusList2021(args, context) {
         // generate index
         const statusListIndex = args.statusOptions.statusListIndex ||
@@ -958,24 +1578,7 @@ export class Cheqd {
         // add credential status to credential
         args.issuanceOptions.credential.credentialStatus = credentialStatus;
         // add relevant context
-        args.issuanceOptions.credential['@context'] = (function () {
-            // if no context is provided, add default context
-            if (!args.issuanceOptions.credential['@context']) {
-                return [Cheqd.defaultContextV1, Cheqd.statusList2021Context];
-            }
-            // if context is provided as an array, add default context if it is not already present
-            if (Array.isArray(args.issuanceOptions.credential['@context'])) {
-                if (args.issuanceOptions.credential['@context'].length === 0) {
-                    return [Cheqd.defaultContextV1, Cheqd.statusList2021Context];
-                }
-                if (!args.issuanceOptions.credential['@context'].includes(Cheqd.statusList2021Context)) {
-                    return [...args.issuanceOptions.credential['@context'], Cheqd.statusList2021Context];
-                }
-            }
-            // if context is provided as a string, add default context if it is not already present
-            if (typeof args.issuanceOptions.credential['@context'] === 'string')
-                return [Cheqd.defaultContextV1, Cheqd.statusList2021Context];
-        })();
+        args.issuanceOptions.credential['@context'] = this.addStatusList2021Contexts(args.issuanceOptions.credential);
         // create a credential
         const credential = await context.agent.createVerifiableCredential(args.issuanceOptions);
         return credential;
@@ -1000,28 +1603,34 @@ export class Cheqd {
         // add credential status to credential
         args.issuanceOptions.credential.credentialStatus = credentialStatus;
         // add relevant context
-        args.issuanceOptions.credential['@context'] = (function () {
-            // if no context is provided, add default context
-            if (!args.issuanceOptions.credential['@context']) {
-                return [Cheqd.defaultContextV1, Cheqd.statusList2021Context];
-            }
-            // if context is provided as an array, add default context if it is not already present
-            if (Array.isArray(args.issuanceOptions.credential['@context'])) {
-                if (args.issuanceOptions.credential['@context'].length === 0) {
-                    return [Cheqd.defaultContextV1, Cheqd.statusList2021Context];
-                }
-                if (!args.issuanceOptions.credential['@context'].includes(Cheqd.statusList2021Context)) {
-                    return [...args.issuanceOptions.credential['@context'], Cheqd.statusList2021Context];
-                }
-            }
-            // if context is provided as a string, add default context if it is not already present
-            if (typeof args.issuanceOptions.credential['@context'] === 'string')
-                return [Cheqd.defaultContextV1, Cheqd.statusList2021Context];
-        })();
+        args.issuanceOptions.credential['@context'] = this.addStatusList2021Contexts(args.issuanceOptions.credential);
         // create a credential
         const credential = await context.agent.createVerifiableCredential(args.issuanceOptions);
         return credential;
     }
+    addStatusList2021Contexts(credential) {
+        const contexts = credential['@context'] || [];
+        // if context is provided as an array, add default context if it is not already present
+        if (Array.isArray(contexts)) {
+            const requiredContexts = [Cheqd.defaultContextV1, Cheqd.statusList2021Context];
+            const missingContexts = requiredContexts.filter((ctx) => !contexts.includes(ctx));
+            return [...contexts, ...missingContexts];
+        }
+        // if no context return default context
+        return [Cheqd.defaultContextV1, Cheqd.statusList2021Context];
+    }
+    addBitstringStatusListContexts(credential) {
+        const contexts = credential['@context'] || [];
+        // if context is provided as an array, add default context if it is not already present
+        if (Array.isArray(contexts)) {
+            // TODO: Credential V1 context is used now, replace when V2 is implemented
+            const requiredContexts = [Cheqd.defaultContextV1, Cheqd.DefaultBitstringContexts.statusList];
+            const missingContexts = requiredContexts.filter((ctx) => !contexts.includes(ctx));
+            return [...contexts, ...missingContexts];
+        }
+        // if no context return default context
+        return [Cheqd.DefaultBitstringContexts.v2, Cheqd.DefaultBitstringContexts.statusList];
+    }
     async VerifyCredentialWithStatusList2021(args, context) {
         // verify default policies
         const verificationResult = await context.agent.verifyCredential({
@@ -1062,6 +1671,259 @@ export class Cheqd {
                 throw new Error(`[did-provider-cheqd]: verify credential: Unsupported status purpose: ${credential.credentialStatus?.statusPurpose}`);
         }
     }
+    async VerifyCredentialWithBitstringStatusList(args, context) {
+        // verify default policies
+        const verificationResult = await context.agent.verifyCredential({
+            ...args?.verificationArgs,
+            credential: args.credential,
+            policies: {
+                ...args?.verificationArgs?.policies,
+                credentialStatus: false,
+            },
+        });
+        // if jwt credential, decode it
+        const credential = typeof args.credential === 'string' ? await Cheqd.decodeCredentialJWT(args.credential) : args.credential;
+        // early return if verification failed
+        if (!verificationResult.verified) {
+            return {
+                verified: false,
+                status: 1,
+                purpose: credential.credentialStatus?.statusPurpose,
+                valid: false,
+                error: verificationResult.error,
+            };
+        }
+        // define issuer
+        const issuer = typeof credential.issuer === 'string' ? credential.issuer : credential.issuer.id;
+        // define provider, if applicable
+        this.didProvider = await Cheqd.getProviderFromDidUrl(issuer, this.supportedDidProviders);
+        // define provider id, if applicable
+        this.providerId = Cheqd.generateProviderId(issuer);
+        // define dkg options, if provided
+        args.dkgOptions ||= this.didProvider.dkgOptions;
+        // Fetch and verify the Bitstring status list VC
+        let publishedList;
+        try {
+            publishedList = await Cheqd.fetchBitstringStatusList({
+                credentialStatus: {
+                    id: credential.credentialStatus?.statusListCredential,
+                },
+            });
+        }
+        catch {
+            throw new Error('[did-provider-cheqd]: STATUS_RETRIEVAL_ERROR');
+        }
+        // Validate proof on the Bitstring status list VC
+        const checkCredential = await this.VerifyStatusListCredential({ credential: publishedList.bitstringStatusListCredential }, context);
+        if (!checkCredential.verified) {
+            throw new Error('[did-provider-cheqd]: STATUS_VERIFICATION_ERROR');
+        }
+        const validationResult = await Cheqd.validateBitstringStatus(credential, publishedList, {
+            ...args.options,
+            topArgs: args,
+            instantiateDkgClient: () => this.didProvider.instantiateDkgThresholdProtocolClient(),
+        });
+        // verify credential status
+        switch (credential.credentialStatus?.statusPurpose) {
+            case BitstringStatusPurposeTypes.revocation:
+                return {
+                    ...verificationResult,
+                    revoked: !validationResult.valid,
+                    ...validationResult,
+                };
+            case BitstringStatusPurposeTypes.suspension:
+                return {
+                    ...verificationResult,
+                    suspended: !validationResult.valid,
+                    ...validationResult,
+                };
+            case BitstringStatusPurposeTypes.message:
+            case BitstringStatusPurposeTypes.refresh:
+                return { ...verificationResult, ...validationResult };
+            default:
+                throw new Error(`[did-provider-cheqd]: verify credential: Unsupported status purpose: ${credential.credentialStatus?.statusPurpose}`);
+        }
+    }
+    static async validateBitstringStatus(vcToValidate, publishedList, options = { fetchList: true }) {
+        if (!vcToValidate?.credentialStatus) {
+            throw new Error('[did-provider-cheqd]: CREDENTIAL_STATUS_MISSING');
+        }
+        // validate dkgOptions
+        if (!options?.topArgs?.dkgOptions) {
+            throw new Error('[did-provider-cheqd]: dkgOptions is required');
+        }
+        const statusEntry = vcToValidate.credentialStatus;
+        const { statusPurpose, statusListIndex, statusSize = 1, // default to 1 if not given
+         } = statusEntry;
+        // Validate statusPurpose match in Bitstring statuslist VC
+        const listSubject = publishedList?.bitstringStatusListCredential.credentialSubject;
+        const purposesDeclared = Array.isArray(listSubject?.statusPurpose)
+            ? listSubject.statusPurpose
+            : [listSubject?.statusPurpose];
+        if (!purposesDeclared.includes(statusPurpose)) {
+            throw new Error("[did-provider-cheqd]: STATUS_VERIFICATION_ERROR 'statusPurpose' does not match Bitstring Status List 'statusPurpose'");
+        }
+        // Extract and decompress the bitstring
+        const encoded = listSubject?.encodedList;
+        if (!encoded) {
+            throw new Error('[did-provider-cheqd]: STATUS_LIST_MISSING_ENCODED');
+        }
+        // validate encoded list
+        if (!isValidEncodedBitstring(encoded))
+            throw new Error('[did-provider-cheqd]: Invalid encodedList format. Must be base64url encoded GZIP compressed bitstring');
+        // fetch bitstring status list inscribed in credential
+        const bitstringStatusList = await Cheqd.fetchAndDecryptBitstring(publishedList, options);
+        // Expand bitstring and validate size
+        const decompressedBuffer = await DBBitstring.decodeBits({ encoded: bitstringStatusList });
+        const decompressedBitstring = new DBBitstring({ buffer: decompressedBuffer });
+        const totalBits = decompressedBitstring.length;
+        const numEntries = Math.floor(totalBits / statusSize);
+        if (numEntries < Cheqd.DefaultBitstringLength) {
+            throw new Error('[did-provider-cheqd]: STATUS_LIST_LENGTH_ERROR');
+        }
+        // Compute index
+        const index = parseInt(statusListIndex, 10);
+        const bitPosition = index * statusSize;
+        if (bitPosition + statusSize > totalBits) {
+            throw new Error('[did-provider-cheqd]: RANGE_ERROR');
+        }
+        const value = Cheqd.getBitValue(decompressedBitstring, bitPosition, statusSize);
+        const result = {
+            status: value,
+            purpose: statusPurpose,
+            valid: value === 0,
+        };
+        // Lookup statusMessage. if statusSize > 1
+        const statusMessages = statusEntry.statusMessage;
+        if (statusPurpose === BitstringStatusPurposeTypes.message && Array.isArray(statusMessages)) {
+            const messageEntry = statusMessages.find((msg) => msg.status === `0x${value.toString(16)}`);
+            if (messageEntry) {
+                result.message = messageEntry.message;
+            }
+        }
+        return result;
+    }
+    async VerifyPresentationWithBitstringStatusList(args, context) {
+        // Verify default presentation policies first
+        const verificationResult = await context.agent.verifyPresentation({
+            ...args?.verificationArgs,
+            presentation: args.presentation,
+            policies: {
+                ...args?.verificationArgs?.policies,
+                audience: false,
+                credentialStatus: false, // We'll handle status verification separately
+            },
+        });
+        // Early return if basic presentation verification failed
+        if (!verificationResult.verified) {
+            return {
+                verified: false,
+                status: 1,
+                purpose: 'unknown',
+                valid: false,
+                error: verificationResult.error,
+            };
+        }
+        // Early return if no verifiable credentials are provided
+        if (!args.presentation.verifiableCredential || !Array.isArray(args.presentation.verifiableCredential)) {
+            throw new Error('[did-provider-cheqd]: verify presentation: presentation.verifiableCredential is required and must be an array');
+        }
+        if (args.presentation.verifiableCredential.length === 0) {
+            throw new Error('[did-provider-cheqd]: verify presentation: presentation must contain at least one verifiable credential');
+        }
+        // Verify each credential's status
+        const credentialResults = [];
+        let overallValid = true;
+        let hasRevoked = false;
+        let hasSuspended = false;
+        for (let credential of args.presentation.verifiableCredential) {
+            // If JWT credential, decode it
+            if (typeof credential === 'string') {
+                credential = await Cheqd.decodeCredentialJWT(credential);
+            }
+            // Skip credentials without status (they're considered valid)
+            if (!credential.credentialStatus || credential.credentialStatus.type !== 'BitstringStatusListEntry') {
+                credentialResults.push({
+                    verified: true,
+                    status: 0,
+                    purpose: 'none',
+                    valid: true,
+                });
+                continue;
+            }
+            try {
+                // Define issuer for provider selection
+                const issuer = typeof credential.issuer === 'string'
+                    ? credential.issuer
+                    : credential.issuer.id;
+                // Define provider, if applicable
+                this.didProvider = await Cheqd.getProviderFromDidUrl(issuer, this.supportedDidProviders);
+                this.providerId = Cheqd.generateProviderId(issuer);
+                args.dkgOptions ||= this.didProvider.dkgOptions;
+                // Verify credential with Bitstring status list
+                const credentialVerificationResult = await this.VerifyCredentialWithBitstringStatusList({
+                    credential: credential,
+                    verificationArgs: {
+                        ...args?.verificationArgs,
+                        policies: {
+                            ...args?.verificationArgs?.policies,
+                            credentialStatus: false, // We handle this manually
+                        },
+                        credential: '',
+                    },
+                    fetchList: args?.fetchList ?? true,
+                    dkgOptions: args.dkgOptions,
+                    options: args.options,
+                }, context);
+                credentialResults.push(credentialVerificationResult);
+                // Track overall status
+                if (!credentialVerificationResult.verified || !credentialVerificationResult.valid) {
+                    overallValid = false;
+                }
+                switch (credentialVerificationResult.status) {
+                    case BitstringStatusValue.REVOKED:
+                        hasRevoked = true;
+                        overallValid = false;
+                        break;
+                    case BitstringStatusValue.SUSPENDED:
+                        hasSuspended = true;
+                        overallValid = false;
+                        break;
+                    default:
+                        hasSuspended = false;
+                        hasRevoked = false;
+                        overallValid = true;
+                }
+            }
+            catch (error) {
+                credentialResults.push({
+                    verified: false,
+                    status: 1,
+                    purpose: credential.credentialStatus?.statusPurpose || 'unknown',
+                    valid: false,
+                    error: error,
+                });
+                overallValid = false;
+            }
+        }
+        // Determine overall verification result
+        const allCredentialsVerified = credentialResults.every((result) => result.verified);
+        const overallVerified = verificationResult.verified && allCredentialsVerified;
+        // Find the most significant status issue for reporting
+        const firstFailedResult = credentialResults.find((result) => !result.verified || !result.valid);
+        const resultStatus = firstFailedResult?.status ?? 0;
+        const resultPurpose = firstFailedResult?.purpose ?? credentialResults[0]?.purpose ?? 'unknown';
+        return {
+            verified: overallVerified,
+            status: resultStatus,
+            purpose: resultPurpose,
+            valid: overallValid,
+            revoked: hasRevoked,
+            suspended: hasSuspended,
+            message: firstFailedResult?.message,
+            error: firstFailedResult?.error,
+        };
+    }
     async VerifyPresentationWithStatusList2021(args, context) {
         // verify default policies
         const verificationResult = await context.agent.verifyPresentation({
@@ -1181,6 +2043,340 @@ export class Cheqd {
                 throw new Error(`[did-provider-cheqd]: check status: Unsupported status purpose: ${credential.credentialStatus?.statusPurpose}`);
         }
     }
+    async UpdateCredentialWithStatusList(args, context) {
+        // Verify credential if provided and update options are not
+        if (args?.credential && !args?.updateOptions) {
+            const verificationResult = await context.agent.verifyCredential({
+                ...args?.verificationOptions,
+                credential: args.credential,
+                policies: {
+                    credentialStatus: false,
+                },
+            });
+            if (!verificationResult.verified) {
+                return {
+                    updated: false,
+                    statusValue: BitstringStatusValue.UNKNOWN,
+                    statusMessage: 'unknown',
+                    error: verificationResult.error,
+                };
+            }
+        }
+        if (typeof args.newStatus !== 'number' || args.newStatus < 0 || args.newStatus > 3)
+            throw new Error('[did-provider-cheqd]: updateOptions.newStatus must be 0-3 (valid/revoked/suspended/unknown)');
+        // if update options are provided, give precedence
+        if (args?.updateOptions) {
+            // Validate update options
+            if (!args.updateOptions.issuerDid)
+                throw new Error('[did-provider-cheqd]: updateOptions.issuerDid is required');
+            if (!args.updateOptions.statusListName)
+                throw new Error('[did-provider-cheqd]: updateOptions.statusListName is required');
+            if (typeof args.updateOptions.statusListIndex !== 'number')
+                throw new Error('[did-provider-cheqd]: updateOptions.statusListIndex is required');
+            // Construct status list credential URL
+            const statusListCredential = `${DefaultResolverUrl}${args.updateOptions.issuerDid}?resourceName=${args.updateOptions.statusListName}&resourceType=${BitstringStatusListResourceType}`;
+            // fetch latest status list
+            const statusList = await Cheqd.fetchBitstringStatusList({
+                credentialStatus: {
+                    id: statusListCredential,
+                },
+            });
+            // For multi-purpose status lists, we need to determine the appropriate statusPurpose
+            // based on the credential's current status entry or the new status being set
+            const statusPurpose = this.getStatusPurposeForMultiPurposeList(args.newStatus);
+            // Override the credential with new status information
+            args.credential = {
+                '@context': [],
+                issuer: args.updateOptions.issuerDid,
+                credentialSubject: {},
+                credentialStatus: {
+                    id: `${statusListCredential}#${args.updateOptions.statusListIndex}`,
+                    type: 'BitstringStatusListEntry',
+                    statusPurpose: statusPurpose,
+                    statusListIndex: `${args.updateOptions.statusListIndex}`,
+                    statusListCredential,
+                    statusSize: statusList.metadata.statusSize || 1,
+                    statusMessage: statusList.metadata.statusMessages || [],
+                },
+                issuanceDate: '',
+                proof: {},
+            };
+        }
+        // if jwt credential, decode it
+        const credential = typeof args.credential === 'string' ? await Cheqd.decodeCredentialJWT(args.credential) : args.credential;
+        // Validate that credential MUST have credentialStatus
+        if (!credential?.credentialStatus) {
+            throw new Error('[did-provider-cheqd]: update: credential must have credentialStatus');
+        }
+        // Validate that credentialStatus is BitstringStatusListEntry
+        if (credential.credentialStatus.type !== 'BitstringStatusListEntry') {
+            throw new Error('[did-provider-cheqd]: update: credential must have BitstringStatusListEntry credentialStatus');
+        }
+        // validate args in pairs - case: statusListFile and statusList
+        if (args.options?.statusListFile && args.options?.statusList) {
+            throw new Error('[did-provider-cheqd]: revocation: statusListFile and statusList are mutually exclusive');
+        }
+        // validate args in pairs - case: statusListFile and fetchList
+        if (args.options?.statusListFile && args.options?.fetchList) {
+            throw new Error('[did-provider-cheqd]: revocation: statusListFile and fetchList are mutually exclusive');
+        }
+        // validate args in pairs - case: statusList and fetchList
+        if (args.options?.statusList && args.options?.fetchList) {
+            throw new Error('[did-provider-cheqd]: revocation: statusList and fetchList are mutually exclusive');
+        }
+        // validate args in pairs - case: publish
+        if (args.options?.publish && !args.fetchList && !(args.options?.statusListFile || args.options?.statusList)) {
+            throw new Error('[did-provider-cheqd]: revocation: publish requires statusListFile or statusList, if fetchList is disabled');
+        }
+        // Define issuer and provider
+        const issuer = typeof credential.issuer === 'string' ? credential.issuer : credential.issuer.id;
+        this.didProvider = await Cheqd.getProviderFromDidUrl(issuer, this.supportedDidProviders);
+        this.providerId = Cheqd.generateProviderId(issuer);
+        args.dkgOptions ||= this.didProvider.dkgOptions;
+        // Perform the status update
+        return await Cheqd.updateBitstringCredentialStatus(credential, {
+            ...args.options,
+            topArgs: args,
+            publishOptions: {
+                context,
+                statusListEncoding: args?.options?.statusListEncoding,
+                statusListValidUntil: args?.options?.statusListValidUntil,
+                resourceId: args?.options?.resourceId,
+                resourceVersion: args?.options?.resourceVersion,
+                resourceAlsoKnownAs: args?.options?.alsoKnownAs,
+                signInputs: args?.options?.signInputs,
+                fee: args?.options?.fee,
+            },
+        });
+    }
+    getStatusPurposeForMultiPurposeList(newStatus) {
+        // TODO Add map with messages
+        // Since the default status list supports multiple purposes, we can use any of them
+        // For multi-purpose lists, typically 'message' is used as it's the most flexible
+        return BitstringStatusPurposeTypes.message;
+    }
+    // Core status update logic for multi-purpose Bitstring Status Lists
+    static async updateBitstringCredentialStatus(credential, options) {
+        try {
+            // Validate credential status
+            if (!credential.credentialStatus) {
+                throw new Error('[did-provider-cheqd]: update: Credential status is not present');
+            }
+            // Fetch published status list
+            const publishedList = await Cheqd.fetchBitstringStatusList(credential);
+            // Validate that this is a multi-purpose status list with 2-bit status
+            if (publishedList.metadata.statusSize !== 2) {
+                throw new Error('[did-provider-cheqd]: update: Status list must use 2-bit status size');
+            }
+            // Validate status messages are present for 2-bit status
+            if (!publishedList.metadata.statusMessages || publishedList.metadata.statusMessages.length !== 4) {
+                throw new Error('[did-provider-cheqd]: update: Status list must have 4 status messages for 2-bit status');
+            }
+            // Early return if encrypted and no decryption key provided
+            if (publishedList.metadata.encrypted && !options?.topArgs?.symmetricKey) {
+                throw new Error('[did-provider-cheqd]: update: symmetricKey is required for encrypted status list');
+            }
+            // Calculate positions and values
+            const statusIndex = parseInt(credential.credentialStatus.statusListIndex, 10);
+            const statusSize = publishedList.metadata.statusSize; // Should be 2
+            const newStatusValue = options?.topArgs.newStatus;
+            // Fetch and decrypt the current bitstring
+            const currentBitstring = await Cheqd.fetchAndDecryptBitstring(publishedList, options);
+            // Parse the bitstring
+            const decompressedBuffer = await DBBitstring.decodeBits({ encoded: currentBitstring });
+            const bitstring = new DBBitstring({ buffer: decompressedBuffer });
+            // Get current status value
+            const bitPosition = statusIndex * statusSize;
+            const currentStatusValue = Cheqd.getBitValue(bitstring, bitPosition, statusSize);
+            // Check if update is needed
+            if (currentStatusValue === newStatusValue) {
+                const statusMessage = publishedList.metadata.statusMessages.find((msg) => parseInt(msg.status, 16) === currentStatusValue)
+                    ?.message || 'unknown';
+                return {
+                    updated: false,
+                    statusValue: currentStatusValue,
+                    statusMessage,
+                    error: { message: `Credential already has status value ${newStatusValue} (${statusMessage})` },
+                };
+            }
+            // Update the bitstring
+            Cheqd.setBitValue(bitstring, bitPosition, newStatusValue, statusSize);
+            // Compress the updated bitstring
+            const compressedBitstring = await bitstring.compressBits();
+            const encodedBitstring = toString(compressedBitstring, 'base64url');
+            // Create updated status list credential
+            const updatedStatusListCredential = {
+                ...publishedList.bitstringStatusListCredential,
+                credentialSubject: {
+                    ...publishedList.bitstringStatusListCredential.credentialSubject,
+                    encodedList: encodedBitstring,
+                },
+            };
+            const updatedStatusList = {
+                bitstringStatusListCredential: updatedStatusListCredential,
+                metadata: publishedList.metadata,
+            };
+            // Write to file if requested
+            if (options?.topArgs?.writeToFile) {
+                await Cheqd.writeFile(compressedBitstring, options?.statusListFile);
+            }
+            // Publish if requested
+            const published = options?.topArgs?.publish
+                ? await Cheqd.publishUpdatedBitstringStatusList(updatedStatusList, credential, options)
+                : undefined;
+            // Get status message for new value
+            const newStatusMessage = publishedList.metadata.statusMessages.find((msg) => parseInt(msg.status, 16) === newStatusValue)
+                ?.message || 'unknown';
+            const previousStatusMessage = publishedList.metadata.statusMessages.find((msg) => parseInt(msg.status, 16) === currentStatusValue)
+                ?.message || 'unknown';
+            return {
+                updated: true,
+                statusValue: newStatusValue,
+                previousStatusValue: currentStatusValue,
+                statusMessage: newStatusMessage,
+                published: options?.topArgs?.publish ? !!published : undefined,
+                statusList: options?.topArgs?.returnUpdatedStatusList ? updatedStatusList : undefined,
+                symmetricKey: options?.topArgs?.returnSymmetricKey && published?.symmetricKey
+                    ? published.symmetricKey
+                    : undefined,
+                resourceMetadata: options?.topArgs?.returnStatusListMetadata
+                    ? await Cheqd.fetchStatusListMetadata(credential)
+                    : undefined,
+            };
+        }
+        catch (error) {
+            console.error('[did-provider-cheqd]: update error:', error);
+            return {
+                updated: false,
+                statusValue: BitstringStatusValue.UNKNOWN,
+                statusMessage: 'unknown',
+                error: error,
+            };
+        }
+    }
+    // Helper function to fetch and decrypt bitstring (same as before)
+    static async fetchAndDecryptBitstring(publishedList, options) {
+        const topArgs = options?.topArgs;
+        const encoded = publishedList.bitstringStatusListCredential.credentialSubject.encodedList;
+        if (topArgs?.fetchList) {
+            // if not encrypted, return published bitstring (always base64url encoded)
+            if (!publishedList.metadata.encrypted) {
+                return encoded;
+            }
+            // otherwise, Decrypt using threshold encryption
+            const { thresholdEncryptionCiphertext } = decodeWithMetadata(publishedList.bitstringStatusListCredential.credentialSubject.encodedList, publishedList.metadata.symmetricLength);
+            const lit = (await options.instantiateDkgClient());
+            // construct access control conditions
+            const unifiedAccessControlConditions = await Promise.all(publishedList.metadata.paymentConditions.map(async (condition) => {
+                switch (condition.type) {
+                    case AccessControlConditionTypes.timelockPayment:
+                        return await LitProtocol.generateCosmosAccessControlConditionInverseTimelock({
+                            key: '$.tx_responses.*.timestamp',
+                            comparator: '<=',
+                            value: `${condition.intervalInSeconds}`,
+                        }, condition.feePaymentAmount, condition.feePaymentAddress, condition?.blockHeight, options?.topArgs?.dkgOptions?.chain);
+                    default:
+                        throw new Error(`[did-provider-cheqd]: unsupported access control condition type ${condition.type}`);
+                }
+            }));
+            return await lit.decrypt(toString(thresholdEncryptionCiphertext, 'base64url'), publishedList.metadata.statusListHash, unifiedAccessControlConditions);
+        }
+        else {
+            // Use provided symmetric key or file
+            if (options?.statusListFile) {
+                // if not encrypted, return bitstring
+                if (!publishedList.metadata.encrypted) {
+                    // construct encoded status list
+                    const bitstring = new DBBitstring({
+                        buffer: await Cheqd.getFile(options.statusListFile),
+                    });
+                    const compressed = await bitstring.compressBits();
+                    // validate against published list
+                    if (encoded !== toString(compressed, 'base64url'))
+                        throw new Error('[did-provider-cheqd]: statusListFile does not match published Bitstring status list');
+                    // return compressed
+                    return compressed;
+                }
+                // otherwise, decrypt and return bitstring
+                const scopedRawBlob = await toBlob(await Cheqd.getFile(options.statusListFile));
+                const decrypted = toString(await LitProtocol.decryptDirect(scopedRawBlob, await safeDeserialise(options?.topArgs?.symmetricKey, fromString, ['hex'], 'Invalid symmetric key')), 'base64url');
+                // validate against published list
+                if (decrypted !== encoded)
+                    throw new Error('[did-provider-cheqd]: statusListFile does not match published Bitstring status list');
+                // return decrypted
+                return decrypted;
+            }
+            if (!options?.statusListInlineBitstring) {
+                throw new Error('[did-provider-cheqd]: statusListInlineBitstring required if statusListFile not provided');
+            }
+            // validate against published list
+            if (options?.statusListInlineBitstring !== encoded)
+                throw new Error('[did-provider-cheqd]: statusListInlineBitstring does not match published bitstring status list');
+            // otherwise, read from inline bitstring
+            return options.statusListInlineBitstring;
+        }
+    }
+    // Helper function to publish updated status list
+    static async publishUpdatedBitstringStatusList(updatedStatusList, credential, options) {
+        const topArgs = options?.topArgs;
+        // Fetch current metadata
+        const statusListMetadata = await Cheqd.fetchStatusListMetadata(credential);
+        // Handle encrypted publishing if needed
+        if (topArgs.publishEncrypted && updatedStatusList.metadata.encrypted) {
+            // Re-encrypt with new content
+            const bitstring = updatedStatusList.bitstringStatusListCredential.credentialSubject.encodedList;
+            // Encrypt bitstring - case: symmetric
+            const { encryptedString: symmetricEncryptionCiphertext, symmetricKey } = await LitProtocol.encryptDirect(fromString(bitstring, 'base64url'));
+            // Get DKG client and encrypt threshold
+            const lit = await options.publishOptions.instantiateDkgClient();
+            const unifiedAccessControlConditions = await Promise.all(updatedStatusList.metadata.paymentConditions.map(async (condition) => {
+                switch (condition.type) {
+                    case AccessControlConditionTypes.timelockPayment:
+                        return await LitProtocol.generateCosmosAccessControlConditionInverseTimelock({
+                            key: '$.tx_responses.*.timestamp',
+                            comparator: '<=',
+                            value: `${condition.intervalInSeconds}`,
+                        }, condition.feePaymentAmount, condition.feePaymentAddress, condition?.blockHeight, topArgs?.dkgOptions?.chain);
+                    default:
+                        throw new Error(`[did-provider-cheqd]: unsupported access control condition type ${condition.type}`);
+                }
+            }));
+            const { encryptedString: thresholdEncryptionCiphertext, stringHash } = await lit.encrypt(fromString(bitstring, 'base64url'), unifiedAccessControlConditions);
+            // Update encoded list with encrypted content
+            const { encodedList, symmetricLength } = await encodeWithMetadata(symmetricEncryptionCiphertext, thresholdEncryptionCiphertext);
+            updatedStatusList.bitstringStatusListCredential.credentialSubject.encodedList = encodedList;
+            updatedStatusList.metadata.statusListHash = stringHash;
+            updatedStatusList.metadata.symmetricLength = symmetricLength;
+            // Publish the encrypted status list
+            await Cheqd.publishBitstringStatusList(fromString(JSON.stringify(updatedStatusList), 'utf-8'), statusListMetadata, options?.publishOptions);
+            return { symmetricKey: toString(symmetricKey, 'hex') };
+        }
+        else {
+            // Publish unencrypted
+            await Cheqd.publishBitstringStatusList(fromString(JSON.stringify(updatedStatusList), 'utf-8'), statusListMetadata, options?.publishOptions);
+            return {};
+        }
+    }
+    // Helper function to publish bitstring status list
+    static async publishBitstringStatusList(statusListRaw, statusListMetadata, options) {
+        // Construct payload
+        const payload = {
+            id: options?.resourceId || v4(),
+            collectionId: statusListMetadata.resourceCollectionId,
+            name: statusListMetadata.resourceName,
+            version: options?.resourceVersion || new Date().toISOString(),
+            alsoKnownAs: options?.resourceAlsoKnownAs || [],
+            resourceType: BitstringStatusListResourceType,
+            data: statusListRaw,
+        };
+        return await options.context.agent[BroadcastStatusListMethodName]({
+            kms: (await options.context.agent.keyManagerGetKeyManagementSystems())[0],
+            payload,
+            network: statusListMetadata.resourceURI.split(':')[2],
+            signInputs: options?.signInputs,
+            fee: options?.fee,
+        });
+    }
     async RevokeCredentialWithStatusList2021(args, context) {
         // verify credential, if provided and revocation options are not
         if (args?.credential && !args?.revocationOptions) {
@@ -1273,6 +2469,254 @@ export class Cheqd {
             },
         });
     }
+    async BulkUpdateCredentialsWithStatusList(args, context) {
+        // validate new status value
+        if (typeof args.newStatus !== 'number' || args.newStatus < 0 || args.newStatus > 3) {
+            throw new Error('[did-provider-cheqd]: bulk update: newStatus must be 0-3 (valid/revoked/suspended/unknown)');
+        }
+        // verify credentials, if provided and update options are not
+        if (args?.credentials && !args?.updateOptions) {
+            const verificationResult = await Promise.all(args.credentials.map(async (credential) => {
+                return await context.agent.verifyCredential({
+                    ...args?.verificationOptions,
+                    credential,
+                    policies: {
+                        credentialStatus: false,
+                    },
+                });
+            }));
+            // early return if verification failed for any credential
+            if (verificationResult.some((result) => !result.verified)) {
+                return {
+                    updated: Array(args.credentials.length).fill(false),
+                    statusValues: Array(args.credentials.length).fill(BitstringStatusValue.UNKNOWN),
+                    statusMessages: Array(args.credentials.length).fill('verification failed'),
+                    error: verificationResult.find((result) => !result.verified).error || {
+                        message: 'verification: could not verify credential',
+                    },
+                };
+            }
+        }
+        // if update options are provided, give precedence
+        if (args?.updateOptions) {
+            // validate update options
+            if (!args.updateOptions.issuerDid) {
+                throw new Error('[did-provider-cheqd]: bulk update: updateOptions.issuerDid is required');
+            }
+            if (!args.updateOptions.statusListName) {
+                throw new Error('[did-provider-cheqd]: bulk update: updateOptions.statusListName is required');
+            }
+            if (!args.updateOptions.statusListIndices || !Array.isArray(args.updateOptions.statusListIndices)) {
+                throw new Error('[did-provider-cheqd]: bulk update: updateOptions.statusListIndices is required and must be an array');
+            }
+            // Construct status list credential URL
+            const statusListCredential = `${DefaultResolverUrl}${args.updateOptions.issuerDid}?resourceName=${args.updateOptions.statusListName}&resourceType=${BitstringStatusListResourceType}`;
+            // fetch latest status list to get metadata
+            const statusList = await Cheqd.fetchBitstringStatusList({
+                credentialStatus: {
+                    id: statusListCredential,
+                },
+            });
+            // For multi-purpose status lists, determine the appropriate statusPurpose
+            const statusPurpose = this.getStatusPurposeForMultiPurposeList(args.newStatus);
+            // construct credentials with proper status entries
+            args.credentials = args.updateOptions.statusListIndices.map((index, i) => ({
+                '@context': [],
+                issuer: args.updateOptions.issuerDid,
+                credentialSubject: {},
+                credentialStatus: {
+                    id: `${statusListCredential}#${index}`,
+                    type: 'BitstringStatusListEntry',
+                    statusPurpose: statusPurpose,
+                    statusListIndex: `${index}`,
+                    statusListCredential,
+                    statusSize: statusList.metadata.statusSize || 1,
+                    statusMessage: statusList.metadata.statusMessages || [],
+                },
+                issuanceDate: '',
+                proof: {},
+            }));
+        }
+        // if jwt credentials, decode them
+        const credentials = await Promise.all(args.credentials.map(async (credential) => typeof credential === 'string' ? await Cheqd.decodeCredentialJWT(credential) : credential));
+        // Validate that ALL credentials MUST have credentialStatus
+        const credentialsWithoutStatus = credentials.filter((credential, index) => !credential.credentialStatus);
+        if (credentialsWithoutStatus.length > 0) {
+            throw new Error(`[did-provider-cheqd]: bulk update: ${credentialsWithoutStatus.length} credential(s) missing credentialStatus`);
+        }
+        // Validate that all credentials have BitstringStatusListEntry type
+        const invalidStatusTypes = credentials.filter((credential) => credential.credentialStatus?.type !== 'BitstringStatusListEntry');
+        if (invalidStatusTypes.length > 0) {
+            throw new Error(`[did-provider-cheqd]: bulk update: ${invalidStatusTypes.length} credential(s) must have BitstringStatusListEntry credentialStatus`);
+        }
+        // validate credentials - case: consistent issuer
+        if (credentials
+            .map((credential) => {
+            return credential.issuer.id
+                ? credential.issuer.id
+                : credential.issuer;
+        })
+            .filter((value, _, self) => value && value !== self[0]).length > 0) {
+            throw new Error('[did-provider-cheqd]: bulk update: Credentials must be issued by the same issuer');
+        }
+        // validate credentials - case: status list index uniqueness
+        if (credentials
+            .map((credential) => credential.credentialStatus.statusListIndex)
+            .filter((value, index, self) => self.indexOf(value) !== index).length > 0) {
+            throw new Error('[did-provider-cheqd]: bulk update: Credentials must have unique status list index');
+        }
+        // validate credentials - case: status list credential consistency
+        const statusListCredentialUrl = credentials[0].credentialStatus?.statusListCredential;
+        if (!statusListCredentialUrl) {
+            throw new Error('[did-provider-cheqd]: bulk update: Invalid status list credential URL');
+        }
+        if (!credentials.every((credential) => credential.credentialStatus?.statusListCredential === statusListCredentialUrl)) {
+            throw new Error('[did-provider-cheqd]: bulk update: Credentials must belong to the same status list');
+        }
+        // validate credentials - case: status list type
+        if (!credentials.every((credential) => credential.credentialStatus?.type === 'BitstringStatusListEntry')) {
+            throw new Error('[did-provider-cheqd]: bulk update: Invalid status list type');
+        }
+        // validate args in pairs - case: statusListFile and statusList
+        if (args.options?.statusListFile && args.options?.statusList) {
+            throw new Error('[did-provider-cheqd]: bulk update: statusListFile and statusList are mutually exclusive');
+        }
+        // validate args in pairs - case: statusListFile and fetchList
+        if (args.options?.statusListFile && args.options?.fetchList) {
+            throw new Error('[did-provider-cheqd]: bulk update: statusListFile and fetchList are mutually exclusive');
+        }
+        // validate args in pairs - case: statusList and fetchList
+        if (args.options?.statusList && args.options?.fetchList) {
+            throw new Error('[did-provider-cheqd]: bulk update: statusList and fetchList are mutually exclusive');
+        }
+        // validate args in pairs - case: publish
+        if (args.options?.publish && !args.fetchList && !(args.options?.statusListFile || args.options?.statusList)) {
+            throw new Error('[did-provider-cheqd]: bulk update: publish requires statusListFile or statusList, if fetchList is disabled');
+        }
+        // Define issuer and provider
+        const issuer = typeof credentials[0].issuer === 'string'
+            ? credentials[0].issuer
+            : credentials[0].issuer.id;
+        this.didProvider = await Cheqd.getProviderFromDidUrl(issuer, this.supportedDidProviders);
+        this.providerId = Cheqd.generateProviderId(issuer);
+        args.dkgOptions ||= this.didProvider.dkgOptions;
+        try {
+            // Fetch published status list
+            const publishedList = await Cheqd.fetchBitstringStatusList(credentials[0]);
+            // Error if encrypted and no decryption key provided
+            if (publishedList.metadata.encrypted && !args?.symmetricKey) {
+                throw new Error('[did-provider-cheqd]: bulk update: symmetricKey is required for encrypted status list');
+            }
+            // Fetch and decrypt the current bitstring
+            const currentBitstring = await Cheqd.fetchAndDecryptBitstring(publishedList, {
+                ...args.options,
+                topArgs: args,
+                instantiateDkgClient: () => this.didProvider.instantiateDkgThresholdProtocolClient(),
+            });
+            // Parse the bitstring
+            const decompressedBuffer = await DBBitstring.decodeBits({ encoded: currentBitstring });
+            const bitstring = new DBBitstring({ buffer: decompressedBuffer });
+            const statusSize = publishedList.metadata.statusSize || Cheqd.DefaultBitstringStatusSize;
+            const newStatusValue = args.newStatus;
+            // Process all credentials
+            const results = [];
+            let anyUpdated = false;
+            for (const credential of credentials) {
+                const statusIndex = parseInt(credential.credentialStatus.statusListIndex, 10);
+                const bitPosition = statusIndex * statusSize;
+                // Get current status value
+                const currentStatusValue = Cheqd.getBitValue(bitstring, bitPosition, statusSize);
+                // Check if update is needed
+                if (currentStatusValue === newStatusValue) {
+                    const statusMessage = publishedList.metadata.statusMessages?.find((msg) => parseInt(msg.status, 16) === currentStatusValue)?.message || 'unknown';
+                    results.push({
+                        updated: false,
+                        statusValue: currentStatusValue,
+                        statusMessage,
+                    });
+                }
+                else {
+                    // Update the bitstring
+                    Cheqd.setBitValue(bitstring, bitPosition, newStatusValue, statusSize);
+                    const newStatusMessage = publishedList.metadata.statusMessages?.find((msg) => parseInt(msg.status, 16) === newStatusValue)?.message || 'unknown';
+                    results.push({
+                        updated: true,
+                        statusValue: newStatusValue,
+                        previousStatusValue: currentStatusValue,
+                        statusMessage: newStatusMessage,
+                    });
+                    anyUpdated = true;
+                }
+            }
+            // If no updates needed, return early
+            if (!anyUpdated) {
+                return {
+                    updated: results.map((r) => r.updated),
+                    statusValues: results.map((r) => r.statusValue),
+                    previousStatusValues: results.map((r) => r.previousStatusValue).filter((v) => v !== undefined),
+                    statusMessages: results.map((r) => r.statusMessage).filter((m) => m !== undefined),
+                };
+            }
+            // Compress the updated bitstring
+            const compressedBitstring = await bitstring.compressBits();
+            const encodedBitstring = toString(compressedBitstring, 'base64url');
+            // Create updated status list credential
+            const updatedStatusListCredential = {
+                ...publishedList.bitstringStatusListCredential,
+                credentialSubject: {
+                    ...publishedList.bitstringStatusListCredential.credentialSubject,
+                    encodedList: encodedBitstring,
+                },
+            };
+            const updatedStatusList = {
+                bitstringStatusListCredential: updatedStatusListCredential,
+                metadata: publishedList.metadata,
+            };
+            // Write to file if requested
+            if (args?.writeToFile) {
+                await Cheqd.writeFile(compressedBitstring, args.options?.statusListFile);
+            }
+            // Publish if requested
+            const published = args?.publish
+                ? await Cheqd.publishUpdatedBitstringStatusList(updatedStatusList, credentials[0], {
+                    ...args.options,
+                    topArgs: args,
+                    publishOptions: {
+                        context,
+                        statusListEncoding: args?.options?.statusListEncoding,
+                        statusListValidUntil: args?.options?.statusListValidUntil,
+                        resourceId: args?.options?.resourceId,
+                        resourceVersion: args?.options?.resourceVersion,
+                        resourceAlsoKnownAs: args?.options?.alsoKnownAs,
+                        signInputs: args?.options?.signInputs,
+                        fee: args?.options?.fee,
+                        instantiateDkgClient: () => this.didProvider.instantiateDkgThresholdProtocolClient(),
+                    },
+                })
+                : undefined;
+            return {
+                updated: results.map((r) => r.updated),
+                statusValues: results.map((r) => r.statusValue),
+                previousStatusValues: results.map((r) => r.previousStatusValue).filter((v) => v !== undefined),
+                statusMessages: results.map((r) => r.statusMessage).filter((m) => m !== undefined),
+                published: args?.publish ? !!published : undefined,
+                statusList: args?.returnUpdatedStatusList ? updatedStatusList : undefined,
+                symmetricKey: args?.returnSymmetricKey && published?.symmetricKey ? published.symmetricKey : undefined,
+                resourceMetadata: args?.returnStatusListMetadata
+                    ? await Cheqd.fetchStatusListMetadata(credentials[0])
+                    : undefined,
+            };
+        }
+        catch (error) {
+            console.error('[did-provider-cheqd]: bulk update error:', error);
+            return {
+                updated: Array(credentials.length).fill(false),
+                statusValues: Array(credentials.length).fill(BitstringStatusValue.UNKNOWN),
+                statusMessages: Array(credentials.length).fill('update failed'),
+                error: error,
+            };
+        }
+    }
     async RevokeBulkCredentialsWithStatusList2021(args, context) {
         // verify credential, if provided and revocation options are not
         if (args?.credentials && !args?.revocationOptions) {
@@ -2098,13 +3542,13 @@ export class Cheqd {
             const published = topArgs?.publish
                 ? await (async function () {
                     // fetch status list 2021 metadata
-                    const statusListMetadata = await Cheqd.fetchStatusList2021Metadata(credential);
+                    const statusListMetadata = await Cheqd.fetchStatusListMetadata(credential);
                     // publish status list 2021 as new version
                     const scoped = topArgs.publishEncrypted
                         ? await (async function () {
                             // validate encoding, if provided
                             if (options?.publishOptions?.statusListEncoding &&
-                                !Object.values(DefaultStatusList2021Encodings).includes(options?.publishOptions?.statusListEncoding)) {
+                                !Object.values(DefaultStatusListEncodings).includes(options?.publishOptions?.statusListEncoding)) {
                                 throw new Error('[did-provider-cheqd]: revocation: Invalid status list encoding');
                             }
                             // validate validUntil, if provided
@@ -2233,7 +3677,7 @@ export class Cheqd {
                         : await (async function () {
                             // validate encoding, if provided
                             if (options?.publishOptions?.statusListEncoding &&
-                                !Object.values(DefaultStatusList2021Encodings).includes(options?.publishOptions?.statusListEncoding)) {
+                                !Object.values(DefaultStatusListEncodings).includes(options?.publishOptions?.statusListEncoding)) {
                                 throw new Error('[did-provider-cheqd]: revocation: Invalid status list encoding');
                             }
                             // validate validUntil, if provided
@@ -2293,7 +3737,7 @@ export class Cheqd {
                     ? toString(published?.[1]?.symmetricKey, 'hex')
                     : undefined,
                 resourceMetadata: topArgs?.returnStatusListMetadata
-                    ? await Cheqd.fetchStatusList2021Metadata(credential)
+                    ? await Cheqd.fetchStatusListMetadata(credential)
                     : undefined,
             };
         }
@@ -2437,13 +3881,13 @@ export class Cheqd {
             const published = topArgs?.publish
                 ? await (async function () {
                     // fetch status list 2021 metadata
-                    const statusListMetadata = await Cheqd.fetchStatusList2021Metadata(credentials[0]);
+                    const statusListMetadata = await Cheqd.fetchStatusListMetadata(credentials[0]);
                     // publish status list 2021 as new version
                     const scoped = topArgs.publishEncrypted
                         ? await (async function () {
                             // validate encoding, if provided
                             if (options?.publishOptions?.statusListEncoding &&
-                                !Object.values(DefaultStatusList2021Encodings).includes(options?.publishOptions?.statusListEncoding)) {
+                                !Object.values(DefaultStatusListEncodings).includes(options?.publishOptions?.statusListEncoding)) {
                                 throw new Error('[did-provider-cheqd]: revocation: Invalid status list encoding');
                             }
                             // validate validUntil, if provided
@@ -2572,7 +4016,7 @@ export class Cheqd {
                         : await (async function () {
                             // validate encoding, if provided
                             if (options?.publishOptions?.statusListEncoding &&
-                                !Object.values(DefaultStatusList2021Encodings).includes(options?.publishOptions?.statusListEncoding)) {
+                                !Object.values(DefaultStatusListEncodings).includes(options?.publishOptions?.statusListEncoding)) {
                                 throw new Error('[did-provider-cheqd]: revocation: Invalid status list encoding');
                             }
                             // validate validUntil, if provided
@@ -2632,7 +4076,7 @@ export class Cheqd {
                     ? toString(published?.[1]?.symmetricKey, 'hex')
                     : undefined,
                 resourceMetadata: topArgs?.returnStatusListMetadata
-                    ? await Cheqd.fetchStatusList2021Metadata(credentials[0])
+                    ? await Cheqd.fetchStatusListMetadata(credentials[0])
                     : undefined,
             };
         }
@@ -2728,13 +4172,13 @@ export class Cheqd {
             const published = topArgs?.publish
                 ? await (async function () {
                     // fetch status list 2021 metadata
-                    const statusListMetadata = await Cheqd.fetchStatusList2021Metadata(credential);
+                    const statusListMetadata = await Cheqd.fetchStatusListMetadata(credential);
                     // publish status list 2021 as new version
                     const scoped = topArgs.publishEncrypted
                         ? await (async function () {
                             // validate encoding, if provided
                             if (options?.publishOptions?.statusListEncoding &&
-                                !Object.values(DefaultStatusList2021Encodings).includes(options?.publishOptions?.statusListEncoding)) {
+                                !Object.values(DefaultStatusListEncodings).includes(options?.publishOptions?.statusListEncoding)) {
                                 throw new Error('[did-provider-cheqd]: suspension: Invalid status list encoding');
                             }
                             // validate validUntil, if provided
@@ -2863,7 +4307,7 @@ export class Cheqd {
                         : await (async function () {
                             // validate encoding, if provided
                             if (options?.publishOptions?.statusListEncoding &&
-                                !Object.values(DefaultStatusList2021Encodings).includes(options?.publishOptions?.statusListEncoding)) {
+                                !Object.values(DefaultStatusListEncodings).includes(options?.publishOptions?.statusListEncoding)) {
                                 throw new Error('[did-provider-cheqd]: suspension: Invalid status list encoding');
                             }
                             // validate validUntil, if provided
@@ -2923,7 +4367,7 @@ export class Cheqd {
                     ? toString(published?.[1]?.symmetricKey, 'hex')
                     : undefined,
                 resourceMetadata: topArgs?.returnStatusListMetadata
-                    ? await Cheqd.fetchStatusList2021Metadata(credential)
+                    ? await Cheqd.fetchStatusListMetadata(credential)
                     : undefined,
             };
         }
@@ -3067,13 +4511,13 @@ export class Cheqd {
             const published = topArgs?.publish
                 ? await (async function () {
                     // fetch status list 2021 metadata
-                    const statusListMetadata = await Cheqd.fetchStatusList2021Metadata(credentials[0]);
+                    const statusListMetadata = await Cheqd.fetchStatusListMetadata(credentials[0]);
                     // publish status list 2021 as new version
                     const scoped = topArgs.publishEncrypted
                         ? await (async function () {
                             // validate encoding, if provided
                             if (options?.publishOptions?.statusListEncoding &&
-                                !Object.values(DefaultStatusList2021Encodings).includes(options?.publishOptions?.statusListEncoding)) {
+                                !Object.values(DefaultStatusListEncodings).includes(options?.publishOptions?.statusListEncoding)) {
                                 throw new Error('[did-provider-cheqd]: suspension: Invalid status list encoding');
                             }
                             // validate validUntil, if provided
@@ -3202,7 +4646,7 @@ export class Cheqd {
                         : await (async function () {
                             // validate encoding, if provided
                             if (options?.publishOptions?.statusListEncoding &&
-                                !Object.values(DefaultStatusList2021Encodings).includes(options?.publishOptions?.statusListEncoding)) {
+                                !Object.values(DefaultStatusListEncodings).includes(options?.publishOptions?.statusListEncoding)) {
                                 throw new Error('[did-provider-cheqd]: suspension: Invalid status list encoding');
                             }
                             // validate validUntil, if provided
@@ -3262,7 +4706,7 @@ export class Cheqd {
                     ? toString(published?.[1]?.symmetricKey, 'hex')
                     : undefined,
                 resourceMetadata: topArgs?.returnStatusListMetadata
-                    ? await Cheqd.fetchStatusList2021Metadata(credentials[0])
+                    ? await Cheqd.fetchStatusListMetadata(credentials[0])
                     : undefined,
             };
         }
@@ -3358,13 +4802,13 @@ export class Cheqd {
             const published = topArgs?.publish
                 ? await (async function () {
                     // fetch status list 2021 metadata
-                    const statusListMetadata = await Cheqd.fetchStatusList2021Metadata(credential);
+                    const statusListMetadata = await Cheqd.fetchStatusListMetadata(credential);
                     // publish status list 2021 as new version
                     const scoped = topArgs.publishEncrypted
                         ? await (async function () {
                             // validate encoding, if provided
                             if (options?.publishOptions?.statusListEncoding &&
-                                !Object.values(DefaultStatusList2021Encodings).includes(options?.publishOptions?.statusListEncoding)) {
+                                !Object.values(DefaultStatusListEncodings).includes(options?.publishOptions?.statusListEncoding)) {
                                 throw new Error('[did-provider-cheqd]: unsuspension: Invalid status list encoding');
                             }
                             // validate validUntil, if provided
@@ -3493,7 +4937,7 @@ export class Cheqd {
                         : await (async function () {
                             // validate encoding, if provided
                             if (options?.publishOptions?.statusListEncoding &&
-                                !Object.values(DefaultStatusList2021Encodings).includes(options?.publishOptions?.statusListEncoding)) {
+                                !Object.values(DefaultStatusListEncodings).includes(options?.publishOptions?.statusListEncoding)) {
                                 throw new Error('[did-provider-cheqd]: unsuspension: Invalid status list encoding');
                             }
                             // validate validUntil, if provided
@@ -3553,7 +4997,7 @@ export class Cheqd {
                     ? toString(published?.[1]?.symmetricKey, 'hex')
                     : undefined,
                 resourceMetadata: topArgs?.returnStatusListMetadata
-                    ? await Cheqd.fetchStatusList2021Metadata(credential)
+                    ? await Cheqd.fetchStatusListMetadata(credential)
                     : undefined,
             };
         }
@@ -3697,13 +5141,13 @@ export class Cheqd {
             const published = topArgs?.publish
                 ? await (async function () {
                     // fetch status list 2021 metadata
-                    const statusListMetadata = await Cheqd.fetchStatusList2021Metadata(credentials[0]);
+                    const statusListMetadata = await Cheqd.fetchStatusListMetadata(credentials[0]);
                     // publish status list 2021 as new version
                     const scoped = topArgs.publishEncrypted
                         ? await (async function () {
                             // validate encoding, if provided
                             if (options?.publishOptions?.statusListEncoding &&
-                                !Object.values(DefaultStatusList2021Encodings).includes(options?.publishOptions?.statusListEncoding)) {
+                                !Object.values(DefaultStatusListEncodings).includes(options?.publishOptions?.statusListEncoding)) {
                                 throw new Error('[did-provider-cheqd]: unsuspension: Invalid status list encoding');
                             }
                             // validate validUntil, if provided
@@ -3832,7 +5276,7 @@ export class Cheqd {
                         : await (async function () {
                             // validate encoding, if provided
                             if (options?.publishOptions?.statusListEncoding &&
-                                !Object.values(DefaultStatusList2021Encodings).includes(options?.publishOptions?.statusListEncoding)) {
+                                !Object.values(DefaultStatusListEncodings).includes(options?.publishOptions?.statusListEncoding)) {
                                 throw new Error('[did-provider-cheqd]: unsuspension: Invalid status list encoding');
                             }
                             // validate validUntil, if provided
@@ -3892,7 +5336,7 @@ export class Cheqd {
                     ? toString(published?.[1]?.symmetricKey, 'hex')
                     : undefined,
                 resourceMetadata: topArgs?.returnStatusListMetadata
-                    ? await Cheqd.fetchStatusList2021Metadata(credentials[0])
+                    ? await Cheqd.fetchStatusListMetadata(credentials[0])
                     : undefined,
             };
         }
@@ -4295,7 +5739,7 @@ export class Cheqd {
         // otherwise, return content
         return content;
     }
-    static async fetchStatusList2021Metadata(credential) {
+    static async fetchStatusListMetadata(credential) {
         // get base url
         const baseUrl = new URL(credential.credentialStatus.id.split('#')[0]);
         // get resource name
@@ -4326,6 +5770,26 @@ export class Cheqd {
         return (resourceVersioning.find((resource) => !resource.nextVersionId) ||
             resourceVersioning.sort((a, b) => new Date(b.created).getTime() - new Date(a.created).getTime())[0]);
     }
+    /**
+     * Fetch the JSON metadata from a bitstring status list credential URL
+     */
+    static async fetchBitstringStatusList(credential) {
+        // get base url
+        const baseUrl = new URL(credential.credentialStatus.id.split('#')[0]);
+        // fetch collection metadata
+        const response = await fetch(baseUrl, {
+            method: 'GET',
+            headers: {
+                Accept: 'application/json',
+                'Content-Type': 'application/json',
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`[did-provider-cheqd]: Bitstring Status List retrieval error ${response.status}: ${response.statusText}`);
+        }
+        const data = await response.json();
+        return data;
+    }
     static async getProviderFromDidUrl(didUrl, providers, message) {
         const provider = providers.find((provider) => didUrl.includes(`${DidPrefix}:${CheqdDidMethod}:${provider.network}:`));
         if (!provider) {
@@ -4392,5 +5856,21 @@ export class Cheqd {
             issuer: decodedCredential.payload.iss,
         };
     }
+    static getBitValue(bitstring, bitIndex, statusSize = 1) {
+        let value = 0;
+        for (let i = 0; i < statusSize; i++) {
+            const bit = bitstring.get(bitIndex + i);
+            value |= bit << i;
+        }
+        return value;
+    }
+    // Helper function to set bit values in a bitstring (2-bit values)
+    static setBitValue(bitstring, bitIndex, value, statusSize = 2) {
+        for (let i = 0; i < statusSize; i++) {
+            const bit = (value >> i) & 1;
+            bitstring.set(bitIndex + i, bit === 1);
+        }
+    }
 }
+export { BitstringStatusListResourceType, DefaultStatusListEncodings };
 //# sourceMappingURL=ICheqd.js.map