@credo-ts/indy-vdr 0.6.1-pr-2091-20241119140918 → 0.6.2-alpha-20251210145840

package/build/anoncreds/IndyVdrAnonCredsRegistry.mjs

@@ -0,0 +1,586 @@
+import { verificationPublicJwkForIndyDid } from "../dids/didIndyUtil.mjs";
+import { IndyVdrPoolService } from "../pool/IndyVdrPoolService.mjs";
+import "../pool/index.mjs";
+import { multiSignRequest } from "../utils/sign.mjs";
+import { getDidIndyCredentialDefinitionId, getDidIndyRevocationRegistryDefinitionId, getDidIndyRevocationRegistryEntryId, getDidIndySchemaId, indyVdrAnonCredsRegistryIdentifierRegex } from "./utils/identifiers.mjs";
+import { anonCredsRevocationStatusListFromIndyVdr, indyVdrCreateLatestRevocationDelta } from "./utils/transform.mjs";
+import { AnonCredsRegistryService, dateToTimestamp, getUnqualifiedCredentialDefinitionId, getUnqualifiedRevocationRegistryDefinitionId, getUnqualifiedSchemaId, parseIndyCredentialDefinitionId, parseIndyDid, parseIndyRevocationRegistryId, parseIndySchemaId } from "@credo-ts/anoncreds";
+import { CredoError } from "@credo-ts/core";
+import { CredentialDefinitionRequest, CustomRequest, GetCredentialDefinitionRequest, GetRevocationRegistryDefinitionRequest, GetRevocationRegistryDeltaRequest, GetSchemaRequest, GetTransactionRequest, RevocationRegistryDefinitionRequest, RevocationRegistryEntryRequest, SchemaRequest } from "@hyperledger/indy-vdr-shared";
+
+//#region src/anoncreds/IndyVdrAnonCredsRegistry.ts
+var IndyVdrAnonCredsRegistry = class {
+	constructor() {
+		this.methodName = "indy";
+		this.supportedIdentifier = indyVdrAnonCredsRegistryIdentifierRegex;
+		this.allowsCaching = true;
+		this.allowsLocalRecord = true;
+	}
+	async getSchema(agentContext, schemaId) {
+		try {
+			const indyVdrPoolService = agentContext.dependencyManager.resolve(IndyVdrPoolService);
+			const { did, namespaceIdentifier, schemaName, schemaVersion } = parseIndySchemaId(schemaId);
+			const { pool } = await indyVdrPoolService.getPoolForDid(agentContext, did);
+			agentContext.config.logger.debug(`Getting schema '${schemaId}' from ledger '${pool.indyNamespace}'`);
+			const request = new GetSchemaRequest({ schemaId: getUnqualifiedSchemaId(namespaceIdentifier, schemaName, schemaVersion) });
+			agentContext.config.logger.trace(`Submitting get schema request for schema '${schemaId}' to ledger '${pool.indyNamespace}'`);
+			const response = await pool.submitRequest(request);
+			agentContext.config.logger.trace(`Got un-parsed schema '${schemaId}' from ledger '${pool.indyNamespace}'`, { response });
+			if (!("attr_names" in response.result.data)) {
+				agentContext.config.logger.error(`Error retrieving schema '${schemaId}'`);
+				return {
+					schemaId,
+					resolutionMetadata: {
+						error: "notFound",
+						message: `unable to find schema with id ${schemaId}`
+					},
+					schemaMetadata: {}
+				};
+			}
+			return {
+				schema: {
+					attrNames: response.result.data.attr_names,
+					name: response.result.data.name,
+					version: response.result.data.version,
+					issuerId: did
+				},
+				schemaId,
+				resolutionMetadata: {},
+				schemaMetadata: {
+					didIndyNamespace: pool.indyNamespace,
+					indyLedgerSeqNo: response.result.seqNo
+				}
+			};
+		} catch (error) {
+			agentContext.config.logger.error(`Error retrieving schema '${schemaId}'`, {
+				error,
+				schemaId
+			});
+			return {
+				schemaId,
+				resolutionMetadata: { error: "notFound" },
+				schemaMetadata: {}
+			};
+		}
+	}
+	async registerSchema(agentContext, options) {
+		const schema = options.schema;
+		const { issuerId, name, version, attrNames } = schema;
+		try {
+			const { namespaceIdentifier, namespace } = parseIndyDid(issuerId);
+			const { endorserDid, endorserMode } = options.options;
+			const pool = agentContext.dependencyManager.resolve(IndyVdrPoolService).getPoolForNamespace(namespace);
+			let writeRequest;
+			const didIndySchemaId = getDidIndySchemaId(namespace, namespaceIdentifier, schema.name, schema.version);
+			const endorsedTransaction = options.options.endorsedTransaction;
+			if (endorsedTransaction) {
+				agentContext.config.logger.debug(`Preparing endorsed tx '${endorsedTransaction}' for submission on ledger '${namespace}' with did '${issuerId}'`, schema);
+				writeRequest = new CustomRequest({ customRequest: endorsedTransaction });
+			} else {
+				agentContext.config.logger.debug(`Create schema tx on ledger '${namespace}' with did '${issuerId}'`, schema);
+				const schemaRequest = new SchemaRequest({
+					submitterDid: namespaceIdentifier,
+					schema: {
+						id: getUnqualifiedSchemaId(namespaceIdentifier, name, version),
+						name,
+						ver: "1.0",
+						version,
+						attrNames
+					}
+				});
+				const submitterKey = await verificationPublicJwkForIndyDid(agentContext, issuerId);
+				writeRequest = await pool.prepareWriteRequest(agentContext, schemaRequest, submitterKey, endorserDid !== issuerId ? endorserDid : void 0);
+				if (endorserMode === "external") return {
+					jobId: didIndySchemaId,
+					schemaState: {
+						state: "action",
+						action: "endorseIndyTransaction",
+						schemaId: didIndySchemaId,
+						schema,
+						schemaRequest: writeRequest.body
+					},
+					registrationMetadata: {},
+					schemaMetadata: {}
+				};
+				if (endorserMode === "internal" && endorserDid !== issuerId) {
+					const endorserKey = await verificationPublicJwkForIndyDid(agentContext, endorserDid);
+					await multiSignRequest(agentContext, writeRequest, endorserKey, parseIndyDid(endorserDid).namespaceIdentifier);
+				}
+			}
+			const response = await pool.submitRequest(writeRequest);
+			agentContext.config.logger.debug(`Registered schema '${didIndySchemaId}' on ledger '${pool.indyNamespace}'`, {
+				response,
+				writeRequest
+			});
+			return {
+				schemaState: {
+					state: "finished",
+					schema,
+					schemaId: didIndySchemaId
+				},
+				registrationMetadata: {},
+				schemaMetadata: { indyLedgerSeqNo: response?.result?.txnMetadata?.seqNo }
+			};
+		} catch (error) {
+			agentContext.config.logger.error(`Error registering schema for did '${issuerId}'`, {
+				error,
+				did: issuerId,
+				schema
+			});
+			return {
+				schemaMetadata: {},
+				registrationMetadata: {},
+				schemaState: {
+					state: "failed",
+					schema,
+					reason: `unknownError: ${error.message}`
+				}
+			};
+		}
+	}
+	async getCredentialDefinition(agentContext, credentialDefinitionId) {
+		try {
+			const indyVdrPoolService = agentContext.dependencyManager.resolve(IndyVdrPoolService);
+			const { did, namespaceIdentifier, schemaSeqNo, tag } = parseIndyCredentialDefinitionId(credentialDefinitionId);
+			const { pool } = await indyVdrPoolService.getPoolForDid(agentContext, did);
+			agentContext.config.logger.debug(`Getting credential definition '${credentialDefinitionId}' from ledger '${pool.indyNamespace}'`);
+			const request = new GetCredentialDefinitionRequest({ credentialDefinitionId: getUnqualifiedCredentialDefinitionId(namespaceIdentifier, schemaSeqNo, tag) });
+			agentContext.config.logger.trace(`Submitting get credential definition request for credential definition '${credentialDefinitionId}' to ledger '${pool.indyNamespace}'`);
+			const response = await pool.submitRequest(request);
+			const schema = await this.fetchIndySchemaWithSeqNo(agentContext, response.result.ref, namespaceIdentifier);
+			if (!schema || !response.result.data) {
+				agentContext.config.logger.error(`Error retrieving credential definition '${credentialDefinitionId}'`);
+				return {
+					credentialDefinitionId,
+					credentialDefinitionMetadata: {},
+					resolutionMetadata: {
+						error: "notFound",
+						message: `unable to resolve credential definition with id ${credentialDefinitionId}`
+					}
+				};
+			}
+			return {
+				credentialDefinitionId,
+				credentialDefinition: {
+					issuerId: did,
+					schemaId: credentialDefinitionId.startsWith("did:indy") ? getDidIndySchemaId(pool.indyNamespace, schema.schema.issuerId, schema.schema.name, schema.schema.version) : schema.schema.schemaId,
+					tag: response.result.tag,
+					type: "CL",
+					value: response.result.data
+				},
+				credentialDefinitionMetadata: { didIndyNamespace: pool.indyNamespace },
+				resolutionMetadata: {}
+			};
+		} catch (error) {
+			agentContext.config.logger.error(`Error retrieving credential definition '${credentialDefinitionId}'`, {
+				error,
+				credentialDefinitionId
+			});
+			return {
+				credentialDefinitionId,
+				credentialDefinitionMetadata: {},
+				resolutionMetadata: {
+					error: "notFound",
+					message: `unable to resolve credential definition: ${error.message}`
+				}
+			};
+		}
+	}
+	async registerCredentialDefinition(agentContext, options) {
+		const credentialDefinition = options.credentialDefinition;
+		const { schemaId, issuerId, tag, value } = credentialDefinition;
+		try {
+			const { namespaceIdentifier, namespace } = parseIndyDid(issuerId);
+			const { endorserDid, endorserMode } = options.options;
+			const pool = agentContext.dependencyManager.resolve(IndyVdrPoolService).getPoolForNamespace(namespace);
+			agentContext.config.logger.debug(`Registering credential definition on ledger '${namespace}' with did '${issuerId}'`, options.credentialDefinition);
+			let writeRequest;
+			let didIndyCredentialDefinitionId;
+			let schemaSeqNo;
+			const endorsedTransaction = options.options.endorsedTransaction;
+			if (endorsedTransaction) {
+				agentContext.config.logger.debug(`Preparing endorsed tx '${endorsedTransaction}' for submission on ledger '${namespace}' with did '${issuerId}'`, credentialDefinition);
+				writeRequest = new CustomRequest({ customRequest: endorsedTransaction });
+				const operation = JSON.parse(endorsedTransaction)?.operation;
+				schemaSeqNo = Number(operation?.ref);
+				didIndyCredentialDefinitionId = getDidIndyCredentialDefinitionId(namespace, namespaceIdentifier, schemaSeqNo, tag);
+			} else {
+				const { schemaMetadata, resolutionMetadata } = await agentContext.resolve(AnonCredsRegistryService).getSchema(agentContext, schemaId, { useLocalRecord: false });
+				if (!schemaMetadata?.indyLedgerSeqNo || typeof schemaMetadata.indyLedgerSeqNo !== "number") return {
+					registrationMetadata: {},
+					credentialDefinitionMetadata: { didIndyNamespace: pool.indyNamespace },
+					credentialDefinitionState: {
+						credentialDefinition: options.credentialDefinition,
+						state: "failed",
+						reason: `error resolving schema with id ${schemaId}: ${resolutionMetadata.error} ${resolutionMetadata.message}`
+					}
+				};
+				schemaSeqNo = schemaMetadata.indyLedgerSeqNo;
+				const legacyCredentialDefinitionId = getUnqualifiedCredentialDefinitionId(issuerId, schemaSeqNo, tag);
+				didIndyCredentialDefinitionId = getDidIndyCredentialDefinitionId(namespace, namespaceIdentifier, schemaSeqNo, tag);
+				const credentialDefinitionRequest = new CredentialDefinitionRequest({
+					submitterDid: namespaceIdentifier,
+					credentialDefinition: {
+						ver: "1.0",
+						id: legacyCredentialDefinitionId,
+						schemaId: schemaSeqNo.toString(),
+						type: "CL",
+						tag,
+						value
+					}
+				});
+				const submitterKey = await verificationPublicJwkForIndyDid(agentContext, issuerId);
+				writeRequest = await pool.prepareWriteRequest(agentContext, credentialDefinitionRequest, submitterKey, endorserDid !== issuerId ? endorserDid : void 0);
+				if (endorserMode === "external") return {
+					jobId: didIndyCredentialDefinitionId,
+					credentialDefinitionState: {
+						state: "action",
+						action: "endorseIndyTransaction",
+						credentialDefinition,
+						credentialDefinitionId: didIndyCredentialDefinitionId,
+						credentialDefinitionRequest: writeRequest.body
+					},
+					registrationMetadata: {},
+					credentialDefinitionMetadata: {}
+				};
+				if (endorserMode === "internal" && endorserDid !== issuerId) {
+					const endorserKey = await verificationPublicJwkForIndyDid(agentContext, endorserDid);
+					await multiSignRequest(agentContext, writeRequest, endorserKey, parseIndyDid(endorserDid).namespaceIdentifier);
+				}
+			}
+			const response = await pool.submitRequest(writeRequest);
+			agentContext.config.logger.debug(`Registered credential definition '${didIndyCredentialDefinitionId}' on ledger '${pool.indyNamespace}'`, {
+				response,
+				credentialDefinition: options.credentialDefinition
+			});
+			return {
+				credentialDefinitionMetadata: {},
+				credentialDefinitionState: {
+					credentialDefinition,
+					credentialDefinitionId: didIndyCredentialDefinitionId,
+					state: "finished"
+				},
+				registrationMetadata: {}
+			};
+		} catch (error) {
+			agentContext.config.logger.error(`Error registering credential definition for schema '${schemaId}'`, {
+				error,
+				did: issuerId,
+				credentialDefinition: options.credentialDefinition
+			});
+			return {
+				credentialDefinitionMetadata: {},
+				registrationMetadata: {},
+				credentialDefinitionState: {
+					credentialDefinition: options.credentialDefinition,
+					state: "failed",
+					reason: `unknownError: ${error.message}`
+				}
+			};
+		}
+	}
+	async getRevocationRegistryDefinition(agentContext, revocationRegistryDefinitionId) {
+		try {
+			const indyVdrPoolService = agentContext.dependencyManager.resolve(IndyVdrPoolService);
+			const { did, namespaceIdentifier, credentialDefinitionTag, revocationRegistryTag, schemaSeqNo } = parseIndyRevocationRegistryId(revocationRegistryDefinitionId);
+			const { pool } = await indyVdrPoolService.getPoolForDid(agentContext, did);
+			agentContext.config.logger.debug(`Using ledger '${pool.indyNamespace}' to retrieve revocation registry definition '${revocationRegistryDefinitionId}'`);
+			const request = new GetRevocationRegistryDefinitionRequest({ revocationRegistryId: getUnqualifiedRevocationRegistryDefinitionId(namespaceIdentifier, schemaSeqNo, credentialDefinitionTag, revocationRegistryTag) });
+			agentContext.config.logger.trace(`Submitting get revocation registry definition request for revocation registry definition '${revocationRegistryDefinitionId}' to ledger`);
+			const response = await pool.submitRequest(request);
+			if (!response.result.data) {
+				agentContext.config.logger.error(`Error retrieving revocation registry definition '${revocationRegistryDefinitionId}' from ledger`, { revocationRegistryDefinitionId });
+				return {
+					resolutionMetadata: {
+						error: "notFound",
+						message: "unable to resolve revocation registry definition"
+					},
+					revocationRegistryDefinitionId,
+					revocationRegistryDefinitionMetadata: {}
+				};
+			}
+			agentContext.config.logger.trace(`Got revocation registry definition '${revocationRegistryDefinitionId}' from ledger '${pool.indyNamespace}'`, { response });
+			const credentialDefinitionId = revocationRegistryDefinitionId.startsWith("did:indy:") ? getDidIndyCredentialDefinitionId(pool.indyNamespace, namespaceIdentifier, schemaSeqNo, credentialDefinitionTag) : getUnqualifiedCredentialDefinitionId(namespaceIdentifier, schemaSeqNo, credentialDefinitionTag);
+			return {
+				revocationRegistryDefinitionId,
+				revocationRegistryDefinition: {
+					issuerId: did,
+					revocDefType: response.result.data.revocDefType,
+					value: {
+						maxCredNum: response.result.data.value.maxCredNum,
+						tailsHash: response.result.data.value.tailsHash,
+						tailsLocation: response.result.data.value.tailsLocation,
+						publicKeys: { accumKey: { z: response.result.data.value.publicKeys.accumKey.z } }
+					},
+					tag: response.result.data.tag,
+					credDefId: credentialDefinitionId
+				},
+				revocationRegistryDefinitionMetadata: {
+					issuanceType: response.result.data.value.issuanceType,
+					didIndyNamespace: pool.indyNamespace
+				},
+				resolutionMetadata: {}
+			};
+		} catch (error) {
+			agentContext.config.logger.error(`Error retrieving revocation registry definition '${revocationRegistryDefinitionId}' from ledger`, {
+				error,
+				revocationRegistryDefinitionId
+			});
+			return {
+				resolutionMetadata: {
+					error: "notFound",
+					message: `unable to resolve revocation registry definition: ${error.message}`
+				},
+				revocationRegistryDefinitionId,
+				revocationRegistryDefinitionMetadata: {}
+			};
+		}
+	}
+	async registerRevocationRegistryDefinition(agentContext, { options, revocationRegistryDefinition }) {
+		try {
+			const { namespaceIdentifier, namespace } = parseIndyDid(revocationRegistryDefinition.issuerId);
+			const pool = agentContext.dependencyManager.resolve(IndyVdrPoolService).getPoolForNamespace(namespace);
+			agentContext.config.logger.debug(`Registering revocation registry definition on ledger '${namespace}' with did '${revocationRegistryDefinition.issuerId}'`, revocationRegistryDefinition);
+			let writeRequest;
+			let didIndyRevocationRegistryDefinitionId;
+			const { schemaSeqNo, tag: credentialDefinitionTag } = parseIndyCredentialDefinitionId(revocationRegistryDefinition.credDefId);
+			const { endorsedTransaction, endorserDid, endorserMode } = options;
+			if (endorsedTransaction) {
+				agentContext.config.logger.debug(`Preparing endorsed tx '${endorsedTransaction}' for submission on ledger '${namespace}' with did '${revocationRegistryDefinition.issuerId}'`, revocationRegistryDefinition);
+				writeRequest = new CustomRequest({ customRequest: endorsedTransaction });
+				didIndyRevocationRegistryDefinitionId = getDidIndyRevocationRegistryDefinitionId(namespace, namespaceIdentifier, schemaSeqNo, credentialDefinitionTag, revocationRegistryDefinition.tag);
+			} else {
+				const legacyRevocationRegistryDefinitionId = getUnqualifiedRevocationRegistryDefinitionId(namespaceIdentifier, schemaSeqNo, credentialDefinitionTag, revocationRegistryDefinition.tag);
+				didIndyRevocationRegistryDefinitionId = getDidIndyRevocationRegistryDefinitionId(namespace, namespaceIdentifier, schemaSeqNo, credentialDefinitionTag, revocationRegistryDefinition.tag);
+				const revocationRegistryDefinitionRequest = new RevocationRegistryDefinitionRequest({
+					submitterDid: namespaceIdentifier,
+					revocationRegistryDefinitionV1: {
+						id: legacyRevocationRegistryDefinitionId,
+						ver: "1.0",
+						credDefId: getUnqualifiedCredentialDefinitionId(namespaceIdentifier, schemaSeqNo, credentialDefinitionTag),
+						tag: revocationRegistryDefinition.tag,
+						revocDefType: revocationRegistryDefinition.revocDefType,
+						value: {
+							issuanceType: "ISSUANCE_BY_DEFAULT",
+							...revocationRegistryDefinition.value
+						}
+					}
+				});
+				const submitterKey = await verificationPublicJwkForIndyDid(agentContext, revocationRegistryDefinition.issuerId);
+				writeRequest = await pool.prepareWriteRequest(agentContext, revocationRegistryDefinitionRequest, submitterKey, endorserDid !== revocationRegistryDefinition.issuerId ? endorserDid : void 0);
+				if (endorserMode === "external") return {
+					jobId: didIndyRevocationRegistryDefinitionId,
+					revocationRegistryDefinitionState: {
+						state: "action",
+						action: "endorseIndyTransaction",
+						revocationRegistryDefinition,
+						revocationRegistryDefinitionId: didIndyRevocationRegistryDefinitionId,
+						revocationRegistryDefinitionRequest: writeRequest.body
+					},
+					registrationMetadata: {},
+					revocationRegistryDefinitionMetadata: {}
+				};
+				if (endorserMode === "internal" && endorserDid !== revocationRegistryDefinition.issuerId) {
+					const endorserKey = await verificationPublicJwkForIndyDid(agentContext, endorserDid);
+					await multiSignRequest(agentContext, writeRequest, endorserKey, parseIndyDid(endorserDid).namespaceIdentifier);
+				}
+			}
+			const response = await pool.submitRequest(writeRequest);
+			agentContext.config.logger.debug(`Registered revocation registry definition '${didIndyRevocationRegistryDefinitionId}' on ledger '${pool.indyNamespace}'`, {
+				response,
+				revocationRegistryDefinition
+			});
+			return {
+				revocationRegistryDefinitionMetadata: {},
+				revocationRegistryDefinitionState: {
+					revocationRegistryDefinition,
+					revocationRegistryDefinitionId: didIndyRevocationRegistryDefinitionId,
+					state: "finished"
+				},
+				registrationMetadata: {}
+			};
+		} catch (error) {
+			agentContext.config.logger.error(`Error registering revocation registry definition for credential definition '${revocationRegistryDefinition.credDefId}'`, {
+				error,
+				did: revocationRegistryDefinition.issuerId,
+				revocationRegistryDefinition
+			});
+			return {
+				revocationRegistryDefinitionMetadata: {},
+				registrationMetadata: {},
+				revocationRegistryDefinitionState: {
+					revocationRegistryDefinition,
+					state: "failed",
+					reason: `unknownError: ${error.message}`
+				}
+			};
+		}
+	}
+	async getRevocationStatusList(agentContext, revocationRegistryDefinitionId, timestamp) {
+		try {
+			const indyVdrPoolService = agentContext.dependencyManager.resolve(IndyVdrPoolService);
+			const { did } = parseIndyRevocationRegistryId(revocationRegistryDefinitionId);
+			const { pool } = await indyVdrPoolService.getPoolForDid(agentContext, did);
+			const revocationDelta = await this.fetchIndyRevocationDelta(agentContext, revocationRegistryDefinitionId, timestamp);
+			if (!revocationDelta) return {
+				resolutionMetadata: {
+					error: "notFound",
+					message: `Error retrieving revocation registry delta '${revocationRegistryDefinitionId}' from ledger, potentially revocation interval ends before revocation registry creation`
+				},
+				revocationStatusListMetadata: {}
+			};
+			const { revocationRegistryDefinition, resolutionMetadata, revocationRegistryDefinitionMetadata } = await agentContext.resolve(AnonCredsRegistryService).getRevocationRegistryDefinition(agentContext, revocationRegistryDefinitionId);
+			if (!revocationRegistryDefinition || !revocationRegistryDefinitionMetadata.issuanceType || typeof revocationRegistryDefinitionMetadata.issuanceType !== "string") return {
+				resolutionMetadata: { error: `error resolving revocation registry definition with id ${revocationRegistryDefinitionId}: ${resolutionMetadata.error} ${resolutionMetadata.message}` },
+				revocationStatusListMetadata: { didIndyNamespace: pool.indyNamespace }
+			};
+			return {
+				resolutionMetadata: {},
+				revocationStatusList: anonCredsRevocationStatusListFromIndyVdr(revocationRegistryDefinitionId, revocationRegistryDefinition, revocationDelta, revocationRegistryDefinitionMetadata.issuanceType === "ISSUANCE_BY_DEFAULT"),
+				revocationStatusListMetadata: { didIndyNamespace: pool.indyNamespace }
+			};
+		} catch (error) {
+			agentContext.config.logger.error(`Error retrieving revocation registry delta '${revocationRegistryDefinitionId}' from ledger, potentially revocation interval ends before revocation registry creation?"`, {
+				error,
+				revocationRegistryId: revocationRegistryDefinitionId
+			});
+			return {
+				resolutionMetadata: {
+					error: "notFound",
+					message: `Error retrieving revocation registry delta '${revocationRegistryDefinitionId}' from ledger, potentially revocation interval ends before revocation registry creation: ${error.message}`
+				},
+				revocationStatusListMetadata: {}
+			};
+		}
+	}
+	async registerRevocationStatusList(agentContext, { options, revocationStatusList }) {
+		try {
+			const { endorsedTransaction, endorserDid, endorserMode } = options;
+			const { namespaceIdentifier, namespace } = parseIndyDid(revocationStatusList.issuerId);
+			const pool = agentContext.dependencyManager.resolve(IndyVdrPoolService).getPoolForNamespace(namespace);
+			agentContext.config.logger.debug(`Registering revocation status list on ledger '${namespace}' with did '${revocationStatusList.issuerId}'`, revocationStatusList);
+			let writeRequest;
+			const { schemaSeqNo, credentialDefinitionTag, namespaceIdentifier: revocationRegistryNamespaceIdentifier, revocationRegistryTag, namespace: revocationRegistryNamespace } = parseIndyRevocationRegistryId(revocationStatusList.revRegDefId);
+			const legacyRevocationRegistryDefinitionId = getUnqualifiedRevocationRegistryDefinitionId(namespaceIdentifier, schemaSeqNo, credentialDefinitionTag, revocationRegistryTag);
+			const didIndyRevocationRegistryEntryId = getDidIndyRevocationRegistryEntryId(namespace, namespaceIdentifier, schemaSeqNo, credentialDefinitionTag, revocationRegistryTag);
+			if (revocationRegistryNamespace && revocationRegistryNamespace !== namespace) throw new CredoError(`Issued id '${revocationStatusList.issuerId}' does not have the same namespace (${namespace}) as the revocation registry definition '${revocationRegistryNamespace}'`);
+			if (revocationRegistryNamespaceIdentifier !== namespaceIdentifier) throw new CredoError(`Cannot register revocation registry definition using a different DID. Revocation registry definition contains '${revocationRegistryNamespaceIdentifier}', but DID used was '${namespaceIdentifier}'`);
+			if (endorsedTransaction) {
+				agentContext.config.logger.debug(`Preparing endorsed tx '${endorsedTransaction}' for submission on ledger '${namespace}' with did '${revocationStatusList.issuerId}'`, revocationStatusList);
+				writeRequest = new CustomRequest({ customRequest: endorsedTransaction });
+			} else {
+				const previousDelta = await this.fetchIndyRevocationDelta(agentContext, legacyRevocationRegistryDefinitionId, dateToTimestamp(/* @__PURE__ */ new Date()));
+				const revocationRegistryDefinitionRequest = new RevocationRegistryEntryRequest({
+					submitterDid: namespaceIdentifier,
+					revocationRegistryEntry: {
+						ver: "1.0",
+						value: indyVdrCreateLatestRevocationDelta(revocationStatusList.currentAccumulator, revocationStatusList.revocationList, previousDelta ?? void 0)
+					},
+					revocationRegistryDefinitionType: "CL_ACCUM",
+					revocationRegistryDefinitionId: legacyRevocationRegistryDefinitionId
+				});
+				const submitterKey = await verificationPublicJwkForIndyDid(agentContext, revocationStatusList.issuerId);
+				writeRequest = await pool.prepareWriteRequest(agentContext, revocationRegistryDefinitionRequest, submitterKey, endorserDid !== revocationStatusList.issuerId ? endorserDid : void 0);
+				if (endorserMode === "external") return {
+					jobId: didIndyRevocationRegistryEntryId,
+					revocationStatusListState: {
+						state: "action",
+						action: "endorseIndyTransaction",
+						revocationStatusList,
+						revocationStatusListRequest: writeRequest.body
+					},
+					registrationMetadata: {},
+					revocationStatusListMetadata: {}
+				};
+				if (endorserMode === "internal" && endorserDid !== revocationStatusList.issuerId) {
+					const endorserKey = await verificationPublicJwkForIndyDid(agentContext, endorserDid);
+					await multiSignRequest(agentContext, writeRequest, endorserKey, parseIndyDid(endorserDid).namespaceIdentifier);
+				}
+			}
+			const response = await pool.submitRequest(writeRequest);
+			agentContext.config.logger.debug(`Registered revocation status list '${didIndyRevocationRegistryEntryId}' on ledger '${pool.indyNamespace}'`, {
+				response,
+				revocationStatusList
+			});
+			return {
+				revocationStatusListMetadata: {},
+				revocationStatusListState: {
+					revocationStatusList: {
+						...revocationStatusList,
+						timestamp: response.result.txnMetadata.txnTime
+					},
+					state: "finished"
+				},
+				registrationMetadata: {}
+			};
+		} catch (error) {
+			agentContext.config.logger.error(`Error registering revocation status list for revocation registry definition '${revocationStatusList.revRegDefId}}'`, {
+				error,
+				did: revocationStatusList.issuerId
+			});
+			return {
+				registrationMetadata: {},
+				revocationStatusListMetadata: {},
+				revocationStatusListState: {
+					revocationStatusList,
+					state: "failed",
+					reason: `unknownError: ${error.message}`
+				}
+			};
+		}
+	}
+	async fetchIndySchemaWithSeqNo(agentContext, seqNo, did) {
+		const { pool } = await agentContext.dependencyManager.resolve(IndyVdrPoolService).getPoolForDid(agentContext, did);
+		agentContext.config.logger.debug(`Getting transaction with seqNo '${seqNo}' from ledger '${pool.indyNamespace}'`);
+		const request = new GetTransactionRequest({
+			ledgerType: 1,
+			seqNo
+		});
+		agentContext.config.logger.trace(`Submitting get transaction request to ledger '${pool.indyNamespace}'`);
+		const response = await pool.submitRequest(request);
+		if (response.result.data?.txn.type !== "101") {
+			agentContext.config.logger.error(`Could not get schema from ledger for seq no ${seqNo}'`);
+			return null;
+		}
+		const schema = response.result.data?.txn.data;
+		const schemaDid = response.result.data?.txn.metadata.from;
+		return {
+			schema: {
+				schemaId: getUnqualifiedSchemaId(schemaDid, schema.data.name, schema.data.version),
+				attr_name: schema.data.attr_names,
+				name: schema.data.name,
+				version: schema.data.version,
+				issuerId: schemaDid,
+				seqNo
+			},
+			indyNamespace: pool.indyNamespace
+		};
+	}
+	async fetchIndyRevocationDelta(agentContext, revocationRegistryDefinitionId, toTs) {
+		const indyVdrPoolService = agentContext.dependencyManager.resolve(IndyVdrPoolService);
+		const { did, namespaceIdentifier, schemaSeqNo, credentialDefinitionTag, revocationRegistryTag } = parseIndyRevocationRegistryId(revocationRegistryDefinitionId);
+		const { pool } = await indyVdrPoolService.getPoolForDid(agentContext, did);
+		agentContext.config.logger.debug(`Using ledger '${pool.indyNamespace}' to retrieve revocation registry deltas with revocation registry definition id '${revocationRegistryDefinitionId}' until ${toTs}`);
+		const deltaRequest = new GetRevocationRegistryDeltaRequest({
+			toTs,
+			submitterDid: namespaceIdentifier,
+			revocationRegistryId: getUnqualifiedRevocationRegistryDefinitionId(namespaceIdentifier, schemaSeqNo, credentialDefinitionTag, revocationRegistryTag)
+		});
+		agentContext.config.logger.trace(`Submitting get transaction request to ledger '${pool.indyNamespace}'`);
+		const { result: { data, type, txnTime } } = await pool.submitRequest(deltaRequest);
+		if (type !== "117" || data === null || !txnTime) {
+			agentContext.config.logger.warn(`Could not get any deltas from ledger for revocation registry definition '${revocationRegistryDefinitionId}' from ledger '${pool.indyNamespace}'`);
+			return null;
+		}
+		return {
+			revoked: data.value.revoked,
+			issued: data.value.issued,
+			accum: data.value.accum_to.value.accum,
+			txnTime
+		};
+	}
+};
+
+//#endregion
+export { IndyVdrAnonCredsRegistry };
+//# sourceMappingURL=IndyVdrAnonCredsRegistry.mjs.map