@cheqd/did-provider-cheqd 4.4.1 → 4.5.0-develop.1

package/build/cjs/agent/ICheqd.js

@@ -1,4399 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Cheqd = exports.CheqdDidMethod = exports.DidPrefix = exports.DelegateCapacityCreditMethodName = exports.MintCapacityCreditMethodName = exports.ObservePaymentConditionMethodName = exports.TransactSendTokensMethodName = exports.UnsuspendCredentialsMethodName = exports.UnsuspendCredentialMethodName = exports.SuspendCredentialsMethodName = exports.SuspendCredentialMethodName = exports.RevokeCredentialsMethodName = exports.RevokeCredentialMethodName = exports.CheckCredentialStatusMethodName = exports.VerifyPresentationMethodName = exports.VerifyCredentialMethodName = exports.IssueSuspendableCredentialWithStatusList2021MethodName = exports.IssueRevocableCredentialWithStatusList2021MethodName = exports.GenerateStatusList2021MethodName = exports.GenerateVersionIdMethodName = exports.GenerateKeyPairMethodName = exports.GenerateDidDocWithLinkedResourceMethodName = exports.GenerateDidDocMethodName = exports.BroadcastStatusList2021MethodName = exports.CreateStatusList2021MethodName = exports.CreateResourceMethodName = exports.DeactivateIdentifierMethodName = exports.UpdateIdentifierMethodName = exports.CreateIdentifierMethodName = exports.RemoteListPattern = exports.AccessControlConditionReturnValueComparators = exports.AccessControlConditionTypes = void 0;
-/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-unused-vars, @typescript-eslint/no-non-null-assertion */
-// any is used for extensibility
-// 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
-const sdk_1 = require("@cheqd/sdk");
-const cheqd_did_provider_js_1 = require("../did-manager/cheqd-did-provider.js");
-const uint8arrays_1 = require("uint8arrays");
-const did_jwt_1 = require("did-jwt");
-const vc_status_list_1 = require("@digitalbazaar/vc-status-list");
-const uuid_1 = require("uuid");
-const fs_1 = __importDefault(require("fs"));
-const debug_1 = __importDefault(require("debug"));
-const v6_js_1 = require("../dkg-threshold/lit-protocol/v6.js");
-const helpers_js_1 = require("../utils/helpers.js");
-const cheqd_did_resolver_js_1 = require("../did-manager/cheqd-did-resolver.js");
-const v2_js_1 = require("../dkg-threshold/lit-protocol/v2.js");
-const debug = (0, debug_1.default)('veramo:did-provider-cheqd');
-exports.AccessControlConditionTypes = {
-    timelockPayment: 'timelockPayment',
-    memoNonce: 'memoNonce',
-    balance: 'balance',
-};
-exports.AccessControlConditionReturnValueComparators = {
-    lessThan: '<',
-    greaterThan: '>',
-    equalTo: '=',
-    lessThanOrEqualTo: '<=',
-    greaterThanOrEqualTo: '>=',
-};
-exports.RemoteListPattern = /^(https:\/\/)?[a-z0-9_-]+(\.[a-z0-9_-]+)*\.[a-z]{2,}\/1\.0\/identifiers\/did:cheqd:[a-z]+:[a-zA-Z0-9-]+\?((resourceName=[^&]*)&(resourceType=[^&]*)|((resourceType=[^&]*)&(resourceName=[^&]*)))$/;
-exports.CreateIdentifierMethodName = 'cheqdCreateIdentifier';
-exports.UpdateIdentifierMethodName = 'cheqdUpdateIdentifier';
-exports.DeactivateIdentifierMethodName = 'cheqdDeactivateIdentifier';
-exports.CreateResourceMethodName = 'cheqdCreateLinkedResource';
-exports.CreateStatusList2021MethodName = 'cheqdCreateStatusList2021';
-exports.BroadcastStatusList2021MethodName = 'cheqdBroadcastStatusList2021';
-exports.GenerateDidDocMethodName = 'cheqdGenerateDidDoc';
-exports.GenerateDidDocWithLinkedResourceMethodName = 'cheqdGenerateDidDocWithLinkedResource';
-exports.GenerateKeyPairMethodName = 'cheqdGenerateIdentityKeys';
-exports.GenerateVersionIdMethodName = 'cheqdGenerateVersionId';
-exports.GenerateStatusList2021MethodName = 'cheqdGenerateStatusList2021';
-exports.IssueRevocableCredentialWithStatusList2021MethodName = 'cheqdIssueRevocableCredentialWithStatusList2021';
-exports.IssueSuspendableCredentialWithStatusList2021MethodName = 'cheqdIssueSuspendableCredentialWithStatusList2021';
-exports.VerifyCredentialMethodName = 'cheqdVerifyCredential';
-exports.VerifyPresentationMethodName = 'cheqdVerifyPresentation';
-exports.CheckCredentialStatusMethodName = 'cheqdCheckCredentialStatus';
-exports.RevokeCredentialMethodName = 'cheqdRevokeCredential';
-exports.RevokeCredentialsMethodName = 'cheqdRevokeCredentials';
-exports.SuspendCredentialMethodName = 'cheqdSuspendCredential';
-exports.SuspendCredentialsMethodName = 'cheqdSuspendCredentials';
-exports.UnsuspendCredentialMethodName = 'cheqdUnsuspendCredential';
-exports.UnsuspendCredentialsMethodName = 'cheqdUnsuspendCredentials';
-exports.TransactSendTokensMethodName = 'cheqdTransactSendTokens';
-exports.ObservePaymentConditionMethodName = 'cheqdObservePaymentCondition';
-exports.MintCapacityCreditMethodName = 'cheqdMintCapacityCredit';
-exports.DelegateCapacityCreditMethodName = 'cheqdDelegateCapacityCredit';
-exports.DidPrefix = 'did';
-exports.CheqdDidMethod = 'cheqd';
-class Cheqd {
-    methods;
-    schema = {
-        components: {
-            schemas: {},
-            methods: {
-                cheqdCreateIdentifier: {
-                    description: 'Create a new identifier',
-                    arguments: {
-                        type: 'object',
-                        properties: {
-                            args: {
-                                type: 'object',
-                                description: 'A cheqdCreateIdentifierArgs object as any for extensibility',
-                            },
-                        },
-                        required: ['args'],
-                    },
-                    returnType: {
-                        type: 'object',
-                    },
-                },
-                cheqdUpdateIdentifier: {
-                    description: 'Update an identifier',
-                    arguments: {
-                        type: 'object',
-                        properties: {
-                            args: {
-                                type: 'object',
-                                description: 'A cheqdUpdateIdentifierArgs object as any for extensibility',
-                            },
-                        },
-                        required: ['args'],
-                    },
-                    returnType: {
-                        type: 'object',
-                    },
-                },
-                cheqdDeactivateIdentifier: {
-                    description: 'Deactivate an identifier',
-                    arguments: {
-                        type: 'object',
-                        properties: {
-                            args: {
-                                type: 'object',
-                                description: 'A cheqdDeactivateIdentifierArgs object as any for extensibility',
-                            },
-                        },
-                        required: ['args'],
-                    },
-                    returnType: {
-                        type: 'object',
-                    },
-                },
-                cheqdCreateLinkedResource: {
-                    description: 'Create a new resource',
-                    arguments: {
-                        type: 'object',
-                        properties: {
-                            args: {
-                                type: 'object',
-                                description: 'A cheqdCreateLinkedResource object as any for extensibility',
-                            },
-                        },
-                        required: ['args'],
-                    },
-                    returnType: {
-                        type: 'boolean',
-                    },
-                },
-                cheqdCreateStatusList2021: {
-                    description: 'Create a new Status List 2021',
-                    arguments: {
-                        type: 'object',
-                        properties: {
-                            args: {
-                                type: 'object',
-                                description: 'A cheqdCreateStatusList2021Args object as any for extensibility',
-                            },
-                        },
-                        required: ['args'],
-                    },
-                    returnType: {
-                        type: 'object',
-                    },
-                },
-                cheqdBroadcastStatusList2021: {
-                    description: 'Broadcast a Status List 2021 to cheqd ledger',
-                    arguments: {
-                        type: 'object',
-                        properties: {
-                            args: {
-                                type: 'object',
-                                description: 'A cheqdBroadcastStatusList2021Args object as any for extensibility',
-                            },
-                        },
-                        required: ['args'],
-                    },
-                    returnType: {
-                        type: 'object',
-                    },
-                },
-                cheqdGenerateDidDoc: {
-                    description: 'Generate a new DID document to use with `createIdentifier`',
-                    arguments: {
-                        type: 'object',
-                        properties: {
-                            args: {
-                                type: 'object',
-                                description: 'A cheqdGenerateDidDocArgs object as any for extensibility',
-                            },
-                        },
-                        required: ['args'],
-                    },
-                    returnType: {
-                        type: 'object',
-                    },
-                },
-                cheqdGenerateDidDocWithLinkedResource: {
-                    description: 'Generate a new DID document to use with `createIdentifier` and / or `createResource`',
-                    arguments: {
-                        type: 'object',
-                        properties: {
-                            args: {
-                                type: 'object',
-                                description: 'A cheqdGenerateDidDocWithLinkedResourceArgs object as any for extensibility',
-                            },
-                        },
-                        required: ['args'],
-                    },
-                    returnType: {
-                        type: 'object',
-                    },
-                },
-                cheqdGenerateIdentityKeys: {
-                    description: 'Generate a new key pair in hex to use with `createIdentifier`',
-                    arguments: {
-                        type: 'object',
-                        properties: {
-                            args: {
-                                type: 'object',
-                                description: 'A cheqdGenerateIdentityKeysArgs object as any for extensibility',
-                            },
-                        },
-                    },
-                    returnType: {
-                        type: 'object',
-                    },
-                },
-                cheqdGenerateVersionId: {
-                    description: 'Generate a random uuid',
-                    arguments: {
-                        type: 'object',
-                        properties: {
-                            args: {
-                                type: 'object',
-                                description: 'A cheqdGenerateVersionIdArgs object as any for extensibility',
-                            },
-                        },
-                    },
-                    returnType: {
-                        type: 'object',
-                    },
-                },
-                cheqdGenerateStatusList2021: {
-                    description: 'Generate a new Status List 2021',
-                    arguments: {
-                        type: 'object',
-                        properties: {
-                            args: {
-                                type: 'object',
-                                description: 'A cheqdGenerateStatusList2021Args object as any for extensibility',
-                            },
-                        },
-                    },
-                    returnType: {
-                        type: 'string',
-                    },
-                },
-                cheqdIssueRevocableCredentialWithStatusList2021: {
-                    description: 'Issue a revocable credential with a Status List 2021 as credential status registry',
-                    arguments: {
-                        type: 'object',
-                        properties: {
-                            args: {
-                                type: 'object',
-                                description: 'A cheqdIssueCredentialWithStatusList2021Args object as any for extensibility',
-                            },
-                        },
-                        required: ['args'],
-                    },
-                    returnType: {
-                        type: 'object',
-                    },
-                },
-                cheqdIssueSuspendableCredentialWithStatusList2021: {
-                    description: 'Issue a suspendable credential with a Status List 2021 as credential status registry',
-                    arguments: {
-                        type: 'object',
-                        properties: {
-                            args: {
-                                type: 'object',
-                                description: 'A cheqdIssueCredentialWithStatusList2021Args object as any for extensibility',
-                            },
-                        },
-                        required: ['args'],
-                    },
-                    returnType: {
-                        type: 'object',
-                    },
-                },
-                cheqdVerifyCredential: {
-                    description: 'Verify a credential, enhanced by revocation / suspension check with a Status List 2021 as credential status registry',
-                    arguments: {
-                        type: 'object',
-                        properties: {
-                            args: {
-                                type: 'object',
-                                description: 'A cheqdVerifyCredentialWithStatusList2021Args object as any for extensibility',
-                            },
-                        },
-                        required: ['args'],
-                    },
-                    returnType: {
-                        type: 'object',
-                    },
-                },
-                cheqdVerifyPresentation: {
-                    description: 'Verify a presentation, enhanced by revocation / suspension check with a Status List 2021 as credential status registry',
-                    arguments: {
-                        type: 'object',
-                        properties: {
-                            args: {
-                                type: 'object',
-                                description: 'A cheqdVerifyPresentationWithStatusList2021Args object as any for extensibility',
-                            },
-                        },
-                        required: ['args'],
-                    },
-                    returnType: {
-                        type: 'object',
-                    },
-                },
-                cheqdCheckCredentialStatus: {
-                    description: 'Check the revocation / suspension status of a credential with a Status List 2021 as credential status registry',
-                    arguments: {
-                        type: 'object',
-                        properties: {
-                            args: {
-                                type: 'object',
-                                description: 'A cheqdCheckCredentialStatusWithStatusList2021Args object as any for extensibility',
-                            },
-                        },
-                        required: ['args'],
-                    },
-                    returnType: {
-                        type: 'object',
-                    },
-                },
-                cheqdRevokeCredential: {
-                    description: 'Revoke a credential against a Status List 2021 as credential status registry',
-                    arguments: {
-                        type: 'object',
-                        properties: {
-                            args: {
-                                type: 'object',
-                                description: 'A cheqdRevokeCredentialWithStatusList2021Args object as any for extensibility',
-                            },
-                        },
-                        required: ['args'],
-                    },
-                    returnType: {
-                        type: 'object',
-                    },
-                },
-                cheqdRevokeCredentials: {
-                    description: 'Revoke multiple credentials against a Status List 2021 as credential status registry',
-                    arguments: {
-                        type: 'object',
-                        properties: {
-                            args: {
-                                type: 'object',
-                                description: 'A cheqdRevokeBulkCredentialsWithStatusList2021Args object as any for extensibility',
-                            },
-                        },
-                        required: ['args'],
-                    },
-                    returnType: {
-                        type: 'array',
-                    },
-                },
-                cheqdSuspendCredential: {
-                    description: 'Suspend a credential against a Status List 2021 as credential status registry',
-                    arguments: {
-                        type: 'object',
-                        properties: {
-                            args: {
-                                type: 'object',
-                                description: 'A cheqdSuspendCredentialWithStatusList2021Args object as any for extensibility',
-                            },
-                        },
-                        required: ['args'],
-                    },
-                    returnType: {
-                        type: 'object',
-                    },
-                },
-                cheqdSuspendCredentials: {
-                    description: 'Suspend multiple credentials against a Status List 2021 as credential status registry',
-                    arguments: {
-                        type: 'object',
-                        properties: {
-                            args: {
-                                type: 'object',
-                                description: 'A cheqdSuspendBulkCredentialsWithStatusList2021Args object as any for extensibility',
-                            },
-                        },
-                        required: ['args'],
-                    },
-                    returnType: {
-                        type: 'array',
-                    },
-                },
-                cheqdUnsuspendCredential: {
-                    description: 'Unsuspend a credential against a Status List 2021 as credential status registry',
-                    arguments: {
-                        type: 'object',
-                        properties: {
-                            args: {
-                                type: 'object',
-                                description: 'cheqdUnsuspendCredentialWithStatusList2021Args object as any for extensibility',
-                            },
-                        },
-                        required: ['args'],
-                    },
-                    returnType: {
-                        type: 'object',
-                    },
-                },
-                cheqdUnsuspendCredentials: {
-                    description: 'Unsuspend multiple credentials against a Status List 2021 as credential status registry',
-                    arguments: {
-                        type: 'object',
-                        properties: {
-                            args: {
-                                type: 'object',
-                                description: 'A cheqdUnsuspendBulkCredentialsWithStatusList2021Args object as any for extensibility',
-                            },
-                        },
-                        required: ['args'],
-                    },
-                    returnType: {
-                        type: 'array',
-                    },
-                },
-                cheqdTransactSendTokens: {
-                    description: 'Send tokens from one account to another',
-                    arguments: {
-                        type: 'object',
-                        properties: {
-                            args: {
-                                type: 'object',
-                                description: 'A cheqdTransactSendTokensArgs object as any for extensibility',
-                            },
-                        },
-                        required: ['args'],
-                    },
-                    returnType: {
-                        type: 'object',
-                    },
-                },
-                cheqdObservePaymentCondition: {
-                    description: 'Observe payment conditions for a given set of payment conditions',
-                    arguments: {
-                        type: 'object',
-                        properties: {
-                            args: {
-                                type: 'object',
-                                description: 'cheqdObservePaymentConditionArgs object as any for extensibility',
-                            },
-                        },
-                        required: ['args'],
-                    },
-                    returnType: {
-                        type: 'object',
-                    },
-                },
-            },
-        },
-    };
-    supportedDidProviders;
-    didProvider;
-    providerId;
-    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';
-    constructor(args) {
-        if (typeof args.providers !== 'object') {
-            throw new Error('[did-provider-cheqd]: at least one did provider is required');
-        }
-        this.supportedDidProviders = args.providers;
-        this.didProvider = args.providers[0];
-        this.providerId = Cheqd.generateProviderId(this.didProvider.network);
-        this.methods = {
-            [exports.CreateIdentifierMethodName]: this.CreateIdentifier.bind(this),
-            [exports.UpdateIdentifierMethodName]: this.UpdateIdentifier.bind(this),
-            [exports.DeactivateIdentifierMethodName]: this.DeactivateIdentifier.bind(this),
-            [exports.CreateResourceMethodName]: this.CreateResource.bind(this),
-            [exports.CreateStatusList2021MethodName]: this.CreateStatusList2021.bind(this),
-            [exports.BroadcastStatusList2021MethodName]: this.BroadcastStatusList2021.bind(this),
-            [exports.GenerateDidDocMethodName]: this.GenerateDidDoc.bind(this),
-            [exports.GenerateDidDocWithLinkedResourceMethodName]: this.GenerateDidDocWithLinkedResource.bind(this),
-            [exports.GenerateKeyPairMethodName]: this.GenerateIdentityKeys.bind(this),
-            [exports.GenerateVersionIdMethodName]: this.GenerateVersionId.bind(this),
-            [exports.GenerateStatusList2021MethodName]: this.GenerateStatusList2021.bind(this),
-            [exports.IssueRevocableCredentialWithStatusList2021MethodName]: this.IssueRevocableCredentialWithStatusList2021.bind(this),
-            [exports.IssueSuspendableCredentialWithStatusList2021MethodName]: this.IssueSuspendableCredentialWithStatusList2021.bind(this),
-            [exports.VerifyCredentialMethodName]: this.VerifyCredentialWithStatusList2021.bind(this),
-            [exports.VerifyPresentationMethodName]: this.VerifyPresentationWithStatusList2021.bind(this),
-            [exports.CheckCredentialStatusMethodName]: this.CheckCredentialStatusWithStatusList2021.bind(this),
-            [exports.RevokeCredentialMethodName]: this.RevokeCredentialWithStatusList2021.bind(this),
-            [exports.RevokeCredentialsMethodName]: this.RevokeBulkCredentialsWithStatusList2021.bind(this),
-            [exports.SuspendCredentialMethodName]: this.SuspendCredentialWithStatusList2021.bind(this),
-            [exports.SuspendCredentialsMethodName]: this.SuspendBulkCredentialsWithStatusList2021.bind(this),
-            [exports.UnsuspendCredentialMethodName]: this.UnsuspendCredentialWithStatusList2021.bind(this),
-            [exports.UnsuspendCredentialsMethodName]: this.UnsuspendBulkCredentialsWithStatusList2021.bind(this),
-            [exports.TransactSendTokensMethodName]: this.TransactSendTokens.bind(this),
-            [exports.ObservePaymentConditionMethodName]: this.ObservePaymentCondition.bind(this),
-            [exports.MintCapacityCreditMethodName]: this.MintCapacityCredit.bind(this),
-            [exports.DelegateCapacityCreditMethodName]: this.DelegateCapacityCredit.bind(this),
-        };
-    }
-    async CreateIdentifier(args, context) {
-        if (typeof args.kms !== 'string') {
-            throw new Error('[did-provider-cheqd]: kms is required');
-        }
-        if (typeof args.alias !== 'string') {
-            throw new Error('[did-provider-cheqd]: alias is required');
-        }
-        if (typeof args.document !== 'object') {
-            throw new Error('[did-provider-cheqd]: document object is required');
-        }
-        const provider = await Cheqd.getProviderFromDidUrl(args.document.id, this.supportedDidProviders);
-        this.didProvider = provider;
-        this.providerId = Cheqd.generateProviderId(this.didProvider.network);
-        return await context.agent.didManagerCreate({
-            kms: args.kms,
-            alias: args.alias,
-            provider: this.providerId,
-            options: {
-                document: args.document,
-                keys: args.keys,
-                versionId: args?.versionId,
-                fee: args?.fee,
-            },
-        });
-    }
-    async UpdateIdentifier(args, context) {
-        if (typeof args.kms !== 'string') {
-            throw new Error('[did-provider-cheqd]: kms is required');
-        }
-        if (typeof args.document !== 'object') {
-            throw new Error('[did-provider-cheqd]: document object is required');
-        }
-        const provider = await Cheqd.getProviderFromDidUrl(args.document.id, this.supportedDidProviders);
-        this.didProvider = provider;
-        this.providerId = Cheqd.generateProviderId(this.didProvider.network);
-        return await context.agent.didManagerUpdate({
-            did: args.document.id,
-            document: args.document,
-            options: {
-                kms: args.kms,
-                keys: args.keys,
-                versionId: args?.versionId,
-                fee: args?.fee,
-            },
-        });
-    }
-    async DeactivateIdentifier(args, context) {
-        if (typeof args.kms !== 'string') {
-            throw new Error('[did-provider-cheqd]: kms is required');
-        }
-        if (typeof args.document !== 'object') {
-            throw new Error('[did-provider-cheqd]: document object is required');
-        }
-        const provider = await Cheqd.getProviderFromDidUrl(args.document.id, this.supportedDidProviders);
-        this.didProvider = provider;
-        this.providerId = Cheqd.generateProviderId(this.didProvider.network);
-        return await this.didProvider.deactivateIdentifier({
-            did: args.document.id,
-            document: args.document,
-            options: {
-                keys: args.keys,
-                fee: args?.fee,
-            },
-        }, context);
-    }
-    async CreateResource(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 = (0, uint8arrays_1.fromString)(args.payload.data, 'base64');
-        }
-        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,
-            },
-        }, context);
-    }
-    async CreateStatusList2021(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 (typeof args.statusPurpose !== 'string' || !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
-        if (!Object.values(cheqd_did_provider_js_1.DefaultStatusList2021StatusPurposeTypes).includes(args.statusPurpose)) {
-            throw new Error(`[did-provider-cheqd]: statusPurpose must be one of ${Object.values(cheqd_did_provider_js_1.DefaultStatusList2021StatusPurposeTypes).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.defaultStatusList2021Length) {
-                throw new Error(`[did-provider-cheqd]: statusListLength must be greater than or equal to ${Cheqd.defaultStatusList2021Length} number of entries`);
-            }
-        }
-        // validate statusListEncoding
-        if (args?.statusListEncoding) {
-            if (typeof args.statusListEncoding !== 'string') {
-                throw new Error('[did-provider-cheqd]: statusListEncoding must be string');
-            }
-            if (!Object.values(cheqd_did_provider_js_1.DefaultStatusList2021Encodings).includes(args.statusListEncoding)) {
-                throw new Error(`[did-provider-cheqd]: statusListEncoding must be one of ${Object.values(cheqd_did_provider_js_1.DefaultStatusList2021Encodings).join(', ')}`);
-            }
-        }
-        // 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 === exports.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[exports.GenerateStatusList2021MethodName]({
-            length: args?.statusListLength || Cheqd.defaultStatusList2021Length,
-            bitstringEncoding: args?.statusListEncoding || cheqd_did_provider_js_1.DefaultStatusList2021Encodings.base64url,
-        });
-        // construct data and metadata tuple
-        const data = args.encrypted
-            ? await (async function (that) {
-                // encrypt bitstring - case: symmetric
-                const { encryptedString: symmetricEncryptionCiphertext, symmetricKey } = await v6_js_1.LitProtocol.encryptDirect((0, uint8arrays_1.fromString)(bitstring, args?.statusListEncoding || cheqd_did_provider_js_1.DefaultStatusList2021Encodings.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 exports.AccessControlConditionTypes.timelockPayment:
-                            return await v6_js_1.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((0, uint8arrays_1.fromString)(bitstring, args?.statusListEncoding || cheqd_did_provider_js_1.DefaultStatusList2021Encodings.base64url), unifiedAccessControlConditions);
-                // construct encoded list
-                const encodedList = `${await (0, helpers_js_1.blobToHexString)(symmetricEncryptionCiphertext)}-${(0, uint8arrays_1.toString)(thresholdEncryptionCiphertext, 'hex')}`;
-                // return result tuple
-                switch (args.statusPurpose) {
-                    case cheqd_did_provider_js_1.DefaultStatusList2021StatusPurposeTypes.revocation:
-                        return [
-                            {
-                                StatusList2021: {
-                                    statusPurpose: args.statusPurpose,
-                                    encodedList,
-                                    validFrom: new Date().toISOString(),
-                                    validUntil: args?.validUntil,
-                                },
-                                metadata: {
-                                    type: cheqd_did_provider_js_1.DefaultStatusList2021ResourceTypes.revocation,
-                                    encrypted: true,
-                                    encoding: args?.statusListEncoding || cheqd_did_provider_js_1.DefaultStatusList2021Encodings.base64url,
-                                    statusListHash: stringHash,
-                                    paymentConditions: args.paymentConditions,
-                                },
-                            },
-                            {
-                                symmetricEncryptionCiphertext: await (0, helpers_js_1.blobToHexString)(symmetricEncryptionCiphertext),
-                                thresholdEncryptionCiphertext: (0, uint8arrays_1.toString)(thresholdEncryptionCiphertext, 'hex'),
-                                stringHash,
-                                symmetricKey: (0, uint8arrays_1.toString)(symmetricKey, 'hex'),
-                            },
-                        ];
-                    case cheqd_did_provider_js_1.DefaultStatusList2021StatusPurposeTypes.suspension:
-                        return [
-                            {
-                                StatusList2021: {
-                                    statusPurpose: args.statusPurpose,
-                                    encodedList,
-                                    validFrom: new Date().toISOString(),
-                                    validUntil: args?.validUntil,
-                                },
-                                metadata: {
-                                    type: cheqd_did_provider_js_1.DefaultStatusList2021ResourceTypes.suspension,
-                                    encrypted: true,
-                                    encoding: args?.statusListEncoding || cheqd_did_provider_js_1.DefaultStatusList2021Encodings.base64url,
-                                    statusListHash: stringHash,
-                                    paymentConditions: args.paymentConditions,
-                                },
-                            },
-                            {
-                                symmetricEncryptionCiphertext: await (0, helpers_js_1.blobToHexString)(symmetricEncryptionCiphertext),
-                                thresholdEncryptionCiphertext: (0, uint8arrays_1.toString)(thresholdEncryptionCiphertext, 'hex'),
-                                stringHash,
-                                symmetricKey: (0, uint8arrays_1.toString)(symmetricKey, 'hex'),
-                            },
-                        ];
-                    default:
-                        throw new Error(`[did-provider-cheqd]: status purpose is not valid ${args.statusPurpose}`);
-                }
-            })(this)
-            : await (async function () {
-                switch (args.statusPurpose) {
-                    case cheqd_did_provider_js_1.DefaultStatusList2021StatusPurposeTypes.revocation:
-                        return [
-                            {
-                                StatusList2021: {
-                                    statusPurpose: args.statusPurpose,
-                                    encodedList: bitstring,
-                                    validFrom: new Date().toISOString(),
-                                    validUntil: args?.validUntil,
-                                },
-                                metadata: {
-                                    type: cheqd_did_provider_js_1.DefaultStatusList2021ResourceTypes.revocation,
-                                    encrypted: false,
-                                    encoding: args?.statusListEncoding || cheqd_did_provider_js_1.DefaultStatusList2021Encodings.base64url,
-                                },
-                            },
-                            undefined,
-                        ];
-                    case cheqd_did_provider_js_1.DefaultStatusList2021StatusPurposeTypes.suspension:
-                        return [
-                            {
-                                StatusList2021: {
-                                    statusPurpose: args.statusPurpose,
-                                    encodedList: bitstring,
-                                    validFrom: new Date().toISOString(),
-                                    validUntil: args?.validUntil,
-                                },
-                                metadata: {
-                                    type: cheqd_did_provider_js_1.DefaultStatusList2021ResourceTypes.suspension,
-                                    encrypted: false,
-                                    encoding: args?.statusListEncoding || cheqd_did_provider_js_1.DefaultStatusList2021Encodings.base64url,
-                                },
-                            },
-                            undefined,
-                        ];
-                    default:
-                        throw new Error('[did-provider-cheqd]: statusPurpose is not valid');
-                }
-            })();
-        // construct payload
-        const payload = {
-            id: (0, uuid_1.v4)(),
-            collectionId: args.issuerDid.split(':').reverse()[0],
-            name: args.statusListName,
-            resourceType: cheqd_did_provider_js_1.DefaultStatusList2021ResourceTypes[args.statusPurpose],
-            version: args?.resourceVersion || new Date().toISOString(),
-            alsoKnownAs: args?.alsoKnownAs || [],
-            data: (0, uint8arrays_1.fromString)(JSON.stringify(data[0]), 'utf-8'),
-        };
-        // return result
-        return {
-            created: await context.agent[exports.BroadcastStatusList2021MethodName]({
-                kms: args.kms,
-                payload,
-                network: network,
-            }),
-            resource: data[0],
-            resourceMetadata: await Cheqd.fetchStatusList2021Metadata({
-                credentialStatus: {
-                    id: `${cheqd_did_resolver_js_1.DefaultResolverUrl}${args.issuerDid}?resourceName=${args.statusListName}&resourceType=${cheqd_did_provider_js_1.DefaultStatusList2021ResourceTypes[args.statusPurpose]}`,
-                    type: 'StatusList2021Entry',
-                },
-            }),
-            encrypted: args.encrypted,
-            symmetricKey: args.encrypted && args.returnSymmetricKey ? data[1]?.symmetricKey : undefined,
-        };
-    }
-    async BroadcastStatusList2021(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 = (0, uint8arrays_1.fromString)(args.payload.data, 'base64');
-        }
-        // TODO: validate data as per bitstring
-        // validate resource type
-        if (!Object.values(cheqd_did_provider_js_1.DefaultStatusList2021ResourceTypes).includes(args?.payload?.resourceType)) {
-            throw new Error(`[did-provider-cheqd]: resourceType must be one of ${Object.values(cheqd_did_provider_js_1.DefaultStatusList2021ResourceTypes).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 sdk_1.ResourceModule.generateCreateResourceJsonFees((await this.didProvider.getWalletAccounts())[0].address)),
-            },
-        }, context);
-    }
-    async GenerateDidDoc(args, context) {
-        if (typeof args.verificationMethod !== 'string') {
-            throw new Error('[did-provider-cheqd]: verificationMethod is required');
-        }
-        if (typeof args.methodSpecificIdAlgo !== 'string') {
-            throw new Error('[did-provider-cheqd]: methodSpecificIdAlgo is required');
-        }
-        if (typeof args.network !== 'string') {
-            throw new Error('[did-provider-cheqd]: network is required');
-        }
-        const keyPair = (0, sdk_1.createKeyPairBase64)();
-        const keyPairHex = {
-            publicKey: (0, uint8arrays_1.toString)((0, uint8arrays_1.fromString)(keyPair.publicKey, 'base64'), 'hex'),
-            privateKey: (0, uint8arrays_1.toString)((0, uint8arrays_1.fromString)(keyPair.privateKey, 'base64'), 'hex'),
-        };
-        const verificationKeys = (0, sdk_1.createVerificationKeys)(keyPair.publicKey, args.methodSpecificIdAlgo, 'key-1', args.network);
-        const verificationMethods = (0, sdk_1.createDidVerificationMethod)([args.verificationMethod], [verificationKeys]);
-        return {
-            didDoc: (0, sdk_1.createDidPayload)(verificationMethods, [verificationKeys]),
-            versionId: (0, uuid_1.v4)(),
-            keys: [
-                {
-                    publicKeyHex: keyPairHex.publicKey,
-                    privateKeyHex: keyPairHex.privateKey,
-                    kid: keyPairHex.publicKey,
-                    type: 'Ed25519',
-                },
-            ],
-        };
-    }
-    async GenerateDidDocWithLinkedResource(args, context) {
-        if (typeof args.verificationMethod !== 'string') {
-            throw new Error('[did-provider-cheqd]: verificationMethod is required');
-        }
-        if (typeof args.methodSpecificIdAlgo !== 'string') {
-            throw new Error('[did-provider-cheqd]: methodSpecificIdAlgo is required');
-        }
-        if (typeof args.network !== 'string') {
-            throw new Error('[did-provider-cheqd]: network is required');
-        }
-        const keyPair = (0, sdk_1.createKeyPairBase64)();
-        const keyPairHex = {
-            publicKey: (0, uint8arrays_1.toString)((0, uint8arrays_1.fromString)(keyPair.publicKey, 'base64'), 'hex'),
-            privateKey: (0, uint8arrays_1.toString)((0, uint8arrays_1.fromString)(keyPair.privateKey, 'base64'), 'hex'),
-        };
-        const verificationKeys = (0, sdk_1.createVerificationKeys)(keyPair.publicKey, args.methodSpecificIdAlgo, 'key-1', args.network);
-        const verificationMethods = (0, sdk_1.createDidVerificationMethod)([args.verificationMethod], [verificationKeys]);
-        const payload = (0, sdk_1.createDidPayload)(verificationMethods, [verificationKeys]);
-        return {
-            didDoc: payload,
-            versionId: (0, uuid_1.v4)(),
-            keys: [
-                {
-                    publicKeyHex: keyPairHex.publicKey,
-                    privateKeyHex: keyPairHex.privateKey,
-                    kid: keyPairHex.publicKey,
-                    type: 'Ed25519',
-                },
-            ],
-            linkedResource: {
-                id: (0, uuid_1.v4)(),
-                collectionId: payload.id.split(':').reverse()[0],
-                name: 'sample json resource',
-                version: '1.0.0',
-                resourceType: 'SampleResource',
-                alsoKnownAs: [],
-                data: (0, uint8arrays_1.toString)(new TextEncoder().encode(JSON.stringify({ sample: 'json' })), 'base64'),
-            },
-        };
-    }
-    async GenerateIdentityKeys(args, context) {
-        const keyPair = (0, sdk_1.createKeyPairHex)();
-        return {
-            publicKeyHex: keyPair.publicKey,
-            privateKeyHex: keyPair.privateKey,
-            kid: keyPair.publicKey,
-            type: 'Ed25519',
-        };
-    }
-    async GenerateVersionId(args, context) {
-        return (0, uuid_1.v4)();
-    }
-    async GenerateStatusList2021(args, context) {
-        const statusList = args?.buffer
-            ? new vc_status_list_1.StatusList({ buffer: args.buffer })
-            : new vc_status_list_1.StatusList({ length: args?.length || Cheqd.defaultStatusList2021Length });
-        const encoded = (await statusList.encode());
-        switch (args?.bitstringEncoding) {
-            case 'base64url':
-                return encoded;
-            case 'hex':
-                return (0, uint8arrays_1.toString)((0, uint8arrays_1.fromString)(encoded, 'base64url'), 'hex');
-            default:
-                return encoded;
-        }
-    }
-    async IssueRevocableCredentialWithStatusList2021(args, context) {
-        // generate index
-        const statusListIndex = args.statusOptions.statusListIndex ||
-            (await (0, helpers_js_1.randomFromRange)(args.statusOptions.statusListRangeStart || 0, (args.statusOptions.statusListRangeEnd || Cheqd.defaultStatusList2021Length) - 1, args.statusOptions.indexNotIn || []));
-        // construct issuer
-        const issuer = args.issuanceOptions.credential.issuer.id
-            ? args.issuanceOptions.credential.issuer.id
-            : args.issuanceOptions.credential.issuer;
-        // generate status list credential
-        const statusListCredential = `${cheqd_did_resolver_js_1.DefaultResolverUrl}${issuer}?resourceName=${args.statusOptions.statusListName}&resourceType=${cheqd_did_provider_js_1.DefaultStatusList2021ResourceTypes.revocation}`;
-        // construct credential status
-        const credentialStatus = {
-            id: `${statusListCredential}#${statusListIndex}`,
-            type: 'StatusList2021Entry',
-            statusPurpose: cheqd_did_provider_js_1.DefaultStatusList2021StatusPurposeTypes.revocation,
-            statusListIndex: `${statusListIndex}`,
-        };
-        // 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];
-        })();
-        // create a credential
-        const credential = await context.agent.createVerifiableCredential(args.issuanceOptions);
-        return credential;
-    }
-    async IssueSuspendableCredentialWithStatusList2021(args, context) {
-        // generate index
-        const statusListIndex = args.statusOptions.statusListIndex ||
-            (await (0, helpers_js_1.randomFromRange)(args.statusOptions.statusListRangeStart || 0, (args.statusOptions.statusListRangeEnd || Cheqd.defaultStatusList2021Length) - 1, args.statusOptions.indexNotIn || []));
-        // construct issuer
-        const issuer = args.issuanceOptions.credential.issuer.id
-            ? args.issuanceOptions.credential.issuer.id
-            : args.issuanceOptions.credential.issuer;
-        // generate status list credential
-        const statusListCredential = `${cheqd_did_resolver_js_1.DefaultResolverUrl}${issuer}?resourceName=${args.statusOptions.statusListName}&resourceType=${cheqd_did_provider_js_1.DefaultStatusList2021ResourceTypes.suspension}`;
-        // construct credential status
-        const credentialStatus = {
-            id: `${statusListCredential}#${statusListIndex}`,
-            type: 'StatusList2021Entry',
-            statusPurpose: cheqd_did_provider_js_1.DefaultStatusList2021StatusPurposeTypes.suspension,
-            statusListIndex: `${statusListIndex}`,
-        };
-        // 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];
-        })();
-        // create a credential
-        const credential = await context.agent.createVerifiableCredential(args.issuanceOptions);
-        return credential;
-    }
-    async VerifyCredentialWithStatusList2021(args, context) {
-        // verify default policies
-        const verificationResult = await context.agent.verifyCredential({
-            ...args?.verificationArgs,
-            credential: args.credential,
-            policies: {
-                ...args?.verificationArgs?.policies,
-                credentialStatus: false,
-            },
-        });
-        // early return if verification failed
-        if (!verificationResult.verified) {
-            return { verified: false, error: verificationResult.error };
-        }
-        // if jwt credential, decode it
-        const credential = typeof args.credential === 'string' ? await Cheqd.decodeCredentialJWT(args.credential) : args.credential;
-        // 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;
-        // verify credential status
-        switch (credential.credentialStatus?.statusPurpose) {
-            case cheqd_did_provider_js_1.DefaultStatusList2021StatusPurposeTypes.revocation:
-                return {
-                    ...verificationResult,
-                    revoked: await Cheqd.checkRevoked(credential, { ...args.options, topArgs: args }),
-                };
-            case cheqd_did_provider_js_1.DefaultStatusList2021StatusPurposeTypes.suspension:
-                return {
-                    ...verificationResult,
-                    suspended: await Cheqd.checkSuspended(credential, { ...args.options, topArgs: args }),
-                };
-            default:
-                throw new Error(`[did-provider-cheqd]: verify credential: Unsupported status purpose: ${credential.credentialStatus?.statusPurpose}`);
-        }
-    }
-    async VerifyPresentationWithStatusList2021(args, context) {
-        // verify default policies
-        const verificationResult = await context.agent.verifyPresentation({
-            ...args?.verificationArgs,
-            presentation: args.presentation,
-            policies: {
-                ...args?.verificationArgs?.policies,
-                credentialStatus: false,
-            },
-        });
-        // early return if verification failed
-        if (!verificationResult.verified) {
-            return { verified: false, error: verificationResult.error };
-        }
-        // early return if no verifiable credentials are provided
-        if (!args.presentation.verifiableCredential)
-            throw new Error('[did-provider-cheqd]: verify presentation: presentation.verifiableCredential is required');
-        // verify credential(s) status(es)
-        for (let credential of args.presentation.verifiableCredential) {
-            // if jwt credential, decode it
-            if (typeof credential === 'string')
-                credential = await Cheqd.decodeCredentialJWT(credential);
-            // 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;
-            switch (credential.credentialStatus?.statusPurpose) {
-                case cheqd_did_provider_js_1.DefaultStatusList2021StatusPurposeTypes.revocation:
-                    return {
-                        ...verificationResult,
-                        revoked: await Cheqd.checkRevoked(credential, { ...args.options, topArgs: args }),
-                    };
-                case cheqd_did_provider_js_1.DefaultStatusList2021StatusPurposeTypes.suspension:
-                    return {
-                        ...verificationResult,
-                        suspended: await Cheqd.checkSuspended(credential, { ...args.options, topArgs: args }),
-                    };
-                default:
-                    throw new Error(`[did-provider-cheqd]: verify presentation: Unsupported status purpose: ${credential.credentialStatus?.statusPurpose}`);
-            }
-        }
-        return { ...verificationResult, verified: true };
-    }
-    async CheckCredentialStatusWithStatusList2021(args, context) {
-        // verify credential, if provided and status options are not
-        if (args?.credential && !args?.statusOptions) {
-            const verificationResult = await context.agent.verifyCredential({
-                ...args?.verificationOptions,
-                credential: args.credential,
-                policies: {
-                    credentialStatus: false,
-                },
-            });
-            // early return if verification failed
-            if (!verificationResult.verified) {
-                return { revoked: false, error: verificationResult.error };
-            }
-        }
-        // if status options are provided, give precedence
-        if (args?.statusOptions) {
-            // validate status options - case: statusOptions.issuerDid
-            if (!args.statusOptions.issuerDid)
-                throw new Error('[did-provider-cheqd]: check status: statusOptions.issuerDid is required');
-            // validate status options - case: statusOptions.statusListName
-            if (!args.statusOptions.statusListName)
-                throw new Error('[did-provider-cheqd]: check status: statusOptions.statusListName is required');
-            // validate status options - case: statusOptions.statusListIndex
-            if (!args.statusOptions.statusPurpose)
-                throw new Error('[did-provider-cheqd]: check status: statusOptions.statusListIndex is required');
-            // validate status options - case: statusOptions.statusListIndex
-            if (!args.statusOptions.statusListIndex)
-                throw new Error('[did-provider-cheqd]: check status: statusOptions.statusListIndex is required');
-            // generate resource type
-            const resourceType = args.statusOptions.statusPurpose === cheqd_did_provider_js_1.DefaultStatusList2021StatusPurposeTypes.revocation
-                ? cheqd_did_provider_js_1.DefaultStatusList2021ResourceTypes.revocation
-                : cheqd_did_provider_js_1.DefaultStatusList2021ResourceTypes.suspension;
-            // construct status list credential
-            const statusListCredential = `${cheqd_did_resolver_js_1.DefaultResolverUrl}${args.statusOptions.issuerDid}?resourceName=${args.statusOptions.statusListName}&resourceType=${resourceType}`;
-            // construct credential status
-            args.credential = {
-                '@context': [],
-                issuer: args.statusOptions.issuerDid,
-                credentialSubject: {},
-                credentialStatus: {
-                    id: `${statusListCredential}#${args.statusOptions.statusListIndex}`,
-                    type: 'StatusList2021Entry',
-                    statusPurpose: `${args.statusOptions.statusPurpose}`,
-                    statusListIndex: `${args.statusOptions.statusListIndex}`,
-                },
-                issuanceDate: '',
-                proof: {},
-            };
-        }
-        // validate args - case: credential
-        if (!args.credential)
-            throw new Error('[did-provider-cheqd]: revocation: credential is required');
-        // if jwt credential, decode it
-        const credential = typeof args.credential === 'string' ? await Cheqd.decodeCredentialJWT(args.credential) : args.credential;
-        // 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;
-        switch (credential.credentialStatus?.statusPurpose) {
-            case cheqd_did_provider_js_1.DefaultStatusList2021StatusPurposeTypes.revocation:
-                return { revoked: await Cheqd.checkRevoked(credential, { ...args.options, topArgs: args }) };
-            case cheqd_did_provider_js_1.DefaultStatusList2021StatusPurposeTypes.suspension:
-                return { suspended: await Cheqd.checkSuspended(credential, { ...args.options, topArgs: args }) };
-            default:
-                throw new Error(`[did-provider-cheqd]: check status: Unsupported status purpose: ${credential.credentialStatus?.statusPurpose}`);
-        }
-    }
-    async RevokeCredentialWithStatusList2021(args, context) {
-        // verify credential, if provided and revocation options are not
-        if (args?.credential && !args?.revocationOptions) {
-            const verificationResult = await context.agent.verifyCredential({
-                ...args?.verificationOptions,
-                credential: args.credential,
-                policies: {
-                    credentialStatus: false,
-                },
-            });
-            // early return if verification failed
-            if (!verificationResult.verified) {
-                return { revoked: false, error: verificationResult.error };
-            }
-        }
-        // if revocation options are provided, give precedence
-        if (args?.revocationOptions) {
-            // validate revocation options - case: revocationOptions.issuerDid
-            if (!args.revocationOptions.issuerDid)
-                throw new Error('[did-provider-cheqd]: revocation: revocationOptions.issuerDid is required');
-            // validate revocation options - case: revocationOptions.statusListName
-            if (!args.revocationOptions.statusListName)
-                throw new Error('[did-provider-cheqd]: revocation: revocationOptions.statusListName is required');
-            // validate revocation options - case: revocationOptions.statusListIndex
-            if (!args.revocationOptions.statusListIndex)
-                throw new Error('[did-provider-cheqd]: revocation: revocationOptions.statusListIndex is required');
-            // construct status list credential
-            const statusListCredential = `${cheqd_did_resolver_js_1.DefaultResolverUrl}${args.revocationOptions.issuerDid}?resourceName=${args.revocationOptions.statusListName}&resourceType=${cheqd_did_provider_js_1.DefaultStatusList2021ResourceTypes.revocation}`;
-            // construct credential status
-            args.credential = {
-                '@context': [],
-                issuer: args.revocationOptions.issuerDid,
-                credentialSubject: {},
-                credentialStatus: {
-                    id: `${statusListCredential}#${args.revocationOptions.statusListIndex}`,
-                    type: 'StatusList2021Entry',
-                    statusPurpose: cheqd_did_provider_js_1.DefaultStatusList2021StatusPurposeTypes.revocation,
-                    statusListIndex: `${args.revocationOptions.statusListIndex}`,
-                },
-                issuanceDate: '',
-                proof: {},
-            };
-        }
-        // validate args - case: credential
-        if (!args.credential)
-            throw new Error('[did-provider-cheqd]: revocation: credential is required');
-        // if jwt credential, decode it
-        const credential = typeof args.credential === 'string' ? await Cheqd.decodeCredentialJWT(args.credential) : args.credential;
-        // validate status purpose
-        if (credential.credentialStatus?.statusPurpose !== cheqd_did_provider_js_1.DefaultStatusList2021StatusPurposeTypes.revocation) {
-            throw new Error(`[did-provider-cheqd]: revocation: Unsupported status purpose: ${credential.credentialStatus?.statusPurpose}`);
-        }
-        // 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
-        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;
-        // revoke credential
-        return await Cheqd.revokeCredential(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,
-            },
-        });
-    }
-    async RevokeBulkCredentialsWithStatusList2021(args, context) {
-        // verify credential, if provided and revocation options are not
-        if (args?.credentials && !args?.revocationOptions) {
-            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)) {
-                // define verified
-                return {
-                    revoked: Array(args.credentials.length).fill(false),
-                    error: verificationResult.find((result) => !result.verified).error || {
-                        message: 'verification: could not verify credential',
-                    },
-                };
-            }
-        }
-        // if revocation options are provided, give precedence
-        if (args?.revocationOptions) {
-            // validate revocation options - case: revocationOptions.issuerDid
-            if (!args.revocationOptions.issuerDid)
-                throw new Error('[did-provider-cheqd]: revocation: revocationOptions.issuerDid is required');
-            // validate revocation options - case: revocationOptions.statusListName
-            if (!args.revocationOptions.statusListName)
-                throw new Error('[did-provider-cheqd]: revocation: revocationOptions.statusListName is required');
-            // validate revocation options - case: revocationOptions.statusListIndices
-            if (!args.revocationOptions.statusListIndices ||
-                !args.revocationOptions.statusListIndices.length ||
-                args.revocationOptions.statusListIndices.length === 0 ||
-                !args.revocationOptions.statusListIndices.every((index) => !isNaN(+index)))
-                throw new Error('[did-provider-cheqd]: revocation: revocationOptions.statusListIndex is required and must be an array of indices');
-            // construct status list credential
-            const statusListCredential = `${cheqd_did_resolver_js_1.DefaultResolverUrl}${args.revocationOptions.issuerDid}?resourceName=${args.revocationOptions.statusListName}&resourceType=${cheqd_did_provider_js_1.DefaultStatusList2021ResourceTypes.revocation}`;
-            // construct credential status
-            args.credentials = args.revocationOptions.statusListIndices.map((index) => ({
-                '@context': [],
-                issuer: args.revocationOptions.issuerDid,
-                credentialSubject: {},
-                credentialStatus: {
-                    id: `${statusListCredential}#${index}`,
-                    type: 'StatusList2021Entry',
-                    statusPurpose: cheqd_did_provider_js_1.DefaultStatusList2021StatusPurposeTypes.revocation,
-                    statusListIndex: `${index}`,
-                },
-                issuanceDate: '',
-                proof: {},
-            }));
-        }
-        // validate args - case: credentials
-        if (!args.credentials || !args.credentials.length || args.credentials.length === 0)
-            throw new Error('[did-provider-cheqd]: revocation: credentials is required and must be an array of credentials');
-        // if jwt credentials, decode them
-        const credentials = await Promise.all(args.credentials.map(async (credential) => typeof credential === 'string' ? await Cheqd.decodeCredentialJWT(credential) : credential));
-        // 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
-        const issuer = typeof credentials[0].issuer === 'string'
-            ? credentials[0].issuer
-            : credentials[0].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;
-        // revoke credentials
-        return await Cheqd.revokeCredentials(credentials, {
-            ...args.options,
-            topArgs: args,
-            publishOptions: {
-                context,
-                resourceId: args?.options?.resourceId,
-                resourceVersion: args?.options?.resourceVersion,
-                resourceAlsoKnownAs: args?.options?.alsoKnownAs,
-                signInputs: args?.options?.signInputs,
-                fee: args?.options?.fee,
-            },
-        });
-    }
-    async SuspendCredentialWithStatusList2021(args, context) {
-        // verify credential, if provided and suspension options are not
-        if (args?.credential && !args?.suspensionOptions) {
-            const verificationResult = await context.agent.verifyCredential({
-                ...args?.verificationOptions,
-                credential: args.credential,
-                policies: {
-                    credentialStatus: false,
-                },
-            });
-            // early return if verification failed
-            if (!verificationResult.verified) {
-                return { suspended: false, error: verificationResult.error };
-            }
-        }
-        // if suspension options are provided, give precedence
-        if (args?.suspensionOptions) {
-            // validate suspension options - case: suspensionOptions.issuerDid
-            if (!args.suspensionOptions.issuerDid)
-                throw new Error('[did-provider-cheqd]: suspension: suspensionOptions.issuerDid is required');
-            // validate suspension options - case: suspensionOptions.statusListName
-            if (!args.suspensionOptions.statusListName)
-                throw new Error('[did-provider-cheqd]: suspension: suspensionOptions.statusListName is required');
-            // validate suspension options - case: suspensionOptions.statusListIndex
-            if (!args.suspensionOptions.statusListIndex)
-                throw new Error('[did-provider-cheqd]: suspension: suspensionOptions.statusListIndex is required');
-            // construct status list credential
-            const statusListCredential = `${cheqd_did_resolver_js_1.DefaultResolverUrl}${args.suspensionOptions.issuerDid}?resourceName=${args.suspensionOptions.statusListName}&resourceType=${cheqd_did_provider_js_1.DefaultStatusList2021ResourceTypes.suspension}`;
-            // construct credential status
-            args.credential = {
-                '@context': [],
-                issuer: args.suspensionOptions.issuerDid,
-                credentialSubject: {},
-                credentialStatus: {
-                    id: `${statusListCredential}#${args.suspensionOptions.statusListIndex}`,
-                    type: 'StatusList2021Entry',
-                    statusPurpose: cheqd_did_provider_js_1.DefaultStatusList2021StatusPurposeTypes.suspension,
-                    statusListIndex: `${args.suspensionOptions.statusListIndex}`,
-                },
-                issuanceDate: '',
-                proof: {},
-            };
-        }
-        // validate args - case: credential
-        if (!args.credential)
-            throw new Error('[did-provider-cheqd]: suspension: credential is required');
-        // if jwt credential, decode it
-        const credential = typeof args.credential === 'string' ? await Cheqd.decodeCredentialJWT(args.credential) : args.credential;
-        // validate status purpose
-        if (credential.credentialStatus?.statusPurpose !== cheqd_did_provider_js_1.DefaultStatusList2021StatusPurposeTypes.suspension) {
-            throw new Error(`[did-provider-cheqd]: suspension: Unsupported status purpose: ${credential.credentialStatus?.statusPurpose}`);
-        }
-        // validate args in pairs - case: statusListFile and statusList
-        if (args.options?.statusListFile && args.options?.statusList) {
-            throw new Error('[did-provider-cheqd]: suspension: 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]: suspension: 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]: suspension: 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]: suspension: publish requires statusListFile or statusList, if fetchList is disabled');
-        }
-        // 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;
-        // suspend credential
-        return await Cheqd.suspendCredential(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,
-            },
-        });
-    }
-    async SuspendBulkCredentialsWithStatusList2021(args, context) {
-        // verify credential, if provided and suspension options are not
-        if (args?.credentials && !args?.suspensionOptions) {
-            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)) {
-                // define verified
-                return {
-                    suspended: Array(args.credentials.length).fill(false),
-                    error: verificationResult.find((result) => !result.verified).error || {
-                        message: 'verification: could not verify credential',
-                    },
-                };
-            }
-        }
-        // if suspension options are provided, give precedence
-        if (args?.suspensionOptions) {
-            // validate suspension options - case: suspensionOptions.issuerDid
-            if (!args.suspensionOptions.issuerDid)
-                throw new Error('[did-provider-cheqd]: suspension: suspensionOptions.issuerDid is required');
-            // validate suspension options - case: suspensionOptions.statusListName
-            if (!args.suspensionOptions.statusListName)
-                throw new Error('[did-provider-cheqd]: suspension: suspensionOptions.statusListName is required');
-            // validate suspension options - case: suspensionOptions.statusListIndices
-            if (!args.suspensionOptions.statusListIndices ||
-                !args.suspensionOptions.statusListIndices.length ||
-                args.suspensionOptions.statusListIndices.length === 0 ||
-                !args.suspensionOptions.statusListIndices.every((index) => !isNaN(+index)))
-                throw new Error('[did-provider-cheqd]: suspension: suspensionOptions.statusListIndex is required and must be an array of indices');
-            // construct status list credential
-            const statusListCredential = `${cheqd_did_resolver_js_1.DefaultResolverUrl}${args.suspensionOptions.issuerDid}?resourceName=${args.suspensionOptions.statusListName}&resourceType=${cheqd_did_provider_js_1.DefaultStatusList2021ResourceTypes.suspension}`;
-            // construct credential status
-            args.credentials = args.suspensionOptions.statusListIndices.map((index) => ({
-                '@context': [],
-                issuer: args.suspensionOptions.issuerDid,
-                credentialSubject: {},
-                credentialStatus: {
-                    id: `${statusListCredential}#${index}`,
-                    type: 'StatusList2021Entry',
-                    statusPurpose: cheqd_did_provider_js_1.DefaultStatusList2021StatusPurposeTypes.suspension,
-                    statusListIndex: `${index}`,
-                },
-                issuanceDate: '',
-                proof: {},
-            }));
-        }
-        // validate args - case: credentials
-        if (!args.credentials || !args.credentials.length || args.credentials.length === 0)
-            throw new Error('[did-provider-cheqd]: suspension: credentials is required and must be an array of credentials');
-        // if jwt credentials, decode them
-        const credentials = await Promise.all(args.credentials.map(async (credential) => typeof credential === 'string' ? await Cheqd.decodeCredentialJWT(credential) : credential));
-        // validate args in pairs - case: statusListFile and statusList
-        if (args.options?.statusListFile && args.options?.statusList) {
-            throw new Error('[did-provider-cheqd]: suspension: 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]: suspension: 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]: suspension: 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]: suspension: publish requires statusListFile or statusList, if fetchList is disabled');
-        }
-        // define issuer
-        const issuer = typeof credentials[0].issuer === 'string'
-            ? credentials[0].issuer
-            : credentials[0].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;
-        // suspend credentials
-        return await Cheqd.suspendCredentials(credentials, {
-            ...args.options,
-            topArgs: args,
-            publishOptions: {
-                context,
-                resourceId: args?.options?.resourceId,
-                resourceVersion: args?.options?.resourceVersion,
-                resourceAlsoKnownAs: args?.options?.alsoKnownAs,
-                signInputs: args?.options?.signInputs,
-                fee: args?.options?.fee,
-            },
-        });
-    }
-    async UnsuspendCredentialWithStatusList2021(args, context) {
-        // verify credential, if provided and unsuspension options are not
-        if (args?.credential && !args?.unsuspensionOptions) {
-            const verificationResult = await context.agent.verifyCredential({
-                ...args?.verificationOptions,
-                credential: args.credential,
-                policies: {
-                    credentialStatus: false,
-                },
-            });
-            // early return if verification failed
-            if (!verificationResult.verified) {
-                return { unsuspended: false, error: verificationResult.error };
-            }
-        }
-        // if unsuspension options are provided, give precedence
-        if (args?.unsuspensionOptions) {
-            // validate unsuspension options - case: unsuspensionOptions.issuerDid
-            if (!args.unsuspensionOptions.issuerDid)
-                throw new Error('[did-provider-cheqd]: unsuspension: unsuspensionOptions.issuerDid is required');
-            // validate unsuspension options - case: unsuspensionOptions.statusListName
-            if (!args.unsuspensionOptions.statusListName)
-                throw new Error('[did-provider-cheqd]: unsuspension: unsuspensionOptions.statusListName is required');
-            // validate unsuspension options - case: unsuspensionOptions.statusListIndex
-            if (!args.unsuspensionOptions.statusListIndex)
-                throw new Error('[did-provider-cheqd]: unsuspension: unsuspensionOptions.statusListIndex is required');
-            // construct status list credential
-            const statusListCredential = `${cheqd_did_resolver_js_1.DefaultResolverUrl}${args.unsuspensionOptions.issuerDid}?resourceName=${args.unsuspensionOptions.statusListName}&resourceType=${cheqd_did_provider_js_1.DefaultStatusList2021ResourceTypes.suspension}`;
-            // construct credential status
-            args.credential = {
-                '@context': [],
-                issuer: args.unsuspensionOptions.issuerDid,
-                credentialSubject: {},
-                credentialStatus: {
-                    id: `${statusListCredential}#${args.unsuspensionOptions.statusListIndex}`,
-                    type: 'StatusList2021Entry',
-                    statusPurpose: cheqd_did_provider_js_1.DefaultStatusList2021StatusPurposeTypes.suspension,
-                    statusListIndex: `${args.unsuspensionOptions.statusListIndex}`,
-                },
-                issuanceDate: '',
-                proof: {},
-            };
-        }
-        // validate args - case: credential
-        if (!args.credential)
-            throw new Error('[did-provider-cheqd]: unsuspension: credential is required');
-        // if jwt credential, decode it
-        const credential = typeof args.credential === 'string' ? await Cheqd.decodeCredentialJWT(args.credential) : args.credential;
-        // validate status purpose
-        if (credential.credentialStatus?.statusPurpose !== cheqd_did_provider_js_1.DefaultStatusList2021StatusPurposeTypes.suspension) {
-            throw new Error(`[did-provider-cheqd]: suspension: Unsupported status purpose: ${credential.credentialStatus?.statusPurpose}`);
-        }
-        // validate args in pairs - case: statusListFile and statusList
-        if (args.options?.statusListFile && args.options?.statusList) {
-            throw new Error('[did-provider-cheqd]: suspension: 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]: suspension: 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]: suspension: 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]: suspension: publish requires statusListFile or statusList, if fetchList is disabled');
-        }
-        // 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;
-        // suspend credential
-        return await Cheqd.unsuspendCredential(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,
-            },
-        });
-    }
-    async UnsuspendBulkCredentialsWithStatusList2021(args, context) {
-        // verify credential, if provided and unsuspension options are not
-        if (args?.credentials && !args?.unsuspensionOptions) {
-            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)) {
-                // define verified
-                return {
-                    unsuspended: Array(args.credentials.length).fill(false),
-                    error: verificationResult.find((result) => !result.verified).error || {
-                        message: 'verification: could not verify credential',
-                    },
-                };
-            }
-        }
-        // if unsuspension options are provided, give precedence
-        if (args?.unsuspensionOptions) {
-            // validate unsuspension options - case: unsuspensionOptions.issuerDid
-            if (!args.unsuspensionOptions.issuerDid)
-                throw new Error('[did-provider-cheqd]: unsuspension: unsuspensionOptions.issuerDid is required');
-            // validate unsuspension options - case: unsuspensionOptions.statusListName
-            if (!args.unsuspensionOptions.statusListName)
-                throw new Error('[did-provider-cheqd]: unsuspension: unsuspensionOptions.statusListName is required');
-            // validate unsuspension options - case: unsuspensionOptions.statusListIndices
-            if (!args.unsuspensionOptions.statusListIndices ||
-                !args.unsuspensionOptions.statusListIndices.length ||
-                args.unsuspensionOptions.statusListIndices.length === 0 ||
-                !args.unsuspensionOptions.statusListIndices.every((index) => !isNaN(+index)))
-                throw new Error('[did-provider-cheqd]: unsuspension: unsuspensionOptions.statusListIndex is required and must be an array of indices');
-            // construct status list credential
-            const statusListCredential = `${cheqd_did_resolver_js_1.DefaultResolverUrl}${args.unsuspensionOptions.issuerDid}?resourceName=${args.unsuspensionOptions.statusListName}&resourceType=${cheqd_did_provider_js_1.DefaultStatusList2021ResourceTypes.suspension}`;
-            // construct credential status
-            args.credentials = args.unsuspensionOptions.statusListIndices.map((index) => ({
-                '@context': [],
-                issuer: args.unsuspensionOptions.issuerDid,
-                credentialSubject: {},
-                credentialStatus: {
-                    id: `${statusListCredential}#${index}`,
-                    type: 'StatusList2021Entry',
-                    statusPurpose: cheqd_did_provider_js_1.DefaultStatusList2021StatusPurposeTypes.suspension,
-                    statusListIndex: `${index}`,
-                },
-                issuanceDate: '',
-                proof: {},
-            }));
-        }
-        // validate args - case: credentials
-        if (!args.credentials || !args.credentials.length || args.credentials.length === 0)
-            throw new Error('[did-provider-cheqd]: unsuspension: credentials is required and must be an array of credentials');
-        // if jwt credentials, decode them
-        const credentials = await Promise.all(args.credentials.map(async (credential) => typeof credential === 'string' ? await Cheqd.decodeCredentialJWT(credential) : credential));
-        // validate args in pairs - case: statusListFile and statusList
-        if (args.options?.statusListFile && args.options?.statusList) {
-            throw new Error('[did-provider-cheqd]: unsuspension: 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]: unsuspension: 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]: unsuspension: 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]: unsuspension: publish requires statusListFile or statusList, if fetchList is disabled');
-        }
-        // define issuer
-        const issuer = typeof credentials[0].issuer === 'string'
-            ? credentials[0].issuer
-            : credentials[0].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;
-        // suspend credentials
-        return await Cheqd.unsuspendCredentials(credentials, {
-            ...args.options,
-            topArgs: args,
-            publishOptions: {
-                context,
-                resourceId: args?.options?.resourceId,
-                resourceVersion: args?.options?.resourceVersion,
-                resourceAlsoKnownAs: args?.options?.alsoKnownAs,
-                signInputs: args?.options?.signInputs,
-                fee: args?.options?.fee,
-            },
-        });
-    }
-    async TransactSendTokens(args, context) {
-        // define provider
-        const provider = await Cheqd.getProviderFromNetwork(args.network, this.supportedDidProviders);
-        try {
-            // delegate to provider
-            const transactionResult = await provider.transactSendTokens({
-                recipientAddress: args.recipientAddress,
-                amount: args.amount,
-                memo: args.memo,
-                txBytes: args.txBytes,
-            });
-            // return transaction result
-            return {
-                successful: !transactionResult.code,
-                transactionHash: transactionResult.transactionHash,
-                events: transactionResult.events,
-                rawLog: transactionResult.rawLog,
-                txResponse: args?.returnTxResponse ? transactionResult : undefined,
-            };
-        }
-        catch (error) {
-            // return error
-            return {
-                successful: false,
-                error: error,
-            };
-        }
-    }
-    async ObservePaymentCondition(args, context) {
-        // verify with raw unified access control condition, if any
-        if (args?.unifiedAccessControlCondition) {
-            // validate args - case: unifiedAccessControlCondition.chain
-            if (!args.unifiedAccessControlCondition.chain ||
-                !Object.values(v6_js_1.LitCompatibleCosmosChains).includes(args.unifiedAccessControlCondition.chain))
-                throw new Error('[did-provider-cheqd]: observe: unifiedAccessControlCondition.chain is required and must be a valid Lit-compatible chain');
-            // validate args - case: unifiedAccessControlCondition.path
-            if (!args.unifiedAccessControlCondition.path)
-                throw new Error('[did-provider-cheqd]: observe: unifiedAccessControlCondition.path is required');
-            // validate args - case: unifiedAccessControlCondition.conditionType
-            if (args.unifiedAccessControlCondition.conditionType !== 'cosmos')
-                throw new Error('[did-provider-cheqd]: observe: unifiedAccessControlCondition.conditionType must be cosmos');
-            // validate args - case: unifiedAccessControlCondition.method
-            if (args.unifiedAccessControlCondition.method !== 'timelock')
-                throw new Error('[did-provider-cheqd]: observe: unifiedAccessControlCondition.method must be timelock');
-            // validate args - case: unifiedAccessControlCondition.parameters
-            if (!args.unifiedAccessControlCondition.parameters ||
-                !Array.isArray(args.unifiedAccessControlCondition.parameters) ||
-                args.unifiedAccessControlCondition.parameters.length === 0 ||
-                args.unifiedAccessControlCondition.parameters.length > 1)
-                throw new Error('[did-provider-cheqd]: observe: unifiedAccessControlCondition.parameters is required and must be an array of length 1 of type string content');
-            // validate args - case: unifiedAccessControlCondition.returnValueTest
-            if (!args.unifiedAccessControlCondition.returnValueTest ||
-                !args.unifiedAccessControlCondition.returnValueTest.comparator ||
-                !args.unifiedAccessControlCondition.returnValueTest.key ||
-                !args.unifiedAccessControlCondition.returnValueTest.value)
-                throw new Error('[did-provider-cheqd]: observe: unifiedAccessControlCondition.returnValueTest is required');
-            try {
-                // define network
-                const network = (function () {
-                    switch (args.unifiedAccessControlCondition.chain) {
-                        case v6_js_1.LitCompatibleCosmosChains.cheqdMainnet:
-                            return sdk_1.CheqdNetwork.Mainnet;
-                        case v6_js_1.LitCompatibleCosmosChains.cheqdTestnet:
-                            return sdk_1.CheqdNetwork.Testnet;
-                        default:
-                            throw new Error(`[did-provider-cheqd]: observe: Unsupported chain: ${args.unifiedAccessControlCondition.chain}`);
-                    }
-                })();
-                // get block height url
-                const blockHeightUrl = (function () {
-                    switch (args.unifiedAccessControlCondition.parameters[0]) {
-                        case 'latest':
-                            return `${cheqd_did_provider_js_1.DefaultRESTUrls[network]}/cosmos/base/tendermint/v1beta1/blocks/latest`;
-                        default:
-                            return `${cheqd_did_provider_js_1.DefaultRESTUrls[network]}/cosmos/base/tendermint/v1beta1/blocks/${args.unifiedAccessControlCondition.parameters[0]}`;
-                    }
-                })();
-                // fetch block response
-                const blockHeightResponse = (await (await fetch(blockHeightUrl)).json());
-                // get timestamp from block response
-                const blockTimestamp = Date.parse(blockHeightResponse.block.header.time);
-                // construct url
-                const url = `${cheqd_did_provider_js_1.DefaultRESTUrls[network]}${args.unifiedAccessControlCondition.path}`;
-                // fetch relevant txs
-                const txs = (await (await fetch(url)).json());
-                // skim through txs for relevant events, in which case the transaction timestamp is within the defined interval in seconds, from the block timestamp
-                const meetsConditionTxIndex = txs?.tx_responses?.findIndex((tx) => {
-                    // get tx timestamp
-                    const txTimestamp = Date.parse(tx.timestamp);
-                    // calculate diff in seconds
-                    const diffInSeconds = Math.floor((blockTimestamp - txTimestamp) / 1000);
-                    // return meets condition
-                    switch (args.unifiedAccessControlCondition.returnValueTest.comparator) {
-                        case '<':
-                            return diffInSeconds < parseInt(args.unifiedAccessControlCondition.returnValueTest.value);
-                        case '<=':
-                            return diffInSeconds <= parseInt(args.unifiedAccessControlCondition.returnValueTest.value);
-                        default:
-                            throw new Error(`[did-provider-cheqd]: observe: Unsupported comparator: ${args.unifiedAccessControlCondition.returnValueTest.comparator}`);
-                    }
-                });
-                // define meetsCondition
-                const meetsCondition = typeof meetsConditionTxIndex !== 'undefined' && meetsConditionTxIndex !== -1;
-                // return observation result
-                return {
-                    subscribed: true,
-                    meetsCondition: meetsCondition,
-                    transactionHash: meetsCondition ? txs.tx_responses[meetsConditionTxIndex].txhash : undefined,
-                    events: meetsCondition ? txs.tx_responses[meetsConditionTxIndex].events : undefined,
-                    rawLog: meetsCondition ? txs.tx_responses[meetsConditionTxIndex].raw_log : undefined,
-                    txResponse: meetsCondition
-                        ? args?.returnTxResponse
-                            ? txs.tx_responses[meetsConditionTxIndex]
-                            : undefined
-                        : undefined,
-                };
-            }
-            catch (error) {
-                // return error
-                return {
-                    subscribed: false,
-                    meetsCondition: false,
-                    error: error,
-                };
-            }
-        }
-        // validate access control conditions components - case: recipientAddress
-        if (!args.recipientAddress) {
-            throw new Error('[did-provider-cheqd]: observation: recipientAddress is required');
-        }
-        // validate access control conditions components - case: amount
-        if (!args.amount || !args.amount.amount || !args.amount.denom || args.amount.denom !== 'ncheq') {
-            throw new Error('[did-provider-cheqd]: observation: amount is required, and must be an object with amount and denom valid string properties, amongst which denom must be `ncheq`');
-        }
-        // validate access control conditions components - case: intervalInSeconds
-        if (!args.intervalInSeconds) {
-            throw new Error('[did-provider-cheqd]: observation: intervalInSeconds is required');
-        }
-        // validate access control conditions components - case: comparator
-        if (!args.comparator || (args.comparator !== '<' && args.comparator !== '<=')) {
-            throw new Error('[did-provider-cheqd]: observation: comparator is required and must be either `<` or `<=`');
-        }
-        // validate access control conditions components - case: network
-        if (!args.network) {
-            throw new Error('[did-provider-cheqd]: observation: network is required');
-        }
-        // define block height, if not provided
-        args.blockHeight ||= 'latest';
-        try {
-            // get block height url
-            const blockHeightUrl = (function () {
-                switch (args.blockHeight) {
-                    case 'latest':
-                        return `${cheqd_did_provider_js_1.DefaultRESTUrls[args.network]}/cosmos/base/tendermint/v1beta1/blocks/latest`;
-                    default:
-                        return `${cheqd_did_provider_js_1.DefaultRESTUrls[args.network]}/cosmos/base/tendermint/v1beta1/blocks/${args.blockHeight}`;
-                }
-            })();
-            // fetch block response
-            const blockHeightResponse = (await (await fetch(blockHeightUrl)).json());
-            // get timestamp from block response
-            const blockTimestamp = Date.parse(blockHeightResponse.block.header.time);
-            // otherwise, construct url, as per components
-            const url = `${cheqd_did_provider_js_1.DefaultRESTUrls[args.network]}/cosmos/tx/v1beta1/txs?events=transfer.recipient='${args.recipientAddress}'&events=transfer.amount='${args.amount.amount}${args.amount.denom}'&order_by=2&pagination.limit=1`;
-            // fetch relevant txs
-            const txs = (await (await fetch(url)).json());
-            // skim through txs for relevant events, in which case the transaction timestamp is within the defined interval in seconds, from the block timestamp
-            const meetsConditionTxIndex = txs?.tx_responses?.findIndex((tx) => {
-                // get tx timestamp
-                const txTimestamp = Date.parse(tx.timestamp);
-                // calculate diff in seconds
-                const diffInSeconds = Math.floor((blockTimestamp - txTimestamp) / 1000);
-                // return meets condition
-                switch (args.comparator) {
-                    case '<':
-                        return diffInSeconds < args.intervalInSeconds;
-                    case '<=':
-                        return diffInSeconds <= args.intervalInSeconds;
-                    default:
-                        throw new Error(`[did-provider-cheqd]: observe: Unsupported comparator: ${args.unifiedAccessControlCondition.returnValueTest.comparator}`);
-                }
-            });
-            // define meetsCondition
-            const meetsCondition = typeof meetsConditionTxIndex !== 'undefined' && meetsConditionTxIndex !== -1;
-            // return observation result
-            return {
-                subscribed: true,
-                meetsCondition: meetsCondition,
-                transactionHash: meetsCondition ? txs.tx_responses[meetsConditionTxIndex].txhash : undefined,
-                events: meetsCondition ? txs.tx_responses[meetsConditionTxIndex].events : undefined,
-                rawLog: meetsCondition ? txs.tx_responses[meetsConditionTxIndex].raw_log : undefined,
-                txResponse: meetsCondition
-                    ? args?.returnTxResponse
-                        ? txs.tx_responses[meetsConditionTxIndex]
-                        : undefined
-                    : undefined,
-            };
-        }
-        catch (error) {
-            // return error
-            return {
-                subscribed: false,
-                meetsCondition: false,
-                error: error,
-            };
-        }
-    }
-    async MintCapacityCredit(args, context) {
-        // define provider
-        const provider = await Cheqd.getProviderFromNetwork(args.network, this.supportedDidProviders);
-        try {
-            // delegate to provider
-            const mintingResult = await provider.mintCapacityCredit({
-                effectiveDays: args.effectiveDays,
-                requestsPerDay: args.requestsPerDay,
-                requestsPerSecond: args.requestsPerSecond,
-                requestsPerKilosecond: args.requestsPerKilosecond,
-            });
-            // return mint result
-            return {
-                minted: true,
-                ...mintingResult,
-            };
-        }
-        catch (error) {
-            // return error
-            return {
-                minted: false,
-                error: error,
-            };
-        }
-    }
-    async DelegateCapacityCredit(args, context) {
-        // define provider
-        const provider = await Cheqd.getProviderFromNetwork(args.network, this.supportedDidProviders);
-        try {
-            // delegate to provider
-            const delegationResult = await provider.delegateCapacityCredit({
-                capacityTokenId: args.capacityTokenId,
-                delegateeAddresses: args.delegateeAddresses,
-                uses: args.usesPermitted,
-                expiration: args.expiration,
-                statement: args.statement,
-            });
-            // return delegation result
-            return {
-                delegated: true,
-                ...delegationResult,
-            };
-        }
-        catch (error) {
-            // return error
-            return {
-                delegated: false,
-                error: error,
-            };
-        }
-    }
-    static async revokeCredential(credential, options) {
-        try {
-            // validate status purpose
-            if (credential?.credentialStatus?.statusPurpose !== cheqd_did_provider_js_1.DefaultStatusList2021StatusPurposeTypes.revocation)
-                throw new Error('[did-provider-cheqd]: revocation: Invalid status purpose');
-            // fetch status list 2021
-            const publishedList = (await Cheqd.fetchStatusList2021(credential));
-            // early return, if encrypted and no decryption key provided
-            if (publishedList.metadata.encrypted && !options?.topArgs?.symmetricKey)
-                throw new Error('[did-provider-cheqd]: revocation: symmetricKey is required, if status list 2021 is encrypted');
-            // fetch status list 2021 inscribed in credential
-            const statusList2021 = options?.topArgs?.fetchList
-                ? await (async function () {
-                    // if not encrypted, return bitstring
-                    if (!publishedList.metadata.encrypted)
-                        return publishedList.metadata.encoding === 'base64url'
-                            ? publishedList.StatusList2021.encodedList
-                            : (0, uint8arrays_1.toString)((0, uint8arrays_1.fromString)(publishedList.StatusList2021.encodedList, publishedList.metadata.encoding), 'base64url');
-                    // decrypt + return bitstring, if qualified for migration
-                    if (publishedList.metadata.encryptedSymmetricKey)
-                        return await v2_js_1.LitProtocolV2.decryptDirect(await (0, helpers_js_1.toBlob)((0, uint8arrays_1.fromString)(publishedList.StatusList2021
-                            .encodedList, 'hex')), (0, uint8arrays_1.fromString)(options?.topArgs?.symmetricKey, 'hex'));
-                    // validate encoded list
-                    if (!(0, helpers_js_1.isEncodedList)(publishedList.StatusList2021.encodedList))
-                        throw new Error('[did-provider-cheqd]: revocation: Invalid encoded list');
-                    // otherwise, decrypt and return raw bitstring
-                    const scopedRawBlob = await (0, helpers_js_1.toBlob)((0, uint8arrays_1.fromString)((0, helpers_js_1.getEncodedList)(publishedList.StatusList2021.encodedList, false)[0], 'hex'));
-                    // decrypt
-                    return (0, uint8arrays_1.toString)(await v6_js_1.LitProtocol.decryptDirect(scopedRawBlob, await (0, helpers_js_1.safeDeserialise)(options?.topArgs?.symmetricKey, uint8arrays_1.fromString, ['hex'], 'Invalid symmetric key')), 'base64url');
-                })()
-                : await (async function () {
-                    // transcode to base64url, if needed
-                    const publishedListTranscoded = publishedList.metadata.encoding === 'base64url'
-                        ? publishedList.StatusList2021.encodedList
-                        : (0, uint8arrays_1.toString)((0, uint8arrays_1.fromString)(publishedList.StatusList2021.encodedList, publishedList.metadata.encoding), 'base64url');
-                    // if status list 2021 is not fetched, read from file
-                    if (options?.statusListFile) {
-                        // if not encrypted, return bitstring
-                        if (!publishedList.metadata.encrypted) {
-                            // construct encoded status list
-                            const encoded = new vc_status_list_1.StatusList({
-                                buffer: await Cheqd.getFile(options.statusListFile),
-                            }).encode();
-                            // validate against published list
-                            if (encoded !== publishedListTranscoded)
-                                throw new Error('[did-provider-cheqd]: revocation: statusListFile does not match published status list 2021');
-                            // return encoded
-                            return encoded;
-                        }
-                        // otherwise, decrypt and return bitstring
-                        const scopedRawBlob = await (0, helpers_js_1.toBlob)(await Cheqd.getFile(options.statusListFile));
-                        // decrypt
-                        const decrypted = (0, uint8arrays_1.toString)(await v6_js_1.LitProtocol.decryptDirect(scopedRawBlob, await (0, helpers_js_1.safeDeserialise)(options?.topArgs?.symmetricKey, uint8arrays_1.fromString, ['hex'], 'Invalid symmetric key')), 'base64url');
-                        // validate against published list
-                        if (decrypted !== publishedListTranscoded)
-                            throw new Error('[did-provider-cheqd]: revocation: statusListFile does not match published status list 2021');
-                        // return decrypted
-                        return decrypted;
-                    }
-                    if (!options?.statusListInlineBitstring)
-                        throw new Error('[did-provider-cheqd]: revocation: statusListInlineBitstring is required, if statusListFile is not provided');
-                    // validate against published list
-                    if (options?.statusListInlineBitstring !== publishedListTranscoded)
-                        throw new Error('[did-provider-cheqd]: revocation: statusListInlineBitstring does not match published status list 2021');
-                    // otherwise, read from inline bitstring
-                    return options?.statusListInlineBitstring;
-                })();
-            // parse status list 2021
-            const statusList = await vc_status_list_1.StatusList.decode({ encodedList: statusList2021 });
-            // early exit, if credential is already revoked
-            if (statusList.getStatus(Number(credential.credentialStatus.statusListIndex)))
-                return { revoked: true };
-            // update revocation status
-            statusList.setStatus(Number(credential.credentialStatus.statusListIndex), true);
-            // set in-memory status list ref
-            const bitstring = (await statusList.encode());
-            // cast top-level args
-            const topArgs = options?.topArgs;
-            // write status list 2021 to file, if provided
-            if (topArgs?.writeToFile) {
-                await Cheqd.writeFile((0, uint8arrays_1.fromString)(bitstring, 'base64url'), options?.statusListFile);
-            }
-            // publish status list 2021, if provided
-            const published = topArgs?.publish
-                ? await (async function () {
-                    // fetch status list 2021 metadata
-                    const statusListMetadata = await Cheqd.fetchStatusList2021Metadata(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(cheqd_did_provider_js_1.DefaultStatusList2021Encodings).includes(options?.publishOptions?.statusListEncoding)) {
-                                throw new Error('[did-provider-cheqd]: revocation: Invalid status list encoding');
-                            }
-                            // validate validUntil, if provided
-                            if (options?.publishOptions?.statusListValidUntil) {
-                                // validate validUntil as string
-                                if (typeof options?.publishOptions?.statusListValidUntil !== 'string')
-                                    throw new Error('[did-provider-cheqd]: revocation: Invalid status list validUntil (must be string)');
-                                // validate validUntil as date
-                                if (isNaN(Date.parse(options?.publishOptions?.statusListValidUntil)))
-                                    throw new Error('[did-provider-cheqd]: revocation: Invalid status list validUntil (must be date)');
-                                // validate validUntil as future date
-                                if (new Date(options?.publishOptions?.statusListValidUntil) < new Date())
-                                    throw new Error('[did-provider-cheqd]: revocation: Invalid status list validUntil (must be future date)');
-                                // validate validUntil towards validFrom
-                                if (new Date(options?.publishOptions?.statusListValidUntil) <=
-                                    new Date(publishedList.StatusList2021.validFrom))
-                                    throw new Error('[did-provider-cheqd]: revocation: Invalid status list validUntil (must be after validFrom)');
-                            }
-                            // validate paymentConditions, if provided
-                            if (topArgs?.paymentConditions) {
-                                if (!topArgs?.paymentConditions?.every((condition) => condition.feePaymentAddress &&
-                                    condition.feePaymentAmount &&
-                                    condition.intervalInSeconds)) {
-                                    throw new Error('[did-provider-cheqd]: paymentConditions must contain feePaymentAddress and feeAmount and intervalInSeconds');
-                                }
-                                if (!topArgs?.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 (!topArgs?.paymentConditions?.every((condition) => condition.type === exports.AccessControlConditionTypes.timelockPayment)) {
-                                    throw new Error('[did-provider-cheqd]: paymentConditions must be of type timelockPayment');
-                                }
-                            }
-                            // validate dkgOptions
-                            if (!topArgs?.dkgOptions ||
-                                !topArgs?.dkgOptions?.chain ||
-                                !topArgs?.dkgOptions?.network) {
-                                throw new Error('[did-provider-cheqd]: dkgOptions is required');
-                            }
-                            // encrypt bitstring - case: symmetric
-                            const { encryptedString: symmetricEncryptionCiphertext, stringHash: symmetricEncryptionStringHash, symmetricKey, } = await v6_js_1.LitProtocol.encryptDirect((0, uint8arrays_1.fromString)(bitstring, 'base64url'));
-                            // instantiate dkg-threshold client, in which case lit-protocol is used
-                            const lit = (await options.publishOptions.instantiateDkgClient);
-                            // construct access control conditions and payment conditions tuple
-                            const unifiedAccessControlConditionsTuple = publishedList.metadata.encrypted
-                                ? await (async function () {
-                                    // define payment conditions, give precedence to top-level args
-                                    const paymentConditions = topArgs?.paymentConditions ||
-                                        publishedList.metadata.paymentConditions;
-                                    // return access control conditions and payment conditions tuple
-                                    return [
-                                        await Promise.all(paymentConditions.map(async (condition) => {
-                                            switch (condition.type) {
-                                                case exports.AccessControlConditionTypes.timelockPayment:
-                                                    return await v6_js_1.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}`);
-                                            }
-                                        })),
-                                        paymentConditions,
-                                    ];
-                                })()
-                                : await (async function () {
-                                    // validate paymentConditions
-                                    if (!topArgs?.paymentConditions) {
-                                        throw new Error('[did-provider-cheqd]: paymentConditions is required');
-                                    }
-                                    // return access control conditions and payment conditions tuple
-                                    return [
-                                        await Promise.all(topArgs.paymentConditions.map(async (condition) => {
-                                            switch (condition.type) {
-                                                case exports.AccessControlConditionTypes.timelockPayment:
-                                                    return await v6_js_1.LitProtocol.generateCosmosAccessControlConditionInverseTimelock({
-                                                        key: '$.tx_responses.*.timestamp',
-                                                        comparator: '<=',
-                                                        value: `${condition.intervalInSeconds}`,
-                                                    }, condition.feePaymentAmount, condition.feePaymentAddress, condition?.blockHeight);
-                                                default:
-                                                    throw new Error(`[did-provider-cheqd]: unsupported access control condition type ${condition.type}`);
-                                            }
-                                        })),
-                                        topArgs.paymentConditions,
-                                    ];
-                                })();
-                            // encrypt bitstring - case: threshold
-                            const { encryptedString: thresholdEncryptionCiphertext, stringHash: thresholdEncryptionStringHash, } = await lit.encrypt((0, uint8arrays_1.fromString)(bitstring, 'base64url'), unifiedAccessControlConditionsTuple[0]);
-                            // construct encoded list
-                            const encodedList = `${await (0, helpers_js_1.blobToHexString)(symmetricEncryptionCiphertext)}-${(0, uint8arrays_1.toString)(thresholdEncryptionCiphertext, 'hex')}`;
-                            // define status list content
-                            const content = {
-                                StatusList2021: {
-                                    statusPurpose: publishedList.StatusList2021.statusPurpose,
-                                    encodedList,
-                                    validFrom: publishedList.StatusList2021.validFrom,
-                                    validUntil: options?.publishOptions?.statusListValidUntil ||
-                                        publishedList.StatusList2021.validUntil,
-                                },
-                                metadata: {
-                                    type: publishedList.metadata.type,
-                                    encrypted: true,
-                                    encoding: options?.publishOptions?.statusListEncoding || publishedList.metadata.encoding,
-                                    statusListHash: symmetricEncryptionStringHash === thresholdEncryptionStringHash
-                                        ? symmetricEncryptionStringHash
-                                        : (function () {
-                                            throw new Error('[did-provider-cheqd]: revocation: symmetricEncryptionStringHash and thresholdEncryptionStringHash do not match');
-                                        })(),
-                                    paymentConditions: unifiedAccessControlConditionsTuple[1],
-                                },
-                            };
-                            // return tuple of publish result and encryption relevant metadata
-                            return [
-                                await Cheqd.publishStatusList2021((0, uint8arrays_1.fromString)(JSON.stringify(content), 'utf-8'), statusListMetadata, options?.publishOptions),
-                                {
-                                    symmetricEncryptionCiphertext,
-                                    thresholdEncryptionCiphertext,
-                                    stringHash: symmetricEncryptionStringHash,
-                                    symmetricKey,
-                                },
-                            ];
-                        })()
-                        : await (async function () {
-                            // validate encoding, if provided
-                            if (options?.publishOptions?.statusListEncoding &&
-                                !Object.values(cheqd_did_provider_js_1.DefaultStatusList2021Encodings).includes(options?.publishOptions?.statusListEncoding)) {
-                                throw new Error('[did-provider-cheqd]: revocation: Invalid status list encoding');
-                            }
-                            // validate validUntil, if provided
-                            if (options?.publishOptions?.statusListValidUntil) {
-                                // validate validUntil as string
-                                if (typeof options?.publishOptions?.statusListValidUntil !== 'string')
-                                    throw new Error('[did-provider-cheqd]: revocation: Invalid status list validUntil (must be string)');
-                                // validate validUntil as date
-                                if (isNaN(Date.parse(options?.publishOptions?.statusListValidUntil)))
-                                    throw new Error('[did-provider-cheqd]: revocation: Invalid status list validUntil (must be date)');
-                                // validate validUntil as future date
-                                if (new Date(options?.publishOptions?.statusListValidUntil) < new Date())
-                                    throw new Error('[did-provider-cheqd]: revocation: Invalid status list validUntil (must be future date)');
-                                // validate validUntil towards validFrom
-                                if (new Date(options?.publishOptions?.statusListValidUntil) <=
-                                    new Date(publishedList.StatusList2021.validFrom))
-                                    throw new Error('[did-provider-cheqd]: revocation: Invalid status list validUntil (must be after validFrom)');
-                            }
-                            // define status list content
-                            const content = {
-                                StatusList2021: {
-                                    statusPurpose: publishedList.StatusList2021.statusPurpose,
-                                    encodedList: publishedList.metadata.encoding === 'base64url'
-                                        ? bitstring
-                                        : (0, uint8arrays_1.toString)((0, uint8arrays_1.fromString)(bitstring, 'base64url'), options.publishOptions
-                                            .statusListEncoding),
-                                    validFrom: publishedList.StatusList2021.validFrom,
-                                    validUntil: options?.publishOptions?.statusListValidUntil ||
-                                        publishedList.StatusList2021.validUntil,
-                                },
-                                metadata: {
-                                    type: publishedList.metadata.type,
-                                    encoding: options?.publishOptions?.statusListEncoding || publishedList.metadata.encoding,
-                                    encrypted: false,
-                                },
-                            };
-                            // return tuple of publish result and encryption relevant metadata
-                            return [
-                                await Cheqd.publishStatusList2021((0, uint8arrays_1.fromString)(JSON.stringify(content), 'utf-8'), statusListMetadata, options?.publishOptions),
-                                undefined,
-                            ];
-                        })();
-                    // early exit, if publish failed
-                    if (!scoped[0])
-                        throw new Error('[did-provider-cheqd]: revocation: Failed to publish status list 2021');
-                    // return publish result
-                    return scoped;
-                })()
-                : undefined;
-            return {
-                revoked: true,
-                published: topArgs?.publish ? true : undefined,
-                statusList: topArgs?.returnUpdatedStatusList
-                    ? (await Cheqd.fetchStatusList2021(credential))
-                    : undefined,
-                symmetricKey: topArgs?.returnSymmetricKey
-                    ? (0, uint8arrays_1.toString)(published?.[1]?.symmetricKey, 'hex')
-                    : undefined,
-                resourceMetadata: topArgs?.returnStatusListMetadata
-                    ? await Cheqd.fetchStatusList2021Metadata(credential)
-                    : undefined,
-            };
-        }
-        catch (error) {
-            // silent fail + early exit
-            console.error(error);
-            return { revoked: false, error: error };
-        }
-    }
-    static async revokeCredentials(credentials, options) {
-        // validate credentials - case: empty
-        if (!credentials.length || credentials.length === 0)
-            throw new Error('[did-provider-cheqd]: revocation: No credentials provided');
-        // 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]: revocation: Credentials must be issued by the same issuer');
-        // validate credentials - case: status list index
-        if (credentials
-            .map((credential) => credential.credentialStatus.statusListIndex)
-            .filter((value, index, self) => self.indexOf(value) !== index).length > 0)
-            throw new Error('[did-provider-cheqd]: revocation: Credentials must have unique status list index');
-        // validate credentials - case: status purpose
-        if (!credentials.every((credential) => credential.credentialStatus?.statusPurpose === cheqd_did_provider_js_1.DefaultStatusList2021StatusPurposeTypes.revocation))
-            throw new Error('[did-provider-cheqd]: revocation: Invalid status purpose');
-        // validate credentials - case: status list id
-        const remote = credentials[0].credentialStatus?.id
-            ? credentials[0].credentialStatus.id.split('#')[0]
-            : (function () {
-                throw new Error('[did-provider-cheqd]: revocation: Invalid status list id');
-            })();
-        // validate credentials - case: status list id format
-        if (!exports.RemoteListPattern.test(remote))
-            throw new Error('[did-provider-cheqd]: revocation: Invalid status list id format: expected: https://<optional_subdomain>.<sld>.<tld>/1.0/identifiers/<did:cheqd:<namespace>:<method_specific_id>>?resourceName=<resource_name>&resourceType=<resource_type>');
-        if (!credentials.every((credential) => {
-            return credential.credentialStatus.id.split('#')[0] === remote;
-        }))
-            throw new Error('[did-provider-cheqd]: revocation: Credentials must belong to the same status list');
-        // validate credentials - case: status list type
-        if (!credentials.every((credential) => credential.credentialStatus?.type === 'StatusList2021Entry'))
-            throw new Error('[did-provider-cheqd]: revocation: Invalid status list type');
-        try {
-            // fetch status list 2021
-            const publishedList = (await Cheqd.fetchStatusList2021(credentials[0]));
-            // early return, if encrypted and no decryption key provided
-            if (publishedList.metadata.encrypted && !options?.topArgs?.symmetricKey)
-                throw new Error('[did-provider-cheqd]: revocation: symmetricKey is required, if status list 2021 is encrypted');
-            // fetch status list 2021 inscribed in credential
-            const statusList2021 = options?.topArgs?.fetchList
-                ? await (async function () {
-                    // if not encrypted, return bitstring
-                    if (!publishedList.metadata.encrypted)
-                        return publishedList.metadata.encoding === 'base64url'
-                            ? publishedList.StatusList2021.encodedList
-                            : (0, uint8arrays_1.toString)((0, uint8arrays_1.fromString)(publishedList.StatusList2021.encodedList, publishedList.metadata.encoding), 'base64url');
-                    // decrypt + return bitstring, if qualified for migration
-                    if (publishedList.metadata.encryptedSymmetricKey)
-                        return await v2_js_1.LitProtocolV2.decryptDirect(await (0, helpers_js_1.toBlob)((0, uint8arrays_1.fromString)(publishedList.StatusList2021
-                            .encodedList, 'hex')), (0, uint8arrays_1.fromString)(options?.topArgs?.symmetricKey, 'hex'));
-                    // validate encoded list
-                    if (!(0, helpers_js_1.isEncodedList)(publishedList.StatusList2021.encodedList))
-                        throw new Error('[did-provider-cheqd]: revocation: Invalid encoded list');
-                    // otherwise, decrypt and return raw bitstring
-                    const scopedRawBlob = await (0, helpers_js_1.toBlob)((0, uint8arrays_1.fromString)((0, helpers_js_1.getEncodedList)(publishedList.StatusList2021.encodedList, false)[0], 'hex'));
-                    // decrypt
-                    return (0, uint8arrays_1.toString)(await v6_js_1.LitProtocol.decryptDirect(scopedRawBlob, await (0, helpers_js_1.safeDeserialise)(options?.topArgs?.symmetricKey, uint8arrays_1.fromString, ['hex'], 'Invalid symmetric key')), 'base64url');
-                })()
-                : await (async function () {
-                    // transcode to base64url, if needed
-                    const publishedListTranscoded = publishedList.metadata.encoding === 'base64url'
-                        ? publishedList.StatusList2021.encodedList
-                        : (0, uint8arrays_1.toString)((0, uint8arrays_1.fromString)(publishedList.StatusList2021.encodedList, publishedList.metadata.encoding), 'base64url');
-                    // if status list 2021 is not fetched, read from file
-                    if (options?.statusListFile) {
-                        // if not encrypted, return bitstring
-                        if (!publishedList.metadata.encrypted) {
-                            // construct encoded status list
-                            const encoded = new vc_status_list_1.StatusList({
-                                buffer: await Cheqd.getFile(options.statusListFile),
-                            }).encode();
-                            // validate against published list
-                            if (encoded !== publishedListTranscoded)
-                                throw new Error('[did-provider-cheqd]: revocation: statusListFile does not match published status list 2021');
-                            // return encoded
-                            return encoded;
-                        }
-                        // otherwise, decrypt and return bitstring
-                        const scopedRawBlob = await (0, helpers_js_1.toBlob)(await Cheqd.getFile(options.statusListFile));
-                        // decrypt
-                        const decrypted = (0, uint8arrays_1.toString)(await v6_js_1.LitProtocol.decryptDirect(scopedRawBlob, await (0, helpers_js_1.safeDeserialise)(options?.topArgs?.symmetricKey, uint8arrays_1.fromString, ['hex'], 'Invalid symmetric key')), 'base64url');
-                        // validate against published list
-                        if (decrypted !== publishedListTranscoded)
-                            throw new Error('[did-provider-cheqd]: revocation: statusListFile does not match published status list 2021');
-                        // return decrypted
-                        return decrypted;
-                    }
-                    if (!options?.statusListInlineBitstring)
-                        throw new Error('[did-provider-cheqd]: revocation: statusListInlineBitstring is required, if statusListFile is not provided');
-                    // validate against published list
-                    if (options?.statusListInlineBitstring !== publishedListTranscoded)
-                        throw new Error('[did-provider-cheqd]: revocation: statusListInlineBitstring does not match published status list 2021');
-                    // otherwise, read from inline bitstring
-                    return options?.statusListInlineBitstring;
-                })();
-            // parse status list 2021
-            const statusList = await vc_status_list_1.StatusList.decode({ encodedList: statusList2021 });
-            // initiate bulk revocation
-            const revoked = (await Promise.allSettled(credentials.map((credential) => {
-                return (async function () {
-                    // early return, if no credential status
-                    if (!credential.credentialStatus)
-                        return { revoked: false };
-                    // early exit, if credential is already revoked
-                    if (statusList.getStatus(Number(credential.credentialStatus.statusListIndex)))
-                        return { revoked: true };
-                    // update revocation status
-                    statusList.setStatus(Number(credential.credentialStatus.statusListIndex), true);
-                    // return revocation status
-                    return { revoked: true };
-                })();
-            })));
-            // revert bulk ops, if some failed
-            if (revoked.some((result) => result.status === 'fulfilled' && !result.value.revoked))
-                throw new Error(`[did-provider-cheqd]: revocation: Bulk revocation failed: already revoked credentials in revocation bundle: raw log: ${JSON.stringify(revoked.map((result) => ({
-                    revoked: result.status === 'fulfilled' ? result.value.revoked : false,
-                })))}`);
-            // set in-memory status list ref
-            const bitstring = (await statusList.encode());
-            // cast top-level args
-            const topArgs = options?.topArgs;
-            // write status list 2021 to file, if provided
-            if (topArgs?.writeToFile) {
-                await Cheqd.writeFile((0, uint8arrays_1.fromString)(bitstring, 'base64url'), options?.statusListFile);
-            }
-            // publish status list 2021, if provided
-            const published = topArgs?.publish
-                ? await (async function () {
-                    // fetch status list 2021 metadata
-                    const statusListMetadata = await Cheqd.fetchStatusList2021Metadata(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(cheqd_did_provider_js_1.DefaultStatusList2021Encodings).includes(options?.publishOptions?.statusListEncoding)) {
-                                throw new Error('[did-provider-cheqd]: revocation: Invalid status list encoding');
-                            }
-                            // validate validUntil, if provided
-                            if (options?.publishOptions?.statusListValidUntil) {
-                                // validate validUntil as string
-                                if (typeof options?.publishOptions?.statusListValidUntil !== 'string')
-                                    throw new Error('[did-provider-cheqd]: revocation: Invalid status list validUntil (must be string)');
-                                // validate validUntil as date
-                                if (isNaN(Date.parse(options?.publishOptions?.statusListValidUntil)))
-                                    throw new Error('[did-provider-cheqd]: revocation: Invalid status list validUntil (must be date)');
-                                // validate validUntil as future date
-                                if (new Date(options?.publishOptions?.statusListValidUntil) < new Date())
-                                    throw new Error('[did-provider-cheqd]: revocation: Invalid status list validUntil (must be future date)');
-                                // validate validUntil towards validFrom
-                                if (new Date(options?.publishOptions?.statusListValidUntil) <=
-                                    new Date(publishedList.StatusList2021.validFrom))
-                                    throw new Error('[did-provider-cheqd]: revocation: Invalid status list validUntil (must be after validFrom)');
-                            }
-                            // validate paymentConditions, if provided
-                            if (topArgs?.paymentConditions) {
-                                if (!topArgs?.paymentConditions?.every((condition) => condition.feePaymentAddress &&
-                                    condition.feePaymentAmount &&
-                                    condition.intervalInSeconds)) {
-                                    throw new Error('[did-provider-cheqd]: paymentConditions must contain feePaymentAddress and feeAmount and intervalInSeconds');
-                                }
-                                if (!topArgs?.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 (!topArgs?.paymentConditions?.every((condition) => condition.type === exports.AccessControlConditionTypes.timelockPayment)) {
-                                    throw new Error('[did-provider-cheqd]: paymentConditions must be of type timelockPayment');
-                                }
-                            }
-                            // validate dkgOptions
-                            if (!topArgs?.dkgOptions ||
-                                !topArgs?.dkgOptions?.chain ||
-                                !topArgs?.dkgOptions?.network) {
-                                throw new Error('[did-provider-cheqd]: dkgOptions is required');
-                            }
-                            // encrypt bitstring - case: symmetric
-                            const { encryptedString: symmetricEncryptionCiphertext, stringHash: symmetricEncryptionStringHash, symmetricKey, } = await v6_js_1.LitProtocol.encryptDirect((0, uint8arrays_1.fromString)(bitstring, 'base64url'));
-                            // instantiate dkg-threshold client, in which case lit-protocol is used
-                            const lit = (await options.publishOptions.instantiateDkgClient);
-                            // construct access control conditions and payment conditions tuple
-                            const unifiedAccessControlConditionsTuple = publishedList.metadata.encrypted
-                                ? await (async function () {
-                                    // define payment conditions, give precedence to top-level args
-                                    const paymentConditions = topArgs?.paymentConditions ||
-                                        publishedList.metadata.paymentConditions;
-                                    // return access control conditions and payment conditions tuple
-                                    return [
-                                        await Promise.all(paymentConditions.map(async (condition) => {
-                                            switch (condition.type) {
-                                                case exports.AccessControlConditionTypes.timelockPayment:
-                                                    return await v6_js_1.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}`);
-                                            }
-                                        })),
-                                        paymentConditions,
-                                    ];
-                                })()
-                                : await (async function () {
-                                    // validate paymentConditions
-                                    if (!topArgs?.paymentConditions) {
-                                        throw new Error('[did-provider-cheqd]: paymentConditions is required');
-                                    }
-                                    // return access control conditions and payment conditions tuple
-                                    return [
-                                        await Promise.all(topArgs.paymentConditions.map(async (condition) => {
-                                            switch (condition.type) {
-                                                case exports.AccessControlConditionTypes.timelockPayment:
-                                                    return await v6_js_1.LitProtocol.generateCosmosAccessControlConditionInverseTimelock({
-                                                        key: '$.tx_responses.*.timestamp',
-                                                        comparator: '<=',
-                                                        value: `${condition.intervalInSeconds}`,
-                                                    }, condition.feePaymentAmount, condition.feePaymentAddress, condition?.blockHeight);
-                                                default:
-                                                    throw new Error(`[did-provider-cheqd]: unsupported access control condition type ${condition.type}`);
-                                            }
-                                        })),
-                                        topArgs.paymentConditions,
-                                    ];
-                                })();
-                            // encrypt bitstring - case: threshold
-                            const { encryptedString: thresholdEncryptionCiphertext, stringHash: thresholdEncryptionStringHash, } = await lit.encrypt((0, uint8arrays_1.fromString)(bitstring, 'base64url'), unifiedAccessControlConditionsTuple[0]);
-                            // construct encoded list
-                            const encodedList = `${await (0, helpers_js_1.blobToHexString)(symmetricEncryptionCiphertext)}-${(0, uint8arrays_1.toString)(thresholdEncryptionCiphertext, 'hex')}`;
-                            // define status list content
-                            const content = {
-                                StatusList2021: {
-                                    statusPurpose: publishedList.StatusList2021.statusPurpose,
-                                    encodedList,
-                                    validFrom: publishedList.StatusList2021.validFrom,
-                                    validUntil: options?.publishOptions?.statusListValidUntil ||
-                                        publishedList.StatusList2021.validUntil,
-                                },
-                                metadata: {
-                                    type: publishedList.metadata.type,
-                                    encrypted: true,
-                                    encoding: options?.publishOptions?.statusListEncoding || publishedList.metadata.encoding,
-                                    statusListHash: symmetricEncryptionStringHash === thresholdEncryptionStringHash
-                                        ? symmetricEncryptionStringHash
-                                        : (function () {
-                                            throw new Error('[did-provider-cheqd]: revocation: symmetricEncryptionStringHash and thresholdEncryptionStringHash do not match');
-                                        })(),
-                                    paymentConditions: unifiedAccessControlConditionsTuple[1],
-                                },
-                            };
-                            // return tuple of publish result and encryption relevant metadata
-                            return [
-                                await Cheqd.publishStatusList2021((0, uint8arrays_1.fromString)(JSON.stringify(content), 'utf-8'), statusListMetadata, options?.publishOptions),
-                                {
-                                    symmetricEncryptionCiphertext,
-                                    thresholdEncryptionCiphertext,
-                                    stringHash: symmetricEncryptionStringHash,
-                                    symmetricKey,
-                                },
-                            ];
-                        })()
-                        : await (async function () {
-                            // validate encoding, if provided
-                            if (options?.publishOptions?.statusListEncoding &&
-                                !Object.values(cheqd_did_provider_js_1.DefaultStatusList2021Encodings).includes(options?.publishOptions?.statusListEncoding)) {
-                                throw new Error('[did-provider-cheqd]: revocation: Invalid status list encoding');
-                            }
-                            // validate validUntil, if provided
-                            if (options?.publishOptions?.statusListValidUntil) {
-                                // validate validUntil as string
-                                if (typeof options?.publishOptions?.statusListValidUntil !== 'string')
-                                    throw new Error('[did-provider-cheqd]: revocation: Invalid status list validUntil (must be string)');
-                                // validate validUntil as date
-                                if (isNaN(Date.parse(options?.publishOptions?.statusListValidUntil)))
-                                    throw new Error('[did-provider-cheqd]: revocation: Invalid status list validUntil (must be date)');
-                                // validate validUntil as future date
-                                if (new Date(options?.publishOptions?.statusListValidUntil) < new Date())
-                                    throw new Error('[did-provider-cheqd]: revocation: Invalid status list validUntil (must be future date)');
-                                // validate validUntil towards validFrom
-                                if (new Date(options?.publishOptions?.statusListValidUntil) <=
-                                    new Date(publishedList.StatusList2021.validFrom))
-                                    throw new Error('[did-provider-cheqd]: revocation: Invalid status list validUntil (must be after validFrom)');
-                            }
-                            // define status list content
-                            const content = {
-                                StatusList2021: {
-                                    statusPurpose: publishedList.StatusList2021.statusPurpose,
-                                    encodedList: publishedList.metadata.encoding === 'base64url'
-                                        ? bitstring
-                                        : (0, uint8arrays_1.toString)((0, uint8arrays_1.fromString)(bitstring, 'base64url'), options.publishOptions
-                                            .statusListEncoding),
-                                    validFrom: publishedList.StatusList2021.validFrom,
-                                    validUntil: options?.publishOptions?.statusListValidUntil ||
-                                        publishedList.StatusList2021.validUntil,
-                                },
-                                metadata: {
-                                    type: publishedList.metadata.type,
-                                    encoding: options?.publishOptions?.statusListEncoding || publishedList.metadata.encoding,
-                                    encrypted: false,
-                                },
-                            };
-                            // return tuple of publish result and encryption relevant metadata
-                            return [
-                                await Cheqd.publishStatusList2021((0, uint8arrays_1.fromString)(JSON.stringify(content), 'utf-8'), statusListMetadata, options?.publishOptions),
-                                undefined,
-                            ];
-                        })();
-                    // early exit, if publish failed
-                    if (!scoped[0])
-                        throw new Error('[did-provider-cheqd]: revocation: Failed to publish status list 2021');
-                    // return publish result
-                    return scoped;
-                })()
-                : undefined;
-            return {
-                revoked: revoked.map((result) => (result.status === 'fulfilled' ? result.value.revoked : false)),
-                published: topArgs?.publish ? true : undefined,
-                statusList: topArgs?.returnUpdatedStatusList
-                    ? (await Cheqd.fetchStatusList2021(credentials[0]))
-                    : undefined,
-                symmetricKey: topArgs?.returnSymmetricKey
-                    ? (0, uint8arrays_1.toString)(published?.[1]?.symmetricKey, 'hex')
-                    : undefined,
-                resourceMetadata: topArgs?.returnStatusListMetadata
-                    ? await Cheqd.fetchStatusList2021Metadata(credentials[0])
-                    : undefined,
-            };
-        }
-        catch (error) {
-            // silent fail + early exit
-            console.error(error);
-            return { revoked: [], error: error };
-        }
-    }
-    static async suspendCredential(credential, options) {
-        try {
-            // validate status purpose
-            if (credential?.credentialStatus?.statusPurpose !== cheqd_did_provider_js_1.DefaultStatusList2021StatusPurposeTypes.suspension)
-                throw new Error('[did-provider-cheqd]: suspension: Invalid status purpose');
-            // fetch status list 2021
-            const publishedList = (await Cheqd.fetchStatusList2021(credential));
-            // early return, if encrypted and no decryption key provided
-            if (publishedList.metadata.encrypted && !options?.topArgs?.symmetricKey)
-                throw new Error('[did-provider-cheqd]: suspension: symmetricKey is required, if status list 2021 is encrypted');
-            // fetch status list 2021 inscribed in credential
-            const statusList2021 = options?.topArgs?.fetchList
-                ? await (async function () {
-                    // if not encrypted, return bitstring
-                    if (!publishedList.metadata.encrypted)
-                        return publishedList.metadata.encoding === 'base64url'
-                            ? publishedList.StatusList2021.encodedList
-                            : (0, uint8arrays_1.toString)((0, uint8arrays_1.fromString)(publishedList.StatusList2021.encodedList, publishedList.metadata.encoding), 'base64url');
-                    // decrypt + return bitstring, if qualified for migration
-                    if (publishedList.metadata.encryptedSymmetricKey)
-                        return await v2_js_1.LitProtocolV2.decryptDirect(await (0, helpers_js_1.toBlob)((0, uint8arrays_1.fromString)(publishedList.StatusList2021
-                            .encodedList, 'hex')), (0, uint8arrays_1.fromString)(options?.topArgs?.symmetricKey, 'hex'));
-                    // validate encoded list
-                    if (!(0, helpers_js_1.isEncodedList)(publishedList.StatusList2021.encodedList))
-                        throw new Error('[did-provider-cheqd]: suspension: Invalid encoded list');
-                    // otherwise, decrypt and return raw bitstring
-                    const scopedRawBlob = await (0, helpers_js_1.toBlob)((0, uint8arrays_1.fromString)((0, helpers_js_1.getEncodedList)(publishedList.StatusList2021.encodedList, false)[0], 'hex'));
-                    // decrypt
-                    return (0, uint8arrays_1.toString)(await v6_js_1.LitProtocol.decryptDirect(scopedRawBlob, await (0, helpers_js_1.safeDeserialise)(options?.topArgs?.symmetricKey, uint8arrays_1.fromString, ['hex'], 'Invalid symmetric key')), 'base64url');
-                })()
-                : await (async function () {
-                    // transcode to base64url, if needed
-                    const publishedListTranscoded = publishedList.metadata.encoding === 'base64url'
-                        ? publishedList.StatusList2021.encodedList
-                        : (0, uint8arrays_1.toString)((0, uint8arrays_1.fromString)(publishedList.StatusList2021.encodedList, publishedList.metadata.encoding), 'base64url');
-                    // if status list 2021 is not fetched, read from file
-                    if (options?.statusListFile) {
-                        // if not encrypted, return bitstring
-                        if (!publishedList.metadata.encrypted) {
-                            // construct encoded status list
-                            const encoded = new vc_status_list_1.StatusList({
-                                buffer: await Cheqd.getFile(options.statusListFile),
-                            }).encode();
-                            // validate against published list
-                            if (encoded !== publishedListTranscoded)
-                                throw new Error('[did-provider-cheqd]: suspension: statusListFile does not match published status list 2021');
-                            // return encoded
-                            return encoded;
-                        }
-                        // otherwise, decrypt and return bitstring
-                        const scopedRawBlob = await (0, helpers_js_1.toBlob)(await Cheqd.getFile(options.statusListFile));
-                        // decrypt
-                        const decrypted = (0, uint8arrays_1.toString)(await v6_js_1.LitProtocol.decryptDirect(scopedRawBlob, await (0, helpers_js_1.safeDeserialise)(options?.topArgs?.symmetricKey, uint8arrays_1.fromString, ['hex'], 'Invalid symmetric key')), 'base64url');
-                        // validate against published list
-                        if (decrypted !== publishedListTranscoded)
-                            throw new Error('[did-provider-cheqd]: suspension: statusListFile does not match published status list 2021');
-                        // return decrypted
-                        return decrypted;
-                    }
-                    if (!options?.statusListInlineBitstring)
-                        throw new Error('[did-provider-cheqd]: suspension: statusListInlineBitstring is required, if statusListFile is not provided');
-                    // validate against published list
-                    if (options?.statusListInlineBitstring !== publishedListTranscoded)
-                        throw new Error('[did-provider-cheqd]: suspension: statusListInlineBitstring does not match published status list 2021');
-                    // otherwise, read from inline bitstring
-                    return options?.statusListInlineBitstring;
-                })();
-            // parse status list 2021
-            const statusList = await vc_status_list_1.StatusList.decode({ encodedList: statusList2021 });
-            // early exit, if already suspended
-            if (statusList.getStatus(Number(credential.credentialStatus.statusListIndex)))
-                return { suspended: true };
-            // update suspension status
-            statusList.setStatus(Number(credential.credentialStatus.statusListIndex), true);
-            // set in-memory status list ref
-            const bitstring = (await statusList.encode());
-            // cast top-level args
-            const topArgs = options?.topArgs;
-            // write status list 2021 to file, if provided
-            if (topArgs?.writeToFile) {
-                await Cheqd.writeFile((0, uint8arrays_1.fromString)(bitstring, 'base64url'), options?.statusListFile);
-            }
-            // publish status list 2021, if provided
-            const published = topArgs?.publish
-                ? await (async function () {
-                    // fetch status list 2021 metadata
-                    const statusListMetadata = await Cheqd.fetchStatusList2021Metadata(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(cheqd_did_provider_js_1.DefaultStatusList2021Encodings).includes(options?.publishOptions?.statusListEncoding)) {
-                                throw new Error('[did-provider-cheqd]: suspension: Invalid status list encoding');
-                            }
-                            // validate validUntil, if provided
-                            if (options?.publishOptions?.statusListValidUntil) {
-                                // validate validUntil as string
-                                if (typeof options?.publishOptions?.statusListValidUntil !== 'string')
-                                    throw new Error('[did-provider-cheqd]: suspension: Invalid status list validUntil (must be string)');
-                                // validate validUntil as date
-                                if (isNaN(Date.parse(options?.publishOptions?.statusListValidUntil)))
-                                    throw new Error('[did-provider-cheqd]: suspension: Invalid status list validUntil (must be date)');
-                                // validate validUntil as future date
-                                if (new Date(options?.publishOptions?.statusListValidUntil) < new Date())
-                                    throw new Error('[did-provider-cheqd]: suspension: Invalid status list validUntil (must be future date)');
-                                // validate validUntil towards validFrom
-                                if (new Date(options?.publishOptions?.statusListValidUntil) <=
-                                    new Date(publishedList.StatusList2021.validFrom))
-                                    throw new Error('[did-provider-cheqd]: suspension: Invalid status list validUntil (must be after validFrom)');
-                            }
-                            // validate paymentConditions, if provided
-                            if (topArgs?.paymentConditions) {
-                                if (!topArgs?.paymentConditions?.every((condition) => condition.feePaymentAddress &&
-                                    condition.feePaymentAmount &&
-                                    condition.intervalInSeconds)) {
-                                    throw new Error('[did-provider-cheqd]: paymentConditions must contain feePaymentAddress and feeAmount and intervalInSeconds');
-                                }
-                                if (!topArgs?.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 (!topArgs?.paymentConditions?.every((condition) => condition.type === exports.AccessControlConditionTypes.timelockPayment)) {
-                                    throw new Error('[did-provider-cheqd]: paymentConditions must be of type timelockPayment');
-                                }
-                            }
-                            // validate dkgOptions
-                            if (!topArgs?.dkgOptions ||
-                                !topArgs?.dkgOptions?.chain ||
-                                !topArgs?.dkgOptions?.network) {
-                                throw new Error('[did-provider-cheqd]: dkgOptions is required');
-                            }
-                            // encrypt bitstring - case: symmetric
-                            const { encryptedString: symmetricEncryptionCiphertext, stringHash: symmetricEncryptionStringHash, symmetricKey, } = await v6_js_1.LitProtocol.encryptDirect((0, uint8arrays_1.fromString)(bitstring, 'base64url'));
-                            // instantiate dkg-threshold client, in which case lit-protocol is used
-                            const lit = (await options.publishOptions.instantiateDkgClient);
-                            // construct access control conditions and payment conditions tuple
-                            const unifiedAccessControlConditionsTuple = publishedList.metadata.encrypted
-                                ? await (async function () {
-                                    // define payment conditions, give precedence to top-level args
-                                    const paymentConditions = topArgs?.paymentConditions ||
-                                        publishedList.metadata.paymentConditions;
-                                    // return access control conditions and payment conditions tuple
-                                    return [
-                                        await Promise.all(paymentConditions.map(async (condition) => {
-                                            switch (condition.type) {
-                                                case exports.AccessControlConditionTypes.timelockPayment:
-                                                    return await v6_js_1.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}`);
-                                            }
-                                        })),
-                                        paymentConditions,
-                                    ];
-                                })()
-                                : await (async function () {
-                                    // validate paymentConditions
-                                    if (!topArgs?.paymentConditions) {
-                                        throw new Error('[did-provider-cheqd]: paymentConditions is required');
-                                    }
-                                    // return access control conditions and payment conditions tuple
-                                    return [
-                                        await Promise.all(topArgs.paymentConditions.map(async (condition) => {
-                                            switch (condition.type) {
-                                                case exports.AccessControlConditionTypes.timelockPayment:
-                                                    return await v6_js_1.LitProtocol.generateCosmosAccessControlConditionInverseTimelock({
-                                                        key: '$.tx_responses.*.timestamp',
-                                                        comparator: '<=',
-                                                        value: `${condition.intervalInSeconds}`,
-                                                    }, condition.feePaymentAmount, condition.feePaymentAddress, condition?.blockHeight);
-                                                default:
-                                                    throw new Error(`[did-provider-cheqd]: unsupported access control condition type ${condition.type}`);
-                                            }
-                                        })),
-                                        topArgs.paymentConditions,
-                                    ];
-                                })();
-                            // encrypt bitstring - case: threshold
-                            const { encryptedString: thresholdEncryptionCiphertext, stringHash: thresholdEncryptionStringHash, } = await lit.encrypt((0, uint8arrays_1.fromString)(bitstring, 'base64url'), unifiedAccessControlConditionsTuple[0]);
-                            // construct encoded list
-                            const encodedList = `${await (0, helpers_js_1.blobToHexString)(symmetricEncryptionCiphertext)}-${(0, uint8arrays_1.toString)(thresholdEncryptionCiphertext, 'hex')}`;
-                            // define status list content
-                            const content = {
-                                StatusList2021: {
-                                    statusPurpose: publishedList.StatusList2021.statusPurpose,
-                                    encodedList,
-                                    validFrom: publishedList.StatusList2021.validFrom,
-                                    validUntil: options?.publishOptions?.statusListValidUntil ||
-                                        publishedList.StatusList2021.validUntil,
-                                },
-                                metadata: {
-                                    type: publishedList.metadata.type,
-                                    encrypted: true,
-                                    encoding: options?.publishOptions?.statusListEncoding || publishedList.metadata.encoding,
-                                    statusListHash: symmetricEncryptionStringHash === thresholdEncryptionStringHash
-                                        ? symmetricEncryptionStringHash
-                                        : (function () {
-                                            throw new Error('[did-provider-cheqd]: suspension: symmetricEncryptionStringHash and thresholdEncryptionStringHash do not match');
-                                        })(),
-                                    paymentConditions: unifiedAccessControlConditionsTuple[1],
-                                },
-                            };
-                            // return tuple of publish result and encryption relevant metadata
-                            return [
-                                await Cheqd.publishStatusList2021((0, uint8arrays_1.fromString)(JSON.stringify(content), 'utf-8'), statusListMetadata, options?.publishOptions),
-                                {
-                                    symmetricEncryptionCiphertext,
-                                    thresholdEncryptionCiphertext,
-                                    stringHash: symmetricEncryptionStringHash,
-                                    symmetricKey,
-                                },
-                            ];
-                        })()
-                        : await (async function () {
-                            // validate encoding, if provided
-                            if (options?.publishOptions?.statusListEncoding &&
-                                !Object.values(cheqd_did_provider_js_1.DefaultStatusList2021Encodings).includes(options?.publishOptions?.statusListEncoding)) {
-                                throw new Error('[did-provider-cheqd]: suspension: Invalid status list encoding');
-                            }
-                            // validate validUntil, if provided
-                            if (options?.publishOptions?.statusListValidUntil) {
-                                // validate validUntil as string
-                                if (typeof options?.publishOptions?.statusListValidUntil !== 'string')
-                                    throw new Error('[did-provider-cheqd]: suspension: Invalid status list validUntil (must be string)');
-                                // validate validUntil as date
-                                if (isNaN(Date.parse(options?.publishOptions?.statusListValidUntil)))
-                                    throw new Error('[did-provider-cheqd]: suspension: Invalid status list validUntil (must be date)');
-                                // validate validUntil as future date
-                                if (new Date(options?.publishOptions?.statusListValidUntil) < new Date())
-                                    throw new Error('[did-provider-cheqd]: suspension: Invalid status list validUntil (must be future date)');
-                                // validate validUntil towards validFrom
-                                if (new Date(options?.publishOptions?.statusListValidUntil) <=
-                                    new Date(publishedList.StatusList2021.validFrom))
-                                    throw new Error('[did-provider-cheqd]: suspension: Invalid status list validUntil (must be after validFrom)');
-                            }
-                            // define status list content
-                            const content = {
-                                StatusList2021: {
-                                    statusPurpose: publishedList.StatusList2021.statusPurpose,
-                                    encodedList: publishedList.metadata.encoding === 'base64url'
-                                        ? bitstring
-                                        : (0, uint8arrays_1.toString)((0, uint8arrays_1.fromString)(bitstring, 'base64url'), options.publishOptions
-                                            .statusListEncoding),
-                                    validFrom: publishedList.StatusList2021.validFrom,
-                                    validUntil: options?.publishOptions?.statusListValidUntil ||
-                                        publishedList.StatusList2021.validUntil,
-                                },
-                                metadata: {
-                                    type: publishedList.metadata.type,
-                                    encoding: options?.publishOptions?.statusListEncoding || publishedList.metadata.encoding,
-                                    encrypted: false,
-                                },
-                            };
-                            // return tuple of publish result and encryption relevant metadata
-                            return [
-                                await Cheqd.publishStatusList2021((0, uint8arrays_1.fromString)(JSON.stringify(content), 'utf-8'), statusListMetadata, options?.publishOptions),
-                                undefined,
-                            ];
-                        })();
-                    // early exit, if publish failed
-                    if (!scoped[0])
-                        throw new Error('[did-provider-cheqd]: suspension: Failed to publish status list 2021');
-                    // return publish result
-                    return scoped;
-                })()
-                : undefined;
-            return {
-                suspended: true,
-                published: topArgs?.publish ? true : undefined,
-                statusList: topArgs?.returnUpdatedStatusList
-                    ? (await Cheqd.fetchStatusList2021(credential))
-                    : undefined,
-                symmetricKey: topArgs?.returnSymmetricKey
-                    ? (0, uint8arrays_1.toString)(published?.[1]?.symmetricKey, 'hex')
-                    : undefined,
-                resourceMetadata: topArgs?.returnStatusListMetadata
-                    ? await Cheqd.fetchStatusList2021Metadata(credential)
-                    : undefined,
-            };
-        }
-        catch (error) {
-            // silent fail + early exit
-            console.error(error);
-            return { suspended: false, error: error };
-        }
-    }
-    static async suspendCredentials(credentials, options) {
-        // validate credentials - case: empty
-        if (!credentials.length || credentials.length === 0)
-            throw new Error('[did-provider-cheqd]: suspension: No credentials provided');
-        // 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]: suspension: Credentials must be issued by the same issuer');
-        // validate credentials - case: status list index
-        if (credentials
-            .map((credential) => credential.credentialStatus.statusListIndex)
-            .filter((value, index, self) => self.indexOf(value) !== index).length > 0)
-            throw new Error('[did-provider-cheqd]: suspension: Credentials must have unique status list index');
-        // validate credentials - case: status purpose
-        if (!credentials.every((credential) => credential.credentialStatus?.statusPurpose === cheqd_did_provider_js_1.DefaultStatusList2021StatusPurposeTypes.suspension))
-            throw new Error('[did-provider-cheqd]: suspension: Invalid status purpose');
-        // validate credentials - case: status list id
-        const remote = credentials[0].credentialStatus?.id
-            ? credentials[0].credentialStatus.id.split('#')[0]
-            : (function () {
-                throw new Error('[did-provider-cheqd]: suspension: Invalid status list id');
-            })();
-        // validate credentials - case: status list id format
-        if (!exports.RemoteListPattern.test(remote))
-            throw new Error('[did-provider-cheqd]: suspension: Invalid status list id format: expected: https://<optional_subdomain>.<sld>.<tld>/1.0/identifiers/<did:cheqd:<namespace>:<method_specific_id>>?resourceName=<resource_name>&resourceType=<resource_type>');
-        if (!credentials.every((credential) => {
-            return credential.credentialStatus.id.split('#')[0] === remote;
-        }))
-            throw new Error('[did-provider-cheqd]: suspension: Credentials must belong to the same status list');
-        // validate credentials - case: status list type
-        if (!credentials.every((credential) => credential.credentialStatus?.type === 'StatusList2021Entry'))
-            throw new Error('[did-provider-cheqd]: suspension: Invalid status list type');
-        try {
-            // fetch status list 2021
-            const publishedList = (await Cheqd.fetchStatusList2021(credentials[0]));
-            // early return, if encrypted and no decryption key provided
-            if (publishedList.metadata.encrypted && !options?.topArgs?.symmetricKey)
-                throw new Error('[did-provider-cheqd]: suspension: symmetricKey is required, if status list 2021 is encrypted');
-            // fetch status list 2021 inscribed in credential
-            const statusList2021 = options?.topArgs?.fetchList
-                ? await (async function () {
-                    // if not encrypted, return bitstring
-                    if (!publishedList.metadata.encrypted)
-                        return publishedList.metadata.encoding === 'base64url'
-                            ? publishedList.StatusList2021.encodedList
-                            : (0, uint8arrays_1.toString)((0, uint8arrays_1.fromString)(publishedList.StatusList2021.encodedList, publishedList.metadata.encoding), 'base64url');
-                    // decrypt + return bitstring, if qualified for migration
-                    if (publishedList.metadata.encryptedSymmetricKey)
-                        return await v2_js_1.LitProtocolV2.decryptDirect(await (0, helpers_js_1.toBlob)((0, uint8arrays_1.fromString)(publishedList.StatusList2021
-                            .encodedList, 'hex')), (0, uint8arrays_1.fromString)(options?.topArgs?.symmetricKey, 'hex'));
-                    // validate encoded list
-                    if (!(0, helpers_js_1.isEncodedList)(publishedList.StatusList2021.encodedList))
-                        throw new Error('[did-provider-cheqd]: suspension: Invalid encoded list');
-                    // otherwise, decrypt and return raw bitstring
-                    const scopedRawBlob = await (0, helpers_js_1.toBlob)((0, uint8arrays_1.fromString)((0, helpers_js_1.getEncodedList)(publishedList.StatusList2021.encodedList, false)[0], 'hex'));
-                    // decrypt
-                    return (0, uint8arrays_1.toString)(await v6_js_1.LitProtocol.decryptDirect(scopedRawBlob, await (0, helpers_js_1.safeDeserialise)(options?.topArgs?.symmetricKey, uint8arrays_1.fromString, ['hex'], 'Invalid symmetric key')), 'base64url');
-                })()
-                : await (async function () {
-                    // transcode to base64url, if needed
-                    const publishedListTranscoded = publishedList.metadata.encoding === 'base64url'
-                        ? publishedList.StatusList2021.encodedList
-                        : (0, uint8arrays_1.toString)((0, uint8arrays_1.fromString)(publishedList.StatusList2021.encodedList, publishedList.metadata.encoding), 'base64url');
-                    // if status list 2021 is not fetched, read from file
-                    if (options?.statusListFile) {
-                        // if not encrypted, return bitstring
-                        if (!publishedList.metadata.encrypted) {
-                            // construct encoded status list
-                            const encoded = new vc_status_list_1.StatusList({
-                                buffer: await Cheqd.getFile(options.statusListFile),
-                            }).encode();
-                            // validate against published list
-                            if (encoded !== publishedListTranscoded)
-                                throw new Error('[did-provider-cheqd]: suspension: statusListFile does not match published status list 2021');
-                            // return encoded
-                            return encoded;
-                        }
-                        // otherwise, decrypt and return bitstring
-                        const scopedRawBlob = await (0, helpers_js_1.toBlob)(await Cheqd.getFile(options.statusListFile));
-                        // decrypt
-                        const decrypted = (0, uint8arrays_1.toString)(await v6_js_1.LitProtocol.decryptDirect(scopedRawBlob, await (0, helpers_js_1.safeDeserialise)(options?.topArgs?.symmetricKey, uint8arrays_1.fromString, ['hex'], 'Invalid symmetric key')), 'base64url');
-                        // validate against published list
-                        if (decrypted !== publishedListTranscoded)
-                            throw new Error('[did-provider-cheqd]: suspension: statusListFile does not match published status list 2021');
-                        // return decrypted
-                        return decrypted;
-                    }
-                    if (!options?.statusListInlineBitstring)
-                        throw new Error('[did-provider-cheqd]: suspension: statusListInlineBitstring is required, if statusListFile is not provided');
-                    // validate against published list
-                    if (options?.statusListInlineBitstring !== publishedListTranscoded)
-                        throw new Error('[did-provider-cheqd]: suspension: statusListInlineBitstring does not match published status list 2021');
-                    // otherwise, read from inline bitstring
-                    return options?.statusListInlineBitstring;
-                })();
-            // parse status list 2021
-            const statusList = await vc_status_list_1.StatusList.decode({ encodedList: statusList2021 });
-            // initiate bulk suspension
-            const suspended = (await Promise.allSettled(credentials.map((credential) => {
-                return (async function () {
-                    // early return, if no credential status
-                    if (!credential.credentialStatus)
-                        return { suspended: false };
-                    // early exit, if credential is already suspended
-                    if (statusList.getStatus(Number(credential.credentialStatus.statusListIndex)))
-                        return { suspended: true };
-                    // update suspension status
-                    statusList.setStatus(Number(credential.credentialStatus.statusListIndex), true);
-                    // return suspension status
-                    return { suspended: true };
-                })();
-            })));
-            // revert bulk ops, if some failed
-            if (suspended.some((result) => result.status === 'fulfilled' && !result.value.suspended))
-                throw new Error(`[did-provider-cheqd]: suspension: Bulk suspension failed: already suspended credentials in suspension bundle: raw log: ${JSON.stringify(suspended.map((result) => ({
-                    suspended: result.status === 'fulfilled' ? result.value.suspended : false,
-                })))}`);
-            // set in-memory status list ref
-            const bitstring = (await statusList.encode());
-            // cast top-level args
-            const topArgs = options?.topArgs;
-            // write status list 2021 to file, if provided
-            if (topArgs?.writeToFile) {
-                await Cheqd.writeFile((0, uint8arrays_1.fromString)(bitstring, 'base64url'), options?.statusListFile);
-            }
-            // publish status list 2021, if provided
-            const published = topArgs?.publish
-                ? await (async function () {
-                    // fetch status list 2021 metadata
-                    const statusListMetadata = await Cheqd.fetchStatusList2021Metadata(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(cheqd_did_provider_js_1.DefaultStatusList2021Encodings).includes(options?.publishOptions?.statusListEncoding)) {
-                                throw new Error('[did-provider-cheqd]: suspension: Invalid status list encoding');
-                            }
-                            // validate validUntil, if provided
-                            if (options?.publishOptions?.statusListValidUntil) {
-                                // validate validUntil as string
-                                if (typeof options?.publishOptions?.statusListValidUntil !== 'string')
-                                    throw new Error('[did-provider-cheqd]: suspension: Invalid status list validUntil (must be string)');
-                                // validate validUntil as date
-                                if (isNaN(Date.parse(options?.publishOptions?.statusListValidUntil)))
-                                    throw new Error('[did-provider-cheqd]: suspension: Invalid status list validUntil (must be date)');
-                                // validate validUntil as future date
-                                if (new Date(options?.publishOptions?.statusListValidUntil) < new Date())
-                                    throw new Error('[did-provider-cheqd]: suspension: Invalid status list validUntil (must be future date)');
-                                // validate validUntil towards validFrom
-                                if (new Date(options?.publishOptions?.statusListValidUntil) <=
-                                    new Date(publishedList.StatusList2021.validFrom))
-                                    throw new Error('[did-provider-cheqd]: suspension: Invalid status list validUntil (must be after validFrom)');
-                            }
-                            // validate paymentConditions, if provided
-                            if (topArgs?.paymentConditions) {
-                                if (!topArgs?.paymentConditions?.every((condition) => condition.feePaymentAddress &&
-                                    condition.feePaymentAmount &&
-                                    condition.intervalInSeconds)) {
-                                    throw new Error('[did-provider-cheqd]: paymentConditions must contain feePaymentAddress and feeAmount and intervalInSeconds');
-                                }
-                                if (!topArgs?.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 (!topArgs?.paymentConditions?.every((condition) => condition.type === exports.AccessControlConditionTypes.timelockPayment)) {
-                                    throw new Error('[did-provider-cheqd]: paymentConditions must be of type timelockPayment');
-                                }
-                            }
-                            // validate dkgOptions
-                            if (!topArgs?.dkgOptions ||
-                                !topArgs?.dkgOptions?.chain ||
-                                !topArgs?.dkgOptions?.network) {
-                                throw new Error('[did-provider-cheqd]: dkgOptions is required');
-                            }
-                            // encrypt bitstring - case: symmetric
-                            const { encryptedString: symmetricEncryptionCiphertext, stringHash: symmetricEncryptionStringHash, symmetricKey, } = await v6_js_1.LitProtocol.encryptDirect((0, uint8arrays_1.fromString)(bitstring, 'base64url'));
-                            // instantiate dkg-threshold client, in which case lit-protocol is used
-                            const lit = (await options.publishOptions.instantiateDkgClient);
-                            // construct access control conditions and payment conditions tuple
-                            const unifiedAccessControlConditionsTuple = publishedList.metadata.encrypted
-                                ? await (async function () {
-                                    // define payment conditions, give precedence to top-level args
-                                    const paymentConditions = topArgs?.paymentConditions ||
-                                        publishedList.metadata.paymentConditions;
-                                    // return access control conditions and payment conditions tuple
-                                    return [
-                                        await Promise.all(paymentConditions.map(async (condition) => {
-                                            switch (condition.type) {
-                                                case exports.AccessControlConditionTypes.timelockPayment:
-                                                    return await v6_js_1.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}`);
-                                            }
-                                        })),
-                                        paymentConditions,
-                                    ];
-                                })()
-                                : await (async function () {
-                                    // validate paymentConditions
-                                    if (!topArgs?.paymentConditions) {
-                                        throw new Error('[did-provider-cheqd]: paymentConditions is required');
-                                    }
-                                    // return access control conditions and payment conditions tuple
-                                    return [
-                                        await Promise.all(topArgs.paymentConditions.map(async (condition) => {
-                                            switch (condition.type) {
-                                                case exports.AccessControlConditionTypes.timelockPayment:
-                                                    return await v6_js_1.LitProtocol.generateCosmosAccessControlConditionInverseTimelock({
-                                                        key: '$.tx_responses.*.timestamp',
-                                                        comparator: '<=',
-                                                        value: `${condition.intervalInSeconds}`,
-                                                    }, condition.feePaymentAmount, condition.feePaymentAddress, condition?.blockHeight);
-                                                default:
-                                                    throw new Error(`[did-provider-cheqd]: unsupported access control condition type ${condition.type}`);
-                                            }
-                                        })),
-                                        topArgs.paymentConditions,
-                                    ];
-                                })();
-                            // encrypt bitstring - case: threshold
-                            const { encryptedString: thresholdEncryptionCiphertext, stringHash: thresholdEncryptionStringHash, } = await lit.encrypt((0, uint8arrays_1.fromString)(bitstring, 'base64url'), unifiedAccessControlConditionsTuple[0]);
-                            // construct encoded list
-                            const encodedList = `${await (0, helpers_js_1.blobToHexString)(symmetricEncryptionCiphertext)}-${(0, uint8arrays_1.toString)(thresholdEncryptionCiphertext, 'hex')}`;
-                            // define status list content
-                            const content = {
-                                StatusList2021: {
-                                    statusPurpose: publishedList.StatusList2021.statusPurpose,
-                                    encodedList,
-                                    validFrom: publishedList.StatusList2021.validFrom,
-                                    validUntil: options?.publishOptions?.statusListValidUntil ||
-                                        publishedList.StatusList2021.validUntil,
-                                },
-                                metadata: {
-                                    type: publishedList.metadata.type,
-                                    encrypted: true,
-                                    encoding: options?.publishOptions?.statusListEncoding || publishedList.metadata.encoding,
-                                    statusListHash: symmetricEncryptionStringHash === thresholdEncryptionStringHash
-                                        ? symmetricEncryptionStringHash
-                                        : (function () {
-                                            throw new Error('[did-provider-cheqd]: suspension: symmetricEncryptionStringHash and thresholdEncryptionStringHash do not match');
-                                        })(),
-                                    paymentConditions: unifiedAccessControlConditionsTuple[1],
-                                },
-                            };
-                            // return tuple of publish result and encryption relevant metadata
-                            return [
-                                await Cheqd.publishStatusList2021((0, uint8arrays_1.fromString)(JSON.stringify(content), 'utf-8'), statusListMetadata, options?.publishOptions),
-                                {
-                                    symmetricEncryptionCiphertext,
-                                    thresholdEncryptionCiphertext,
-                                    stringHash: symmetricEncryptionStringHash,
-                                    symmetricKey,
-                                },
-                            ];
-                        })()
-                        : await (async function () {
-                            // validate encoding, if provided
-                            if (options?.publishOptions?.statusListEncoding &&
-                                !Object.values(cheqd_did_provider_js_1.DefaultStatusList2021Encodings).includes(options?.publishOptions?.statusListEncoding)) {
-                                throw new Error('[did-provider-cheqd]: suspension: Invalid status list encoding');
-                            }
-                            // validate validUntil, if provided
-                            if (options?.publishOptions?.statusListValidUntil) {
-                                // validate validUntil as string
-                                if (typeof options?.publishOptions?.statusListValidUntil !== 'string')
-                                    throw new Error('[did-provider-cheqd]: suspension: Invalid status list validUntil (must be string)');
-                                // validate validUntil as date
-                                if (isNaN(Date.parse(options?.publishOptions?.statusListValidUntil)))
-                                    throw new Error('[did-provider-cheqd]: suspension: Invalid status list validUntil (must be date)');
-                                // validate validUntil as future date
-                                if (new Date(options?.publishOptions?.statusListValidUntil) < new Date())
-                                    throw new Error('[did-provider-cheqd]: suspension: Invalid status list validUntil (must be future date)');
-                                // validate validUntil towards validFrom
-                                if (new Date(options?.publishOptions?.statusListValidUntil) <=
-                                    new Date(publishedList.StatusList2021.validFrom))
-                                    throw new Error('[did-provider-cheqd]: suspension: Invalid status list validUntil (must be after validFrom)');
-                            }
-                            // define status list content
-                            const content = {
-                                StatusList2021: {
-                                    statusPurpose: publishedList.StatusList2021.statusPurpose,
-                                    encodedList: publishedList.metadata.encoding === 'base64url'
-                                        ? bitstring
-                                        : (0, uint8arrays_1.toString)((0, uint8arrays_1.fromString)(bitstring, 'base64url'), options.publishOptions
-                                            .statusListEncoding),
-                                    validFrom: publishedList.StatusList2021.validFrom,
-                                    validUntil: options?.publishOptions?.statusListValidUntil ||
-                                        publishedList.StatusList2021.validUntil,
-                                },
-                                metadata: {
-                                    type: publishedList.metadata.type,
-                                    encoding: options?.publishOptions?.statusListEncoding || publishedList.metadata.encoding,
-                                    encrypted: false,
-                                },
-                            };
-                            // return tuple of publish result and encryption relevant metadata
-                            return [
-                                await Cheqd.publishStatusList2021((0, uint8arrays_1.fromString)(JSON.stringify(content), 'utf-8'), statusListMetadata, options?.publishOptions),
-                                undefined,
-                            ];
-                        })();
-                    // early exit, if publish failed
-                    if (!scoped[0])
-                        throw new Error('[did-provider-cheqd]: suspension: Failed to publish status list 2021');
-                    // return publish result
-                    return scoped;
-                })()
-                : undefined;
-            return {
-                suspended: suspended.map((result) => (result.status === 'fulfilled' ? result.value.suspended : false)),
-                published: topArgs?.publish ? true : undefined,
-                statusList: topArgs?.returnUpdatedStatusList
-                    ? (await Cheqd.fetchStatusList2021(credentials[0]))
-                    : undefined,
-                symmetricKey: topArgs?.returnSymmetricKey
-                    ? (0, uint8arrays_1.toString)(published?.[1]?.symmetricKey, 'hex')
-                    : undefined,
-                resourceMetadata: topArgs?.returnStatusListMetadata
-                    ? await Cheqd.fetchStatusList2021Metadata(credentials[0])
-                    : undefined,
-            };
-        }
-        catch (error) {
-            // silent fail + early exit
-            console.error(error);
-            return { suspended: [], error: error };
-        }
-    }
-    static async unsuspendCredential(credential, options) {
-        try {
-            // validate status purpose
-            if (credential?.credentialStatus?.statusPurpose !== cheqd_did_provider_js_1.DefaultStatusList2021StatusPurposeTypes.suspension)
-                throw new Error('[did-provider-cheqd]: unsuspension: Invalid status purpose');
-            // fetch status list 2021
-            const publishedList = (await Cheqd.fetchStatusList2021(credential));
-            // early return, if encrypted and no decryption key provided
-            if (publishedList.metadata.encrypted && !options?.topArgs?.symmetricKey)
-                throw new Error('[did-provider-cheqd]: unsuspension: symmetricKey is required, if status list 2021 is encrypted');
-            // fetch status list 2021 inscribed in credential
-            const statusList2021 = options?.topArgs?.fetchList
-                ? await (async function () {
-                    // if not encrypted, return bitstring
-                    if (!publishedList.metadata.encrypted)
-                        return publishedList.metadata.encoding === 'base64url'
-                            ? publishedList.StatusList2021.encodedList
-                            : (0, uint8arrays_1.toString)((0, uint8arrays_1.fromString)(publishedList.StatusList2021.encodedList, publishedList.metadata.encoding), 'base64url');
-                    // decrypt + return bitstring, if qualified for migration
-                    if (publishedList.metadata.encryptedSymmetricKey)
-                        return await v2_js_1.LitProtocolV2.decryptDirect(await (0, helpers_js_1.toBlob)((0, uint8arrays_1.fromString)(publishedList.StatusList2021
-                            .encodedList, 'hex')), (0, uint8arrays_1.fromString)(options?.topArgs?.symmetricKey, 'hex'));
-                    // validate encoded list
-                    if (!(0, helpers_js_1.isEncodedList)(publishedList.StatusList2021.encodedList))
-                        throw new Error('[did-provider-cheqd]: unsuspension: Invalid encoded list');
-                    // otherwise, decrypt and return raw bitstring
-                    const scopedRawBlob = await (0, helpers_js_1.toBlob)((0, uint8arrays_1.fromString)((0, helpers_js_1.getEncodedList)(publishedList.StatusList2021.encodedList, false)[0], 'hex'));
-                    // decrypt
-                    return (0, uint8arrays_1.toString)(await v6_js_1.LitProtocol.decryptDirect(scopedRawBlob, await (0, helpers_js_1.safeDeserialise)(options?.topArgs?.symmetricKey, uint8arrays_1.fromString, ['hex'], 'Invalid symmetric key')), 'base64url');
-                })()
-                : await (async function () {
-                    // transcode to base64url, if needed
-                    const publishedListTranscoded = publishedList.metadata.encoding === 'base64url'
-                        ? publishedList.StatusList2021.encodedList
-                        : (0, uint8arrays_1.toString)((0, uint8arrays_1.fromString)(publishedList.StatusList2021.encodedList, publishedList.metadata.encoding), 'base64url');
-                    // if status list 2021 is not fetched, read from file
-                    if (options?.statusListFile) {
-                        // if not encrypted, return bitstring
-                        if (!publishedList.metadata.encrypted) {
-                            // construct encoded status list
-                            const encoded = new vc_status_list_1.StatusList({
-                                buffer: await Cheqd.getFile(options.statusListFile),
-                            }).encode();
-                            // validate against published list
-                            if (encoded !== publishedListTranscoded)
-                                throw new Error('[did-provider-cheqd]: unsuspension: statusListFile does not match published status list 2021');
-                            // return encoded
-                            return encoded;
-                        }
-                        // otherwise, decrypt and return bitstring
-                        const scopedRawBlob = await (0, helpers_js_1.toBlob)(await Cheqd.getFile(options.statusListFile));
-                        // decrypt
-                        const decrypted = (0, uint8arrays_1.toString)(await v6_js_1.LitProtocol.decryptDirect(scopedRawBlob, await (0, helpers_js_1.safeDeserialise)(options?.topArgs?.symmetricKey, uint8arrays_1.fromString, ['hex'], 'Invalid symmetric key')), 'base64url');
-                        // validate against published list
-                        if (decrypted !== publishedListTranscoded)
-                            throw new Error('[did-provider-cheqd]: unsuspension: statusListFile does not match published status list 2021');
-                        // return decrypted
-                        return decrypted;
-                    }
-                    if (!options?.statusListInlineBitstring)
-                        throw new Error('[did-provider-cheqd]: unsuspension: statusListInlineBitstring is required, if statusListFile is not provided');
-                    // validate against published list
-                    if (options?.statusListInlineBitstring !== publishedListTranscoded)
-                        throw new Error('[did-provider-cheqd]: unsuspension: statusListInlineBitstring does not match published status list 2021');
-                    // otherwise, read from inline bitstring
-                    return options?.statusListInlineBitstring;
-                })();
-            // parse status list 2021
-            const statusList = await vc_status_list_1.StatusList.decode({ encodedList: statusList2021 });
-            // early exit, if already unsuspended
-            if (!statusList.getStatus(Number(credential.credentialStatus.statusListIndex)))
-                return { unsuspended: true };
-            // update suspension status
-            statusList.setStatus(Number(credential.credentialStatus.statusListIndex), false);
-            // set in-memory status list ref
-            const bitstring = (await statusList.encode());
-            // cast top-level args
-            const topArgs = options?.topArgs;
-            // write status list 2021 to file, if provided
-            if (topArgs?.writeToFile) {
-                await Cheqd.writeFile((0, uint8arrays_1.fromString)(bitstring, 'base64url'), options?.statusListFile);
-            }
-            // publish status list 2021, if provided
-            const published = topArgs?.publish
-                ? await (async function () {
-                    // fetch status list 2021 metadata
-                    const statusListMetadata = await Cheqd.fetchStatusList2021Metadata(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(cheqd_did_provider_js_1.DefaultStatusList2021Encodings).includes(options?.publishOptions?.statusListEncoding)) {
-                                throw new Error('[did-provider-cheqd]: unsuspension: Invalid status list encoding');
-                            }
-                            // validate validUntil, if provided
-                            if (options?.publishOptions?.statusListValidUntil) {
-                                // validate validUntil as string
-                                if (typeof options?.publishOptions?.statusListValidUntil !== 'string')
-                                    throw new Error('[did-provider-cheqd]: unsuspension: Invalid status list validUntil (must be string)');
-                                // validate validUntil as date
-                                if (isNaN(Date.parse(options?.publishOptions?.statusListValidUntil)))
-                                    throw new Error('[did-provider-cheqd]: unsuspension: Invalid status list validUntil (must be date)');
-                                // validate validUntil as future date
-                                if (new Date(options?.publishOptions?.statusListValidUntil) < new Date())
-                                    throw new Error('[did-provider-cheqd]: unsuspension: Invalid status list validUntil (must be future date)');
-                                // validate validUntil towards validFrom
-                                if (new Date(options?.publishOptions?.statusListValidUntil) <=
-                                    new Date(publishedList.StatusList2021.validFrom))
-                                    throw new Error('[did-provider-cheqd]: unsuspension: Invalid status list validUntil (must be after validFrom)');
-                            }
-                            // validate paymentConditions, if provided
-                            if (topArgs?.paymentConditions) {
-                                if (!topArgs?.paymentConditions?.every((condition) => condition.feePaymentAddress &&
-                                    condition.feePaymentAmount &&
-                                    condition.intervalInSeconds)) {
-                                    throw new Error('[did-provider-cheqd]: paymentConditions must contain feePaymentAddress and feeAmount and intervalInSeconds');
-                                }
-                                if (!topArgs?.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 (!topArgs?.paymentConditions?.every((condition) => condition.type === exports.AccessControlConditionTypes.timelockPayment)) {
-                                    throw new Error('[did-provider-cheqd]: paymentConditions must be of type timelockPayment');
-                                }
-                            }
-                            // validate dkgOptions
-                            if (!topArgs?.dkgOptions ||
-                                !topArgs?.dkgOptions?.chain ||
-                                !topArgs?.dkgOptions?.network) {
-                                throw new Error('[did-provider-cheqd]: dkgOptions is required');
-                            }
-                            // encrypt bitstring - case: symmetric
-                            const { encryptedString: symmetricEncryptionCiphertext, stringHash: symmetricEncryptionStringHash, symmetricKey, } = await v6_js_1.LitProtocol.encryptDirect((0, uint8arrays_1.fromString)(bitstring, 'base64url'));
-                            // instantiate dkg-threshold client, in which case lit-protocol is used
-                            const lit = (await options.publishOptions.instantiateDkgClient);
-                            // construct access control conditions and payment conditions tuple
-                            const unifiedAccessControlConditionsTuple = publishedList.metadata.encrypted
-                                ? await (async function () {
-                                    // define payment conditions, give precedence to top-level args
-                                    const paymentConditions = topArgs?.paymentConditions ||
-                                        publishedList.metadata.paymentConditions;
-                                    // return access control conditions and payment conditions tuple
-                                    return [
-                                        await Promise.all(paymentConditions.map(async (condition) => {
-                                            switch (condition.type) {
-                                                case exports.AccessControlConditionTypes.timelockPayment:
-                                                    return await v6_js_1.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}`);
-                                            }
-                                        })),
-                                        paymentConditions,
-                                    ];
-                                })()
-                                : await (async function () {
-                                    // validate paymentConditions
-                                    if (!topArgs?.paymentConditions) {
-                                        throw new Error('[did-provider-cheqd]: paymentConditions is required');
-                                    }
-                                    // return access control conditions and payment conditions tuple
-                                    return [
-                                        await Promise.all(topArgs.paymentConditions.map(async (condition) => {
-                                            switch (condition.type) {
-                                                case exports.AccessControlConditionTypes.timelockPayment:
-                                                    return await v6_js_1.LitProtocol.generateCosmosAccessControlConditionInverseTimelock({
-                                                        key: '$.tx_responses.*.timestamp',
-                                                        comparator: '<=',
-                                                        value: `${condition.intervalInSeconds}`,
-                                                    }, condition.feePaymentAmount, condition.feePaymentAddress, condition?.blockHeight);
-                                                default:
-                                                    throw new Error(`[did-provider-cheqd]: unsupported access control condition type ${condition.type}`);
-                                            }
-                                        })),
-                                        topArgs.paymentConditions,
-                                    ];
-                                })();
-                            // encrypt bitstring - case: threshold
-                            const { encryptedString: thresholdEncryptionCiphertext, stringHash: thresholdEncryptionStringHash, } = await lit.encrypt((0, uint8arrays_1.fromString)(bitstring, 'base64url'), unifiedAccessControlConditionsTuple[0]);
-                            // construct encoded list
-                            const encodedList = `${await (0, helpers_js_1.blobToHexString)(symmetricEncryptionCiphertext)}-${(0, uint8arrays_1.toString)(thresholdEncryptionCiphertext, 'hex')}`;
-                            // define status list content
-                            const content = {
-                                StatusList2021: {
-                                    statusPurpose: publishedList.StatusList2021.statusPurpose,
-                                    encodedList,
-                                    validFrom: publishedList.StatusList2021.validFrom,
-                                    validUntil: options?.publishOptions?.statusListValidUntil ||
-                                        publishedList.StatusList2021.validUntil,
-                                },
-                                metadata: {
-                                    type: publishedList.metadata.type,
-                                    encrypted: true,
-                                    encoding: options?.publishOptions?.statusListEncoding || publishedList.metadata.encoding,
-                                    statusListHash: symmetricEncryptionStringHash === thresholdEncryptionStringHash
-                                        ? symmetricEncryptionStringHash
-                                        : (function () {
-                                            throw new Error('[did-provider-cheqd]: unsuspension: symmetricEncryptionStringHash and thresholdEncryptionStringHash do not match');
-                                        })(),
-                                    paymentConditions: unifiedAccessControlConditionsTuple[1],
-                                },
-                            };
-                            // return tuple of publish result and encryption relevant metadata
-                            return [
-                                await Cheqd.publishStatusList2021((0, uint8arrays_1.fromString)(JSON.stringify(content), 'utf-8'), statusListMetadata, options?.publishOptions),
-                                {
-                                    symmetricEncryptionCiphertext,
-                                    thresholdEncryptionCiphertext,
-                                    stringHash: symmetricEncryptionStringHash,
-                                    symmetricKey,
-                                },
-                            ];
-                        })()
-                        : await (async function () {
-                            // validate encoding, if provided
-                            if (options?.publishOptions?.statusListEncoding &&
-                                !Object.values(cheqd_did_provider_js_1.DefaultStatusList2021Encodings).includes(options?.publishOptions?.statusListEncoding)) {
-                                throw new Error('[did-provider-cheqd]: unsuspension: Invalid status list encoding');
-                            }
-                            // validate validUntil, if provided
-                            if (options?.publishOptions?.statusListValidUntil) {
-                                // validate validUntil as string
-                                if (typeof options?.publishOptions?.statusListValidUntil !== 'string')
-                                    throw new Error('[did-provider-cheqd]: unsuspension: Invalid status list validUntil (must be string)');
-                                // validate validUntil as date
-                                if (isNaN(Date.parse(options?.publishOptions?.statusListValidUntil)))
-                                    throw new Error('[did-provider-cheqd]: unsuspension: Invalid status list validUntil (must be date)');
-                                // validate validUntil as future date
-                                if (new Date(options?.publishOptions?.statusListValidUntil) < new Date())
-                                    throw new Error('[did-provider-cheqd]: unsuspension: Invalid status list validUntil (must be future date)');
-                                // validate validUntil towards validFrom
-                                if (new Date(options?.publishOptions?.statusListValidUntil) <=
-                                    new Date(publishedList.StatusList2021.validFrom))
-                                    throw new Error('[did-provider-cheqd]: unsuspension: Invalid status list validUntil (must be after validFrom)');
-                            }
-                            // define status list content
-                            const content = {
-                                StatusList2021: {
-                                    statusPurpose: publishedList.StatusList2021.statusPurpose,
-                                    encodedList: publishedList.metadata.encoding === 'base64url'
-                                        ? bitstring
-                                        : (0, uint8arrays_1.toString)((0, uint8arrays_1.fromString)(bitstring, 'base64url'), options.publishOptions
-                                            .statusListEncoding),
-                                    validFrom: publishedList.StatusList2021.validFrom,
-                                    validUntil: options?.publishOptions?.statusListValidUntil ||
-                                        publishedList.StatusList2021.validUntil,
-                                },
-                                metadata: {
-                                    type: publishedList.metadata.type,
-                                    encoding: options?.publishOptions?.statusListEncoding || publishedList.metadata.encoding,
-                                    encrypted: false,
-                                },
-                            };
-                            // return tuple of publish result and encryption relevant metadata
-                            return [
-                                await Cheqd.publishStatusList2021((0, uint8arrays_1.fromString)(JSON.stringify(content), 'utf-8'), statusListMetadata, options?.publishOptions),
-                                undefined,
-                            ];
-                        })();
-                    // early exit, if publish failed
-                    if (!scoped[0])
-                        throw new Error('[did-provider-cheqd]: unsuspension: Failed to publish status list 2021');
-                    // return publish result
-                    return scoped;
-                })()
-                : undefined;
-            return {
-                unsuspended: true,
-                published: topArgs?.publish ? true : undefined,
-                statusList: topArgs?.returnUpdatedStatusList
-                    ? (await Cheqd.fetchStatusList2021(credential))
-                    : undefined,
-                symmetricKey: topArgs?.returnSymmetricKey
-                    ? (0, uint8arrays_1.toString)(published?.[1]?.symmetricKey, 'hex')
-                    : undefined,
-                resourceMetadata: topArgs?.returnStatusListMetadata
-                    ? await Cheqd.fetchStatusList2021Metadata(credential)
-                    : undefined,
-            };
-        }
-        catch (error) {
-            // silent fail + early exit
-            console.error(error);
-            return { unsuspended: false, error: error };
-        }
-    }
-    static async unsuspendCredentials(credentials, options) {
-        // validate credentials - case: empty
-        if (!credentials.length || credentials.length === 0)
-            throw new Error('[did-provider-cheqd]: unsuspension: No credentials provided');
-        // 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]: unsuspension: Credentials must be issued by the same issuer');
-        // validate credentials - case: status list index
-        if (credentials
-            .map((credential) => credential.credentialStatus.statusListIndex)
-            .filter((value, index, self) => self.indexOf(value) !== index).length > 0)
-            throw new Error('[did-provider-cheqd]: unsuspension: Credentials must have unique status list index');
-        // validate credentials - case: status purpose
-        if (!credentials.every((credential) => credential.credentialStatus?.statusPurpose === cheqd_did_provider_js_1.DefaultStatusList2021StatusPurposeTypes.suspension))
-            throw new Error('[did-provider-cheqd]: unsuspension: Invalid status purpose');
-        // validate credentials - case: status list id
-        const remote = credentials[0].credentialStatus?.id
-            ? credentials[0].credentialStatus.id.split('#')[0]
-            : (function () {
-                throw new Error('[did-provider-cheqd]: unsuspension: Invalid status list id');
-            })();
-        // validate credentials - case: status list id format
-        if (!exports.RemoteListPattern.test(remote))
-            throw new Error('[did-provider-cheqd]: unsuspension: Invalid status list id format: expected: https://<optional_subdomain>.<sld>.<tld>/1.0/identifiers/<did:cheqd:<namespace>:<method_specific_id>>?resourceName=<resource_name>&resourceType=<resource_type>');
-        if (!credentials.every((credential) => {
-            return credential.credentialStatus.id.split('#')[0] === remote;
-        }))
-            throw new Error('[did-provider-cheqd]: unsuspension: Credentials must belong to the same status list');
-        // validate credentials - case: status list type
-        if (!credentials.every((credential) => credential.credentialStatus?.type === 'StatusList2021Entry'))
-            throw new Error('[did-provider-cheqd]: unsuspension: Invalid status list type');
-        try {
-            // fetch status list 2021
-            const publishedList = (await Cheqd.fetchStatusList2021(credentials[0]));
-            // early return, if encrypted and no decryption key provided
-            if (publishedList.metadata.encrypted && !options?.topArgs?.symmetricKey)
-                throw new Error('[did-provider-cheqd]: unsuspension: symmetricKey is required, if status list 2021 is encrypted');
-            // fetch status list 2021 inscribed in credential
-            const statusList2021 = options?.topArgs?.fetchList
-                ? await (async function () {
-                    // if not encrypted, return bitstring
-                    if (!publishedList.metadata.encrypted)
-                        return publishedList.metadata.encoding === 'base64url'
-                            ? publishedList.StatusList2021.encodedList
-                            : (0, uint8arrays_1.toString)((0, uint8arrays_1.fromString)(publishedList.StatusList2021.encodedList, publishedList.metadata.encoding), 'base64url');
-                    // decrypt + return bitstring, if qualified for migration
-                    if (publishedList.metadata.encryptedSymmetricKey)
-                        return await v2_js_1.LitProtocolV2.decryptDirect(await (0, helpers_js_1.toBlob)((0, uint8arrays_1.fromString)(publishedList.StatusList2021
-                            .encodedList, 'hex')), (0, uint8arrays_1.fromString)(options?.topArgs?.symmetricKey, 'hex'));
-                    // validate encoded list
-                    if (!(0, helpers_js_1.isEncodedList)(publishedList.StatusList2021.encodedList))
-                        throw new Error('[did-provider-cheqd]: unsuspension: Invalid encoded list');
-                    // otherwise, decrypt and return raw bitstring
-                    const scopedRawBlob = await (0, helpers_js_1.toBlob)((0, uint8arrays_1.fromString)((0, helpers_js_1.getEncodedList)(publishedList.StatusList2021.encodedList, false)[0], 'hex'));
-                    // decrypt
-                    return (0, uint8arrays_1.toString)(await v6_js_1.LitProtocol.decryptDirect(scopedRawBlob, await (0, helpers_js_1.safeDeserialise)(options?.topArgs?.symmetricKey, uint8arrays_1.fromString, ['hex'], 'Invalid symmetric key')), 'base64url');
-                })()
-                : await (async function () {
-                    // transcode to base64url, if needed
-                    const publishedListTranscoded = publishedList.metadata.encoding === 'base64url'
-                        ? publishedList.StatusList2021.encodedList
-                        : (0, uint8arrays_1.toString)((0, uint8arrays_1.fromString)(publishedList.StatusList2021.encodedList, publishedList.metadata.encoding), 'base64url');
-                    // if status list 2021 is not fetched, read from file
-                    if (options?.statusListFile) {
-                        // if not encrypted, return bitstring
-                        if (!publishedList.metadata.encrypted) {
-                            // construct encoded status list
-                            const encoded = new vc_status_list_1.StatusList({
-                                buffer: await Cheqd.getFile(options.statusListFile),
-                            }).encode();
-                            // validate against published list
-                            if (encoded !== publishedListTranscoded)
-                                throw new Error('[did-provider-cheqd]: unsuspension: statusListFile does not match published status list 2021');
-                            // return encoded
-                            return encoded;
-                        }
-                        // otherwise, decrypt and return bitstring
-                        const scopedRawBlob = await (0, helpers_js_1.toBlob)(await Cheqd.getFile(options.statusListFile));
-                        // decrypt
-                        const decrypted = (0, uint8arrays_1.toString)(await v6_js_1.LitProtocol.decryptDirect(scopedRawBlob, await (0, helpers_js_1.safeDeserialise)(options?.topArgs?.symmetricKey, uint8arrays_1.fromString, ['hex'], 'Invalid symmetric key')), 'base64url');
-                        // validate against published list
-                        if (decrypted !== publishedListTranscoded)
-                            throw new Error('[did-provider-cheqd]: unsuspension: statusListFile does not match published status list 2021');
-                        // return decrypted
-                        return decrypted;
-                    }
-                    if (!options?.statusListInlineBitstring)
-                        throw new Error('[did-provider-cheqd]: unsuspension: statusListInlineBitstring is required, if statusListFile is not provided');
-                    // validate against published list
-                    if (options?.statusListInlineBitstring !== publishedListTranscoded)
-                        throw new Error('[did-provider-cheqd]: unsuspension: statusListInlineBitstring does not match published status list 2021');
-                    // otherwise, read from inline bitstring
-                    return options?.statusListInlineBitstring;
-                })();
-            // parse status list 2021
-            const statusList = await vc_status_list_1.StatusList.decode({ encodedList: statusList2021 });
-            // initiate bulk unsuspension
-            const unsuspended = (await Promise.allSettled(credentials.map((credential) => {
-                return (async function () {
-                    // early return, if no credential status
-                    if (!credential.credentialStatus)
-                        return { unsuspended: false };
-                    // early exit, if credential is already unsuspended
-                    if (!statusList.getStatus(Number(credential.credentialStatus.statusListIndex)))
-                        return { unsuspended: true };
-                    // update unsuspension status
-                    statusList.setStatus(Number(credential.credentialStatus.statusListIndex), false);
-                    // return unsuspension status
-                    return { unsuspended: true };
-                })();
-            })));
-            // revert bulk ops, if some failed
-            if (unsuspended.some((result) => result.status === 'fulfilled' && !result.value.unsuspended))
-                throw new Error(`[did-provider-cheqd]: unsuspension: Bulk unsuspension failed: already unsuspended credentials in unsuspension bundle: raw log: ${JSON.stringify(unsuspended.map((result) => ({
-                    unsuspended: result.status === 'fulfilled' ? result.value.unsuspended : false,
-                })))}`);
-            // set in-memory status list ref
-            const bitstring = (await statusList.encode());
-            // cast top-level args
-            const topArgs = options?.topArgs;
-            // write status list 2021 to file, if provided
-            if (topArgs?.writeToFile) {
-                await Cheqd.writeFile((0, uint8arrays_1.fromString)(bitstring, 'base64url'), options?.statusListFile);
-            }
-            // publish status list 2021, if provided
-            const published = topArgs?.publish
-                ? await (async function () {
-                    // fetch status list 2021 metadata
-                    const statusListMetadata = await Cheqd.fetchStatusList2021Metadata(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(cheqd_did_provider_js_1.DefaultStatusList2021Encodings).includes(options?.publishOptions?.statusListEncoding)) {
-                                throw new Error('[did-provider-cheqd]: unsuspension: Invalid status list encoding');
-                            }
-                            // validate validUntil, if provided
-                            if (options?.publishOptions?.statusListValidUntil) {
-                                // validate validUntil as string
-                                if (typeof options?.publishOptions?.statusListValidUntil !== 'string')
-                                    throw new Error('[did-provider-cheqd]: unsuspension: Invalid status list validUntil (must be string)');
-                                // validate validUntil as date
-                                if (isNaN(Date.parse(options?.publishOptions?.statusListValidUntil)))
-                                    throw new Error('[did-provider-cheqd]: unsuspension: Invalid status list validUntil (must be date)');
-                                // validate validUntil as future date
-                                if (new Date(options?.publishOptions?.statusListValidUntil) < new Date())
-                                    throw new Error('[did-provider-cheqd]: unsuspension: Invalid status list validUntil (must be future date)');
-                                // validate validUntil towards validFrom
-                                if (new Date(options?.publishOptions?.statusListValidUntil) <=
-                                    new Date(publishedList.StatusList2021.validFrom))
-                                    throw new Error('[did-provider-cheqd]: unsuspension: Invalid status list validUntil (must be after validFrom)');
-                            }
-                            // validate paymentConditions, if provided
-                            if (topArgs?.paymentConditions) {
-                                if (!topArgs?.paymentConditions?.every((condition) => condition.feePaymentAddress &&
-                                    condition.feePaymentAmount &&
-                                    condition.intervalInSeconds)) {
-                                    throw new Error('[did-provider-cheqd]: paymentConditions must contain feePaymentAddress and feeAmount and intervalInSeconds');
-                                }
-                                if (!topArgs?.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 (!topArgs?.paymentConditions?.every((condition) => condition.type === exports.AccessControlConditionTypes.timelockPayment)) {
-                                    throw new Error('[did-provider-cheqd]: paymentConditions must be of type timelockPayment');
-                                }
-                            }
-                            // validate dkgOptions
-                            if (!topArgs?.dkgOptions ||
-                                !topArgs?.dkgOptions?.chain ||
-                                !topArgs?.dkgOptions?.network) {
-                                throw new Error('[did-provider-cheqd]: dkgOptions is required');
-                            }
-                            // encrypt bitstring - case: symmetric
-                            const { encryptedString: symmetricEncryptionCiphertext, stringHash: symmetricEncryptionStringHash, symmetricKey, } = await v6_js_1.LitProtocol.encryptDirect((0, uint8arrays_1.fromString)(bitstring, 'base64url'));
-                            // instantiate dkg-threshold client, in which case lit-protocol is used
-                            const lit = (await options.publishOptions.instantiateDkgClient);
-                            // construct access control conditions and payment conditions tuple
-                            const unifiedAccessControlConditionsTuple = publishedList.metadata.encrypted
-                                ? await (async function () {
-                                    // define payment conditions, give precedence to top-level args
-                                    const paymentConditions = topArgs?.paymentConditions ||
-                                        publishedList.metadata.paymentConditions;
-                                    // return access control conditions and payment conditions tuple
-                                    return [
-                                        await Promise.all(paymentConditions.map(async (condition) => {
-                                            switch (condition.type) {
-                                                case exports.AccessControlConditionTypes.timelockPayment:
-                                                    return await v6_js_1.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}`);
-                                            }
-                                        })),
-                                        paymentConditions,
-                                    ];
-                                })()
-                                : await (async function () {
-                                    // validate paymentConditions
-                                    if (!topArgs?.paymentConditions) {
-                                        throw new Error('[did-provider-cheqd]: paymentConditions is required');
-                                    }
-                                    // return access control conditions and payment conditions tuple
-                                    return [
-                                        await Promise.all(topArgs.paymentConditions.map(async (condition) => {
-                                            switch (condition.type) {
-                                                case exports.AccessControlConditionTypes.timelockPayment:
-                                                    return await v6_js_1.LitProtocol.generateCosmosAccessControlConditionInverseTimelock({
-                                                        key: '$.tx_responses.*.timestamp',
-                                                        comparator: '<=',
-                                                        value: `${condition.intervalInSeconds}`,
-                                                    }, condition.feePaymentAmount, condition.feePaymentAddress, condition?.blockHeight);
-                                                default:
-                                                    throw new Error(`[did-provider-cheqd]: unsupported access control condition type ${condition.type}`);
-                                            }
-                                        })),
-                                        topArgs.paymentConditions,
-                                    ];
-                                })();
-                            // encrypt bitstring - case: threshold
-                            const { encryptedString: thresholdEncryptionCiphertext, stringHash: thresholdEncryptionStringHash, } = await lit.encrypt((0, uint8arrays_1.fromString)(bitstring, 'base64url'), unifiedAccessControlConditionsTuple[0]);
-                            // construct encoded list
-                            const encodedList = `${await (0, helpers_js_1.blobToHexString)(symmetricEncryptionCiphertext)}-${(0, uint8arrays_1.toString)(thresholdEncryptionCiphertext, 'hex')}`;
-                            // define status list content
-                            const content = {
-                                StatusList2021: {
-                                    statusPurpose: publishedList.StatusList2021.statusPurpose,
-                                    encodedList,
-                                    validFrom: publishedList.StatusList2021.validFrom,
-                                    validUntil: options?.publishOptions?.statusListValidUntil ||
-                                        publishedList.StatusList2021.validUntil,
-                                },
-                                metadata: {
-                                    type: publishedList.metadata.type,
-                                    encrypted: true,
-                                    encoding: options?.publishOptions?.statusListEncoding || publishedList.metadata.encoding,
-                                    statusListHash: symmetricEncryptionStringHash === thresholdEncryptionStringHash
-                                        ? symmetricEncryptionStringHash
-                                        : (function () {
-                                            throw new Error('[did-provider-cheqd]: unsuspension: symmetricEncryptionStringHash and thresholdEncryptionStringHash do not match');
-                                        })(),
-                                    paymentConditions: unifiedAccessControlConditionsTuple[1],
-                                },
-                            };
-                            // return tuple of publish result and encryption relevant metadata
-                            return [
-                                await Cheqd.publishStatusList2021((0, uint8arrays_1.fromString)(JSON.stringify(content), 'utf-8'), statusListMetadata, options?.publishOptions),
-                                {
-                                    symmetricEncryptionCiphertext,
-                                    thresholdEncryptionCiphertext,
-                                    stringHash: symmetricEncryptionStringHash,
-                                    symmetricKey,
-                                },
-                            ];
-                        })()
-                        : await (async function () {
-                            // validate encoding, if provided
-                            if (options?.publishOptions?.statusListEncoding &&
-                                !Object.values(cheqd_did_provider_js_1.DefaultStatusList2021Encodings).includes(options?.publishOptions?.statusListEncoding)) {
-                                throw new Error('[did-provider-cheqd]: unsuspension: Invalid status list encoding');
-                            }
-                            // validate validUntil, if provided
-                            if (options?.publishOptions?.statusListValidUntil) {
-                                // validate validUntil as string
-                                if (typeof options?.publishOptions?.statusListValidUntil !== 'string')
-                                    throw new Error('[did-provider-cheqd]: unsuspension: Invalid status list validUntil (must be string)');
-                                // validate validUntil as date
-                                if (isNaN(Date.parse(options?.publishOptions?.statusListValidUntil)))
-                                    throw new Error('[did-provider-cheqd]: unsuspension: Invalid status list validUntil (must be date)');
-                                // validate validUntil as future date
-                                if (new Date(options?.publishOptions?.statusListValidUntil) < new Date())
-                                    throw new Error('[did-provider-cheqd]: unsuspension: Invalid status list validUntil (must be future date)');
-                                // validate validUntil towards validFrom
-                                if (new Date(options?.publishOptions?.statusListValidUntil) <=
-                                    new Date(publishedList.StatusList2021.validFrom))
-                                    throw new Error('[did-provider-cheqd]: unsuspension: Invalid status list validUntil (must be after validFrom)');
-                            }
-                            // define status list content
-                            const content = {
-                                StatusList2021: {
-                                    statusPurpose: publishedList.StatusList2021.statusPurpose,
-                                    encodedList: publishedList.metadata.encoding === 'base64url'
-                                        ? bitstring
-                                        : (0, uint8arrays_1.toString)((0, uint8arrays_1.fromString)(bitstring, 'base64url'), options.publishOptions
-                                            .statusListEncoding),
-                                    validFrom: publishedList.StatusList2021.validFrom,
-                                    validUntil: options?.publishOptions?.statusListValidUntil ||
-                                        publishedList.StatusList2021.validUntil,
-                                },
-                                metadata: {
-                                    type: publishedList.metadata.type,
-                                    encoding: options?.publishOptions?.statusListEncoding || publishedList.metadata.encoding,
-                                    encrypted: false,
-                                },
-                            };
-                            // return tuple of publish result and encryption relevant metadata
-                            return [
-                                await Cheqd.publishStatusList2021((0, uint8arrays_1.fromString)(JSON.stringify(content), 'utf-8'), statusListMetadata, options?.publishOptions),
-                                undefined,
-                            ];
-                        })();
-                    // early exit, if publish failed
-                    if (!scoped[0])
-                        throw new Error('[did-provider-cheqd]: unsuspension: Failed to publish status list 2021');
-                    // return publish result
-                    return scoped;
-                })()
-                : undefined;
-            return {
-                unsuspended: unsuspended.map((result) => result.status === 'fulfilled' ? result.value.unsuspended : false),
-                published: topArgs?.publish ? true : undefined,
-                statusList: topArgs?.returnUpdatedStatusList
-                    ? (await Cheqd.fetchStatusList2021(credentials[0]))
-                    : undefined,
-                symmetricKey: topArgs?.returnSymmetricKey
-                    ? (0, uint8arrays_1.toString)(published?.[1]?.symmetricKey, 'hex')
-                    : undefined,
-                resourceMetadata: topArgs?.returnStatusListMetadata
-                    ? await Cheqd.fetchStatusList2021Metadata(credentials[0])
-                    : undefined,
-            };
-        }
-        catch (error) {
-            // silent fail + early exit
-            console.error(error);
-            return { unsuspended: [], error: error };
-        }
-    }
-    static async checkRevoked(credential, options = { fetchList: true }) {
-        // validate status purpose
-        if (credential.credentialStatus?.statusPurpose !== cheqd_did_provider_js_1.DefaultStatusList2021StatusPurposeTypes.revocation) {
-            throw new Error(`[did-provider-cheqd]: check: revocation: Unsupported status purpose: ${credential.credentialStatus?.statusPurpose}`);
-        }
-        // validate dkgOptions
-        if (!options?.topArgs?.dkgOptions) {
-            throw new Error('[did-provider-cheqd]: dkgOptions is required');
-        }
-        // fetch status list 2021
-        const publishedList = (await Cheqd.fetchStatusList2021(credential));
-        // route to non-migrated action, if applicable
-        if (publishedList.metadata.encryptedSymmetricKey)
-            return await this.checkRevokedNonMigrated(credential, publishedList, options);
-        // fetch status list 2021 inscribed in credential
-        const statusList2021 = options?.topArgs?.fetchList
-            ? await (async function () {
-                // if not encrypted, return bitstring
-                if (!publishedList.metadata.encrypted)
-                    return publishedList.metadata.encoding === 'base64url'
-                        ? publishedList.StatusList2021.encodedList
-                        : (0, uint8arrays_1.toString)((0, uint8arrays_1.fromString)(publishedList.StatusList2021.encodedList, publishedList.metadata.encoding), 'base64url');
-                // validate encoded list
-                if (!(0, helpers_js_1.isEncodedList)(publishedList.StatusList2021.encodedList))
-                    throw new Error('[did-provider-cheqd]: check: revocation: Invalid encoded list');
-                // otherwise, decrypt and return raw bitstring
-                const thresholdEncryptionCiphertext = (0, helpers_js_1.getEncodedList)(publishedList.StatusList2021.encodedList, false)[1];
-                // instantiate dkg-threshold client, in which case lit-protocol is used
-                const lit = (await options.instantiateDkgClient);
-                // construct access control conditions
-                const unifiedAccessControlConditions = await Promise.all(publishedList.metadata.paymentConditions.map(async (condition) => {
-                    switch (condition.type) {
-                        case exports.AccessControlConditionTypes.timelockPayment:
-                            return await v6_js_1.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}`);
-                    }
-                }));
-                // decrypt
-                return await lit.decrypt(thresholdEncryptionCiphertext, publishedList.metadata.statusListHash, unifiedAccessControlConditions, options?.topArgs?.dkgOptions?.capacityDelegationAuthSignature);
-            })()
-            : await (async function () {
-                // transcode to base64url, if needed
-                const publishedListTranscoded = publishedList.metadata.encoding === 'base64url'
-                    ? publishedList.StatusList2021.encodedList
-                    : (0, uint8arrays_1.toString)((0, uint8arrays_1.fromString)(publishedList.StatusList2021.encodedList, publishedList.metadata.encoding), 'base64url');
-                // if status list 2021 is not fetched, read from file
-                if (options?.statusListFile) {
-                    // if not encrypted, return bitstring
-                    if (!publishedList.metadata.encrypted) {
-                        // construct encoded status list
-                        const encoded = new vc_status_list_1.StatusList({
-                            buffer: await Cheqd.getFile(options.statusListFile),
-                        }).encode();
-                        // validate against published list
-                        if (encoded !== publishedListTranscoded)
-                            throw new Error('[did-provider-cheqd]: check: revocation: statusListFile does not match published status list 2021');
-                        // return encoded
-                        return encoded;
-                    }
-                    // otherwise, decrypt and return bitstring
-                    const scopedRawBlob = await (0, helpers_js_1.toBlob)(await Cheqd.getFile(options.statusListFile));
-                    // decrypt
-                    const decrypted = (0, uint8arrays_1.toString)(await v6_js_1.LitProtocol.decryptDirect(scopedRawBlob, await (0, helpers_js_1.safeDeserialise)(options?.topArgs?.symmetricKey, uint8arrays_1.fromString, ['hex'], 'Invalid symmetric key')), 'base64url');
-                    // validate against published list
-                    if (decrypted !== publishedListTranscoded)
-                        throw new Error('[did-provider-cheqd]: check: revocation: statusListFile does not match published status list 2021');
-                    // return decrypted
-                    return decrypted;
-                }
-                if (!options?.statusListInlineBitstring)
-                    throw new Error('[did-provider-cheqd]: check: revocation: statusListInlineBitstring is required, if statusListFile is not provided');
-                // validate against published list
-                if (options?.statusListInlineBitstring !== publishedListTranscoded)
-                    throw new Error('[did-provider-cheqd]: check: revocation: statusListInlineBitstring does not match published status list 2021');
-                // otherwise, read from inline bitstring
-                return options?.statusListInlineBitstring;
-            })();
-        // transcode, if needed
-        const transcodedStatusList2021 = publishedList.metadata.encoding === 'base64url'
-            ? statusList2021
-            : (0, uint8arrays_1.toString)((0, uint8arrays_1.fromString)(statusList2021, publishedList.metadata.encoding), 'base64url');
-        // parse status list 2021
-        const statusList = await vc_status_list_1.StatusList.decode({ encodedList: transcodedStatusList2021 });
-        // get status by index
-        return !!statusList.getStatus(Number(credential.credentialStatus.statusListIndex));
-    }
-    static async checkSuspended(credential, options = { fetchList: true }) {
-        // validate status purpose
-        if (credential.credentialStatus?.statusPurpose !== cheqd_did_provider_js_1.DefaultStatusList2021StatusPurposeTypes.suspension) {
-            throw new Error(`[did-provider-cheqd]: check: suspension: Unsupported status purpose: ${credential.credentialStatus?.statusPurpose}`);
-        }
-        // validate dkgOptions
-        if (!options?.topArgs?.dkgOptions) {
-            throw new Error('[did-provider-cheqd]: dkgOptions is required');
-        }
-        // fetch status list 2021
-        const publishedList = (await Cheqd.fetchStatusList2021(credential));
-        // route to non-migrated action, if applicable
-        if (publishedList.metadata.encryptedSymmetricKey)
-            return await this.checkSuspendedNonMigrated(credential, publishedList, options);
-        // fetch status list 2021 inscribed in credential
-        const statusList2021 = options?.topArgs?.fetchList
-            ? await (async function () {
-                // if not encrypted, return bitstring
-                if (!publishedList.metadata.encrypted)
-                    return publishedList.metadata.encoding === 'base64url'
-                        ? publishedList.StatusList2021.encodedList
-                        : (0, uint8arrays_1.toString)((0, uint8arrays_1.fromString)(publishedList.StatusList2021.encodedList, publishedList.metadata.encoding), 'base64url');
-                // otherwise, decrypt and return bitstring
-                const thresholdEncryptionCiphertext = (0, helpers_js_1.getEncodedList)(publishedList.StatusList2021.encodedList, false)[1];
-                // instantiate dkg-threshold client, in which case lit-protocol is used
-                const lit = (await options.instantiateDkgClient);
-                // construct access control conditions
-                const unifiedAccessControlConditions = await Promise.all(publishedList.metadata.paymentConditions.map(async (condition) => {
-                    switch (condition.type) {
-                        case exports.AccessControlConditionTypes.timelockPayment:
-                            return await v6_js_1.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}`);
-                    }
-                }));
-                // decrypt
-                return await lit.decrypt(thresholdEncryptionCiphertext, publishedList.metadata.statusListHash, unifiedAccessControlConditions, options?.topArgs?.dkgOptions?.capacityDelegationAuthSignature);
-            })()
-            : await (async function () {
-                // transcode to base64url, if needed
-                const publishedListTranscoded = publishedList.metadata.encoding === 'base64url'
-                    ? publishedList.StatusList2021.encodedList
-                    : (0, uint8arrays_1.toString)((0, uint8arrays_1.fromString)(publishedList.StatusList2021.encodedList, publishedList.metadata.encoding), 'base64url');
-                // if status list 2021 is not fetched, read from file
-                if (options?.statusListFile) {
-                    // if not encrypted, return bitstring
-                    if (!publishedList.metadata.encrypted) {
-                        // construct encoded status list
-                        const encoded = new vc_status_list_1.StatusList({
-                            buffer: await Cheqd.getFile(options.statusListFile),
-                        }).encode();
-                        // validate against published list
-                        if (encoded !== publishedListTranscoded)
-                            throw new Error('[did-provider-cheqd]: check: suspension: statusListFile does not match published status list 2021');
-                        // return encoded
-                        return encoded;
-                    }
-                    // otherwise, decrypt and return bitstring
-                    const scopedRawBlob = await (0, helpers_js_1.toBlob)(await Cheqd.getFile(options.statusListFile));
-                    // decrypt
-                    const decrypted = (0, uint8arrays_1.toString)(await v6_js_1.LitProtocol.decryptDirect(scopedRawBlob, await (0, helpers_js_1.safeDeserialise)(options?.topArgs?.symmetricKey, uint8arrays_1.fromString, ['hex'], 'Invalid symmetric key')), 'base64url');
-                    // validate against published list
-                    if (decrypted !== publishedListTranscoded)
-                        throw new Error('[did-provider-cheqd]: check: suspension: statusListFile does not match published status list 2021');
-                    // return decrypted
-                    return decrypted;
-                }
-                if (!options?.statusListInlineBitstring)
-                    throw new Error('[did-provider-cheqd]: check: suspension: statusListInlineBitstring is required, if statusListFile is not provided');
-                // validate against published list
-                if (options?.statusListInlineBitstring !== publishedListTranscoded)
-                    throw new Error('[did-provider-cheqd]: check: suspension: statusListInlineBitstring does not match published status list 2021');
-                // otherwise, read from inline bitstring
-                return options?.statusListInlineBitstring;
-            })();
-        // parse status list 2021
-        const statusList = await vc_status_list_1.StatusList.decode({ encodedList: statusList2021 });
-        // get status by index
-        return !!statusList.getStatus(Number(credential.credentialStatus.statusListIndex));
-    }
-    static async checkRevokedNonMigrated(credential, associatedStatusList, options = { fetchList: true }) {
-        // validate status purpose
-        if (credential.credentialStatus?.statusPurpose !== cheqd_did_provider_js_1.DefaultStatusList2021StatusPurposeTypes.revocation) {
-            throw new Error(`[did-provider-cheqd]: check: revocation: Unsupported status purpose: ${credential.credentialStatus?.statusPurpose}`);
-        }
-        // fetch status list 2021
-        const publishedList = associatedStatusList ||
-            (await Cheqd.fetchStatusList2021(credential));
-        // validate migrated
-        if (!publishedList.metadata.encryptedSymmetricKey)
-            throw new Error('[did-provider-cheqd]: check: revocation: Invalid migrated status list');
-        // fetch status list 2021 inscribed in credential
-        const statusList2021 = options?.topArgs?.fetchList
-            ? await (async function () {
-                // if not encrypted, return bitstring
-                if (!publishedList.metadata.encrypted)
-                    return publishedList.metadata.encoding === 'base64url'
-                        ? publishedList.StatusList2021.encodedList
-                        : (0, uint8arrays_1.toString)((0, uint8arrays_1.fromString)(publishedList.StatusList2021.encodedList, publishedList.metadata.encoding), 'base64url');
-                // otherwise, decrypt and return raw bitstring
-                const scopedRawBlob = await (0, helpers_js_1.toBlob)((0, uint8arrays_1.fromString)(publishedList.StatusList2021.encodedList, 'hex'));
-                // instantiate dkg-threshold client, in which case lit-protocol is used
-                const lit = await v2_js_1.LitProtocolV2.create({
-                    chain: options?.topArgs?.dkgOptions?.chain,
-                    litNetwork: v2_js_1.LitNetworksV2.serrano,
-                });
-                // construct access control conditions
-                const unifiedAccessControlConditions = await Promise.all(publishedList.metadata.paymentConditions.map(async (condition) => {
-                    switch (condition.type) {
-                        case exports.AccessControlConditionTypes.timelockPayment:
-                            return await v6_js_1.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}`);
-                    }
-                }));
-                // decrypt
-                return await lit.decrypt(scopedRawBlob, publishedList.metadata.encryptedSymmetricKey, unifiedAccessControlConditions);
-            })()
-            : await (async function () {
-                // transcode to base64url, if needed
-                const publishedListTranscoded = publishedList.metadata.encoding === 'base64url'
-                    ? publishedList.StatusList2021.encodedList
-                    : (0, uint8arrays_1.toString)((0, uint8arrays_1.fromString)(publishedList.StatusList2021.encodedList, publishedList.metadata.encoding), 'base64url');
-                // if status list 2021 is not fetched, read from file
-                if (options?.statusListFile) {
-                    // if not encrypted, return bitstring
-                    if (!publishedList.metadata.encrypted) {
-                        // construct encoded status list
-                        const encoded = new vc_status_list_1.StatusList({
-                            buffer: await Cheqd.getFile(options.statusListFile),
-                        }).encode();
-                        // validate against published list
-                        if (encoded !== publishedListTranscoded)
-                            throw new Error('[did-provider-cheqd]: check: revocation: statusListFile does not match published status list 2021');
-                        // return encoded
-                        return encoded;
-                    }
-                    // otherwise, decrypt and return bitstring
-                    const scopedRawBlob = await (0, helpers_js_1.toBlob)(await Cheqd.getFile(options.statusListFile));
-                    // decrypt
-                    const decrypted = await v2_js_1.LitProtocolV2.decryptDirect(scopedRawBlob, (0, uint8arrays_1.fromString)(options?.topArgs?.symmetricKey, 'hex'));
-                    // validate against published list
-                    if (decrypted !== publishedListTranscoded)
-                        throw new Error('[did-provider-cheqd]: check: revocation: statusListFile does not match published status list 2021');
-                    // return decrypted
-                    return decrypted;
-                }
-                if (!options?.statusListInlineBitstring)
-                    throw new Error('[did-provider-cheqd]: check: revocation: statusListInlineBitstring is required, if statusListFile is not provided');
-                // validate against published list
-                if (options?.statusListInlineBitstring !== publishedListTranscoded)
-                    throw new Error('[did-provider-cheqd]: check: revocation: statusListInlineBitstring does not match published status list 2021');
-                // otherwise, read from inline bitstring
-                return options?.statusListInlineBitstring;
-            })();
-        // transcode, if needed
-        const transcodedStatusList2021 = publishedList.metadata.encoding === 'base64url'
-            ? statusList2021
-            : (0, uint8arrays_1.toString)((0, uint8arrays_1.fromString)(statusList2021, publishedList.metadata.encoding), 'base64url');
-        // parse status list 2021
-        const statusList = await vc_status_list_1.StatusList.decode({ encodedList: transcodedStatusList2021 });
-        // get status by index
-        return !!statusList.getStatus(Number(credential.credentialStatus.statusListIndex));
-    }
-    static async checkSuspendedNonMigrated(credential, associatedStatusList, options = { fetchList: true }) {
-        // validate status purpose
-        if (credential.credentialStatus?.statusPurpose !== cheqd_did_provider_js_1.DefaultStatusList2021StatusPurposeTypes.suspension) {
-            throw new Error(`[did-provider-cheqd]: check: suspension: Unsupported status purpose: ${credential.credentialStatus?.statusPurpose}`);
-        }
-        // fetch status list 2021
-        const publishedList = associatedStatusList ||
-            (await Cheqd.fetchStatusList2021(credential));
-        // validate migrated
-        if (!publishedList.metadata.encryptedSymmetricKey)
-            throw new Error('[did-provider-cheqd]: check: suspension: Invalid migrated status list');
-        // fetch status list 2021 inscribed in credential
-        const statusList2021 = options?.topArgs?.fetchList
-            ? await (async function () {
-                // if not encrypted, return bitstring
-                if (!publishedList.metadata.encrypted)
-                    return publishedList.metadata.encoding === 'base64url'
-                        ? publishedList.StatusList2021.encodedList
-                        : (0, uint8arrays_1.toString)((0, uint8arrays_1.fromString)(publishedList.StatusList2021.encodedList, publishedList.metadata.encoding), 'base64url');
-                // otherwise, decrypt and return raw bitstring
-                const scopedRawBlob = await (0, helpers_js_1.toBlob)((0, uint8arrays_1.fromString)(publishedList.StatusList2021.encodedList, 'hex'));
-                // instantiate dkg-threshold client, in which case lit-protocol is used
-                const lit = await v2_js_1.LitProtocolV2.create({
-                    chain: options?.topArgs?.dkgOptions?.chain,
-                    litNetwork: v2_js_1.LitNetworksV2.serrano,
-                });
-                // construct access control conditions
-                const unifiedAccessControlConditions = await Promise.all(publishedList.metadata.paymentConditions.map(async (condition) => {
-                    switch (condition.type) {
-                        case exports.AccessControlConditionTypes.timelockPayment:
-                            return await v6_js_1.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}`);
-                    }
-                }));
-                // decrypt
-                return await lit.decrypt(scopedRawBlob, publishedList.metadata.encryptedSymmetricKey, unifiedAccessControlConditions);
-            })()
-            : await (async function () {
-                // transcode to base64url, if needed
-                const publishedListTranscoded = publishedList.metadata.encoding === 'base64url'
-                    ? publishedList.StatusList2021.encodedList
-                    : (0, uint8arrays_1.toString)((0, uint8arrays_1.fromString)(publishedList.StatusList2021.encodedList, publishedList.metadata.encoding), 'base64url');
-                // if status list 2021 is not fetched, read from file
-                if (options?.statusListFile) {
-                    // if not encrypted, return bitstring
-                    if (!publishedList.metadata.encrypted) {
-                        // construct encoded status list
-                        const encoded = new vc_status_list_1.StatusList({
-                            buffer: await Cheqd.getFile(options.statusListFile),
-                        }).encode();
-                        // validate against published list
-                        if (encoded !== publishedListTranscoded)
-                            throw new Error('[did-provider-cheqd]: check: suspension: statusListFile does not match published status list 2021');
-                        // return encoded
-                        return encoded;
-                    }
-                    // otherwise, decrypt and return bitstring
-                    const scopedRawBlob = await (0, helpers_js_1.toBlob)(await Cheqd.getFile(options.statusListFile));
-                    // decrypt
-                    const decrypted = (0, uint8arrays_1.toString)(await v6_js_1.LitProtocol.decryptDirect(scopedRawBlob, await (0, helpers_js_1.safeDeserialise)(options?.topArgs?.symmetricKey, uint8arrays_1.fromString, ['hex'], 'Invalid symmetric key')), 'base64url');
-                    // validate against published list
-                    if (decrypted !== publishedListTranscoded)
-                        throw new Error('[did-provider-cheqd]: check: suspension: statusListFile does not match published status list 2021');
-                    // return decrypted
-                    return decrypted;
-                }
-                if (!options?.statusListInlineBitstring)
-                    throw new Error('[did-provider-cheqd]: check: suspension: statusListInlineBitstring is required, if statusListFile is not provided');
-                // validate against published list
-                if (options?.statusListInlineBitstring !== publishedListTranscoded)
-                    throw new Error('[did-provider-cheqd]: check: suspension: statusListInlineBitstring does not match published status list 2021');
-                // otherwise, read from inline bitstring
-                return options?.statusListInlineBitstring;
-            })();
-        // parse status list 2021
-        const statusList = await vc_status_list_1.StatusList.decode({ encodedList: statusList2021 });
-        // get status by index
-        return !!statusList.getStatus(Number(credential.credentialStatus.statusListIndex));
-    }
-    static async publishStatusList2021(statusList2021Raw, statusList2021Metadata, options) {
-        // construct status list 2021 payload from previous version + new version
-        const payload = {
-            collectionId: statusList2021Metadata.resourceCollectionId,
-            id: options?.resourceId || (0, uuid_1.v4)(),
-            name: statusList2021Metadata.resourceName,
-            version: options?.resourceVersion || new Date().toISOString(),
-            alsoKnownAs: options?.resourceAlsoKnownAs || [],
-            resourceType: statusList2021Metadata.resourceType,
-            data: statusList2021Raw,
-        };
-        return await options.context.agent[exports.BroadcastStatusList2021MethodName]({
-            kms: (await options.context.agent.keyManagerGetKeyManagementSystems())[0],
-            payload,
-            network: statusList2021Metadata.resourceURI.split(':')[2],
-            signInputs: options?.signInputs,
-            fee: options?.fee,
-        });
-    }
-    static async fetchStatusList2021(credential, returnRaw = false) {
-        // validate credential status
-        if (!credential.credentialStatus)
-            throw new Error('[did-provider-cheqd]: fetch status list: Credential status is not present');
-        // validate credential status type
-        if (credential.credentialStatus.type !== 'StatusList2021Entry')
-            throw new Error('[did-provider-cheqd]: fetch status list: Credential status type is not valid');
-        // validate credential status list status purpose
-        if (credential.credentialStatus.statusPurpose !== cheqd_did_provider_js_1.DefaultStatusList2021StatusPurposeTypes.revocation &&
-            credential.credentialStatus.statusPurpose !== cheqd_did_provider_js_1.DefaultStatusList2021StatusPurposeTypes.suspension)
-            throw new Error('[did-provider-cheqd]: fetch status list: Credential status purpose is not valid');
-        // fetch status list 2021
-        const content = (await (await fetch(credential.credentialStatus.id.split('#')[0])).json());
-        if (!(content.StatusList2021 &&
-            content.metadata &&
-            content.StatusList2021.encodedList &&
-            content.StatusList2021.statusPurpose &&
-            content.metadata.encoding)) {
-            throw new Error(`'[did-provider-cheqd]: fetch status list: Status List resource content is not valid'`);
-        }
-        // return raw if requested
-        if (returnRaw) {
-            return (0, uint8arrays_1.fromString)(content.StatusList2021.encodedList, content.metadata.encoding);
-        }
-        // otherwise, return content
-        return content;
-    }
-    static async fetchStatusList2021Metadata(credential) {
-        // get base url
-        const baseUrl = new URL(credential.credentialStatus.id.split('#')[0]);
-        // get resource name
-        const resourceName = baseUrl.searchParams.get('resourceName');
-        // get resource type
-        const resourceType = baseUrl.searchParams.get('resourceType');
-        // unset resource name
-        baseUrl.searchParams.delete('resourceName');
-        // unset resource type
-        baseUrl.searchParams.delete('resourceType');
-        // construct metadata url
-        const metadataUrl = `${baseUrl.toString()}/metadata`;
-        // fetch collection metadata
-        const collectionMetadata = (await (await fetch(metadataUrl)).json());
-        // early exit if no linked resources
-        if (!collectionMetadata?.contentStream?.linkedResourceMetadata)
-            throw new Error('[did-provider-cheqd]: fetch status list metadata: No linked resources found');
-        // find relevant resources by resource name
-        const resourceVersioning = collectionMetadata.contentStream.linkedResourceMetadata.filter((resource) => resource.resourceName === resourceName && resource.resourceType === resourceType);
-        // early exit if no relevant resources
-        if (!resourceVersioning.length || resourceVersioning.length === 0)
-            throw new Error(`[did-provider-cheqd]: fetch status list metadata: No relevant resources found by resource name ${resourceName}`);
-        // get latest resource version by nextVersionId null pointer, or by latest created date as fallback
-        return (resourceVersioning.find((resource) => !resource.nextVersionId) ||
-            resourceVersioning.sort((a, b) => new Date(b.created).getTime() - new Date(a.created).getTime())[0]);
-    }
-    static async getProviderFromDidUrl(didUrl, providers, message) {
-        const provider = providers.find((provider) => didUrl.includes(`${exports.DidPrefix}:${exports.CheqdDidMethod}:${provider.network}:`));
-        if (!provider) {
-            throw new Error(message ||
-                `[did-provider-cheqd]: no relevant providers found for did url ${didUrl}: loaded providers: ${providers.map((provider) => `${exports.DidPrefix}:${exports.CheqdDidMethod}:${provider.network}`).join(', ')}`);
-        }
-        return provider;
-    }
-    static async getProviderFromNetwork(network, providers, message) {
-        const provider = providers.find((provider) => provider.network === network);
-        if (!provider) {
-            throw new Error(message ||
-                `[did-provider-cheqd]: no relevant providers found for network ${network}: loaded providers: ${providers.map((provider) => `${exports.DidPrefix}:${exports.CheqdDidMethod}:${provider.network}`).join(', ')}`);
-        }
-        return provider;
-    }
-    static generateProviderId(namespace) {
-        return `${exports.DidPrefix}:${exports.CheqdDidMethod}:${namespace}`;
-    }
-    static async getFile(filename) {
-        if (typeof filename !== 'string') {
-            throw new Error('[did-provider-cheqd]: filename is required');
-        }
-        if (!fs_1.default.existsSync(filename)) {
-            debug(`[did-provider-cheqd]: File ${filename} not found`);
-            throw new Error(`[did-provider-cheqd]: File ${filename} not found`);
-        }
-        return new Promise((resolve, reject) => {
-            const content = fs_1.default.readFileSync(filename);
-            if (!content) {
-                reject(new Error(`[did-provider-cheqd]: File ${filename} is empty`));
-            }
-            resolve(new Uint8Array(content));
-        });
-    }
-    static async writeFile(content, filename) {
-        if (!filename) {
-            filename = `statusList2021-${(0, uuid_1.v4)()}`;
-        }
-        // alert if file exists
-        if (fs_1.default.existsSync(filename)) {
-            debug(`[did-provider-cheqd]: File ${filename} already exists`);
-            console.warn(`[did-provider-cheqd]: File ${filename} already exists. Overwriting...`);
-        }
-        return new Promise((resolve, reject) => {
-            fs_1.default.writeFile(filename, content, (err) => {
-                if (err) {
-                    reject(new Error(`[did-provider-cheqd]: Error writing file ${filename}: reason: ${err}`));
-                }
-                resolve();
-            });
-        });
-    }
-    static async decodeCredentialJWT(jwt) {
-        const decodedCredential = (0, did_jwt_1.decodeJWT)(jwt);
-        // validate credential payload
-        if (!decodedCredential.payload)
-            throw new Error('[did-provider-cheqd]: decode jwt: decodedCredential.payload is required');
-        // validate credential payload vc property as VerifiableCredential
-        if (!decodedCredential.payload.vc)
-            throw new Error('[did-provider-cheqd]: decode jwt: decodedCredential.payload.vc is required');
-        return {
-            ...decodedCredential.payload.vc,
-            issuer: decodedCredential.payload.iss,
-        };
-    }
-}
-exports.Cheqd = Cheqd;
-//# sourceMappingURL=ICheqd.js.map