@credo-ts/cheqd 0.6.1-pr-2091-20241119140918 → 0.6.1

package/build/CheqdApi.d.mts

@@ -0,0 +1,45 @@
+import { CheqdCreateResourceOptions } from "./dids/CheqdDidRegistrar.mjs";
+import "./dids/index.mjs";
+import { AgentContext } from "@credo-ts/core";
+import * as _cheqd_ts_proto_cheqd_resource_v20 from "@cheqd/ts-proto/cheqd/resource/v2";
+
+//#region src/CheqdApi.d.ts
+declare class CheqdApi {
+  private agentContext;
+  constructor(agentContext: AgentContext);
+  createResource(did: string, options: CheqdCreateResourceOptions): Promise<{
+    resourceMetadata: {};
+    resourceRegistrationMetadata: {};
+    resourceState: {
+      state: string;
+      reason: string;
+      resourceId?: undefined;
+      resource?: undefined;
+    };
+  } | {
+    resourceMetadata: {};
+    resourceRegistrationMetadata: {};
+    resourceState: {
+      state: string;
+      resourceId: string;
+      resource: _cheqd_ts_proto_cheqd_resource_v20.MsgCreateResourcePayload;
+      reason?: undefined;
+    };
+  }>;
+  resolveResource(resourceUrl: string): Promise<{
+    error: string;
+    message: string;
+    resource?: undefined;
+    resourceMetadata?: undefined;
+    resourceResolutionMetadata?: undefined;
+  } | {
+    resource: any;
+    resourceMetadata: _cheqd_ts_proto_cheqd_resource_v20.Metadata;
+    resourceResolutionMetadata: {};
+    error?: undefined;
+    message?: undefined;
+  }>;
+}
+//#endregion
+export { CheqdApi };
+//# sourceMappingURL=CheqdApi.d.mts.map

package/build/CheqdApi.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CheqdApi.d.mts","names":[],"sources":["../src/CheqdApi.ts"],"sourcesContent":[],"mappings":";;;;;;cAMa,QAAA;;4BAGsB;uCAIiB,6BAA0B;IAPjE,gBAAQ,EAAA,CAAA,CAAA;IAGc,4BAAA,EAAA,CAAA,CAAA;IAIiB,aAAA,EAAA;MAA0B,KAAA,EAAA,MAAA;MAAA,MAAA,EAAA,MAAA;MAAA,UAAA,CAAA,EAAA,SAAA;MAK5B,QAAA,CAAA,EAAA,SAAA;IAAA,CAAA;;;;;;;gBAL4B,kCAAA,CAAA;;;;wCAK5B;;;;;;;;sBAL4B,kCAAA,CAAA"}

package/build/CheqdApi.mjs

@@ -0,0 +1,26 @@
+import { __decorateMetadata } from "./_virtual/_@oxc-project_runtime@0.99.0/helpers/decorateMetadata.mjs";
+import { __decorate } from "./_virtual/_@oxc-project_runtime@0.99.0/helpers/decorate.mjs";
+import { CheqdDidRegistrar } from "./dids/CheqdDidRegistrar.mjs";
+import { CheqdDidResolver } from "./dids/CheqdDidResolver.mjs";
+import "./dids/index.mjs";
+import { AgentContext } from "@credo-ts/core";
+import { injectable as injectable$1 } from "tsyringe";
+
+//#region src/CheqdApi.ts
+var _ref;
+let CheqdApi = class CheqdApi$1 {
+	constructor(agentContext) {
+		this.agentContext = agentContext;
+	}
+	async createResource(did, options) {
+		return await this.agentContext.dependencyManager.resolve(CheqdDidRegistrar).createResource(this.agentContext, did, options);
+	}
+	async resolveResource(resourceUrl) {
+		return await this.agentContext.dependencyManager.resolve(CheqdDidResolver).resolveResource(this.agentContext, resourceUrl);
+	}
+};
+CheqdApi = __decorate([injectable$1(), __decorateMetadata("design:paramtypes", [typeof (_ref = typeof AgentContext !== "undefined" && AgentContext) === "function" ? _ref : Object])], CheqdApi);
+
+//#endregion
+export { CheqdApi };
+//# sourceMappingURL=CheqdApi.mjs.map

package/build/CheqdApi.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"CheqdApi.mjs","names":["CheqdApi","injectable"],"sources":["../src/CheqdApi.ts"],"sourcesContent":["import { AgentContext } from '@credo-ts/core'\nimport { injectable } from 'tsyringe'\n\nimport { type CheqdCreateResourceOptions, CheqdDidRegistrar, CheqdDidResolver } from './dids'\n\n@injectable()\nexport class CheqdApi {\n  private agentContext: AgentContext\n\n  public constructor(agentContext: AgentContext) {\n    this.agentContext = agentContext\n  }\n\n  public async createResource(did: string, options: CheqdCreateResourceOptions) {\n    const cheqdDidRegistrar = this.agentContext.dependencyManager.resolve(CheqdDidRegistrar)\n    return await cheqdDidRegistrar.createResource(this.agentContext, did, options)\n  }\n\n  public async resolveResource(resourceUrl: string) {\n    const cheqdDidResolver = this.agentContext.dependencyManager.resolve(CheqdDidResolver)\n    return await cheqdDidResolver.resolveResource(this.agentContext, resourceUrl)\n  }\n}\n"],"mappings":";;;;;;;;;;AAMO,qBAAMA,WAAS;CAGpB,AAAO,YAAY,cAA4B;AAC7C,OAAK,eAAe;;CAGtB,MAAa,eAAe,KAAa,SAAqC;AAE5E,SAAO,MADmB,KAAK,aAAa,kBAAkB,QAAQ,kBAAkB,CACzD,eAAe,KAAK,cAAc,KAAK,QAAQ;;CAGhF,MAAa,gBAAgB,aAAqB;AAEhD,SAAO,MADkB,KAAK,aAAa,kBAAkB,QAAQ,iBAAiB,CACxD,gBAAgB,KAAK,cAAc,YAAY;;;uBAfhFC,cAAY"}

package/build/CheqdModule.d.mts

@@ -0,0 +1,15 @@
+import { CheqdApi } from "./CheqdApi.mjs";
+import { CheqdModuleConfig, CheqdModuleConfigOptions } from "./CheqdModuleConfig.mjs";
+import { AgentContext, DependencyManager, Module } from "@credo-ts/core";
+
+//#region src/CheqdModule.d.ts
+declare class CheqdModule implements Module {
+  readonly config: CheqdModuleConfig;
+  readonly api: typeof CheqdApi;
+  constructor(config: CheqdModuleConfigOptions);
+  register(dependencyManager: DependencyManager): void;
+  initialize(agentContext: AgentContext): Promise<void>;
+}
+//#endregion
+export { CheqdModule };
+//# sourceMappingURL=CheqdModule.d.mts.map

package/build/CheqdModule.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CheqdModule.d.mts","names":[],"sources":["../src/CheqdModule.ts"],"sourcesContent":[],"mappings":";;;;;cAOa,WAAA,YAAuB;EAAvB,SAAA,MAAY,EACC,iBADD;EACC,SAAA,GAAA,EAAA,OACL,QADK;EACL,WAAA,CAAA,MAAA,EAEQ,wBAFR;EAEQ,QAAA,CAAA,iBAAA,EAIQ,iBAJR,CAAA,EAAA,IAAA;EAIQ,UAAA,CAAA,YAAA,EAYG,YAZH,CAAA,EAYkB,OAZlB,CAAA,IAAA,CAAA"}

package/build/CheqdModule.mjs

@@ -0,0 +1,25 @@
+import { CheqdModuleConfig } from "./CheqdModuleConfig.mjs";
+import { CheqdLedgerService } from "./ledger/CheqdLedgerService.mjs";
+import "./ledger/index.mjs";
+import { CheqdApi } from "./CheqdApi.mjs";
+import { Buffer } from "@credo-ts/core";
+
+//#region src/CheqdModule.ts
+var CheqdModule = class {
+	constructor(config) {
+		this.api = CheqdApi;
+		this.config = new CheqdModuleConfig(config);
+	}
+	register(dependencyManager) {
+		dependencyManager.registerInstance(CheqdModuleConfig, this.config);
+		dependencyManager.registerSingleton(CheqdLedgerService);
+		global.Buffer = global.Buffer || Buffer;
+	}
+	async initialize(agentContext) {
+		agentContext.dependencyManager.resolve(CheqdLedgerService).connect();
+	}
+};
+
+//#endregion
+export { CheqdModule };
+//# sourceMappingURL=CheqdModule.mjs.map

package/build/CheqdModule.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"CheqdModule.mjs","names":[],"sources":["../src/CheqdModule.ts"],"sourcesContent":["import type { AgentContext, DependencyManager, Module } from '@credo-ts/core'\nimport { Buffer } from '@credo-ts/core'\nimport { CheqdApi } from './CheqdApi'\nimport type { CheqdModuleConfigOptions } from './CheqdModuleConfig'\nimport { CheqdModuleConfig } from './CheqdModuleConfig'\nimport { CheqdLedgerService } from './ledger'\n\nexport class CheqdModule implements Module {\n  public readonly config: CheqdModuleConfig\n  public readonly api = CheqdApi\n\n  public constructor(config: CheqdModuleConfigOptions) {\n    this.config = new CheqdModuleConfig(config)\n  }\n\n  public register(dependencyManager: DependencyManager) {\n    // Register config\n    dependencyManager.registerInstance(CheqdModuleConfig, this.config)\n\n    dependencyManager.registerSingleton(CheqdLedgerService)\n\n    // Cheqd module needs Buffer to be available globally\n    // If it is not available yet, we overwrite it with the\n    // Buffer implementation from Credo\n    global.Buffer = global.Buffer || Buffer\n  }\n\n  public async initialize(agentContext: AgentContext): Promise<void> {\n    // not required\n    const cheqdLedgerService = agentContext.dependencyManager.resolve(CheqdLedgerService)\n    // We don't await it, as it impact startup time\n    void cheqdLedgerService.connect()\n  }\n}\n"],"mappings":";;;;;;;AAOA,IAAa,cAAb,MAA2C;CAIzC,AAAO,YAAY,QAAkC;OAFrC,MAAM;AAGpB,OAAK,SAAS,IAAI,kBAAkB,OAAO;;CAG7C,AAAO,SAAS,mBAAsC;AAEpD,oBAAkB,iBAAiB,mBAAmB,KAAK,OAAO;AAElE,oBAAkB,kBAAkB,mBAAmB;AAKvD,SAAO,SAAS,OAAO,UAAU;;CAGnC,MAAa,WAAW,cAA2C;AAIjE,EAF2B,aAAa,kBAAkB,QAAQ,mBAAmB,CAE7D,SAAS"}

package/build/CheqdModuleConfig.d.mts

@@ -0,0 +1,21 @@
+//#region src/CheqdModuleConfig.d.ts
+/**
+ * CheqdModuleConfigOptions defines the interface for the options of the CheqdModuleConfig class.
+ */
+interface CheqdModuleConfigOptions {
+  networks: NetworkConfig[];
+}
+interface NetworkConfig {
+  rpcUrl?: string;
+  cosmosPayerSeed?: string;
+  network: string;
+}
+declare class CheqdModuleConfig {
+  private options;
+  constructor(options: CheqdModuleConfigOptions);
+  /** See {@link CheqdModuleConfigOptions.networks} */
+  get networks(): NetworkConfig[];
+}
+//#endregion
+export { CheqdModuleConfig, CheqdModuleConfigOptions };
+//# sourceMappingURL=CheqdModuleConfig.d.mts.map

package/build/CheqdModuleConfig.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CheqdModuleConfig.d.mts","names":[],"sources":["../src/CheqdModuleConfig.ts"],"sourcesContent":[],"mappings":";;AAGA;AAIA;AAMa,UAVI,wBAAA,CAaa;YAZlB;;UAGK,aAAA;;;;;cAMJ,iBAAA;;uBAGiB;;kBAKT"}

package/build/CheqdModuleConfig.mjs

@@ -0,0 +1,14 @@
+//#region src/CheqdModuleConfig.ts
+var CheqdModuleConfig = class {
+	constructor(options) {
+		this.options = options;
+	}
+	/** See {@link CheqdModuleConfigOptions.networks} */
+	get networks() {
+		return this.options.networks;
+	}
+};
+
+//#endregion
+export { CheqdModuleConfig };
+//# sourceMappingURL=CheqdModuleConfig.mjs.map

package/build/CheqdModuleConfig.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"CheqdModuleConfig.mjs","names":[],"sources":["../src/CheqdModuleConfig.ts"],"sourcesContent":["/**\n * CheqdModuleConfigOptions defines the interface for the options of the CheqdModuleConfig class.\n */\nexport interface CheqdModuleConfigOptions {\n  networks: NetworkConfig[]\n}\n\nexport interface NetworkConfig {\n  rpcUrl?: string\n  cosmosPayerSeed?: string\n  network: string\n}\n\nexport class CheqdModuleConfig {\n  private options: CheqdModuleConfigOptions\n\n  public constructor(options: CheqdModuleConfigOptions) {\n    this.options = options\n  }\n\n  /** See {@link CheqdModuleConfigOptions.networks} */\n  public get networks() {\n    return this.options.networks\n  }\n}\n"],"mappings":";AAaA,IAAa,oBAAb,MAA+B;CAG7B,AAAO,YAAY,SAAmC;AACpD,OAAK,UAAU;;;CAIjB,IAAW,WAAW;AACpB,SAAO,KAAK,QAAQ"}

package/build/_virtual/_@oxc-project_runtime@0.99.0/helpers/decorate.mjs

@@ -0,0 +1,10 @@
+//#region \0@oxc-project+runtime@0.99.0/helpers/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+//#endregion
+export { __decorate };

package/build/_virtual/_@oxc-project_runtime@0.99.0/helpers/decorateMetadata.mjs

@@ -0,0 +1,7 @@
+//#region \0@oxc-project+runtime@0.99.0/helpers/decorateMetadata.js
+function __decorateMetadata(k, v) {
+	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+
+//#endregion
+export { __decorateMetadata };

package/build/_virtual/_@oxc-project_runtime@0.99.0/helpers/decorateParam.mjs

@@ -0,0 +1,9 @@
+//#region \0@oxc-project+runtime@0.99.0/helpers/decorateParam.js
+function __decorateParam(paramIndex, decorator) {
+	return function(target, key) {
+		decorator(target, key, paramIndex);
+	};
+}
+
+//#endregion
+export { __decorateParam };

package/build/anoncreds/index.d.mts

@@ -0,0 +1 @@
+import { CheqdAnonCredsRegistry } from "./services/CheqdAnonCredsRegistry.mjs";

package/build/anoncreds/index.mjs

@@ -0,0 +1 @@
+import { CheqdAnonCredsRegistry } from "./services/CheqdAnonCredsRegistry.mjs";

package/build/anoncreds/services/CheqdAnonCredsRegistry.d.mts

@@ -0,0 +1,32 @@
+import { AnonCredsRegistry, GetCredentialDefinitionReturn, GetRevocationRegistryDefinitionReturn, GetRevocationStatusListReturn, GetSchemaReturn, RegisterCredentialDefinitionOptions, RegisterCredentialDefinitionReturn, RegisterRevocationRegistryDefinitionOptions, RegisterRevocationRegistryDefinitionReturn, RegisterRevocationStatusListOptions, RegisterRevocationStatusListReturn, RegisterSchemaOptions, RegisterSchemaReturn } from "@credo-ts/anoncreds";
+import { AgentContext } from "@credo-ts/core";
+
+//#region src/anoncreds/services/CheqdAnonCredsRegistry.d.ts
+declare class CheqdAnonCredsRegistry implements AnonCredsRegistry {
+  methodName: string;
+  allowsCaching: boolean;
+  allowsLocalRecord: boolean;
+  /**
+   * This class supports resolving and registering objects with cheqd identifiers.
+   * It needs to include support for the schema, credential definition, revocation registry as well
+   * as the issuer id (which is needed when registering objects).
+   */
+  readonly supportedIdentifier: RegExp;
+  getSchema(agentContext: AgentContext, schemaId: string): Promise<GetSchemaReturn>;
+  registerSchema(agentContext: AgentContext, options: RegisterSchemaOptions): Promise<RegisterSchemaReturn>;
+  registerCredentialDefinition(agentContext: AgentContext, options: RegisterCredentialDefinitionOptions): Promise<RegisterCredentialDefinitionReturn>;
+  getCredentialDefinition(agentContext: AgentContext, credentialDefinitionId: string): Promise<GetCredentialDefinitionReturn>;
+  getRevocationRegistryDefinition(agentContext: AgentContext, revocationRegistryDefinitionId: string): Promise<GetRevocationRegistryDefinitionReturn>;
+  registerRevocationRegistryDefinition(agentContext: AgentContext, {
+    revocationRegistryDefinition,
+    options
+  }: RegisterRevocationRegistryDefinitionOptions): Promise<RegisterRevocationRegistryDefinitionReturn>;
+  getRevocationStatusList(agentContext: AgentContext, revocationRegistryId: string, timestamp: number): Promise<GetRevocationStatusListReturn>;
+  registerRevocationStatusList(agentContext: AgentContext, {
+    revocationStatusList,
+    options
+  }: RegisterRevocationStatusListOptions): Promise<RegisterRevocationStatusListReturn>;
+}
+//#endregion
+export { CheqdAnonCredsRegistry };
+//# sourceMappingURL=CheqdAnonCredsRegistry.d.mts.map

package/build/anoncreds/services/CheqdAnonCredsRegistry.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CheqdAnonCredsRegistry.d.mts","names":[],"sources":["../../../src/anoncreds/services/CheqdAnonCredsRegistry.ts"],"sourcesContent":[],"mappings":";;;;cAkCa,sBAAA,YAAkC;;EAAlC,aAAA,EAAA,OAAA;EAWwB,iBAAA,EAAA,OAAA;EAEE;;;;;EA4C1B,SAAA,mBAAA,EA9CwB,MA8CxB;EAAR,SAAA,CAAA,YAAA,EA5CkC,YA4ClC,EAAA,QAAA,EAAA,MAAA,CAAA,EA5CmE,OA4CnE,CA5C2E,eA4C3E,CAAA;EAmDa,cAAA,CAAA,YAAA,EArDA,YAqDA,EAAA,OAAA,EApDL,qBAoDK,CAAA,EAnDb,OAmDa,CAnDL,oBAmDK,CAAA;EACL,4BAAA,CAAA,YAAA,EADK,YACL,EAAA,OAAA,EAAA,mCAAA,CAAA,EACR,OADQ,CACA,kCADA,CAAA;EACA,uBAAA,CAAA,YAAA,EAgEK,YAhEL,EAAA,sBAAA,EAAA,MAAA,CAAA,EAkER,OAlEQ,CAkEA,6BAlEA,CAAA;EAAR,+BAAA,CAAA,YAAA,EA0Ga,YA1Gb,EAAA,8BAAA,EAAA,MAAA,CAAA,EA4GA,OA5GA,CA4GQ,qCA5GR,CAAA;EAgEa,oCAAA,CAAA,YAAA,EAiGA,YAjGA,EAAA;IAAA,4BAAA;IAAA;EAAA,CAAA,EAkG6B,2CAlG7B,CAAA,EAmGb,OAnGa,CAmGL,0CAnGK,CAAA;EAEL,uBAAA,CAAA,YAAA,EAyKK,YAzKL,EAAA,oBAAA,EAAA,MAAA,EAAA,SAAA,EAAA,MAAA,CAAA,EA4KR,OA5KQ,CA4KA,6BA5KA,CAAA;EAAR,4BAAA,CAAA,YAAA,EAyOa,YAzOb,EAAA;IAAA,oBAAA;IAAA;EAAA,CAAA,EA0OkC,mCA1OlC,CAAA,EA2OA,OA3OA,CA2OQ,kCA3OR,CAAA"}

package/build/anoncreds/services/CheqdAnonCredsRegistry.mjs

@@ -0,0 +1,349 @@
+import { cheqdAnonCredsResourceTypes, cheqdSdkAnonCredsRegistryIdentifierRegex, parseCheqdDid } from "../utils/identifiers.mjs";
+import { CheqdDidRegistrar } from "../../dids/CheqdDidRegistrar.mjs";
+import { CheqdDidResolver } from "../../dids/CheqdDidResolver.mjs";
+import "../../dids/index.mjs";
+import { CheqdCredentialDefinition, CheqdRevocationRegistryDefinition, CheqdRevocationStatusList, CheqdSchema } from "../utils/transform.mjs";
+import { AnonCredsApi, AnonCredsRegistryService } from "@credo-ts/anoncreds";
+import { CredoError, Hasher, JsonTransformer, TypedArrayEncoder, utils } from "@credo-ts/core";
+
+//#region src/anoncreds/services/CheqdAnonCredsRegistry.ts
+var CheqdAnonCredsRegistry = class {
+	constructor() {
+		this.methodName = "cheqd";
+		this.allowsCaching = true;
+		this.allowsLocalRecord = true;
+		this.supportedIdentifier = cheqdSdkAnonCredsRegistryIdentifierRegex;
+	}
+	async getSchema(agentContext, schemaId) {
+		try {
+			agentContext.dependencyManager.resolve(AnonCredsApi);
+			const cheqdDidResolver = agentContext.dependencyManager.resolve(CheqdDidResolver);
+			const parsedDid = parseCheqdDid(schemaId);
+			if (!parsedDid) throw new CredoError(`Invalid schemaId: ${schemaId}`);
+			agentContext.config.logger.trace(`Submitting get schema request for schema '${schemaId}' to ledger`);
+			const response = await cheqdDidResolver.resolveResource(agentContext, schemaId);
+			if (response.error) throw new Error(`${response.error}: ${response.message}`);
+			const schema = JsonTransformer.fromJSON(response.resource, CheqdSchema);
+			return {
+				schema: {
+					attrNames: schema.attrNames,
+					name: schema.name,
+					version: schema.version,
+					issuerId: parsedDid.did
+				},
+				schemaId,
+				resolutionMetadata: {},
+				schemaMetadata: {}
+			};
+		} catch (error) {
+			agentContext.config.logger.error(`Error retrieving schema '${schemaId}'`, {
+				error,
+				schemaId
+			});
+			return {
+				schemaId,
+				resolutionMetadata: {
+					error: "notFound",
+					message: `unable to resolve schema: ${error.message}`
+				},
+				schemaMetadata: {}
+			};
+		}
+	}
+	async registerSchema(agentContext, options) {
+		try {
+			const cheqdDidRegistrar = agentContext.dependencyManager.resolve(CheqdDidRegistrar);
+			const schema = options.schema;
+			const schemaResource = {
+				id: utils.uuid(),
+				name: `${schema.name}-Schema`,
+				resourceType: cheqdAnonCredsResourceTypes.schema,
+				data: {
+					name: schema.name,
+					version: schema.version,
+					attrNames: schema.attrNames
+				},
+				version: schema.version
+			};
+			const response = await cheqdDidRegistrar.createResource(agentContext, schema.issuerId, schemaResource);
+			if (response.resourceState.state !== "finished") throw new CredoError(response.resourceState.reason ?? "Unknown error");
+			return {
+				schemaState: {
+					state: "finished",
+					schema,
+					schemaId: `${schema.issuerId}/resources/${schemaResource.id}`
+				},
+				registrationMetadata: {},
+				schemaMetadata: {}
+			};
+		} catch (error) {
+			agentContext.config.logger.debug(`Error registering schema for did '${options.schema.issuerId}'`, {
+				error,
+				did: options.schema.issuerId,
+				schema: options
+			});
+			return {
+				schemaMetadata: {},
+				registrationMetadata: {},
+				schemaState: {
+					state: "failed",
+					schema: options.schema,
+					reason: `unknownError: ${error.message}`
+				}
+			};
+		}
+	}
+	async registerCredentialDefinition(agentContext, options) {
+		try {
+			const cheqdDidRegistrar = agentContext.dependencyManager.resolve(CheqdDidRegistrar);
+			const { credentialDefinition } = options;
+			const schema = await agentContext.resolve(AnonCredsRegistryService).getSchema(agentContext, credentialDefinition.schemaId);
+			if (!schema.schema) throw new CredoError(`Schema not found for schemaId: ${credentialDefinition.schemaId}`);
+			const credDefName = `${schema.schema.name}-${credentialDefinition.tag}`;
+			const credDefNameHashBuffer = Hasher.hash(credDefName, "sha-256");
+			const credDefResource = {
+				id: utils.uuid(),
+				name: TypedArrayEncoder.toHex(credDefNameHashBuffer),
+				resourceType: cheqdAnonCredsResourceTypes.credentialDefinition,
+				data: {
+					type: credentialDefinition.type,
+					tag: credentialDefinition.tag,
+					value: credentialDefinition.value,
+					schemaId: credentialDefinition.schemaId
+				},
+				version: utils.uuid()
+			};
+			const response = await cheqdDidRegistrar.createResource(agentContext, credentialDefinition.issuerId, credDefResource);
+			if (response.resourceState.state !== "finished") throw new CredoError(response.resourceState.reason ?? "Unknown error");
+			return {
+				credentialDefinitionState: {
+					state: "finished",
+					credentialDefinition,
+					credentialDefinitionId: `${credentialDefinition.issuerId}/resources/${credDefResource.id}`
+				},
+				registrationMetadata: {},
+				credentialDefinitionMetadata: {}
+			};
+		} catch (error) {
+			agentContext.config.logger.error(`Error registering credential definition for did '${options.credentialDefinition.issuerId}'`, {
+				error,
+				did: options.credentialDefinition.issuerId,
+				schema: options
+			});
+			return {
+				credentialDefinitionMetadata: {},
+				registrationMetadata: {},
+				credentialDefinitionState: {
+					state: "failed",
+					credentialDefinition: options.credentialDefinition,
+					reason: `unknownError: ${error.message}`
+				}
+			};
+		}
+	}
+	async getCredentialDefinition(agentContext, credentialDefinitionId) {
+		try {
+			const cheqdDidResolver = agentContext.dependencyManager.resolve(CheqdDidResolver);
+			const parsedDid = parseCheqdDid(credentialDefinitionId);
+			if (!parsedDid) throw new CredoError(`Invalid credentialDefinitionId: ${credentialDefinitionId}`);
+			agentContext.config.logger.trace(`Submitting get credential definition request for '${credentialDefinitionId}' to ledger`);
+			const response = await cheqdDidResolver.resolveResource(agentContext, credentialDefinitionId);
+			if (response.error) throw new Error(`${response.error}: ${response.message}`);
+			return {
+				credentialDefinition: {
+					...JsonTransformer.fromJSON(response.resource, CheqdCredentialDefinition),
+					issuerId: parsedDid.did
+				},
+				credentialDefinitionId,
+				resolutionMetadata: {},
+				credentialDefinitionMetadata: response.resourceMetadata ?? {}
+			};
+		} catch (error) {
+			agentContext.config.logger.error(`Error retrieving credential definition '${credentialDefinitionId}'`, {
+				error,
+				credentialDefinitionId
+			});
+			return {
+				credentialDefinitionId,
+				resolutionMetadata: {
+					error: "notFound",
+					message: `unable to resolve credential definition: ${error.message}`
+				},
+				credentialDefinitionMetadata: {}
+			};
+		}
+	}
+	async getRevocationRegistryDefinition(agentContext, revocationRegistryDefinitionId) {
+		try {
+			const cheqdDidResolver = agentContext.dependencyManager.resolve(CheqdDidResolver);
+			const parsedDid = parseCheqdDid(revocationRegistryDefinitionId);
+			if (!parsedDid) throw new CredoError(`Invalid revocationRegistryDefinitionId: ${revocationRegistryDefinitionId}`);
+			agentContext.config.logger.trace(`Submitting get revocation registry definition request for '${revocationRegistryDefinitionId}' to ledger`);
+			const searchDid = parsedDid.path ? revocationRegistryDefinitionId : `${revocationRegistryDefinitionId}${revocationRegistryDefinitionId.includes("?") ? "&" : "?"}resourceType=${cheqdAnonCredsResourceTypes.revocationRegistryDefinition}`;
+			const response = await cheqdDidResolver.resolveResource(agentContext, searchDid);
+			if (response.error) throw new Error(`${response.error}: ${response.message}`);
+			return {
+				revocationRegistryDefinition: {
+					...JsonTransformer.fromJSON(response.resource, CheqdRevocationRegistryDefinition),
+					issuerId: parsedDid.did
+				},
+				revocationRegistryDefinitionId,
+				resolutionMetadata: {},
+				revocationRegistryDefinitionMetadata: response.resourceMetadata ?? {}
+			};
+		} catch (error) {
+			agentContext.config.logger.error(`Error retrieving revocation registry definition '${revocationRegistryDefinitionId}'`, {
+				error,
+				revocationRegistryDefinitionId
+			});
+			return {
+				revocationRegistryDefinitionId,
+				resolutionMetadata: {
+					error: "notFound",
+					message: `unable to resolve revocation registry definition: ${error.message}`
+				},
+				revocationRegistryDefinitionMetadata: {}
+			};
+		}
+	}
+	async registerRevocationRegistryDefinition(agentContext, { revocationRegistryDefinition, options }) {
+		try {
+			const credentialDefinition = await agentContext.resolve(AnonCredsRegistryService).getCredentialDefinition(agentContext, revocationRegistryDefinition.credDefId);
+			if (!credentialDefinition.credentialDefinition) throw new CredoError(`Credential definition not found for id: ${revocationRegistryDefinition.credDefId}`);
+			const credentialDefinitionName = credentialDefinition.credentialDefinitionMetadata.name;
+			if (!credentialDefinitionName) throw new CredoError(`Credential definition name not found for id: ${revocationRegistryDefinition.credDefId}`);
+			const cheqdDidRegistrar = agentContext.dependencyManager.resolve(CheqdDidRegistrar);
+			const revocDefName = `${credentialDefinitionName}-${revocationRegistryDefinition.tag}`;
+			const revocDefNameHashedBuffer = Hasher.hash(revocDefName, "sha-256");
+			const revocationRegistryDefinitionResource = {
+				id: utils.uuid(),
+				name: TypedArrayEncoder.toHex(revocDefNameHashedBuffer),
+				resourceType: cheqdAnonCredsResourceTypes.revocationRegistryDefinition,
+				data: {
+					credDefId: revocationRegistryDefinition.credDefId,
+					revocDefType: revocationRegistryDefinition.revocDefType,
+					tag: revocationRegistryDefinition.tag,
+					value: revocationRegistryDefinition.value
+				},
+				version: utils.uuid()
+			};
+			const response = await cheqdDidRegistrar.createResource(agentContext, revocationRegistryDefinition.issuerId, revocationRegistryDefinitionResource);
+			if (response.resourceState.state !== "finished") throw new CredoError(response.resourceState.reason ?? "Unknown error");
+			return {
+				revocationRegistryDefinitionState: {
+					state: "finished",
+					revocationRegistryDefinition,
+					revocationRegistryDefinitionId: `${revocationRegistryDefinition.issuerId}/resources/${revocationRegistryDefinitionResource.id}`
+				},
+				registrationMetadata: {},
+				revocationRegistryDefinitionMetadata: response.resourceMetadata ?? {}
+			};
+		} catch (error) {
+			agentContext.config.logger.error(`Error registering revocation registry definition for did '${revocationRegistryDefinition.issuerId}'`, {
+				error,
+				did: revocationRegistryDefinition.issuerId,
+				options
+			});
+			return {
+				revocationRegistryDefinitionMetadata: {},
+				registrationMetadata: {},
+				revocationRegistryDefinitionState: {
+					state: "failed",
+					revocationRegistryDefinition,
+					reason: `unknownError: ${error.message}`
+				}
+			};
+		}
+	}
+	async getRevocationStatusList(agentContext, revocationRegistryId, timestamp) {
+		try {
+			const cheqdDidResolver = agentContext.dependencyManager.resolve(CheqdDidResolver);
+			const parsedDid = parseCheqdDid(revocationRegistryId);
+			if (!parsedDid) throw new CredoError(`Invalid revocationRegistryId: ${revocationRegistryId}`);
+			agentContext.config.logger.trace(`Submitting get revocation status request for '${revocationRegistryId}' to ledger`);
+			const revocationRegistryDefinition = await agentContext.resolve(AnonCredsRegistryService).getRevocationRegistryDefinition(agentContext, revocationRegistryId);
+			if (!revocationRegistryDefinition.revocationRegistryDefinition) throw new CredoError(`Revocation registry definition not found for id: ${revocationRegistryId}`);
+			const revocationRegistryDefinitionName = revocationRegistryDefinition.revocationRegistryDefinitionMetadata.name;
+			if (!revocationRegistryDefinitionName) throw new CredoError(`Revocation registry definition name not found for id: ${revocationRegistryId}`);
+			const response = await cheqdDidResolver.resolveResource(agentContext, `${parsedDid.did}?resourceType=${cheqdAnonCredsResourceTypes.revocationStatusList}&resourceVersionTime=${timestamp}&resourceName=${revocationRegistryDefinitionName}`);
+			if (response.error) throw new Error(`${response.error}: ${response.message}`);
+			const revocationStatusList = JsonTransformer.fromJSON(response.resource, CheqdRevocationStatusList);
+			const statusListTimestamp = response.resourceMetadata?.created ? Math.floor(response.resourceMetadata.created.getTime() / 1e3) : void 0;
+			if (statusListTimestamp === void 0) throw new CredoError(`Unable to extract revocation status list timestamp from resource ${revocationRegistryId}`);
+			return {
+				revocationStatusList: {
+					...revocationStatusList,
+					issuerId: parsedDid.did,
+					timestamp: statusListTimestamp
+				},
+				resolutionMetadata: {},
+				revocationStatusListMetadata: response.resourceMetadata ?? {}
+			};
+		} catch (error) {
+			agentContext.config.logger.error(`Error retrieving revocation registry status list '${revocationRegistryId}'`, {
+				error,
+				revocationRegistryId
+			});
+			return {
+				resolutionMetadata: {
+					error: "notFound",
+					message: `unable to resolve revocation registry status list: ${error.message}`
+				},
+				revocationStatusListMetadata: {}
+			};
+		}
+	}
+	async registerRevocationStatusList(agentContext, { revocationStatusList, options }) {
+		try {
+			const revocationRegistryDefinition = await agentContext.resolve(AnonCredsRegistryService).getRevocationRegistryDefinition(agentContext, revocationStatusList.revRegDefId);
+			if (!revocationRegistryDefinition.revocationRegistryDefinition) throw new CredoError(`Revocation registry definition not found for id: ${revocationStatusList.revRegDefId}`);
+			const revocationRegistryDefinitionName = revocationRegistryDefinition.revocationRegistryDefinitionMetadata.name;
+			if (!revocationRegistryDefinitionName) throw new CredoError(`Revocation registry definition name not found for id: ${revocationStatusList.revRegDefId}`);
+			const cheqdDidRegistrar = agentContext.dependencyManager.resolve(CheqdDidRegistrar);
+			const revocationStatusListResource = {
+				id: utils.uuid(),
+				name: revocationRegistryDefinitionName,
+				resourceType: cheqdAnonCredsResourceTypes.revocationStatusList,
+				data: {
+					currentAccumulator: revocationStatusList.currentAccumulator,
+					revRegDefId: revocationStatusList.revRegDefId,
+					revocationList: revocationStatusList.revocationList
+				},
+				version: utils.uuid()
+			};
+			const response = await cheqdDidRegistrar.createResource(agentContext, revocationStatusList.issuerId, revocationStatusListResource);
+			if (response.resourceState.state !== "finished") throw new CredoError(response.resourceState.reason ?? "Unknown error");
+			const nowTimestamp = Math.floor(Date.now() / 1e3);
+			return {
+				revocationStatusListState: {
+					state: "finished",
+					revocationStatusList: {
+						...revocationStatusList,
+						timestamp: nowTimestamp
+					}
+				},
+				registrationMetadata: {},
+				revocationStatusListMetadata: response.resourceMetadata ?? {}
+			};
+		} catch (error) {
+			agentContext.config.logger.error(`Error registering revocation status list for did '${revocationStatusList.issuerId}'`, {
+				error,
+				did: revocationStatusList.issuerId,
+				options
+			});
+			return {
+				revocationStatusListMetadata: {},
+				registrationMetadata: {},
+				revocationStatusListState: {
+					state: "failed",
+					revocationStatusList,
+					reason: `unknownError: ${error.message}`
+				}
+			};
+		}
+	}
+};
+
+//#endregion
+export { CheqdAnonCredsRegistry };
+//# sourceMappingURL=CheqdAnonCredsRegistry.mjs.map