@hyperledger/anoncreds-nodejs 0.5.0-alpha-20261027094647 → 0.5.0-alpha-20261027201040

package/build/index.mjs

@@ -0,0 +1,871 @@
+import { createRequire } from "node:module";
+import { AnoncredsError, NativeAnoncreds, ObjectHandle } from "@hyperledger/anoncreds-shared";
+import { TextEncoder } from "node:util";
+import koffi, * as koffi$1 from "koffi";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+export * from "@hyperledger/anoncreds-shared";
+// src/ffi/alloc.ts
+const allocatePointer = () => {
+	return [void 0];
+};
+const allocateStringBuffer = () => {
+	return [void 0];
+};
+const allocateInt8Buffer = () => {
+	return [0];
+};
+const allocateByteBuffer = () => {
+	return {};
+};
+// src/ffi/conversion.ts
+const stringListToStringListStruct = (stringList) => {
+	return {
+		count: stringList.length,
+		data: stringList
+	};
+};
+const byteBufferToString = (byteBuffer) => koffi.decode.string(byteBuffer.data, byteBuffer.len);
+const objectHandleListToObjectHandleListStruct = (objectHandleList) => {
+	return {
+		count: objectHandleList.length,
+		data: objectHandleList.map((h) => h.handle)
+	};
+};
+const i32ListToI32ListStruct = (i32List) => {
+	return {
+		count: i32List.length,
+		data: i32List
+	};
+};
+// src/ffi/primitives.ts
+const FFI_UINT8 = koffi$1.types.uint8_t;
+koffi$1.types.uint64_t;
+const FFI_USIZE = koffi$1.types.size_t;
+const FFI_INT8 = koffi$1.types.int8_t;
+const FFI_INT32 = koffi$1.types.int32_t;
+const FFI_INT64 = koffi$1.types.int64_t;
+const FFI_STRING = koffi$1.types.string;
+const FFI_VOID = koffi$1.types.void;
+let freeAnoncredsString;
+const setFreeAnoncredsString = (free) => {
+	freeAnoncredsString = free;
+};
+const FFI_ANONCREDS_STRING = koffi$1.disposable("anoncreds_string", FFI_STRING, (pointer) => {
+	if (!pointer) return;
+	if (!freeAnoncredsString) throw new Error("Cannot free an AnonCreds string before the AnonCreds library is loaded");
+	freeAnoncredsString(pointer);
+});
+const FFI_OBJECT_HANDLE = FFI_USIZE;
+const FFI_ERROR_CODE = FFI_INT64;
+// src/ffi/serialize.ts
+const serialize = (arg) => {
+	switch (typeof arg) {
+		case "undefined": return null;
+		case "boolean": return Number(arg);
+		case "string": return arg;
+		case "number": return arg;
+		case "function": return arg;
+		case "object":
+			if (arg instanceof ObjectHandle) return arg.handle;
+			if (Array.isArray(arg)) {
+				if (arg.every((it) => typeof it === "string")) return stringListToStringListStruct(arg);
+				if (arg.every((it) => it instanceof ObjectHandle)) return objectHandleListToObjectHandleListStruct(arg);
+				if (arg.every((it) => typeof it === "number")) return i32ListToI32ListStruct(arg);
+			}
+			return JSON.stringify(arg);
+		default: throw new Error("could not serialize value");
+	}
+};
+const serializeArguments = (args) => {
+	const retVal = {};
+	for (const [key, val] of Object.entries(args)) retVal[key] = serialize(val);
+	return retVal;
+};
+// src/ffi/structures.ts
+const ByteBufferStruct = koffi.struct("ByteBufferStruct", {
+	len: FFI_INT64,
+	data: koffi.pointer(FFI_UINT8)
+});
+const StringListStruct = koffi.struct("StringListStruct", {
+	count: FFI_USIZE,
+	data: koffi.pointer(FFI_STRING)
+});
+const I32ListStruct = koffi.struct("I32ListStruct", {
+	count: FFI_USIZE,
+	data: koffi.pointer(FFI_INT32)
+});
+const CredRevInfoStruct = koffi.struct("CredRevInfoStruct", {
+	reg_def: FFI_OBJECT_HANDLE,
+	reg_def_private: FFI_OBJECT_HANDLE,
+	status_list: FFI_OBJECT_HANDLE,
+	reg_idx: FFI_INT64
+});
+const CredentialEntryStruct = koffi.struct("CredentialEntryStruct", {
+	credential: FFI_OBJECT_HANDLE,
+	timestamp: FFI_INT32,
+	rev_state: FFI_OBJECT_HANDLE
+});
+const CredentialEntryStructList = koffi.struct("CredentialEntryStructList", {
+	count: FFI_USIZE,
+	data: koffi.pointer(CredentialEntryStruct)
+});
+const CredentialProveStruct = koffi.struct("CredentialProveStruct", {
+	entry_idx: FFI_INT64,
+	referent: FFI_STRING,
+	is_predicate: FFI_INT8,
+	reveal: FFI_INT8
+});
+const CredentialProveStructList = koffi.struct("CredentialProveStructList", {
+	count: FFI_USIZE,
+	data: koffi.pointer(CredentialProveStruct)
+});
+const ObjectHandleStructList = koffi.struct("ObjectHandleStructList", {
+	count: FFI_USIZE,
+	data: koffi.pointer(FFI_OBJECT_HANDLE)
+});
+const NonrevokedIntervalOverrideStruct = koffi.struct("NonrevokedIntervalOverrideStruct", {
+	rev_reg_def_id: FFI_STRING,
+	requested_from_ts: FFI_INT32,
+	override_rev_status_list_ts: FFI_INT32
+});
+const NonrevokedIntervalOverrideStructList = koffi.struct("NonrevokedIntervalOverrideStructList", {
+	count: FFI_USIZE,
+	data: koffi.pointer(NonrevokedIntervalOverrideStruct)
+});
+// src/library/bindings.ts
+const nativeBindings = {
+	anoncreds_version: [FFI_ANONCREDS_STRING, []],
+	anoncreds_set_default_logger: [FFI_ERROR_CODE, []],
+	anoncreds_get_current_error: [FFI_ERROR_CODE, [koffi$1.out(koffi$1.pointer(FFI_ANONCREDS_STRING))]],
+	anoncreds_generate_nonce: [FFI_ERROR_CODE, [koffi$1.out(koffi$1.pointer(FFI_ANONCREDS_STRING))]],
+	anoncreds_buffer_free: [FFI_VOID, [ByteBufferStruct]],
+	anoncreds_string_free: [FFI_VOID, [koffi$1.pointer(FFI_VOID)]],
+	anoncreds_object_free: [FFI_VOID, [FFI_OBJECT_HANDLE]],
+	anoncreds_object_get_json: [FFI_ERROR_CODE, [FFI_OBJECT_HANDLE, koffi$1.out(koffi$1.pointer(ByteBufferStruct))]],
+	anoncreds_object_get_type_name: [FFI_ERROR_CODE, [FFI_OBJECT_HANDLE, koffi$1.out(koffi$1.pointer(FFI_ANONCREDS_STRING))]],
+	anoncreds_create_schema: [FFI_ERROR_CODE, [
+		FFI_STRING,
+		FFI_STRING,
+		FFI_STRING,
+		StringListStruct,
+		koffi$1.out(koffi$1.pointer(FFI_OBJECT_HANDLE))
+	]],
+	anoncreds_schema_from_json: [FFI_ERROR_CODE, [ByteBufferStruct, koffi$1.out(koffi$1.pointer(FFI_OBJECT_HANDLE))]],
+	anoncreds_create_credential_definition: [FFI_ERROR_CODE, [
+		FFI_STRING,
+		FFI_OBJECT_HANDLE,
+		FFI_STRING,
+		FFI_STRING,
+		FFI_STRING,
+		FFI_INT8,
+		koffi$1.out(koffi$1.pointer(FFI_OBJECT_HANDLE)),
+		koffi$1.out(koffi$1.pointer(FFI_OBJECT_HANDLE)),
+		koffi$1.out(koffi$1.pointer(FFI_OBJECT_HANDLE))
+	]],
+	anoncreds_credential_definition_from_json: [FFI_ERROR_CODE, [ByteBufferStruct, koffi$1.out(koffi$1.pointer(FFI_OBJECT_HANDLE))]],
+	anoncreds_credential_definition_private_from_json: [FFI_ERROR_CODE, [ByteBufferStruct, koffi$1.out(koffi$1.pointer(FFI_OBJECT_HANDLE))]],
+	anoncreds_key_correctness_proof_from_json: [FFI_ERROR_CODE, [ByteBufferStruct, koffi$1.out(koffi$1.pointer(FFI_OBJECT_HANDLE))]],
+	anoncreds_create_revocation_registry_def: [FFI_ERROR_CODE, [
+		FFI_OBJECT_HANDLE,
+		FFI_STRING,
+		FFI_STRING,
+		FFI_STRING,
+		FFI_STRING,
+		FFI_INT64,
+		FFI_STRING,
+		koffi$1.out(koffi$1.pointer(FFI_OBJECT_HANDLE)),
+		koffi$1.out(koffi$1.pointer(FFI_OBJECT_HANDLE))
+	]],
+	anoncreds_revocation_registry_definition_from_json: [FFI_ERROR_CODE, [ByteBufferStruct, koffi$1.out(koffi$1.pointer(FFI_OBJECT_HANDLE))]],
+	anoncreds_revocation_registry_definition_private_from_json: [FFI_ERROR_CODE, [ByteBufferStruct, koffi$1.out(koffi$1.pointer(FFI_OBJECT_HANDLE))]],
+	anoncreds_revocation_registry_definition_get_attribute: [FFI_ERROR_CODE, [
+		FFI_OBJECT_HANDLE,
+		FFI_STRING,
+		koffi$1.out(koffi$1.pointer(FFI_ANONCREDS_STRING))
+	]],
+	anoncreds_revocation_registry_from_json: [FFI_ERROR_CODE, [ByteBufferStruct, koffi$1.out(koffi$1.pointer(FFI_OBJECT_HANDLE))]],
+	anoncreds_create_revocation_status_list: [FFI_ERROR_CODE, [
+		FFI_OBJECT_HANDLE,
+		FFI_STRING,
+		FFI_OBJECT_HANDLE,
+		FFI_OBJECT_HANDLE,
+		FFI_STRING,
+		FFI_INT8,
+		FFI_INT64,
+		koffi$1.out(koffi$1.pointer(FFI_OBJECT_HANDLE))
+	]],
+	anoncreds_update_revocation_status_list: [FFI_ERROR_CODE, [
+		FFI_OBJECT_HANDLE,
+		FFI_OBJECT_HANDLE,
+		FFI_OBJECT_HANDLE,
+		FFI_OBJECT_HANDLE,
+		I32ListStruct,
+		I32ListStruct,
+		FFI_INT64,
+		koffi$1.out(koffi$1.pointer(FFI_OBJECT_HANDLE))
+	]],
+	anoncreds_update_revocation_status_list_timestamp_only: [FFI_ERROR_CODE, [
+		FFI_INT64,
+		FFI_OBJECT_HANDLE,
+		koffi$1.out(koffi$1.pointer(FFI_OBJECT_HANDLE))
+	]],
+	anoncreds_revocation_status_list_from_json: [FFI_ERROR_CODE, [ByteBufferStruct, koffi$1.out(koffi$1.pointer(FFI_OBJECT_HANDLE))]],
+	anoncreds_create_or_update_revocation_state: [FFI_ERROR_CODE, [
+		FFI_OBJECT_HANDLE,
+		FFI_OBJECT_HANDLE,
+		FFI_INT64,
+		FFI_STRING,
+		FFI_OBJECT_HANDLE,
+		FFI_OBJECT_HANDLE,
+		koffi$1.out(koffi$1.pointer(FFI_OBJECT_HANDLE))
+	]],
+	anoncreds_revocation_state_from_json: [FFI_ERROR_CODE, [ByteBufferStruct, koffi$1.out(koffi$1.pointer(FFI_OBJECT_HANDLE))]],
+	anoncreds_create_link_secret: [FFI_ERROR_CODE, [koffi$1.out(koffi$1.pointer(FFI_ANONCREDS_STRING))]],
+	anoncreds_create_credential_offer: [FFI_ERROR_CODE, [
+		FFI_STRING,
+		FFI_STRING,
+		FFI_OBJECT_HANDLE,
+		koffi$1.out(koffi$1.pointer(FFI_OBJECT_HANDLE))
+	]],
+	anoncreds_credential_offer_from_json: [FFI_ERROR_CODE, [ByteBufferStruct, koffi$1.out(koffi$1.pointer(FFI_OBJECT_HANDLE))]],
+	anoncreds_create_credential_request: [FFI_ERROR_CODE, [
+		FFI_STRING,
+		FFI_STRING,
+		FFI_OBJECT_HANDLE,
+		FFI_STRING,
+		FFI_STRING,
+		FFI_OBJECT_HANDLE,
+		koffi$1.out(koffi$1.pointer(FFI_OBJECT_HANDLE)),
+		koffi$1.out(koffi$1.pointer(FFI_OBJECT_HANDLE))
+	]],
+	anoncreds_credential_request_from_json: [FFI_ERROR_CODE, [ByteBufferStruct, koffi$1.out(koffi$1.pointer(FFI_OBJECT_HANDLE))]],
+	anoncreds_credential_request_metadata_from_json: [FFI_ERROR_CODE, [ByteBufferStruct, koffi$1.out(koffi$1.pointer(FFI_OBJECT_HANDLE))]],
+	anoncreds_create_credential: [FFI_ERROR_CODE, [
+		FFI_OBJECT_HANDLE,
+		FFI_OBJECT_HANDLE,
+		FFI_OBJECT_HANDLE,
+		FFI_OBJECT_HANDLE,
+		StringListStruct,
+		StringListStruct,
+		StringListStruct,
+		koffi$1.pointer(CredRevInfoStruct),
+		koffi$1.out(koffi$1.pointer(FFI_OBJECT_HANDLE))
+	]],
+	anoncreds_credential_from_json: [FFI_ERROR_CODE, [ByteBufferStruct, koffi$1.out(koffi$1.pointer(FFI_OBJECT_HANDLE))]],
+	anoncreds_credential_get_attribute: [FFI_ERROR_CODE, [
+		FFI_OBJECT_HANDLE,
+		FFI_STRING,
+		koffi$1.out(koffi$1.pointer(FFI_ANONCREDS_STRING))
+	]],
+	anoncreds_process_credential: [FFI_ERROR_CODE, [
+		FFI_OBJECT_HANDLE,
+		FFI_OBJECT_HANDLE,
+		FFI_STRING,
+		FFI_OBJECT_HANDLE,
+		FFI_OBJECT_HANDLE,
+		koffi$1.out(koffi$1.pointer(FFI_OBJECT_HANDLE))
+	]],
+	anoncreds_encode_credential_attributes: [FFI_ERROR_CODE, [StringListStruct, koffi$1.out(koffi$1.pointer(FFI_ANONCREDS_STRING))]],
+	anoncreds_create_w3c_credential: [FFI_ERROR_CODE, [
+		FFI_OBJECT_HANDLE,
+		FFI_OBJECT_HANDLE,
+		FFI_OBJECT_HANDLE,
+		FFI_OBJECT_HANDLE,
+		StringListStruct,
+		StringListStruct,
+		koffi$1.pointer(CredRevInfoStruct),
+		FFI_STRING,
+		koffi$1.out(koffi$1.pointer(FFI_OBJECT_HANDLE))
+	]],
+	anoncreds_w3c_credential_from_json: [FFI_ERROR_CODE, [ByteBufferStruct, koffi$1.out(koffi$1.pointer(FFI_OBJECT_HANDLE))]],
+	anoncreds_credential_to_w3c: [FFI_ERROR_CODE, [
+		FFI_OBJECT_HANDLE,
+		FFI_STRING,
+		FFI_STRING,
+		koffi$1.out(koffi$1.pointer(FFI_OBJECT_HANDLE))
+	]],
+	anoncreds_credential_from_w3c: [FFI_ERROR_CODE, [FFI_OBJECT_HANDLE, koffi$1.out(koffi$1.pointer(FFI_OBJECT_HANDLE))]],
+	anoncreds_process_w3c_credential: [FFI_ERROR_CODE, [
+		FFI_OBJECT_HANDLE,
+		FFI_OBJECT_HANDLE,
+		FFI_STRING,
+		FFI_OBJECT_HANDLE,
+		FFI_OBJECT_HANDLE,
+		koffi$1.out(koffi$1.pointer(FFI_OBJECT_HANDLE))
+	]],
+	anoncreds_w3c_credential_get_integrity_proof_details: [FFI_ERROR_CODE, [FFI_OBJECT_HANDLE, koffi$1.out(koffi$1.pointer(FFI_OBJECT_HANDLE))]],
+	anoncreds_w3c_credential_proof_get_attribute: [FFI_ERROR_CODE, [
+		FFI_OBJECT_HANDLE,
+		FFI_STRING,
+		koffi$1.out(koffi$1.pointer(FFI_ANONCREDS_STRING))
+	]],
+	anoncreds_presentation_request_from_json: [FFI_ERROR_CODE, [ByteBufferStruct, koffi$1.out(koffi$1.pointer(FFI_OBJECT_HANDLE))]],
+	anoncreds_create_presentation: [FFI_ERROR_CODE, [
+		FFI_OBJECT_HANDLE,
+		CredentialEntryStructList,
+		CredentialProveStructList,
+		StringListStruct,
+		StringListStruct,
+		FFI_STRING,
+		ObjectHandleStructList,
+		StringListStruct,
+		ObjectHandleStructList,
+		StringListStruct,
+		koffi$1.out(koffi$1.pointer(FFI_OBJECT_HANDLE))
+	]],
+	anoncreds_presentation_from_json: [FFI_ERROR_CODE, [ByteBufferStruct, koffi$1.out(koffi$1.pointer(FFI_OBJECT_HANDLE))]],
+	anoncreds_verify_presentation: [FFI_ERROR_CODE, [
+		FFI_OBJECT_HANDLE,
+		FFI_OBJECT_HANDLE,
+		ObjectHandleStructList,
+		StringListStruct,
+		ObjectHandleStructList,
+		StringListStruct,
+		ObjectHandleStructList,
+		StringListStruct,
+		ObjectHandleStructList,
+		NonrevokedIntervalOverrideStructList,
+		koffi$1.out(koffi$1.pointer(FFI_INT8))
+	]],
+	anoncreds_create_w3c_presentation: [FFI_ERROR_CODE, [
+		FFI_OBJECT_HANDLE,
+		CredentialEntryStructList,
+		CredentialProveStructList,
+		FFI_STRING,
+		ObjectHandleStructList,
+		StringListStruct,
+		ObjectHandleStructList,
+		StringListStruct,
+		FFI_STRING,
+		koffi$1.out(koffi$1.pointer(FFI_OBJECT_HANDLE))
+	]],
+	anoncreds_w3c_presentation_from_json: [FFI_ERROR_CODE, [ByteBufferStruct, koffi$1.out(koffi$1.pointer(FFI_OBJECT_HANDLE))]],
+	anoncreds_verify_w3c_presentation: [FFI_ERROR_CODE, [
+		FFI_OBJECT_HANDLE,
+		FFI_OBJECT_HANDLE,
+		ObjectHandleStructList,
+		StringListStruct,
+		ObjectHandleStructList,
+		StringListStruct,
+		ObjectHandleStructList,
+		StringListStruct,
+		ObjectHandleStructList,
+		NonrevokedIntervalOverrideStructList,
+		koffi$1.out(koffi$1.pointer(FFI_INT8))
+	]]
+};
+// src/library/register.ts
+const LIBNAME = "anoncreds";
+const ENV_VAR = "LIB_ANONCREDS_PATH";
+const extensions = {
+	darwin: {
+		prefix: "lib",
+		extension: ".dylib"
+	},
+	linux: {
+		prefix: "lib",
+		extension: ".so"
+	},
+	win32: { extension: ".dll" }
+};
+const libPaths = {
+	darwin: [
+		"/usr/local/lib/",
+		"/usr/lib/",
+		"/opt/homebrew/opt/"
+	],
+	linux: ["/usr/lib/", "/usr/local/lib/"],
+	win32: ["c:\\windows\\system32\\"]
+};
+const doesPathExist = fs.existsSync;
+const getLibrary = () => {
+	const platform = os.platform();
+	if (platform !== "linux" && platform !== "win32" && platform !== "darwin") throw new Error(`Unsupported platform: ${platform}. linux, win32 and darwin are supported.`);
+	const pathFromEnvironment = process.env[ENV_VAR];
+	const platformPaths = libPaths[platform];
+	try {
+		const packageRoot = path.dirname(createRequire(import.meta.url).resolve("@hyperledger/anoncreds-nodejs/package.json"));
+		platformPaths.unshift(path.join(packageRoot, "native"));
+	} catch {}
+	if (pathFromEnvironment) platformPaths.unshift(pathFromEnvironment);
+	const libraries = platformPaths.map((p) => path.join(p, `${extensions[platform].prefix ?? ""}${LIBNAME}${extensions[platform].extension}`));
+	if (!libraries.some((libraryPath) => doesPathExist(libraryPath))) throw new Error(`Could not find ${LIBNAME} with these paths: ${libraries.join(" ")}`);
+	const validLibraryPath = libraries.find((l) => doesPathExist(l));
+	const lib = koffi.load(validLibraryPath);
+	const methods = {};
+	for (const [name, [returnType, argumentTypes]] of Object.entries(nativeBindings)) methods[name] = lib.func(name, returnType, argumentTypes);
+	setFreeAnoncredsString((pointer) => methods.anoncreds_string_free?.(pointer));
+	return methods;
+};
+let nativeAnonCreds;
+const getNativeAnonCreds = () => {
+	if (!nativeAnonCreds) nativeAnonCreds = getLibrary();
+	return nativeAnonCreds;
+};
+// src/NodeJSAnoncreds.ts
+function handleReturnPointer(returnValue) {
+	const value = Array.isArray(returnValue) ? returnValue[0] : returnValue;
+	if (value === null || value === void 0) throw AnoncredsError.customError({ message: "Unexpected null pointer" });
+	return value;
+}
+var NodeJSAnoncreds = class {
+	get nativeAnoncreds() {
+		return getNativeAnonCreds();
+	}
+	/**
+	* Fetch the error from the native library and throw it as a JS error
+	*
+	* NOTE:
+	* Checks whether the error code of the returned error matches the error code that was passed to the function.
+	* If it doesn't, we throw an error with the original errorCode, and a custom message explaining we weren't able
+	* to retrieve the error message from the native library. This should however not break functionality as long as
+	* error codes are used rather than error messages for error handling.
+	*
+	*/
+	getAnoncredsError(errorCode) {
+		const error = this.getCurrentError();
+		if (error.code !== errorCode) return new AnoncredsError({
+			code: errorCode,
+			message: "Error details have already been overwritten on the native side, unable to retrieve error message for the error"
+		});
+		return new AnoncredsError(error);
+	}
+	getCurrentError() {
+		const error = allocateStringBuffer();
+		this.nativeAnoncreds.anoncreds_get_current_error(error);
+		const serializedError = handleReturnPointer(error);
+		return JSON.parse(serializedError);
+	}
+	handleError(errorCode) {
+		if (errorCode === 0) return;
+		throw this.getAnoncredsError(errorCode);
+	}
+	generateNonce() {
+		const ret = allocateStringBuffer();
+		const errorCode = this.nativeAnoncreds.anoncreds_generate_nonce(ret);
+		this.handleError(errorCode);
+		return handleReturnPointer(ret);
+	}
+	createSchema(options) {
+		const { name, version, issuerId, attributeNames } = serializeArguments(options);
+		const ret = allocatePointer();
+		const errorCode = this.nativeAnoncreds.anoncreds_create_schema(name, version, issuerId, attributeNames, ret);
+		this.handleError(errorCode);
+		return new ObjectHandle(handleReturnPointer(ret));
+	}
+	revocationRegistryDefinitionGetAttribute(options) {
+		const { objectHandle, name } = serializeArguments(options);
+		const ret = allocateStringBuffer();
+		const errorCode = this.nativeAnoncreds.anoncreds_revocation_registry_definition_get_attribute(objectHandle, name, ret);
+		this.handleError(errorCode);
+		return handleReturnPointer(ret);
+	}
+	credentialGetAttribute(options) {
+		const { objectHandle, name } = serializeArguments(options);
+		const ret = allocateStringBuffer();
+		const errorCode = this.nativeAnoncreds.anoncreds_credential_get_attribute(objectHandle, name, ret);
+		this.handleError(errorCode);
+		return (Array.isArray(ret) ? ret[0] : ret) ?? null;
+	}
+	createCredentialDefinition(options) {
+		const { schemaId, issuerId, schema, tag, signatureType, supportRevocation } = serializeArguments(options);
+		const credentialDefinitionPtr = allocatePointer();
+		const credentialDefinitionPrivatePtr = allocatePointer();
+		const keyCorrectnessProofPtr = allocatePointer();
+		const errorCode = this.nativeAnoncreds.anoncreds_create_credential_definition(schemaId, schema, tag, issuerId, signatureType, supportRevocation, credentialDefinitionPtr, credentialDefinitionPrivatePtr, keyCorrectnessProofPtr);
+		this.handleError(errorCode);
+		return {
+			credentialDefinition: new ObjectHandle(handleReturnPointer(credentialDefinitionPtr)),
+			credentialDefinitionPrivate: new ObjectHandle(handleReturnPointer(credentialDefinitionPrivatePtr)),
+			keyCorrectnessProof: new ObjectHandle(handleReturnPointer(keyCorrectnessProofPtr))
+		};
+	}
+	createCredential(options) {
+		const { credentialDefinition, credentialDefinitionPrivate, credentialOffer, credentialRequest } = serializeArguments(options);
+		const attributeNames = {
+			count: Object.keys(options.attributeRawValues).length,
+			data: Object.keys(options.attributeRawValues)
+		};
+		const attributeRawValues = {
+			count: Object.keys(options.attributeRawValues).length,
+			data: Object.values(options.attributeRawValues)
+		};
+		const attributeEncodedValues = options.attributeEncodedValues ? {
+			count: Object.keys(options.attributeEncodedValues).length,
+			data: Object.values(options.attributeEncodedValues)
+		} : {};
+		let revocationConfiguration = null;
+		if (options.revocationConfiguration) {
+			const { revocationStatusList, revocationRegistryDefinitionPrivate, revocationRegistryDefinition, registryIndex } = serializeArguments(options.revocationConfiguration);
+			revocationConfiguration = {
+				reg_def: revocationRegistryDefinition,
+				reg_def_private: revocationRegistryDefinitionPrivate,
+				status_list: revocationStatusList,
+				reg_idx: registryIndex
+			};
+		}
+		const credentialPtr = allocatePointer();
+		const errorCode = this.nativeAnoncreds.anoncreds_create_credential(credentialDefinition, credentialDefinitionPrivate, credentialOffer, credentialRequest, attributeNames, attributeRawValues, attributeEncodedValues, revocationConfiguration, credentialPtr);
+		this.handleError(errorCode);
+		return new ObjectHandle(handleReturnPointer(credentialPtr));
+	}
+	encodeCredentialAttributes(options) {
+		const { attributeRawValues } = serializeArguments(options);
+		const ret = allocateStringBuffer();
+		const errorCode = this.nativeAnoncreds.anoncreds_encode_credential_attributes(attributeRawValues, ret);
+		this.handleError(errorCode);
+		return handleReturnPointer(ret).split(",");
+	}
+	processCredential(options) {
+		const { credential, credentialRequestMetadata, linkSecret, credentialDefinition } = serializeArguments(options);
+		const ret = allocatePointer();
+		const errorCode = this.nativeAnoncreds.anoncreds_process_credential(credential, credentialRequestMetadata, linkSecret, credentialDefinition, options.revocationRegistryDefinition?.handle ?? 0, ret);
+		this.handleError(errorCode);
+		return new ObjectHandle(handleReturnPointer(ret));
+	}
+	createCredentialOffer(options) {
+		const { schemaId, credentialDefinitionId, keyCorrectnessProof } = serializeArguments(options);
+		const ret = allocatePointer();
+		const errorCode = this.nativeAnoncreds.anoncreds_create_credential_offer(schemaId, credentialDefinitionId, keyCorrectnessProof, ret);
+		this.handleError(errorCode);
+		return new ObjectHandle(handleReturnPointer(ret));
+	}
+	createCredentialRequest(options) {
+		const { entropy, proverDid, credentialDefinition, linkSecret, linkSecretId, credentialOffer } = serializeArguments(options);
+		const credentialRequestPtr = allocatePointer();
+		const credentialRequestMetadataPtr = allocatePointer();
+		const errorCode = this.nativeAnoncreds.anoncreds_create_credential_request(entropy, proverDid, credentialDefinition, linkSecret, linkSecretId, credentialOffer, credentialRequestPtr, credentialRequestMetadataPtr);
+		this.handleError(errorCode);
+		return {
+			credentialRequest: new ObjectHandle(handleReturnPointer(credentialRequestPtr)),
+			credentialRequestMetadata: new ObjectHandle(handleReturnPointer(credentialRequestMetadataPtr))
+		};
+	}
+	createLinkSecret() {
+		const ret = allocateStringBuffer();
+		const errorCode = this.nativeAnoncreds.anoncreds_create_link_secret(ret);
+		this.handleError(errorCode);
+		return handleReturnPointer(ret);
+	}
+	createPresentation(options) {
+		const { presentationRequest, linkSecret } = serializeArguments(options);
+		const selfAttestNames = {
+			count: Object.keys(options.selfAttest).length,
+			data: Object.keys(options.selfAttest)
+		};
+		const selfAttestValues = {
+			count: Object.values(options.selfAttest).length,
+			data: Object.values(options.selfAttest)
+		};
+		const credentialEntryList = this.convertCredentialList(options.credentials);
+		const credentialProveList = this.convertCredentialProves(options.credentialsProve);
+		const { schemaIds, schemas } = this.convertSchemas(options.schemas);
+		const { credentialDefinitionIds, credentialDefinitions } = this.convertCredDefs(options.credentialDefinitions);
+		const ret = allocatePointer();
+		const errorCode = this.nativeAnoncreds.anoncreds_create_presentation(presentationRequest, credentialEntryList, credentialProveList, selfAttestNames, selfAttestValues, linkSecret, schemas, schemaIds, credentialDefinitions, credentialDefinitionIds, ret);
+		this.handleError(errorCode);
+		return new ObjectHandle(handleReturnPointer(ret));
+	}
+	verifyPresentation(options) {
+		const { presentation, presentationRequest, schemas, credentialDefinitions, revocationRegistryDefinitions, revocationStatusLists, revocationRegistryDefinitionIds, schemaIds, credentialDefinitionIds } = serializeArguments(options);
+		const nonRevokedIntervalOverrideList = this.convertNonRevokedIntervalOverrides(options.nonRevokedIntervalOverrides);
+		const ret = allocateInt8Buffer();
+		const errorCode = this.nativeAnoncreds.anoncreds_verify_presentation(presentation, presentationRequest, schemas, schemaIds, credentialDefinitions, credentialDefinitionIds, revocationRegistryDefinitions ?? {}, revocationRegistryDefinitionIds ?? {}, revocationStatusLists ?? {}, nonRevokedIntervalOverrideList, ret);
+		this.handleError(errorCode);
+		return Boolean(handleReturnPointer(ret));
+	}
+	createRevocationStatusList(options) {
+		const { credentialDefinition, revocationRegistryDefinitionId, revocationRegistryDefinition, revocationRegistryDefinitionPrivate, issuerId, issuanceByDefault, timestamp } = serializeArguments(options);
+		const ret = allocatePointer();
+		const errorCode = this.nativeAnoncreds.anoncreds_create_revocation_status_list(credentialDefinition, revocationRegistryDefinitionId, revocationRegistryDefinition, revocationRegistryDefinitionPrivate, issuerId, issuanceByDefault, timestamp ?? -1, ret);
+		this.handleError(errorCode);
+		return new ObjectHandle(handleReturnPointer(ret));
+	}
+	updateRevocationStatusListTimestampOnly(options) {
+		const { currentRevocationStatusList, timestamp } = serializeArguments(options);
+		const ret = allocatePointer();
+		const errorCode = this.nativeAnoncreds.anoncreds_update_revocation_status_list_timestamp_only(timestamp, currentRevocationStatusList, ret);
+		this.handleError(errorCode);
+		return new ObjectHandle(handleReturnPointer(ret));
+	}
+	updateRevocationStatusList(options) {
+		const { credentialDefinition, revocationRegistryDefinition, revocationRegistryDefinitionPrivate, currentRevocationStatusList, issued, revoked, timestamp } = serializeArguments(options);
+		const ret = allocatePointer();
+		const errorCode = this.nativeAnoncreds.anoncreds_update_revocation_status_list(credentialDefinition, revocationRegistryDefinition, revocationRegistryDefinitionPrivate, currentRevocationStatusList, issued ?? {}, revoked ?? {}, timestamp ?? -1, ret);
+		this.handleError(errorCode);
+		return new ObjectHandle(handleReturnPointer(ret));
+	}
+	createRevocationRegistryDefinition(options) {
+		const { credentialDefinition, credentialDefinitionId, tag, revocationRegistryType, issuerId, maximumCredentialNumber, tailsDirectoryPath } = serializeArguments(options);
+		const revocationRegistryDefinitionPtr = allocatePointer();
+		const revocationRegistryDefinitionPrivate = allocatePointer();
+		const errorCode = this.nativeAnoncreds.anoncreds_create_revocation_registry_def(credentialDefinition, credentialDefinitionId, issuerId, tag, revocationRegistryType, maximumCredentialNumber, tailsDirectoryPath, revocationRegistryDefinitionPtr, revocationRegistryDefinitionPrivate);
+		this.handleError(errorCode);
+		return {
+			revocationRegistryDefinition: new ObjectHandle(handleReturnPointer(revocationRegistryDefinitionPtr)),
+			revocationRegistryDefinitionPrivate: new ObjectHandle(handleReturnPointer(revocationRegistryDefinitionPrivate))
+		};
+	}
+	createOrUpdateRevocationState(options) {
+		const { revocationRegistryDefinition, revocationStatusList, revocationRegistryIndex, tailsPath } = serializeArguments(options);
+		const oldRevocationState = options.oldRevocationState ?? new ObjectHandle(0);
+		const oldRevocationStatusList = options.oldRevocationStatusList ?? new ObjectHandle(0);
+		const ret = allocatePointer();
+		const errorCode = this.nativeAnoncreds.anoncreds_create_or_update_revocation_state(revocationRegistryDefinition, revocationStatusList, revocationRegistryIndex, tailsPath, oldRevocationState.handle, oldRevocationStatusList.handle, ret);
+		this.handleError(errorCode);
+		return new ObjectHandle(handleReturnPointer(ret));
+	}
+	createW3cCredential(options) {
+		const { credentialDefinition, credentialDefinitionPrivate, credentialOffer, credentialRequest, w3cVersion } = serializeArguments(options);
+		const attributeNames = this.convertAttributeNames(options.attributeRawValues);
+		const attributeRawValues = this.convertAttributeRawValues(options.attributeRawValues);
+		const revocationConfiguration = this.convertRevocationConfiguration(options.revocationConfiguration);
+		const credentialPtr = allocatePointer();
+		const errorCode = this.nativeAnoncreds.anoncreds_create_w3c_credential(credentialDefinition, credentialDefinitionPrivate, credentialOffer, credentialRequest, attributeNames, attributeRawValues, revocationConfiguration ?? 0, w3cVersion, credentialPtr);
+		this.handleError(errorCode);
+		return new ObjectHandle(handleReturnPointer(credentialPtr));
+	}
+	processW3cCredential(options) {
+		const { credential, credentialRequestMetadata, linkSecret, credentialDefinition } = serializeArguments(options);
+		const ret = allocatePointer();
+		const errorCode = this.nativeAnoncreds.anoncreds_process_w3c_credential(credential, credentialRequestMetadata, linkSecret, credentialDefinition, options.revocationRegistryDefinition?.handle ?? 0, ret);
+		this.handleError(errorCode);
+		return new ObjectHandle(handleReturnPointer(ret));
+	}
+	createW3cPresentation(options) {
+		const { presentationRequest, linkSecret, w3cVersion } = serializeArguments(options);
+		const credentialEntryList = this.convertCredentialList(options.credentials);
+		const credentialProveList = this.convertCredentialProves(options.credentialsProve);
+		const { schemaIds, schemas } = this.convertSchemas(options.schemas);
+		const { credentialDefinitionIds, credentialDefinitions } = this.convertCredDefs(options.credentialDefinitions);
+		const ret = allocatePointer();
+		const errorCode = this.nativeAnoncreds.anoncreds_create_w3c_presentation(presentationRequest, credentialEntryList, credentialProveList, linkSecret, schemas, schemaIds, credentialDefinitions, credentialDefinitionIds, w3cVersion, ret);
+		this.handleError(errorCode);
+		return new ObjectHandle(handleReturnPointer(ret));
+	}
+	verifyW3cPresentation(options) {
+		const { presentation, presentationRequest, schemas, credentialDefinitions, revocationRegistryDefinitions, revocationStatusLists, revocationRegistryDefinitionIds, schemaIds, credentialDefinitionIds } = serializeArguments(options);
+		const nonRevokedIntervalOverrideList = this.convertNonRevokedIntervalOverrides(options.nonRevokedIntervalOverrides);
+		const ret = allocateInt8Buffer();
+		const errorCode = this.nativeAnoncreds.anoncreds_verify_w3c_presentation(presentation, presentationRequest, schemas, schemaIds, credentialDefinitions, credentialDefinitionIds, revocationRegistryDefinitions ?? {}, revocationRegistryDefinitionIds ?? {}, revocationStatusLists ?? {}, nonRevokedIntervalOverrideList, ret);
+		this.handleError(errorCode);
+		return Boolean(handleReturnPointer(ret));
+	}
+	credentialToW3c(options) {
+		const { objectHandle, issuerId, w3cVersion } = serializeArguments(options);
+		const ret = allocatePointer();
+		const errorCode = this.nativeAnoncreds.anoncreds_credential_to_w3c(objectHandle, issuerId, w3cVersion, ret);
+		this.handleError(errorCode);
+		return new ObjectHandle(handleReturnPointer(ret));
+	}
+	credentialFromW3c(options) {
+		const { objectHandle } = serializeArguments(options);
+		const ret = allocatePointer();
+		const errorCode = this.nativeAnoncreds.anoncreds_credential_from_w3c(objectHandle, ret);
+		this.handleError(errorCode);
+		return new ObjectHandle(handleReturnPointer(ret));
+	}
+	w3cCredentialGetIntegrityProofDetails(options) {
+		const { objectHandle } = serializeArguments(options);
+		const ret = allocatePointer();
+		const errorCode = this.nativeAnoncreds.anoncreds_w3c_credential_get_integrity_proof_details(objectHandle, ret);
+		this.handleError(errorCode);
+		return new ObjectHandle(handleReturnPointer(ret));
+	}
+	w3cCredentialProofGetAttribute(options) {
+		const { objectHandle, name } = serializeArguments(options);
+		const ret = allocateStringBuffer();
+		const errorCode = this.nativeAnoncreds.anoncreds_w3c_credential_proof_get_attribute(objectHandle, name, ret);
+		this.handleError(errorCode);
+		return (Array.isArray(ret) ? ret[0] : ret) ?? null;
+	}
+	w3cCredentialFromJson(options) {
+		return this.objectFromJson(this.nativeAnoncreds.anoncreds_w3c_credential_from_json, options);
+	}
+	w3cPresentationFromJson(options) {
+		return this.objectFromJson(this.nativeAnoncreds.anoncreds_w3c_presentation_from_json, options);
+	}
+	version() {
+		return this.nativeAnoncreds.anoncreds_version();
+	}
+	setDefaultLogger() {
+		const errorCode = this.nativeAnoncreds.anoncreds_set_default_logger();
+		this.handleError(errorCode);
+	}
+	objectFromJson(cb, options) {
+		const ret = allocatePointer();
+		const byteBuffer = new TextEncoder().encode(options.json);
+		const errorCode = cb({
+			data: byteBuffer,
+			len: byteBuffer.length
+		}, ret);
+		this.handleError(errorCode);
+		return new ObjectHandle(handleReturnPointer(ret));
+	}
+	presentationRequestFromJson(options) {
+		return this.objectFromJson(this.nativeAnoncreds.anoncreds_presentation_request_from_json, options);
+	}
+	credentialRequestFromJson(options) {
+		return this.objectFromJson(this.nativeAnoncreds.anoncreds_credential_request_from_json, options);
+	}
+	credentialRequestMetadataFromJson(options) {
+		return this.objectFromJson(this.nativeAnoncreds.anoncreds_credential_request_metadata_from_json, options);
+	}
+	revocationRegistryDefinitionFromJson(options) {
+		return this.objectFromJson(this.nativeAnoncreds.anoncreds_revocation_registry_definition_from_json, options);
+	}
+	revocationRegistryFromJson(options) {
+		return this.objectFromJson(this.nativeAnoncreds.anoncreds_revocation_registry_from_json, options);
+	}
+	revocationStatusListFromJson(options) {
+		return this.objectFromJson(this.nativeAnoncreds.anoncreds_revocation_status_list_from_json, options);
+	}
+	revocationStateFromJson(options) {
+		return this.objectFromJson(this.nativeAnoncreds.anoncreds_revocation_state_from_json, options);
+	}
+	presentationFromJson(options) {
+		return this.objectFromJson(this.nativeAnoncreds.anoncreds_presentation_from_json, options);
+	}
+	credentialOfferFromJson(options) {
+		return this.objectFromJson(this.nativeAnoncreds.anoncreds_credential_offer_from_json, options);
+	}
+	schemaFromJson(options) {
+		return this.objectFromJson(this.nativeAnoncreds.anoncreds_schema_from_json, options);
+	}
+	credentialFromJson(options) {
+		return this.objectFromJson(this.nativeAnoncreds.anoncreds_credential_from_json, options);
+	}
+	revocationRegistryDefinitionPrivateFromJson(options) {
+		return this.objectFromJson(this.nativeAnoncreds.anoncreds_revocation_registry_definition_private_from_json, options);
+	}
+	credentialDefinitionFromJson(options) {
+		return this.objectFromJson(this.nativeAnoncreds.anoncreds_credential_definition_from_json, options);
+	}
+	credentialDefinitionPrivateFromJson(options) {
+		return this.objectFromJson(this.nativeAnoncreds.anoncreds_credential_definition_private_from_json, options);
+	}
+	keyCorrectnessProofFromJson(options) {
+		return this.objectFromJson(this.nativeAnoncreds.anoncreds_key_correctness_proof_from_json, options);
+	}
+	getJson(options) {
+		const { objectHandle } = serializeArguments(options);
+		const ret = allocateByteBuffer();
+		const errorCode = this.nativeAnoncreds.anoncreds_object_get_json(objectHandle, ret);
+		this.handleError(errorCode);
+		const returnValue = handleReturnPointer(ret);
+		const output = byteBufferToString(returnValue);
+		this.nativeAnoncreds.anoncreds_buffer_free(returnValue);
+		return output;
+	}
+	getTypeName(options) {
+		const { objectHandle } = serializeArguments(options);
+		const ret = allocateStringBuffer();
+		const errorCode = this.nativeAnoncreds.anoncreds_object_get_type_name(objectHandle, ret);
+		this.handleError(errorCode);
+		return handleReturnPointer(ret);
+	}
+	objectFree(options) {
+		this.nativeAnoncreds.anoncreds_object_free(options.objectHandle.handle);
+	}
+	convertCredentialList(credentials) {
+		const credentialEntries = credentials.map((value) => ({
+			credential: value.credential.handle,
+			timestamp: value.timestamp ?? -1,
+			rev_state: value.revocationState?.handle ?? 0
+		}));
+		return {
+			count: credentialEntries.length,
+			data: credentialEntries
+		};
+	}
+	convertCredentialProves(credentialsProve) {
+		const credentialProves = credentialsProve.map((value) => {
+			const { entryIndex: entry_idx, isPredicate: is_predicate, reveal, referent } = serializeArguments(value);
+			return {
+				entry_idx,
+				referent,
+				is_predicate,
+				reveal
+			};
+		});
+		return {
+			count: credentialProves.length,
+			data: credentialProves
+		};
+	}
+	convertSchemas(schemas) {
+		const schemaKeys = Object.keys(schemas);
+		const schemaIds = {
+			count: schemaKeys.length,
+			data: schemaKeys
+		};
+		const schemaValues = Object.values(schemas);
+		return {
+			schemaIds,
+			schemas: {
+				count: schemaValues.length,
+				data: schemaValues.map((o) => o.handle)
+			}
+		};
+	}
+	convertCredDefs(credentialDefinitions) {
+		const credentialDefinitionKeys = Object.keys(credentialDefinitions);
+		const credentialDefinitionIds = {
+			count: credentialDefinitionKeys.length,
+			data: credentialDefinitionKeys
+		};
+		const credentialDefinitionValues = Object.values(credentialDefinitions);
+		return {
+			credentialDefinitionIds,
+			credentialDefinitions: {
+				count: credentialDefinitionValues.length,
+				data: credentialDefinitionValues.map((o) => o.handle)
+			}
+		};
+	}
+	convertNonRevokedIntervalOverrides(nonRevokedIntervalOverrides) {
+		const nativeNonRevokedIntervalOverrides = nonRevokedIntervalOverrides?.map((value) => {
+			const { requestedFromTimestamp, revocationRegistryDefinitionId, overrideRevocationStatusListTimestamp } = serializeArguments(value);
+			return {
+				rev_reg_def_id: revocationRegistryDefinitionId,
+				requested_from_ts: requestedFromTimestamp,
+				override_rev_status_list_ts: overrideRevocationStatusListTimestamp
+			};
+		});
+		return {
+			count: nonRevokedIntervalOverrides?.length ?? 0,
+			data: nativeNonRevokedIntervalOverrides
+		};
+	}
+	convertAttributeNames(attributeRawValues) {
+		return {
+			count: Object.keys(attributeRawValues).length,
+			data: Object.keys(attributeRawValues)
+		};
+	}
+	convertAttributeRawValues(attributeRawValues) {
+		return {
+			count: Object.keys(attributeRawValues).length,
+			data: Object.values(attributeRawValues)
+		};
+	}
+	convertRevocationConfiguration(revocationConfiguration) {
+		if (revocationConfiguration) {
+			const { revocationRegistryDefinition, revocationRegistryDefinitionPrivate, revocationStatusList, registryIndex } = serializeArguments(revocationConfiguration);
+			return {
+				reg_def: revocationRegistryDefinition,
+				reg_def_private: revocationRegistryDefinitionPrivate,
+				status_list: revocationStatusList,
+				reg_idx: registryIndex
+			};
+		}
+	}
+};
+// src/index.ts
+const anoncredsNodeJS = new NodeJSAnoncreds();
+NativeAnoncreds.register(anoncredsNodeJS);
+export { anoncredsNodeJS };
+
+//# sourceMappingURL=index.mjs.map