@cheqd/did-provider-cheqd 3.6.9 → 3.6.10-develop.2

package/build/cjs/agent/ICheqd.js

@@ -20,8 +20,18 @@ const lit_protocol_js_1 = require("../dkg-threshold/lit-protocol.js");
 const helpers_js_1 = require("../utils/helpers.js");
 const cheqd_did_resolver_js_1 = require("../did-manager/cheqd-did-resolver.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.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';
@@ -52,434 +62,392 @@ 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"
-                            }
+        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"
-                        ]
+                        required: ['args'],
+                    },
+                    returnType: {
+                        type: 'object',
                     },
-                    "returnType": {
-                        "type": "object"
-                    }
                 },
-                "cheqdUpdateIdentifier": {
-                    "description": "Update an identifier",
-                    "arguments": {
-                        "type": "object",
-                        "properties": {
-                            "args": {
-                                "type": "object",
-                                "description": "A cheqdUpdateIdentifierArgs object as any for extensibility"
-                            }
+                cheqdUpdateIdentifier: {
+                    description: 'Update an identifier',
+                    arguments: {
+                        type: 'object',
+                        properties: {
+                            args: {
+                                type: 'object',
+                                description: 'A cheqdUpdateIdentifierArgs object as any for extensibility',
+                            },
                         },
-                        "required": [
-                            "args"
-                        ]
+                        required: ['args'],
+                    },
+                    returnType: {
+                        type: 'object',
                     },
-                    "returnType": {
-                        "type": "object"
-                    }
                 },
-                "cheqdDeactivateIdentifier": {
-                    "description": "Deactivate an identifier",
-                    "arguments": {
-                        "type": "object",
-                        "properties": {
-                            "args": {
-                                "type": "object",
-                                "description": "A cheqdDeactivateIdentifierArgs object as any for extensibility"
-                            }
+                cheqdDeactivateIdentifier: {
+                    description: 'Deactivate an identifier',
+                    arguments: {
+                        type: 'object',
+                        properties: {
+                            args: {
+                                type: 'object',
+                                description: 'A cheqdDeactivateIdentifierArgs object as any for extensibility',
+                            },
                         },
-                        "required": [
-                            "args"
-                        ]
+                        required: ['args'],
+                    },
+                    returnType: {
+                        type: 'object',
                     },
-                    "returnType": {
-                        "type": "object"
-                    }
                 },
-                "cheqdCreateLinkedResource": {
-                    "description": "Create a new resource",
-                    "arguments": {
-                        "type": "object",
-                        "properties": {
-                            "args": {
-                                "type": "object",
-                                "description": "A cheqdCreateLinkedResource object as any for extensibility"
-                            }
+                cheqdCreateLinkedResource: {
+                    description: 'Create a new resource',
+                    arguments: {
+                        type: 'object',
+                        properties: {
+                            args: {
+                                type: 'object',
+                                description: 'A cheqdCreateLinkedResource object as any for extensibility',
+                            },
                         },
-                        "required": [
-                            "args"
-                        ]
+                        required: ['args'],
+                    },
+                    returnType: {
+                        type: 'boolean',
                     },
-                    "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"
-                            }
+                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"
-                        ]
+                        required: ['args'],
+                    },
+                    returnType: {
+                        type: 'object',
                     },
-                    "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"
-                            }
+                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"
-                        ]
+                        required: ['args'],
+                    },
+                    returnType: {
+                        type: 'object',
                     },
-                    "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"
-                            }
+                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"
-                        ]
+                        required: ['args'],
+                    },
+                    returnType: {
+                        type: 'object',
                     },
-                    "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"
-                            }
+                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"
-                        ]
+                        required: ['args'],
+                    },
+                    returnType: {
+                        type: 'object',
                     },
-                    "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"
-                            }
-                        }
+                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',
                     },
-                    "returnType": {
-                        "type": "object"
-                    }
                 },
-                "cheqdGenerateVersionId": {
-                    "description": "Generate a random uuid",
-                    "arguments": {
-                        "type": "object",
-                        "properties": {
-                            "args": {
-                                "type": "object",
-                                "description": "A cheqdGenerateVersionIdArgs object as any for extensibility"
-                            }
+                cheqdGenerateVersionId: {
+                    description: 'Generate a random uuid',
+                    arguments: {
+                        type: 'object',
+                        properties: {
+                            args: {
+                                type: 'object',
+                                description: 'A cheqdGenerateVersionIdArgs object as any for extensibility',
+                            },
                         },
                     },
-                    "returnType": {
-                        "type": "object"
-                    }
+                    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"
-                            }
+                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"
-                    }
+                    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"
-                            }
+                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"
-                        ]
+                        required: ['args'],
+                    },
+                    returnType: {
+                        type: 'object',
                     },
-                    "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"
-                            }
+                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"
-                        ]
+                        required: ['args'],
+                    },
+                    returnType: {
+                        type: 'object',
                     },
-                    "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"
-                            }
+                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"
-                        ]
+                        required: ['args'],
+                    },
+                    returnType: {
+                        type: 'object',
                     },
-                    "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"
-                            }
+                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"
-                        ]
+                        required: ['args'],
+                    },
+                    returnType: {
+                        type: 'object',
                     },
-                    "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"
-                            }
+                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"
-                        ]
+                        required: ['args'],
+                    },
+                    returnType: {
+                        type: 'object',
                     },
-                    "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"
-                            }
+                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"
-                        ]
+                        required: ['args'],
+                    },
+                    returnType: {
+                        type: 'object',
                     },
-                    "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"
-                            }
+                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"
-                        ]
+                        required: ['args'],
+                    },
+                    returnType: {
+                        type: 'array',
                     },
-                    "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"
-                            }
+                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"
-                        ]
+                        required: ['args'],
+                    },
+                    returnType: {
+                        type: 'object',
                     },
-                    "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"
-                            }
+                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"
-                        ]
+                        required: ['args'],
+                    },
+                    returnType: {
+                        type: 'array',
                     },
-                    "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"
-                            }
+                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"
-                        ]
+                        required: ['args'],
+                    },
+                    returnType: {
+                        type: 'object',
                     },
-                    "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"
-                            }
+                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"
-                        ]
+                        required: ['args'],
+                    },
+                    returnType: {
+                        type: 'array',
                     },
-                    "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"
-                            }
+                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"
-                        ]
+                        required: ['args'],
+                    },
+                    returnType: {
+                        type: 'object',
                     },
-                    "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"
-                            }
+                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"
-                        ]
+                        required: ['args'],
                     },
-                    "returnType": {
-                        "type": "object"
-                    }
-                }
-            }
-        }
+                    returnType: {
+                        type: 'object',
+                    },
+                },
+            },
+        },
     };
     supportedDidProviders;
     didProvider;
@@ -542,8 +510,8 @@ class Cheqd {
                 document: args.document,
                 keys: args.keys,
                 versionId: args?.versionId,
-                fee: args?.fee
-            }
+                fee: args?.fee,
+            },
         });
     }
     async UpdateIdentifier(args, context) {
@@ -563,8 +531,8 @@ class Cheqd {
                 kms: args.kms,
                 keys: args.keys,
                 versionId: args?.versionId,
-                fee: args?.fee
-            }
+                fee: args?.fee,
+            },
         });
     }
     async DeactivateIdentifier(args, context) {
@@ -582,8 +550,8 @@ class Cheqd {
             document: args.document,
             options: {
                 keys: args.keys,
-                fee: args?.fee
-            }
+                fee: args?.fee,
+            },
         }, context);
     }
     async CreateResource(args, context) {
@@ -609,8 +577,8 @@ class Cheqd {
                 kms: args.kms,
                 payload: args.payload,
                 signInputs: args.signInputs,
-                fee: args?.fee
-            }
+                fee: args?.fee,
+            },
         }, context);
     }
     async CreateStatusList2021(args, context) {
@@ -663,13 +631,18 @@ class Cheqd {
         // 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) {
+            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')) {
+            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)) {
@@ -679,10 +652,13 @@ class Cheqd {
         // get network
         const network = args.issuerDid.split(':')[2];
         // generate bitstring
-        const bitstring = await context.agent[exports.GenerateStatusList2021MethodName]({ length: args?.statusListLength || Cheqd.defaultStatusList2021Length, bitstringEncoding: args?.statusListEncoding || cheqd_did_provider_js_1.DefaultStatusList2021Encodings.base64url });
+        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) {
+            ? await (async function (that) {
                 // instantiate dkg-threshold client, in which case lit-protocol is used
                 const lit = await lit_protocol_js_1.LitProtocol.create({
                     chain: args?.dkgOptions?.chain || that.didProvider.dkgOptions.chain,
@@ -706,89 +682,95 @@ class Cheqd {
                 // return result tuple
                 switch (args.statusPurpose) {
                     case cheqd_did_provider_js_1.DefaultStatusList2021StatusPurposeTypes.revocation:
-                        return [{
+                        return [
+                            {
                                 StatusList2021: {
                                     statusPurpose: args.statusPurpose,
                                     encodedList: await (0, helpers_js_1.blobToHexString)(encryptedString),
                                     validFrom: new Date().toISOString(),
-                                    validUntil: args?.validUntil
+                                    validUntil: args?.validUntil,
                                 },
                                 metadata: {
                                     type: cheqd_did_provider_js_1.DefaultStatusList2021ResourceTypes.revocation,
                                     encrypted: true,
                                     encoding: args?.statusListEncoding || cheqd_did_provider_js_1.DefaultStatusList2021Encodings.base64url,
                                     encryptedSymmetricKey,
-                                    paymentConditions: args.paymentConditions
-                                }
+                                    paymentConditions: args.paymentConditions,
+                                },
                             },
                             {
                                 symmetricKey: (0, uint8arrays_1.toString)(symmetricKey, 'hex'),
                                 encryptedSymmetricKey,
                                 encryptedString: await (0, helpers_js_1.blobToHexString)(encryptedString),
-                            }
+                            },
                         ];
                     case cheqd_did_provider_js_1.DefaultStatusList2021StatusPurposeTypes.suspension:
-                        return [{
+                        return [
+                            {
                                 StatusList2021: {
                                     statusPurpose: args.statusPurpose,
                                     encodedList: await (0, helpers_js_1.blobToHexString)(encryptedString),
                                     validFrom: new Date().toISOString(),
-                                    validUntil: args?.validUntil
+                                    validUntil: args?.validUntil,
                                 },
                                 metadata: {
                                     type: cheqd_did_provider_js_1.DefaultStatusList2021ResourceTypes.suspension,
                                     encrypted: true,
                                     encoding: args?.statusListEncoding || cheqd_did_provider_js_1.DefaultStatusList2021Encodings.base64url,
                                     encryptedSymmetricKey,
-                                    paymentConditions: args.paymentConditions
-                                }
+                                    paymentConditions: args.paymentConditions,
+                                },
                             },
                             {
                                 symmetricKey: (0, uint8arrays_1.toString)(symmetricKey, 'hex'),
                                 encryptedSymmetricKey,
                                 encryptedString: await (0, helpers_js_1.blobToHexString)(encryptedString),
-                            }
+                            },
                         ];
                     default:
                         throw new Error(`[did-provider-cheqd]: status purpose is not valid ${args.statusPurpose}`);
                 }
-            }(this)))
-            : (await (async function () {
+            })(this)
+            : await (async function () {
                 switch (args.statusPurpose) {
                     case cheqd_did_provider_js_1.DefaultStatusList2021StatusPurposeTypes.revocation:
-                        return [{
+                        return [
+                            {
                                 StatusList2021: {
                                     statusPurpose: args.statusPurpose,
                                     encodedList: bitstring,
                                     validFrom: new Date().toISOString(),
-                                    validUntil: args?.validUntil
+                                    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];
+                            undefined,
+                        ];
                     case cheqd_did_provider_js_1.DefaultStatusList2021StatusPurposeTypes.suspension:
-                        return [{
+                        return [
+                            {
                                 StatusList2021: {
                                     statusPurpose: args.statusPurpose,
                                     encodedList: bitstring,
                                     validFrom: new Date().toISOString(),
-                                    validUntil: args?.validUntil
+                                    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];
+                            undefined,
+                        ];
                     default:
                         throw new Error('[did-provider-cheqd]: statusPurpose is not valid');
                 }
-            }()));
+            })();
         // construct payload
         const payload = {
             id: (0, uuid_1.v4)(),
@@ -801,9 +783,18 @@ class Cheqd {
         };
         // return result
         return {
-            created: await context.agent[exports.BroadcastStatusList2021MethodName]({ kms: args.kms, payload, network: network }),
+            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' } }),
+            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?.returnSymmetricKey ? data[1]?.symmetricKey : undefined,
         };
@@ -836,8 +827,9 @@ class Cheqd {
                 kms: args.kms,
                 payload: args.payload,
                 signInputs: args.signInputs,
-                fee: args?.fee || await sdk_1.ResourceModule.generateCreateResourceJsonFees((await this.didProvider.getWalletAccounts())[0].address)
-            }
+                fee: args?.fee ||
+                    (await sdk_1.ResourceModule.generateCreateResourceJsonFees((await this.didProvider.getWalletAccounts())[0].address)),
+            },
         }, context);
     }
     async GenerateDidDoc(args, context) {
@@ -851,7 +843,10 @@ class Cheqd {
             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 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 {
@@ -862,9 +857,9 @@ class Cheqd {
                     publicKeyHex: keyPairHex.publicKey,
                     privateKeyHex: keyPairHex.privateKey,
                     kid: keyPairHex.publicKey,
-                    type: 'Ed25519'
-                }
-            ]
+                    type: 'Ed25519',
+                },
+            ],
         };
     }
     async GenerateDidDocWithLinkedResource(args, context) {
@@ -878,7 +873,10 @@ class Cheqd {
             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 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]);
@@ -890,8 +888,8 @@ class Cheqd {
                     publicKeyHex: keyPairHex.publicKey,
                     privateKeyHex: keyPairHex.privateKey,
                     kid: keyPairHex.publicKey,
-                    type: 'Ed25519'
-                }
+                    type: 'Ed25519',
+                },
             ],
             linkedResource: {
                 id: (0, uuid_1.v4)(),
@@ -901,7 +899,7 @@ class Cheqd {
                 resourceType: 'SampleResource',
                 alsoKnownAs: [],
                 data: (0, uint8arrays_1.toString)(new TextEncoder().encode(JSON.stringify({ sample: 'json' })), 'base64'),
-            }
+            },
         };
     }
     async GenerateIdentityKeys(args, context) {
@@ -910,7 +908,7 @@ class Cheqd {
             publicKeyHex: keyPair.publicKey,
             privateKeyHex: keyPair.privateKey,
             kid: keyPair.publicKey,
-            type: 'Ed25519'
+            type: 'Ed25519',
         };
     }
     async GenerateVersionId(args, context) {
@@ -920,7 +918,7 @@ class Cheqd {
         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();
+        const encoded = (await statusList.encode());
         switch (args?.bitstringEncoding) {
             case 'base64url':
                 return encoded;
@@ -934,9 +932,10 @@ class Cheqd {
     }
     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 || []);
+        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)
+        const issuer = args.issuanceOptions.credential.issuer.id
             ? args.issuanceOptions.credential.issuer.id
             : args.issuanceOptions.credential.issuer;
         // generate status list credential
@@ -951,7 +950,7 @@ class Cheqd {
         // add credential status to credential
         args.issuanceOptions.credential.credentialStatus = credentialStatus;
         // add relevant context
-        args.issuanceOptions.credential['@context'] = function () {
+        args.issuanceOptions.credential['@context'] = (function () {
             // if no context is provided, add default context
             if (!args.issuanceOptions.credential['@context']) {
                 return [Cheqd.defaultContextV1, Cheqd.statusList2021Context];
@@ -968,16 +967,17 @@ class Cheqd {
             // 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 || []);
+        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)
+        const issuer = args.issuanceOptions.credential.issuer.id
             ? args.issuanceOptions.credential.issuer.id
             : args.issuanceOptions.credential.issuer;
         // generate status list credential
@@ -992,7 +992,7 @@ class Cheqd {
         // add credential status to credential
         args.issuanceOptions.credential.credentialStatus = credentialStatus;
         // add relevant context
-        args.issuanceOptions.credential['@context'] = function () {
+        args.issuanceOptions.credential['@context'] = (function () {
             // if no context is provided, add default context
             if (!args.issuanceOptions.credential['@context']) {
                 return [Cheqd.defaultContextV1, Cheqd.statusList2021Context];
@@ -1009,7 +1009,7 @@ class Cheqd {
             // 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;
@@ -1021,7 +1021,7 @@ class Cheqd {
             credential: args.credential,
             policies: {
                 ...args?.verificationArgs?.policies,
-                credentialStatus: false
+                credentialStatus: false,
             },
         });
         // early return if verification failed
@@ -1031,9 +1031,7 @@ class Cheqd {
         // 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;
+        const issuer = typeof credential.issuer === 'string' ? credential.issuer : credential.issuer.id;
         // define provider, if applicable
         this.didProvider = await Cheqd.loadProvider(issuer, this.supportedDidProviders);
         // define provider id, if applicable
@@ -1061,7 +1059,7 @@ class Cheqd {
             presentation: args.presentation,
             policies: {
                 ...args?.verificationArgs?.policies,
-                credentialStatus: false
+                credentialStatus: false,
             },
         });
         // early return if verification failed
@@ -1077,9 +1075,7 @@ class Cheqd {
             if (typeof credential === 'string')
                 credential = await Cheqd.decodeCredentialJWT(credential);
             // define issuer
-            const issuer = typeof credential.issuer === 'string'
-                ? credential.issuer
-                : credential.issuer.id;
+            const issuer = typeof credential.issuer === 'string' ? credential.issuer : credential.issuer.id;
             // define provider, if applicable
             this.didProvider = await Cheqd.loadProvider(issuer, this.supportedDidProviders);
             // define provider id, if applicable
@@ -1107,8 +1103,8 @@ class Cheqd {
             const verificationResult = await context.agent.verifyCredential({
                 credential: args.credential,
                 policies: {
-                    credentialStatus: false
-                }
+                    credentialStatus: false,
+                },
             });
             // early return if verification failed
             if (!verificationResult.verified) {
@@ -1130,7 +1126,9 @@ class Cheqd {
             if (!args.statusOptions.statusListIndex)
                 throw new Error('[did-provider-cheqd]: check status: statusOptions.statusListIndex is required');
             // generate resource type
-            const resourceType = args.statusOptions.statusPurpose === 'revocation' ? 'StatusList2021Revocation' : 'StatusList2021Suspension';
+            const resourceType = args.statusOptions.statusPurpose === 'revocation'
+                ? 'StatusList2021Revocation'
+                : 'StatusList2021Suspension';
             // construct status list credential
             const statusListCredential = `${cheqd_did_resolver_js_1.DefaultResolverUrl}${args.statusOptions.issuerDid}?resourceName=${args.statusOptions.statusListName}&resourceType=${resourceType}`;
             // construct credential status
@@ -1145,7 +1143,7 @@ class Cheqd {
                     statusListIndex: `${args.statusOptions.statusListIndex}`,
                 },
                 issuanceDate: '',
-                proof: {}
+                proof: {},
             };
         }
         // validate args - case: credential
@@ -1154,9 +1152,7 @@ class Cheqd {
         // 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;
+        const issuer = typeof credential.issuer === 'string' ? credential.issuer : credential.issuer.id;
         // define provider, if applicable
         this.didProvider = await Cheqd.loadProvider(issuer, this.supportedDidProviders);
         // define provider id, if applicable
@@ -1182,8 +1178,8 @@ class Cheqd {
             const verificationResult = await context.agent.verifyCredential({
                 credential: args.credential,
                 policies: {
-                    credentialStatus: false
-                }
+                    credentialStatus: false,
+                },
             });
             // early return if verification failed
             if (!verificationResult.verified) {
@@ -1215,7 +1211,7 @@ class Cheqd {
                     statusListIndex: `${args.revocationOptions.statusListIndex}`,
                 },
                 issuanceDate: '',
-                proof: {}
+                proof: {},
             };
         }
         // validate args - case: credential
@@ -1244,9 +1240,7 @@ class Cheqd {
             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;
+        const issuer = typeof credential.issuer === 'string' ? credential.issuer : credential.issuer.id;
         // define provider, if applicable
         this.didProvider = await Cheqd.loadProvider(issuer, this.supportedDidProviders);
         // define provider id, if applicable
@@ -1265,8 +1259,8 @@ class Cheqd {
                 resourceVersion: args?.options?.resourceVersion,
                 resourceAlsoKnownAs: args?.options?.alsoKnownAs,
                 signInputs: args?.options?.signInputs,
-                fee: args?.options?.fee
-            }
+                fee: args?.options?.fee,
+            },
         });
     }
     async RevokeBulkCredentialsWithStatusList2021(args, context) {
@@ -1276,14 +1270,19 @@ class Cheqd {
                 return await context.agent.verifyCredential({
                     credential,
                     policies: {
-                        credentialStatus: false
-                    }
+                        credentialStatus: false,
+                    },
                 });
             }));
             // early return if verification failed for any credential
-            if (verificationResult.some(result => !result.verified)) {
+            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' } };
+                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
@@ -1295,12 +1294,15 @@ class Cheqd {
             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)))
+            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=StatusList2021Revocation`;
             // construct credential status
-            args.credentials = args.revocationOptions.statusListIndices.map(index => ({
+            args.credentials = args.revocationOptions.statusListIndices.map((index) => ({
                 '@context': [],
                 issuer: args.revocationOptions.issuerDid,
                 credentialSubject: {},
@@ -1311,7 +1313,7 @@ class Cheqd {
                     statusListIndex: `${index}`,
                 },
                 issuanceDate: '',
-                proof: {}
+                proof: {},
             }));
         }
         // validate args - case: credentials
@@ -1355,8 +1357,8 @@ class Cheqd {
                 resourceVersion: args?.options?.resourceVersion,
                 resourceAlsoKnownAs: args?.options?.alsoKnownAs,
                 signInputs: args?.options?.signInputs,
-                fee: args?.options?.fee
-            }
+                fee: args?.options?.fee,
+            },
         });
     }
     async SuspendCredentialWithStatusList2021(args, context) {
@@ -1365,8 +1367,8 @@ class Cheqd {
             const verificationResult = await context.agent.verifyCredential({
                 credential: args.credential,
                 policies: {
-                    credentialStatus: false
-                }
+                    credentialStatus: false,
+                },
             });
             // early return if verification failed
             if (!verificationResult.verified) {
@@ -1398,7 +1400,7 @@ class Cheqd {
                     statusListIndex: `${args.suspensionOptions.statusListIndex}`,
                 },
                 issuanceDate: '',
-                proof: {}
+                proof: {},
             };
         }
         // validate args - case: credential
@@ -1427,9 +1429,7 @@ class Cheqd {
             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;
+        const issuer = typeof credential.issuer === 'string' ? credential.issuer : credential.issuer.id;
         // define provider, if applicable
         this.didProvider = await Cheqd.loadProvider(issuer, this.supportedDidProviders);
         // define provider id, if applicable
@@ -1448,8 +1448,8 @@ class Cheqd {
                 resourceVersion: args?.options?.resourceVersion,
                 resourceAlsoKnownAs: args?.options?.alsoKnownAs,
                 signInputs: args?.options?.signInputs,
-                fee: args?.options?.fee
-            }
+                fee: args?.options?.fee,
+            },
         });
     }
     async SuspendBulkCredentialsWithStatusList2021(args, context) {
@@ -1459,14 +1459,19 @@ class Cheqd {
                 return await context.agent.verifyCredential({
                     credential,
                     policies: {
-                        credentialStatus: false
-                    }
+                        credentialStatus: false,
+                    },
                 });
             }));
             // early return if verification failed for any credential
-            if (verificationResult.some(result => !result.verified)) {
+            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' } };
+                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
@@ -1478,12 +1483,15 @@ class Cheqd {
             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)))
+            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=StatusList2021Suspension`;
             // construct credential status
-            args.credentials = args.suspensionOptions.statusListIndices.map(index => ({
+            args.credentials = args.suspensionOptions.statusListIndices.map((index) => ({
                 '@context': [],
                 issuer: args.suspensionOptions.issuerDid,
                 credentialSubject: {},
@@ -1494,7 +1502,7 @@ class Cheqd {
                     statusListIndex: `${index}`,
                 },
                 issuanceDate: '',
-                proof: {}
+                proof: {},
             }));
         }
         // validate args - case: credentials
@@ -1538,8 +1546,8 @@ class Cheqd {
                 resourceVersion: args?.options?.resourceVersion,
                 resourceAlsoKnownAs: args?.options?.alsoKnownAs,
                 signInputs: args?.options?.signInputs,
-                fee: args?.options?.fee
-            }
+                fee: args?.options?.fee,
+            },
         });
     }
     async UnsuspendCredentialWithStatusList2021(args, context) {
@@ -1548,8 +1556,8 @@ class Cheqd {
             const verificationResult = await context.agent.verifyCredential({
                 credential: args.credential,
                 policies: {
-                    credentialStatus: false
-                }
+                    credentialStatus: false,
+                },
             });
             // early return if verification failed
             if (!verificationResult.verified) {
@@ -1581,7 +1589,7 @@ class Cheqd {
                     statusListIndex: `${args.unsuspensionOptions.statusListIndex}`,
                 },
                 issuanceDate: '',
-                proof: {}
+                proof: {},
             };
         }
         // validate args - case: credential
@@ -1610,9 +1618,7 @@ class Cheqd {
             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;
+        const issuer = typeof credential.issuer === 'string' ? credential.issuer : credential.issuer.id;
         // define provider, if applicable
         this.didProvider = await Cheqd.loadProvider(issuer, this.supportedDidProviders);
         // define provider id, if applicable
@@ -1631,8 +1637,8 @@ class Cheqd {
                 resourceVersion: args?.options?.resourceVersion,
                 resourceAlsoKnownAs: args?.options?.alsoKnownAs,
                 signInputs: args?.options?.signInputs,
-                fee: args?.options?.fee
-            }
+                fee: args?.options?.fee,
+            },
         });
     }
     async UnsuspendBulkCredentialsWithStatusList2021(args, context) {
@@ -1642,14 +1648,19 @@ class Cheqd {
                 return await context.agent.verifyCredential({
                     credential,
                     policies: {
-                        credentialStatus: false
-                    }
+                        credentialStatus: false,
+                    },
                 });
             }));
             // early return if verification failed for any credential
-            if (verificationResult.some(result => !result.verified)) {
+            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' } };
+                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
@@ -1661,12 +1672,15 @@ class Cheqd {
             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)))
+            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=StatusList2021Suspension`;
             // construct credential status
-            args.credentials = args.unsuspensionOptions.statusListIndices.map(index => ({
+            args.credentials = args.unsuspensionOptions.statusListIndices.map((index) => ({
                 '@context': [],
                 issuer: args.unsuspensionOptions.issuerDid,
                 credentialSubject: {},
@@ -1677,7 +1691,7 @@ class Cheqd {
                     statusListIndex: `${index}`,
                 },
                 issuanceDate: '',
-                proof: {}
+                proof: {},
             }));
         }
         // validate args - case: credentials
@@ -1721,16 +1735,19 @@ class Cheqd {
                 resourceVersion: args?.options?.resourceVersion,
                 resourceAlsoKnownAs: args?.options?.alsoKnownAs,
                 signInputs: args?.options?.signInputs,
-                fee: args?.options?.fee
-            }
+                fee: args?.options?.fee,
+            },
         });
     }
     async TransactSendTokens(args, context) {
         // define provider
-        const provider = function (that) {
+        const provider = (function (that) {
             // switch on network
-            return that.supportedDidProviders.find(provider => provider.network === args.network) || (function () { throw new Error(`[did-provider-cheqd]: transact: no relevant providers found`); }());
-        }(this);
+            return (that.supportedDidProviders.find((provider) => provider.network === args.network) ||
+                (function () {
+                    throw new Error(`[did-provider-cheqd]: transact: no relevant providers found`);
+                })());
+        })(this);
         try {
             // delegate to provider
             const transactionResult = await provider.transactSendTokens({
@@ -1745,14 +1762,14 @@ class Cheqd {
                 transactionHash: transactionResult.transactionHash,
                 events: transactionResult.events,
                 rawLog: transactionResult.rawLog,
-                txResponse: args?.returnTxResponse ? transactionResult : undefined
+                txResponse: args?.returnTxResponse ? transactionResult : undefined,
             };
         }
         catch (error) {
             // return error
             return {
                 successful: false,
-                error: error
+                error: error,
             };
         }
     }
@@ -1760,7 +1777,8 @@ class Cheqd {
         // verify with raw unified access control condition, if any
         if (args?.unifiedAccessControlCondition) {
             // validate args - case: unifiedAccessControlCondition.chain
-            if (!args.unifiedAccessControlCondition.chain || !Object.values(lit_protocol_js_1.LitCompatibleCosmosChains).includes(args.unifiedAccessControlCondition.chain))
+            if (!args.unifiedAccessControlCondition.chain ||
+                !Object.values(lit_protocol_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)
@@ -1772,10 +1790,16 @@ class Cheqd {
             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)
+            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)
+            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
@@ -1788,24 +1812,24 @@ class Cheqd {
                         default:
                             throw new Error(`[did-provider-cheqd]: observe: Unsupported chain: ${args.unifiedAccessControlCondition.chain}`);
                     }
-                }());
+                })();
                 // get block height url
-                const blockHeightUrl = function () {
+                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();
+                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();
+                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
@@ -1823,7 +1847,7 @@ class Cheqd {
                     }
                 });
                 // define meetsCondition
-                const meetsCondition = (typeof meetsConditionTxIndex !== 'undefined' && meetsConditionTxIndex !== -1);
+                const meetsCondition = typeof meetsConditionTxIndex !== 'undefined' && meetsConditionTxIndex !== -1;
                 // return observation result
                 return {
                     subscribed: true,
@@ -1831,7 +1855,11 @@ class Cheqd {
                     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
+                    txResponse: meetsCondition
+                        ? args?.returnTxResponse
+                            ? txs.tx_responses[meetsConditionTxIndex]
+                            : undefined
+                        : undefined,
                 };
             }
             catch (error) {
@@ -1839,7 +1867,7 @@ class Cheqd {
                 return {
                     subscribed: false,
                     meetsCondition: false,
-                    error: error
+                    error: error,
                 };
             }
         }
@@ -1867,22 +1895,22 @@ class Cheqd {
         args.blockHeight ||= 'latest';
         try {
             // get block height url
-            const blockHeightUrl = function () {
+            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();
+            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();
+            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
@@ -1900,7 +1928,7 @@ class Cheqd {
                 }
             });
             // define meetsCondition
-            const meetsCondition = (typeof meetsConditionTxIndex !== 'undefined' && meetsConditionTxIndex !== -1);
+            const meetsCondition = typeof meetsConditionTxIndex !== 'undefined' && meetsConditionTxIndex !== -1;
             // return observation result
             return {
                 subscribed: true,
@@ -1908,7 +1936,11 @@ class Cheqd {
                 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
+                txResponse: meetsCondition
+                    ? args?.returnTxResponse
+                        ? txs.tx_responses[meetsConditionTxIndex]
+                        : undefined
+                    : undefined,
             };
         }
         catch (error) {
@@ -1916,7 +1948,7 @@ class Cheqd {
             return {
                 subscribed: false,
                 meetsCondition: false,
-                error: error
+                error: error,
             };
         }
     }
@@ -1932,7 +1964,7 @@ class Cheqd {
                 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 () {
+                ? await (async function () {
                     // if not encrypted, return bitstring
                     if (!publishedList.metadata.encrypted)
                         return publishedList.metadata.encoding === 'base64url'
@@ -1942,8 +1974,8 @@ class Cheqd {
                     const scopedRawBlob = await (0, helpers_js_1.toBlob)((0, uint8arrays_1.fromString)(publishedList.StatusList2021.encodedList, 'hex'));
                     // decrypt
                     return await lit_protocol_js_1.LitProtocol.decryptDirect(scopedRawBlob, (0, uint8arrays_1.fromString)(options?.topArgs?.symmetricKey, 'hex'));
-                }())
-                : (await async function () {
+                })()
+                : await (async function () {
                     // transcode to base64url, if needed
                     const publishedListTranscoded = publishedList.metadata.encoding === 'base64url'
                         ? publishedList.StatusList2021.encodedList
@@ -1953,7 +1985,9 @@ class Cheqd {
                         // 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();
+                            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');
@@ -1977,7 +2011,7 @@ class Cheqd {
                         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
@@ -1986,7 +2020,7 @@ class Cheqd {
             // update revocation status
             statusList.setStatus(Number(credential.credentialStatus.statusListIndex), true);
             // set in-memory status list ref
-            const bitstring = await statusList.encode();
+            const bitstring = (await statusList.encode());
             // cast top-level args
             const topArgs = options?.topArgs;
             // write status list 2021 to file, if provided
@@ -1995,14 +2029,15 @@ class Cheqd {
             }
             // publish status list 2021, if provided
             const published = topArgs?.publish
-                ? (await async function () {
+                ? 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 () {
+                        ? await (async function () {
                             // validate encoding, if provided
-                            if (options?.publishOptions?.statusListEncoding && !Object.values(cheqd_did_provider_js_1.DefaultStatusList2021Encodings).includes(options?.publishOptions?.statusListEncoding)) {
+                            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
@@ -2017,15 +2052,20 @@ class Cheqd {
                                 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))
+                                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)) {
+                                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')) {
+                                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)) {
@@ -2033,19 +2073,22 @@ class Cheqd {
                                 }
                             }
                             // validate dkgOptions
-                            if (!topArgs?.dkgOptions || !topArgs?.dkgOptions?.chain || !topArgs?.dkgOptions?.network) {
+                            if (!topArgs?.dkgOptions ||
+                                !topArgs?.dkgOptions?.chain ||
+                                !topArgs?.dkgOptions?.network) {
                                 throw new Error('[did-provider-cheqd]: dkgOptions is required');
                             }
                             // instantiate dkg-threshold client, in which case lit-protocol is used
                             const lit = await lit_protocol_js_1.LitProtocol.create({
                                 chain: topArgs?.dkgOptions?.chain,
-                                litNetwork: topArgs?.dkgOptions?.network
+                                litNetwork: topArgs?.dkgOptions?.network,
                             });
                             // construct access control conditions and payment conditions tuple
                             const unifiedAccessControlConditionsTuple = publishedList.metadata.encrypted
-                                ? (await (async function () {
+                                ? await (async function () {
                                     // define payment conditions, give precedence to top-level args
-                                    const paymentConditions = topArgs?.paymentConditions || publishedList.metadata.paymentConditions;
+                                    const paymentConditions = topArgs?.paymentConditions ||
+                                        publishedList.metadata.paymentConditions;
                                     // return access control conditions and payment conditions tuple
                                     return [
                                         await Promise.all(paymentConditions.map(async (condition) => {
@@ -2060,10 +2103,10 @@ class Cheqd {
                                                     throw new Error(`[did-provider-cheqd]: unsupported access control condition type ${condition.type}`);
                                             }
                                         })),
-                                        paymentConditions
+                                        paymentConditions,
                                     ];
-                                }()))
-                                : (await (async function () {
+                                })()
+                                : await (async function () {
                                     // validate paymentConditions
                                     if (!topArgs?.paymentConditions) {
                                         throw new Error('[did-provider-cheqd]: paymentConditions is required');
@@ -2082,9 +2125,9 @@ class Cheqd {
                                                     throw new Error(`[did-provider-cheqd]: unsupported access control condition type ${condition.type}`);
                                             }
                                         })),
-                                        topArgs.paymentConditions
+                                        topArgs.paymentConditions,
                                     ];
-                                }()));
+                                })();
                             // encrypt bitstring
                             const { encryptedString, encryptedSymmetricKey, symmetricKey } = await lit.encrypt(bitstring, unifiedAccessControlConditionsTuple[0], true);
                             // define status list content
@@ -2093,25 +2136,31 @@ class Cheqd {
                                     statusPurpose: publishedList.StatusList2021.statusPurpose,
                                     encodedList: await (0, helpers_js_1.blobToHexString)(encryptedString),
                                     validFrom: publishedList.StatusList2021.validFrom,
-                                    validUntil: options?.publishOptions?.statusListValidUntil || publishedList.StatusList2021.validUntil
+                                    validUntil: options?.publishOptions?.statusListValidUntil ||
+                                        publishedList.StatusList2021.validUntil,
                                 },
                                 metadata: {
                                     type: publishedList.metadata.type,
                                     encrypted: true,
                                     encoding: options?.publishOptions?.statusListEncoding || publishedList.metadata.encoding,
                                     encryptedSymmetricKey,
-                                    paymentConditions: unifiedAccessControlConditionsTuple[1]
-                                }
+                                    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),
-                                { encryptedString, encryptedSymmetricKey, symmetricKey: (0, uint8arrays_1.toString)(symmetricKey, 'hex') }
+                                {
+                                    encryptedString,
+                                    encryptedSymmetricKey,
+                                    symmetricKey: (0, uint8arrays_1.toString)(symmetricKey, 'hex'),
+                                },
                             ];
-                        }())
-                        : (await async function () {
+                        })()
+                        : await (async function () {
                             // validate encoding, if provided
-                            if (options?.publishOptions?.statusListEncoding && !Object.values(cheqd_did_provider_js_1.DefaultStatusList2021Encodings).includes(options?.publishOptions?.statusListEncoding)) {
+                            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
@@ -2126,42 +2175,53 @@ class Cheqd {
                                 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))
+                                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),
+                                    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
+                                    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
+                                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 ? published?.[1]?.symmetricKey : undefined,
-                resourceMetadata: topArgs?.returnStatusListMetadata ? await Cheqd.fetchStatusList2021Metadata(credential) : undefined
+                statusList: topArgs?.returnUpdatedStatusList
+                    ? (await Cheqd.fetchStatusList2021(credential))
+                    : undefined,
+                symmetricKey: topArgs?.returnSymmetricKey
+                    ? published?.[1]?.symmetricKey
+                    : undefined,
+                resourceMetadata: topArgs?.returnStatusListMetadata
+                    ? await Cheqd.fetchStatusList2021Metadata(credential)
+                    : undefined,
             };
         }
         catch (error) {
@@ -2175,14 +2235,18 @@ class Cheqd {
         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)
+        if (credentials
+            .map((credential) => {
+            return credential.issuer.id
                 ? credential.issuer.id
                 : credential.issuer;
-        }).filter((value, _, self) => value && value !== self[0]).length > 0)
+        })
+            .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)
+        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 === 'revocation'))
@@ -2192,7 +2256,7 @@ class Cheqd {
             ? 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>');
@@ -2211,7 +2275,7 @@ class Cheqd {
                 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 () {
+                ? await (async function () {
                     // if not encrypted, return bitstring
                     if (!publishedList.metadata.encrypted)
                         return publishedList.metadata.encoding === 'base64url'
@@ -2221,8 +2285,8 @@ class Cheqd {
                     const scopedRawBlob = await (0, helpers_js_1.toBlob)((0, uint8arrays_1.fromString)(publishedList.StatusList2021.encodedList, 'hex'));
                     // decrypt
                     return await lit_protocol_js_1.LitProtocol.decryptDirect(scopedRawBlob, (0, uint8arrays_1.fromString)(options?.topArgs?.symmetricKey, 'hex'));
-                }())
-                : (await async function () {
+                })()
+                : await (async function () {
                     // transcode to base64url, if needed
                     const publishedListTranscoded = publishedList.metadata.encoding === 'base64url'
                         ? publishedList.StatusList2021.encodedList
@@ -2232,7 +2296,9 @@ class Cheqd {
                         // 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();
+                            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');
@@ -2256,12 +2322,12 @@ class Cheqd {
                         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 () {
+            const revoked = (await Promise.allSettled(credentials.map((credential) => {
+                return (async function () {
                     // early return, if no credential status
                     if (!credential.credentialStatus)
                         return { revoked: false };
@@ -2272,13 +2338,15 @@ class Cheqd {
                     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 })))}`);
+                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();
+            const bitstring = (await statusList.encode());
             // cast top-level args
             const topArgs = options?.topArgs;
             // write status list 2021 to file, if provided
@@ -2287,14 +2355,15 @@ class Cheqd {
             }
             // publish status list 2021, if provided
             const published = topArgs?.publish
-                ? (await async function () {
+                ? 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 () {
+                        ? await (async function () {
                             // validate encoding, if provided
-                            if (options?.publishOptions?.statusListEncoding && !Object.values(cheqd_did_provider_js_1.DefaultStatusList2021Encodings).includes(options?.publishOptions?.statusListEncoding)) {
+                            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
@@ -2309,15 +2378,20 @@ class Cheqd {
                                 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))
+                                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)) {
+                                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')) {
+                                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)) {
@@ -2325,19 +2399,22 @@ class Cheqd {
                                 }
                             }
                             // validate dkgOptions
-                            if (!topArgs?.dkgOptions || !topArgs?.dkgOptions?.chain || !topArgs?.dkgOptions?.network) {
+                            if (!topArgs?.dkgOptions ||
+                                !topArgs?.dkgOptions?.chain ||
+                                !topArgs?.dkgOptions?.network) {
                                 throw new Error('[did-provider-cheqd]: dkgOptions is required');
                             }
                             // instantiate dkg-threshold client, in which case lit-protocol is used
                             const lit = await lit_protocol_js_1.LitProtocol.create({
                                 chain: topArgs?.dkgOptions?.chain,
-                                litNetwork: topArgs?.dkgOptions?.network
+                                litNetwork: topArgs?.dkgOptions?.network,
                             });
                             // construct access control conditions and payment conditions tuple
                             const unifiedAccessControlConditionsTuple = publishedList.metadata.encrypted
-                                ? (await (async function () {
+                                ? await (async function () {
                                     // define payment conditions, give precedence to top-level args
-                                    const paymentConditions = topArgs?.paymentConditions || publishedList.metadata.paymentConditions;
+                                    const paymentConditions = topArgs?.paymentConditions ||
+                                        publishedList.metadata.paymentConditions;
                                     // return access control conditions and payment conditions tuple
                                     return [
                                         await Promise.all(paymentConditions.map(async (condition) => {
@@ -2352,10 +2429,10 @@ class Cheqd {
                                                     throw new Error(`[did-provider-cheqd]: unsupported access control condition type ${condition.type}`);
                                             }
                                         })),
-                                        paymentConditions
+                                        paymentConditions,
                                     ];
-                                }()))
-                                : (await (async function () {
+                                })()
+                                : await (async function () {
                                     // validate paymentConditions
                                     if (!topArgs?.paymentConditions) {
                                         throw new Error('[did-provider-cheqd]: paymentConditions is required');
@@ -2374,9 +2451,9 @@ class Cheqd {
                                                     throw new Error(`[did-provider-cheqd]: unsupported access control condition type ${condition.type}`);
                                             }
                                         })),
-                                        topArgs.paymentConditions
+                                        topArgs.paymentConditions,
                                     ];
-                                }()));
+                                })();
                             // encrypt bitstring
                             const { encryptedString, encryptedSymmetricKey, symmetricKey } = await lit.encrypt(bitstring, unifiedAccessControlConditionsTuple[0], true);
                             // define status list content
@@ -2385,25 +2462,31 @@ class Cheqd {
                                     statusPurpose: publishedList.StatusList2021.statusPurpose,
                                     encodedList: await (0, helpers_js_1.blobToHexString)(encryptedString),
                                     validFrom: publishedList.StatusList2021.validFrom,
-                                    validUntil: options?.publishOptions?.statusListValidUntil || publishedList.StatusList2021.validUntil
+                                    validUntil: options?.publishOptions?.statusListValidUntil ||
+                                        publishedList.StatusList2021.validUntil,
                                 },
                                 metadata: {
                                     type: publishedList.metadata.type,
                                     encrypted: true,
                                     encoding: options?.publishOptions?.statusListEncoding || publishedList.metadata.encoding,
                                     encryptedSymmetricKey,
-                                    paymentConditions: unifiedAccessControlConditionsTuple[1]
-                                }
+                                    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),
-                                { encryptedString, encryptedSymmetricKey, symmetricKey: (0, uint8arrays_1.toString)(symmetricKey, 'hex') }
+                                {
+                                    encryptedString,
+                                    encryptedSymmetricKey,
+                                    symmetricKey: (0, uint8arrays_1.toString)(symmetricKey, 'hex'),
+                                },
                             ];
-                        }())
-                        : (await async function () {
+                        })()
+                        : await (async function () {
                             // validate encoding, if provided
-                            if (options?.publishOptions?.statusListEncoding && !Object.values(cheqd_did_provider_js_1.DefaultStatusList2021Encodings).includes(options?.publishOptions?.statusListEncoding)) {
+                            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
@@ -2418,42 +2501,53 @@ class Cheqd {
                                 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))
+                                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),
+                                    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
+                                    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
+                                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),
+                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 ? published?.[1]?.symmetricKey : undefined,
-                resourceMetadata: topArgs?.returnStatusListMetadata ? await Cheqd.fetchStatusList2021Metadata(credentials[0]) : undefined
+                statusList: topArgs?.returnUpdatedStatusList
+                    ? (await Cheqd.fetchStatusList2021(credentials[0]))
+                    : undefined,
+                symmetricKey: topArgs?.returnSymmetricKey
+                    ? published?.[1]?.symmetricKey
+                    : undefined,
+                resourceMetadata: topArgs?.returnStatusListMetadata
+                    ? await Cheqd.fetchStatusList2021Metadata(credentials[0])
+                    : undefined,
             };
         }
         catch (error) {
@@ -2474,7 +2568,7 @@ class Cheqd {
                 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 () {
+                ? await (async function () {
                     // if not encrypted, return bitstring
                     if (!publishedList.metadata.encrypted)
                         return publishedList.metadata.encoding === 'base64url'
@@ -2484,8 +2578,8 @@ class Cheqd {
                     const scopedRawBlob = await (0, helpers_js_1.toBlob)((0, uint8arrays_1.fromString)(publishedList.StatusList2021.encodedList, 'hex'));
                     // decrypt
                     return await lit_protocol_js_1.LitProtocol.decryptDirect(scopedRawBlob, (0, uint8arrays_1.fromString)(options?.topArgs?.symmetricKey, 'hex'));
-                }())
-                : (await async function () {
+                })()
+                : await (async function () {
                     // transcode to base64url, if needed
                     const publishedListTranscoded = publishedList.metadata.encoding === 'base64url'
                         ? publishedList.StatusList2021.encodedList
@@ -2495,7 +2589,9 @@ class Cheqd {
                         // 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();
+                            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');
@@ -2519,7 +2615,7 @@ class Cheqd {
                         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
@@ -2528,7 +2624,7 @@ class Cheqd {
             // update suspension status
             statusList.setStatus(Number(credential.credentialStatus.statusListIndex), true);
             // set in-memory status list ref
-            const bitstring = await statusList.encode();
+            const bitstring = (await statusList.encode());
             // cast top-level args
             const topArgs = options?.topArgs;
             // write status list 2021 to file, if provided
@@ -2537,14 +2633,15 @@ class Cheqd {
             }
             // publish status list 2021, if provided
             const published = topArgs?.publish
-                ? (await async function () {
+                ? 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 () {
+                        ? await (async function () {
                             // validate encoding, if provided
-                            if (options?.publishOptions?.statusListEncoding && !Object.values(cheqd_did_provider_js_1.DefaultStatusList2021Encodings).includes(options?.publishOptions?.statusListEncoding)) {
+                            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
@@ -2559,15 +2656,20 @@ class Cheqd {
                                 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))
+                                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)) {
+                                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')) {
+                                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)) {
@@ -2575,19 +2677,22 @@ class Cheqd {
                                 }
                             }
                             // validate dkgOptions
-                            if (!topArgs?.dkgOptions || !topArgs?.dkgOptions?.chain || !topArgs?.dkgOptions?.network) {
+                            if (!topArgs?.dkgOptions ||
+                                !topArgs?.dkgOptions?.chain ||
+                                !topArgs?.dkgOptions?.network) {
                                 throw new Error('[did-provider-cheqd]: dkgOptions is required');
                             }
                             // instantiate dkg-threshold client, in which case lit-protocol is used
                             const lit = await lit_protocol_js_1.LitProtocol.create({
                                 chain: topArgs?.dkgOptions?.chain,
-                                litNetwork: topArgs?.dkgOptions?.network
+                                litNetwork: topArgs?.dkgOptions?.network,
                             });
                             // construct access control conditions and payment conditions tuple
                             const unifiedAccessControlConditionsTuple = publishedList.metadata.encrypted
-                                ? (await (async function () {
+                                ? await (async function () {
                                     // define payment conditions, give precedence to top-level args
-                                    const paymentConditions = topArgs?.paymentConditions || publishedList.metadata.paymentConditions;
+                                    const paymentConditions = topArgs?.paymentConditions ||
+                                        publishedList.metadata.paymentConditions;
                                     // return access control conditions and payment conditions tuple
                                     return [
                                         await Promise.all(paymentConditions.map(async (condition) => {
@@ -2602,10 +2707,10 @@ class Cheqd {
                                                     throw new Error(`[did-provider-cheqd]: unsupported access control condition type ${condition.type}`);
                                             }
                                         })),
-                                        paymentConditions
+                                        paymentConditions,
                                     ];
-                                }()))
-                                : (await (async function () {
+                                })()
+                                : await (async function () {
                                     // validate paymentConditions
                                     if (!topArgs?.paymentConditions) {
                                         throw new Error('[did-provider-cheqd]: paymentConditions is required');
@@ -2624,9 +2729,9 @@ class Cheqd {
                                                     throw new Error(`[did-provider-cheqd]: unsupported access control condition type ${condition.type}`);
                                             }
                                         })),
-                                        topArgs.paymentConditions
+                                        topArgs.paymentConditions,
                                     ];
-                                }()));
+                                })();
                             // encrypt bitstring
                             const { encryptedString, encryptedSymmetricKey, symmetricKey } = await lit.encrypt(bitstring, unifiedAccessControlConditionsTuple[0], true);
                             // define status list content
@@ -2635,25 +2740,31 @@ class Cheqd {
                                     statusPurpose: publishedList.StatusList2021.statusPurpose,
                                     encodedList: await (0, helpers_js_1.blobToHexString)(encryptedString),
                                     validFrom: publishedList.StatusList2021.validFrom,
-                                    validUntil: options?.publishOptions?.statusListValidUntil || publishedList.StatusList2021.validUntil
+                                    validUntil: options?.publishOptions?.statusListValidUntil ||
+                                        publishedList.StatusList2021.validUntil,
                                 },
                                 metadata: {
                                     type: publishedList.metadata.type,
                                     encrypted: true,
                                     encoding: options?.publishOptions?.statusListEncoding || publishedList.metadata.encoding,
                                     encryptedSymmetricKey,
-                                    paymentConditions: unifiedAccessControlConditionsTuple[1]
-                                }
+                                    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),
-                                { encryptedString, encryptedSymmetricKey, symmetricKey: (0, uint8arrays_1.toString)(symmetricKey, 'hex') }
+                                {
+                                    encryptedString,
+                                    encryptedSymmetricKey,
+                                    symmetricKey: (0, uint8arrays_1.toString)(symmetricKey, 'hex'),
+                                },
                             ];
-                        }())
-                        : (await async function () {
+                        })()
+                        : await (async function () {
                             // validate encoding, if provided
-                            if (options?.publishOptions?.statusListEncoding && !Object.values(cheqd_did_provider_js_1.DefaultStatusList2021Encodings).includes(options?.publishOptions?.statusListEncoding)) {
+                            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
@@ -2668,42 +2779,53 @@ class Cheqd {
                                 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))
+                                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),
+                                    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
+                                    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
+                                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 ? published?.[1]?.symmetricKey : undefined,
-                resourceMetadata: topArgs?.returnStatusListMetadata ? await Cheqd.fetchStatusList2021Metadata(credential) : undefined
+                statusList: topArgs?.returnUpdatedStatusList
+                    ? (await Cheqd.fetchStatusList2021(credential))
+                    : undefined,
+                symmetricKey: topArgs?.returnSymmetricKey
+                    ? published?.[1]?.symmetricKey
+                    : undefined,
+                resourceMetadata: topArgs?.returnStatusListMetadata
+                    ? await Cheqd.fetchStatusList2021Metadata(credential)
+                    : undefined,
             };
         }
         catch (error) {
@@ -2717,14 +2839,18 @@ class Cheqd {
         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)
+        if (credentials
+            .map((credential) => {
+            return credential.issuer.id
                 ? credential.issuer.id
                 : credential.issuer;
-        }).filter((value, _, self) => value && value !== self[0]).length > 0)
+        })
+            .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)
+        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 === 'suspension'))
@@ -2734,7 +2860,7 @@ class Cheqd {
             ? 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>');
@@ -2753,7 +2879,7 @@ class Cheqd {
                 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 () {
+                ? await (async function () {
                     // if not encrypted, return bitstring
                     if (!publishedList.metadata.encrypted)
                         return publishedList.metadata.encoding === 'base64url'
@@ -2763,8 +2889,8 @@ class Cheqd {
                     const scopedRawBlob = await (0, helpers_js_1.toBlob)((0, uint8arrays_1.fromString)(publishedList.StatusList2021.encodedList, 'hex'));
                     // decrypt
                     return await lit_protocol_js_1.LitProtocol.decryptDirect(scopedRawBlob, (0, uint8arrays_1.fromString)(options?.topArgs?.symmetricKey, 'hex'));
-                }())
-                : (await async function () {
+                })()
+                : await (async function () {
                     // transcode to base64url, if needed
                     const publishedListTranscoded = publishedList.metadata.encoding === 'base64url'
                         ? publishedList.StatusList2021.encodedList
@@ -2774,7 +2900,9 @@ class Cheqd {
                         // 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();
+                            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');
@@ -2798,12 +2926,12 @@ class Cheqd {
                         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 () {
+            const suspended = (await Promise.allSettled(credentials.map((credential) => {
+                return (async function () {
                     // early return, if no credential status
                     if (!credential.credentialStatus)
                         return { suspended: false };
@@ -2814,13 +2942,15 @@ class Cheqd {
                     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 })))}`);
+                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();
+            const bitstring = (await statusList.encode());
             // cast top-level args
             const topArgs = options?.topArgs;
             // write status list 2021 to file, if provided
@@ -2829,14 +2959,15 @@ class Cheqd {
             }
             // publish status list 2021, if provided
             const published = topArgs?.publish
-                ? (await async function () {
+                ? 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 () {
+                        ? await (async function () {
                             // validate encoding, if provided
-                            if (options?.publishOptions?.statusListEncoding && !Object.values(cheqd_did_provider_js_1.DefaultStatusList2021Encodings).includes(options?.publishOptions?.statusListEncoding)) {
+                            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
@@ -2851,15 +2982,20 @@ class Cheqd {
                                 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))
+                                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)) {
+                                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')) {
+                                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)) {
@@ -2867,19 +3003,22 @@ class Cheqd {
                                 }
                             }
                             // validate dkgOptions
-                            if (!topArgs?.dkgOptions || !topArgs?.dkgOptions?.chain || !topArgs?.dkgOptions?.network) {
+                            if (!topArgs?.dkgOptions ||
+                                !topArgs?.dkgOptions?.chain ||
+                                !topArgs?.dkgOptions?.network) {
                                 throw new Error('[did-provider-cheqd]: dkgOptions is required');
                             }
                             // instantiate dkg-threshold client, in which case lit-protocol is used
                             const lit = await lit_protocol_js_1.LitProtocol.create({
                                 chain: topArgs?.dkgOptions?.chain,
-                                litNetwork: topArgs?.dkgOptions?.network
+                                litNetwork: topArgs?.dkgOptions?.network,
                             });
                             // construct access control conditions and payment conditions tuple
                             const unifiedAccessControlConditionsTuple = publishedList.metadata.encrypted
-                                ? (await (async function () {
+                                ? await (async function () {
                                     // define payment conditions, give precedence to top-level args
-                                    const paymentConditions = topArgs?.paymentConditions || publishedList.metadata.paymentConditions;
+                                    const paymentConditions = topArgs?.paymentConditions ||
+                                        publishedList.metadata.paymentConditions;
                                     // return access control conditions and payment conditions tuple
                                     return [
                                         await Promise.all(paymentConditions.map(async (condition) => {
@@ -2894,10 +3033,10 @@ class Cheqd {
                                                     throw new Error(`[did-provider-cheqd]: unsupported access control condition type ${condition.type}`);
                                             }
                                         })),
-                                        paymentConditions
+                                        paymentConditions,
                                     ];
-                                }()))
-                                : (await (async function () {
+                                })()
+                                : await (async function () {
                                     // validate paymentConditions
                                     if (!topArgs?.paymentConditions) {
                                         throw new Error('[did-provider-cheqd]: paymentConditions is required');
@@ -2916,9 +3055,9 @@ class Cheqd {
                                                     throw new Error(`[did-provider-cheqd]: unsupported access control condition type ${condition.type}`);
                                             }
                                         })),
-                                        topArgs.paymentConditions
+                                        topArgs.paymentConditions,
                                     ];
-                                }()));
+                                })();
                             // encrypt bitstring
                             const { encryptedString, encryptedSymmetricKey, symmetricKey } = await lit.encrypt(bitstring, unifiedAccessControlConditionsTuple[0], true);
                             // define status list content
@@ -2927,25 +3066,31 @@ class Cheqd {
                                     statusPurpose: publishedList.StatusList2021.statusPurpose,
                                     encodedList: await (0, helpers_js_1.blobToHexString)(encryptedString),
                                     validFrom: publishedList.StatusList2021.validFrom,
-                                    validUntil: options?.publishOptions?.statusListValidUntil || publishedList.StatusList2021.validUntil
+                                    validUntil: options?.publishOptions?.statusListValidUntil ||
+                                        publishedList.StatusList2021.validUntil,
                                 },
                                 metadata: {
                                     type: publishedList.metadata.type,
                                     encrypted: true,
                                     encoding: options?.publishOptions?.statusListEncoding || publishedList.metadata.encoding,
                                     encryptedSymmetricKey,
-                                    paymentConditions: unifiedAccessControlConditionsTuple[1]
-                                }
+                                    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),
-                                { encryptedString, encryptedSymmetricKey, symmetricKey: (0, uint8arrays_1.toString)(symmetricKey, 'hex') }
+                                {
+                                    encryptedString,
+                                    encryptedSymmetricKey,
+                                    symmetricKey: (0, uint8arrays_1.toString)(symmetricKey, 'hex'),
+                                },
                             ];
-                        }())
-                        : (await async function () {
+                        })()
+                        : await (async function () {
                             // validate encoding, if provided
-                            if (options?.publishOptions?.statusListEncoding && !Object.values(cheqd_did_provider_js_1.DefaultStatusList2021Encodings).includes(options?.publishOptions?.statusListEncoding)) {
+                            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
@@ -2960,42 +3105,53 @@ class Cheqd {
                                 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))
+                                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),
+                                    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
+                                    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
+                                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),
+                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 ? published?.[1]?.symmetricKey : undefined,
-                resourceMetadata: topArgs?.returnStatusListMetadata ? await Cheqd.fetchStatusList2021Metadata(credentials[0]) : undefined
+                statusList: topArgs?.returnUpdatedStatusList
+                    ? (await Cheqd.fetchStatusList2021(credentials[0]))
+                    : undefined,
+                symmetricKey: topArgs?.returnSymmetricKey
+                    ? published?.[1]?.symmetricKey
+                    : undefined,
+                resourceMetadata: topArgs?.returnStatusListMetadata
+                    ? await Cheqd.fetchStatusList2021Metadata(credentials[0])
+                    : undefined,
             };
         }
         catch (error) {
@@ -3016,7 +3172,7 @@ class Cheqd {
                 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 () {
+                ? await (async function () {
                     // if not encrypted, return bitstring
                     if (!publishedList.metadata.encrypted)
                         return publishedList.metadata.encoding === 'base64url'
@@ -3026,8 +3182,8 @@ class Cheqd {
                     const scopedRawBlob = await (0, helpers_js_1.toBlob)((0, uint8arrays_1.fromString)(publishedList.StatusList2021.encodedList, 'hex'));
                     // decrypt
                     return await lit_protocol_js_1.LitProtocol.decryptDirect(scopedRawBlob, (0, uint8arrays_1.fromString)(options?.topArgs?.symmetricKey, 'hex'));
-                }())
-                : (await async function () {
+                })()
+                : await (async function () {
                     // transcode to base64url, if needed
                     const publishedListTranscoded = publishedList.metadata.encoding === 'base64url'
                         ? publishedList.StatusList2021.encodedList
@@ -3037,7 +3193,9 @@ class Cheqd {
                         // 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();
+                            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');
@@ -3061,7 +3219,7 @@ class Cheqd {
                         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
@@ -3070,7 +3228,7 @@ class Cheqd {
             // update suspension status
             statusList.setStatus(Number(credential.credentialStatus.statusListIndex), false);
             // set in-memory status list ref
-            const bitstring = await statusList.encode();
+            const bitstring = (await statusList.encode());
             // cast top-level args
             const topArgs = options?.topArgs;
             // write status list 2021 to file, if provided
@@ -3079,14 +3237,15 @@ class Cheqd {
             }
             // publish status list 2021, if provided
             const published = topArgs?.publish
-                ? (await async function () {
+                ? 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 () {
+                        ? await (async function () {
                             // validate encoding, if provided
-                            if (options?.publishOptions?.statusListEncoding && !Object.values(cheqd_did_provider_js_1.DefaultStatusList2021Encodings).includes(options?.publishOptions?.statusListEncoding)) {
+                            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
@@ -3101,15 +3260,20 @@ class Cheqd {
                                 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))
+                                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)) {
+                                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')) {
+                                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)) {
@@ -3117,19 +3281,22 @@ class Cheqd {
                                 }
                             }
                             // validate dkgOptions
-                            if (!topArgs?.dkgOptions || !topArgs?.dkgOptions?.chain || !topArgs?.dkgOptions?.network) {
+                            if (!topArgs?.dkgOptions ||
+                                !topArgs?.dkgOptions?.chain ||
+                                !topArgs?.dkgOptions?.network) {
                                 throw new Error('[did-provider-cheqd]: dkgOptions is required');
                             }
                             // instantiate dkg-threshold client, in which case lit-protocol is used
                             const lit = await lit_protocol_js_1.LitProtocol.create({
                                 chain: topArgs?.dkgOptions?.chain,
-                                litNetwork: topArgs?.dkgOptions?.network
+                                litNetwork: topArgs?.dkgOptions?.network,
                             });
                             // construct access control conditions and payment conditions tuple
                             const unifiedAccessControlConditionsTuple = publishedList.metadata.encrypted
-                                ? (await (async function () {
+                                ? await (async function () {
                                     // define payment conditions, give precedence to top-level args
-                                    const paymentConditions = topArgs?.paymentConditions || publishedList.metadata.paymentConditions;
+                                    const paymentConditions = topArgs?.paymentConditions ||
+                                        publishedList.metadata.paymentConditions;
                                     // return access control conditions and payment conditions tuple
                                     return [
                                         await Promise.all(paymentConditions.map(async (condition) => {
@@ -3144,10 +3311,10 @@ class Cheqd {
                                                     throw new Error(`[did-provider-cheqd]: unsupported access control condition type ${condition.type}`);
                                             }
                                         })),
-                                        paymentConditions
+                                        paymentConditions,
                                     ];
-                                }()))
-                                : (await (async function () {
+                                })()
+                                : await (async function () {
                                     // validate paymentConditions
                                     if (!topArgs?.paymentConditions) {
                                         throw new Error('[did-provider-cheqd]: paymentConditions is required');
@@ -3166,9 +3333,9 @@ class Cheqd {
                                                     throw new Error(`[did-provider-cheqd]: unsupported access control condition type ${condition.type}`);
                                             }
                                         })),
-                                        topArgs.paymentConditions
+                                        topArgs.paymentConditions,
                                     ];
-                                }()));
+                                })();
                             // encrypt bitstring
                             const { encryptedString, encryptedSymmetricKey, symmetricKey } = await lit.encrypt(bitstring, unifiedAccessControlConditionsTuple[0], true);
                             // define status list content
@@ -3177,25 +3344,31 @@ class Cheqd {
                                     statusPurpose: publishedList.StatusList2021.statusPurpose,
                                     encodedList: await (0, helpers_js_1.blobToHexString)(encryptedString),
                                     validFrom: publishedList.StatusList2021.validFrom,
-                                    validUntil: options?.publishOptions?.statusListValidUntil || publishedList.StatusList2021.validUntil
+                                    validUntil: options?.publishOptions?.statusListValidUntil ||
+                                        publishedList.StatusList2021.validUntil,
                                 },
                                 metadata: {
                                     type: publishedList.metadata.type,
                                     encrypted: true,
                                     encoding: options?.publishOptions?.statusListEncoding || publishedList.metadata.encoding,
                                     encryptedSymmetricKey,
-                                    paymentConditions: unifiedAccessControlConditionsTuple[1]
-                                }
+                                    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),
-                                { encryptedString, encryptedSymmetricKey, symmetricKey: (0, uint8arrays_1.toString)(symmetricKey, 'hex') }
+                                {
+                                    encryptedString,
+                                    encryptedSymmetricKey,
+                                    symmetricKey: (0, uint8arrays_1.toString)(symmetricKey, 'hex'),
+                                },
                             ];
-                        }())
-                        : (await async function () {
+                        })()
+                        : await (async function () {
                             // validate encoding, if provided
-                            if (options?.publishOptions?.statusListEncoding && !Object.values(cheqd_did_provider_js_1.DefaultStatusList2021Encodings).includes(options?.publishOptions?.statusListEncoding)) {
+                            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
@@ -3210,42 +3383,53 @@ class Cheqd {
                                 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))
+                                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),
+                                    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
+                                    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
+                                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 ? published?.[1]?.symmetricKey : undefined,
-                resourceMetadata: topArgs?.returnStatusListMetadata ? await Cheqd.fetchStatusList2021Metadata(credential) : undefined
+                statusList: topArgs?.returnUpdatedStatusList
+                    ? (await Cheqd.fetchStatusList2021(credential))
+                    : undefined,
+                symmetricKey: topArgs?.returnSymmetricKey
+                    ? published?.[1]?.symmetricKey
+                    : undefined,
+                resourceMetadata: topArgs?.returnStatusListMetadata
+                    ? await Cheqd.fetchStatusList2021Metadata(credential)
+                    : undefined,
             };
         }
         catch (error) {
@@ -3259,14 +3443,18 @@ class Cheqd {
         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)
+        if (credentials
+            .map((credential) => {
+            return credential.issuer.id
                 ? credential.issuer.id
                 : credential.issuer;
-        }).filter((value, _, self) => value && value !== self[0]).length > 0)
+        })
+            .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)
+        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 === 'suspension'))
@@ -3276,7 +3464,7 @@ class Cheqd {
             ? 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>');
@@ -3295,7 +3483,7 @@ class Cheqd {
                 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 () {
+                ? await (async function () {
                     // if not encrypted, return bitstring
                     if (!publishedList.metadata.encrypted)
                         return publishedList.metadata.encoding === 'base64url'
@@ -3305,8 +3493,8 @@ class Cheqd {
                     const scopedRawBlob = await (0, helpers_js_1.toBlob)((0, uint8arrays_1.fromString)(publishedList.StatusList2021.encodedList, 'hex'));
                     // decrypt
                     return await lit_protocol_js_1.LitProtocol.decryptDirect(scopedRawBlob, (0, uint8arrays_1.fromString)(options?.topArgs?.symmetricKey, 'hex'));
-                }())
-                : (await async function () {
+                })()
+                : await (async function () {
                     // transcode to base64url, if needed
                     const publishedListTranscoded = publishedList.metadata.encoding === 'base64url'
                         ? publishedList.StatusList2021.encodedList
@@ -3316,7 +3504,9 @@ class Cheqd {
                         // 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();
+                            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');
@@ -3340,12 +3530,12 @@ class Cheqd {
                         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 () {
+            const unsuspended = (await Promise.allSettled(credentials.map((credential) => {
+                return (async function () {
                     // early return, if no credential status
                     if (!credential.credentialStatus)
                         return { unsuspended: false };
@@ -3356,13 +3546,15 @@ class Cheqd {
                     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 })))}`);
+                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();
+            const bitstring = (await statusList.encode());
             // cast top-level args
             const topArgs = options?.topArgs;
             // write status list 2021 to file, if provided
@@ -3371,14 +3563,15 @@ class Cheqd {
             }
             // publish status list 2021, if provided
             const published = topArgs?.publish
-                ? (await async function () {
+                ? 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 () {
+                        ? await (async function () {
                             // validate encoding, if provided
-                            if (options?.publishOptions?.statusListEncoding && !Object.values(cheqd_did_provider_js_1.DefaultStatusList2021Encodings).includes(options?.publishOptions?.statusListEncoding)) {
+                            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
@@ -3393,15 +3586,20 @@ class Cheqd {
                                 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))
+                                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)) {
+                                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')) {
+                                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)) {
@@ -3409,19 +3607,22 @@ class Cheqd {
                                 }
                             }
                             // validate dkgOptions
-                            if (!topArgs?.dkgOptions || !topArgs?.dkgOptions?.chain || !topArgs?.dkgOptions?.network) {
+                            if (!topArgs?.dkgOptions ||
+                                !topArgs?.dkgOptions?.chain ||
+                                !topArgs?.dkgOptions?.network) {
                                 throw new Error('[did-provider-cheqd]: dkgOptions is required');
                             }
                             // instantiate dkg-threshold client, in which case lit-protocol is used
                             const lit = await lit_protocol_js_1.LitProtocol.create({
                                 chain: topArgs?.dkgOptions?.chain,
-                                litNetwork: topArgs?.dkgOptions?.network
+                                litNetwork: topArgs?.dkgOptions?.network,
                             });
                             // construct access control conditions and payment conditions tuple
                             const unifiedAccessControlConditionsTuple = publishedList.metadata.encrypted
-                                ? (await (async function () {
+                                ? await (async function () {
                                     // define payment conditions, give precedence to top-level args
-                                    const paymentConditions = topArgs?.paymentConditions || publishedList.metadata.paymentConditions;
+                                    const paymentConditions = topArgs?.paymentConditions ||
+                                        publishedList.metadata.paymentConditions;
                                     // return access control conditions and payment conditions tuple
                                     return [
                                         await Promise.all(paymentConditions.map(async (condition) => {
@@ -3436,10 +3637,10 @@ class Cheqd {
                                                     throw new Error(`[did-provider-cheqd]: unsupported access control condition type ${condition.type}`);
                                             }
                                         })),
-                                        paymentConditions
+                                        paymentConditions,
                                     ];
-                                }()))
-                                : (await (async function () {
+                                })()
+                                : await (async function () {
                                     // validate paymentConditions
                                     if (!topArgs?.paymentConditions) {
                                         throw new Error('[did-provider-cheqd]: paymentConditions is required');
@@ -3458,9 +3659,9 @@ class Cheqd {
                                                     throw new Error(`[did-provider-cheqd]: unsupported access control condition type ${condition.type}`);
                                             }
                                         })),
-                                        topArgs.paymentConditions
+                                        topArgs.paymentConditions,
                                     ];
-                                }()));
+                                })();
                             // encrypt bitstring
                             const { encryptedString, encryptedSymmetricKey, symmetricKey } = await lit.encrypt(bitstring, unifiedAccessControlConditionsTuple[0], true);
                             // define status list content
@@ -3469,25 +3670,31 @@ class Cheqd {
                                     statusPurpose: publishedList.StatusList2021.statusPurpose,
                                     encodedList: await (0, helpers_js_1.blobToHexString)(encryptedString),
                                     validFrom: publishedList.StatusList2021.validFrom,
-                                    validUntil: options?.publishOptions?.statusListValidUntil || publishedList.StatusList2021.validUntil
+                                    validUntil: options?.publishOptions?.statusListValidUntil ||
+                                        publishedList.StatusList2021.validUntil,
                                 },
                                 metadata: {
                                     type: publishedList.metadata.type,
                                     encrypted: true,
                                     encoding: options?.publishOptions?.statusListEncoding || publishedList.metadata.encoding,
                                     encryptedSymmetricKey,
-                                    paymentConditions: unifiedAccessControlConditionsTuple[1]
-                                }
+                                    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),
-                                { encryptedString, encryptedSymmetricKey, symmetricKey: (0, uint8arrays_1.toString)(symmetricKey, 'hex') }
+                                {
+                                    encryptedString,
+                                    encryptedSymmetricKey,
+                                    symmetricKey: (0, uint8arrays_1.toString)(symmetricKey, 'hex'),
+                                },
                             ];
-                        }())
-                        : (await async function () {
+                        })()
+                        : await (async function () {
                             // validate encoding, if provided
-                            if (options?.publishOptions?.statusListEncoding && !Object.values(cheqd_did_provider_js_1.DefaultStatusList2021Encodings).includes(options?.publishOptions?.statusListEncoding)) {
+                            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
@@ -3502,42 +3709,53 @@ class Cheqd {
                                 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))
+                                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),
+                                    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
+                                    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
+                                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 ? published?.[1]?.symmetricKey : undefined,
-                resourceMetadata: topArgs?.returnStatusListMetadata ? await Cheqd.fetchStatusList2021Metadata(credentials[0]) : undefined
+                statusList: topArgs?.returnUpdatedStatusList
+                    ? (await Cheqd.fetchStatusList2021(credentials[0]))
+                    : undefined,
+                symmetricKey: topArgs?.returnSymmetricKey
+                    ? published?.[1]?.symmetricKey
+                    : undefined,
+                resourceMetadata: topArgs?.returnStatusListMetadata
+                    ? await Cheqd.fetchStatusList2021Metadata(credentials[0])
+                    : undefined,
             };
         }
         catch (error) {
@@ -3555,7 +3773,7 @@ class Cheqd {
         const publishedList = (await Cheqd.fetchStatusList2021(credential));
         // fetch status list 2021 inscribed in credential
         const statusList2021 = options?.topArgs?.fetchList
-            ? (await async function () {
+            ? await (async function () {
                 // if not encrypted, return bitstring
                 if (!publishedList.metadata.encrypted)
                     return publishedList.metadata.encoding === 'base64url'
@@ -3566,7 +3784,7 @@ class Cheqd {
                 // instantiate dkg-threshold client, in which case lit-protocol is used
                 const lit = await lit_protocol_js_1.LitProtocol.create({
                     chain: options?.topArgs?.dkgOptions?.chain,
-                    litNetwork: options?.topArgs?.dkgOptions?.network
+                    litNetwork: options?.topArgs?.dkgOptions?.network,
                 });
                 // construct access control conditions
                 const unifiedAccessControlConditions = await Promise.all(publishedList.metadata.paymentConditions.map(async (condition) => {
@@ -3583,8 +3801,8 @@ class Cheqd {
                 }));
                 // decrypt
                 return await lit.decrypt(scopedRawBlob, publishedList.metadata.encryptedSymmetricKey, unifiedAccessControlConditions);
-            }())
-            : (await async function () {
+            })()
+            : await (async function () {
                 // transcode to base64url, if needed
                 const publishedListTranscoded = publishedList.metadata.encoding === 'base64url'
                     ? publishedList.StatusList2021.encodedList
@@ -3594,7 +3812,9 @@ class Cheqd {
                     // 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();
+                        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');
@@ -3618,7 +3838,7 @@ class Cheqd {
                     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
@@ -3637,7 +3857,7 @@ class Cheqd {
         const publishedList = (await Cheqd.fetchStatusList2021(credential));
         // fetch status list 2021 inscribed in credential
         const statusList2021 = options?.topArgs?.fetchList
-            ? (await async function () {
+            ? await (async function () {
                 // if not encrypted, return bitstring
                 if (!publishedList.metadata.encrypted)
                     return publishedList.metadata.encoding === 'base64url'
@@ -3648,7 +3868,7 @@ class Cheqd {
                 // instantiate dkg-threshold client, in which case lit-protocol is used
                 const lit = await lit_protocol_js_1.LitProtocol.create({
                     chain: options?.topArgs?.dkgOptions?.chain,
-                    litNetwork: options?.topArgs?.dkgOptions?.network
+                    litNetwork: options?.topArgs?.dkgOptions?.network,
                 });
                 // construct access control conditions
                 const unifiedAccessControlConditions = await Promise.all(publishedList.metadata.paymentConditions.map(async (condition) => {
@@ -3665,8 +3885,8 @@ class Cheqd {
                 }));
                 // decrypt
                 return await lit.decrypt(scopedRawBlob, publishedList.metadata.encryptedSymmetricKey, unifiedAccessControlConditions);
-            }())
-            : (await async function () {
+            })()
+            : await (async function () {
                 // transcode to base64url, if needed
                 const publishedListTranscoded = publishedList.metadata.encoding === 'base64url'
                     ? publishedList.StatusList2021.encodedList
@@ -3676,7 +3896,9 @@ class Cheqd {
                     // 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();
+                        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');
@@ -3700,7 +3922,7 @@ class Cheqd {
                     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
@@ -3715,14 +3937,14 @@ class Cheqd {
             version: options?.resourceVersion || new Date().toISOString(),
             alsoKnownAs: options?.resourceAlsoKnownAs || [],
             resourceType: statusList2021Metadata.resourceType,
-            data: statusList2021Raw
+            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
+            fee: options?.fee,
         });
     }
     static async fetchStatusList2021(credential, returnRaw = false) {
@@ -3733,11 +3955,16 @@ class Cheqd {
         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 !== 'revocation' && credential.credentialStatus.statusPurpose !== 'suspension')
+        if (credential.credentialStatus.statusPurpose !== 'revocation' &&
+            credential.credentialStatus.statusPurpose !== '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)) {
+        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
@@ -3761,7 +3988,7 @@ class Cheqd {
         // construct metadata url
         const metadataUrl = `${baseUrl.toString()}/metadata`;
         // fetch collection metadata
-        const collectionMetadata = await (await fetch(metadataUrl)).json();
+        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');
@@ -3771,7 +3998,8 @@ class Cheqd {
         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];
+        return (resourceVersioning.find((resource) => !resource.nextVersionId) ||
+            resourceVersioning.sort((a, b) => new Date(b.created).getTime() - new Date(a.created).getTime())[0]);
     }
     static async loadProvider(didUrl, providers) {
         const provider = providers.find((provider) => didUrl.includes(`${exports.DidPrefix}:${exports.CheqdDidMethod}:${provider.network}`));