@maxandriani/indy-besu-vdr-nodejs 0.0.0-stage → 0.1.0

package/indy_besu_vdr_wasm.js

@@ -0,0 +1,2696 @@
+
+let imports = {};
+imports['__wbindgen_placeholder__'] = module.exports;
+
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_externrefs.set(idx, obj);
+    return idx;
+}
+
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
+
+const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(state => state.dtor(state.a, state.b));
+
+function debugString(val) {
+    // primitive types
+    const type = typeof val;
+    if (type == 'number' || type == 'boolean' || val == null) {
+        return  `${val}`;
+    }
+    if (type == 'string') {
+        return `"${val}"`;
+    }
+    if (type == 'symbol') {
+        const description = val.description;
+        if (description == null) {
+            return 'Symbol';
+        } else {
+            return `Symbol(${description})`;
+        }
+    }
+    if (type == 'function') {
+        const name = val.name;
+        if (typeof name == 'string' && name.length > 0) {
+            return `Function(${name})`;
+        } else {
+            return 'Function';
+        }
+    }
+    // objects
+    if (Array.isArray(val)) {
+        const length = val.length;
+        let debug = '[';
+        if (length > 0) {
+            debug += debugString(val[0]);
+        }
+        for(let i = 1; i < length; i++) {
+            debug += ', ' + debugString(val[i]);
+        }
+        debug += ']';
+        return debug;
+    }
+    // Test for built-in
+    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+    let className;
+    if (builtInMatches && builtInMatches.length > 1) {
+        className = builtInMatches[1];
+    } else {
+        // Failed to match the standard '[object ClassName]'
+        return toString.call(val);
+    }
+    if (className == 'Object') {
+        // we're a user defined class or Object
+        // JSON.stringify avoids problems with cycles, and is generally much
+        // easier than looping through ownProperties of `val`.
+        try {
+            return 'Object(' + JSON.stringify(val) + ')';
+        } catch (_) {
+            return 'Object';
+        }
+    }
+    // errors
+    if (val instanceof Error) {
+        return `${val.name}: ${val.message}\n${val.stack}`;
+    }
+    // TODO we could test for more things here, like `Set`s and `Map`s.
+    return className;
+}
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
+}
+
+let cachedUint32ArrayMemory0 = null;
+function getUint32ArrayMemory0() {
+    if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
+        cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
+    }
+    return cachedUint32ArrayMemory0;
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+function makeMutClosure(arg0, arg1, dtor, f) {
+    const state = { a: arg0, b: arg1, cnt: 1, dtor };
+    const real = (...args) => {
+
+        // First up with a closure we increment the internal reference
+        // count. This ensures that the Rust closure environment won't
+        // be deallocated while we're invoking it.
+        state.cnt++;
+        const a = state.a;
+        state.a = 0;
+        try {
+            return f(a, state.b, ...args);
+        } finally {
+            state.a = a;
+            real._wbg_cb_unref();
+        }
+    };
+    real._wbg_cb_unref = () => {
+        if (--state.cnt === 0) {
+            state.dtor(state.a, state.b);
+            state.a = 0;
+            CLOSURE_DTORS.unregister(state);
+        }
+    };
+    CLOSURE_DTORS.register(real, state, state);
+    return real;
+}
+
+function passArray32ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 4, 4) >>> 0;
+    getUint32ArrayMemory0().set(arg, ptr / 4);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+
+function passArrayJsValueToWasm0(array, malloc) {
+    const ptr = malloc(array.length * 4, 4) >>> 0;
+    for (let i = 0; i < array.length; i++) {
+        const add = addToExternrefTable0(array[i]);
+        getDataViewMemory0().setUint32(ptr + 4 * i, add, true);
+    }
+    WASM_VECTOR_LEN = array.length;
+    return ptr;
+}
+
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_externrefs.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+function decodeText(ptr, len) {
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    }
+}
+
+let WASM_VECTOR_LEN = 0;
+
+function wasm_bindgen__convert__closures_____invoke__h711c3930aef5dacf(arg0, arg1) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h711c3930aef5dacf(arg0, arg1);
+}
+
+function wasm_bindgen__convert__closures_____invoke__hf4d0e3d1df92b3f7(arg0, arg1, arg2) {
+    wasm.wasm_bindgen__convert__closures_____invoke__hf4d0e3d1df92b3f7(arg0, arg1, arg2);
+}
+
+function wasm_bindgen__convert__closures_____invoke__h184b7a090947292c(arg0, arg1) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h184b7a090947292c(arg0, arg1);
+}
+
+function wasm_bindgen__convert__closures_____invoke__hbabdd7037359511e(arg0, arg1, arg2, arg3) {
+    wasm.wasm_bindgen__convert__closures_____invoke__hbabdd7037359511e(arg0, arg1, arg2, arg3);
+}
+
+const __wbindgen_enum_RequestCredentials = ["omit", "same-origin", "include"];
+
+const __wbindgen_enum_RequestMode = ["same-origin", "no-cors", "cors", "navigate"];
+
+const CredentialDefinitionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_credentialdefinition_free(ptr >>> 0, 1));
+
+const CredentialDefinitionRegistryFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_credentialdefinitionregistry_free(ptr >>> 0, 1));
+
+const DidResolverFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_didresolver_free(ptr >>> 0, 1));
+
+const EndorsementFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_endorsement_free(ptr >>> 0, 1));
+
+const EthrDidRegistryFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_ethrdidregistry_free(ptr >>> 0, 1));
+
+const EventQueryFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_eventquery_free(ptr >>> 0, 1));
+
+const IndyDidRegistryFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_indydidregistry_free(ptr >>> 0, 1));
+
+const LedgerClientFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_ledgerclient_free(ptr >>> 0, 1));
+
+const LegacyMappingRegistryFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_legacymappingregistry_free(ptr >>> 0, 1));
+
+const RevocationRegistryFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_revocationregistry_free(ptr >>> 0, 1));
+
+const RevocationRegistryDefinitionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_revocationregistrydefinition_free(ptr >>> 0, 1));
+
+const RevocationRegistryEntryFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_revocationregistryentry_free(ptr >>> 0, 1));
+
+const RevocationRegistryStatusListFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_revocationregistrystatuslist_free(ptr >>> 0, 1));
+
+const RoleControlFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_rolecontrol_free(ptr >>> 0, 1));
+
+const SchemaFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_schema_free(ptr >>> 0, 1));
+
+const SchemaRegistryFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_schemaregistry_free(ptr >>> 0, 1));
+
+const TransactionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_transaction_free(ptr >>> 0, 1));
+
+const TransactionEndorsingDataFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_transactionendorsingdata_free(ptr >>> 0, 1));
+
+const ValidatorControlFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_validatorcontrol_free(ptr >>> 0, 1));
+
+class CredentialDefinition {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(CredentialDefinition.prototype);
+        obj.__wbg_ptr = ptr;
+        CredentialDefinitionFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        CredentialDefinitionFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_credentialdefinition_free(ptr, 0);
+    }
+    /**
+     * @param {string} string
+     * @returns {CredentialDefinition}
+     */
+    static fromString(string) {
+        const ptr0 = passStringToWasm0(string, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.credentialdefinition_fromString(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return CredentialDefinition.__wrap(ret[0]);
+    }
+    /**
+     * @param {string} issuer_id
+     * @param {string} schema_id
+     * @param {string} tag
+     * @param {Record<string, unknown>} value
+     */
+    constructor(issuer_id, schema_id, tag, value) {
+        const ptr0 = passStringToWasm0(issuer_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(schema_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(tag, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.credentialdefinition_new(ptr0, len0, ptr1, len1, ptr2, len2, value);
+        this.__wbg_ptr = ret >>> 0;
+        CredentialDefinitionFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {string}
+     */
+    getId() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.credentialdefinition_getId(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {CredentialDefinitionData}
+     */
+    asValue() {
+        const ret = wasm.credentialdefinition_asValue(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {string}
+     */
+    toString() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.credentialdefinition_toString(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) CredentialDefinition.prototype[Symbol.dispose] = CredentialDefinition.prototype.free;
+exports.CredentialDefinition = CredentialDefinition;
+
+class CredentialDefinitionRegistry {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        CredentialDefinitionRegistryFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_credentialdefinitionregistry_free(ptr, 0);
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {string} id
+     * @returns {Promise<CredentialDefinition>}
+     */
+    static resolveCredentialDefinition(client, id) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.credentialdefinitionregistry_resolveCredentialDefinition(client.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {Uint8Array} bytes
+     * @returns {CredentialDefinitionRecord}
+     */
+    static parseResolveCredentialDefinitionResult(client, bytes) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.credentialdefinitionregistry_parseResolveCredentialDefinitionResult(client.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {string} from
+     * @param {CredentialDefinition} cred_def
+     * @returns {Promise<Transaction>}
+     */
+    static buildCreateCredentialDefinitionTransaction(client, from, cred_def) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passStringToWasm0(from, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        _assertClass(cred_def, CredentialDefinition);
+        const ret = wasm.credentialdefinitionregistry_buildCreateCredentialDefinitionTransaction(client.__wbg_ptr, ptr0, len0, cred_def.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {string} id
+     * @returns {Promise<Transaction>}
+     */
+    static buildResolveCredentialDefinitionTransaction(client, id) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.credentialdefinitionregistry_buildResolveCredentialDefinitionTransaction(client.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {CredentialDefinition} cred_def
+     * @returns {Promise<TransactionEndorsingData>}
+     */
+    static buildCreateCredentialDefinitionEndorsingData(client, cred_def) {
+        _assertClass(client, LedgerClient);
+        _assertClass(cred_def, CredentialDefinition);
+        const ret = wasm.credentialdefinitionregistry_buildCreateCredentialDefinitionEndorsingData(client.__wbg_ptr, cred_def.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) CredentialDefinitionRegistry.prototype[Symbol.dispose] = CredentialDefinitionRegistry.prototype.free;
+exports.CredentialDefinitionRegistry = CredentialDefinitionRegistry;
+
+class DidResolver {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DidResolverFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_didresolver_free(ptr, 0);
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {string} did
+     * @param {DidResolutionOptions | undefined | null} options
+     * @returns {Promise<DidDocumentWithMeta>}
+     */
+    static resolveDid(client, did, options) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passStringToWasm0(did, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.didresolver_resolveDid(client.__wbg_ptr, ptr0, len0, options);
+        return ret;
+    }
+}
+if (Symbol.dispose) DidResolver.prototype[Symbol.dispose] = DidResolver.prototype.free;
+exports.DidResolver = DidResolver;
+
+class Endorsement {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        EndorsementFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_endorsement_free(ptr, 0);
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {string} from
+     * @param {TransactionEndorsingData} endorsing_data
+     * @returns {Promise<Transaction>}
+     */
+    static buildEndorsementTransaction(client, from, endorsing_data) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passStringToWasm0(from, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        _assertClass(endorsing_data, TransactionEndorsingData);
+        const ret = wasm.endorsement_buildEndorsementTransaction(client.__wbg_ptr, ptr0, len0, endorsing_data.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) Endorsement.prototype[Symbol.dispose] = Endorsement.prototype.free;
+exports.Endorsement = Endorsement;
+
+class EthrDidRegistry {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        EthrDidRegistryFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_ethrdidregistry_free(ptr, 0);
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {Uint8Array} bytes
+     * @returns {string}
+     */
+    static parseDidOwnerResult(client, bytes) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            _assertClass(client, LedgerClient);
+            const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.ethrdidregistry_parseDidOwnerResult(client.__wbg_ptr, ptr0, len0);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {Uint8Array} bytes
+     * @returns {bigint}
+     */
+    static parseDidChangedResult(client, bytes) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ethrdidregistry_parseDidChangedResult(client.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return BigInt.asUintN(64, ret[0]);
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {EventLog} log
+     * @returns {DidEvent}
+     */
+    static parseDidEventResponse(client, log) {
+        _assertClass(client, LedgerClient);
+        const ret = wasm.ethrdidregistry_parseDidEventResponse(client.__wbg_ptr, log);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {string} did
+     * @param {bigint | null} [from_block]
+     * @param {bigint | null} [to_block]
+     * @returns {Promise<EventQuery>}
+     */
+    static buildGetDidEventsQuery(client, did, from_block, to_block) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passStringToWasm0(did, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ethrdidregistry_buildGetDidEventsQuery(client.__wbg_ptr, ptr0, len0, !isLikeNone(from_block), isLikeNone(from_block) ? BigInt(0) : from_block, !isLikeNone(to_block), isLikeNone(to_block) ? BigInt(0) : to_block);
+        return ret;
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {string} did
+     * @returns {Promise<Transaction>}
+     */
+    static buildGetDidOwnerTransaction(client, did) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passStringToWasm0(did, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ethrdidregistry_buildGetDidOwnerTransaction(client.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {string} did
+     * @returns {Promise<Transaction>}
+     */
+    static buildGetDidChangedTransaction(client, did) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passStringToWasm0(did, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ethrdidregistry_buildGetDidChangedTransaction(client.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {string} sender
+     * @param {string} did
+     * @param {string} delegate_type
+     * @param {string} delegate
+     * @param {bigint} validity
+     * @returns {Promise<Transaction>}
+     */
+    static buildDidAddDelegateTransaction(client, sender, did, delegate_type, delegate, validity) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passStringToWasm0(sender, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(did, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(delegate_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(delegate, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ret = wasm.ethrdidregistry_buildDidAddDelegateTransaction(client.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, validity);
+        return ret;
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {string} sender
+     * @param {string} did
+     * @param {string} new_owner
+     * @returns {Promise<Transaction>}
+     */
+    static buildDidChangeOwnerTransaction(client, sender, did, new_owner) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passStringToWasm0(sender, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(did, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(new_owner, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.ethrdidregistry_buildDidChangeOwnerTransaction(client.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+        return ret;
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {string} sender
+     * @param {string} did
+     * @param {DidDocAttribute} attribute
+     * @param {bigint} validity
+     * @returns {Promise<Transaction>}
+     */
+    static buildDidSetAttributeTransaction(client, sender, did, attribute, validity) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passStringToWasm0(sender, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(did, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.ethrdidregistry_buildDidSetAttributeTransaction(client.__wbg_ptr, ptr0, len0, ptr1, len1, attribute, validity);
+        return ret;
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {string} identity
+     * @returns {Promise<Transaction>}
+     */
+    static buildGetIdentityNonceTransaction(client, identity) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passStringToWasm0(identity, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ethrdidregistry_buildGetIdentityNonceTransaction(client.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {string} did
+     * @param {string} delegate_type
+     * @param {string} delegate
+     * @param {bigint} validity
+     * @returns {Promise<TransactionEndorsingData>}
+     */
+    static buildDidAddDelegateEndorsingData(client, did, delegate_type, delegate, validity) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passStringToWasm0(did, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(delegate_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(delegate, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.ethrdidregistry_buildDidAddDelegateEndorsingData(client.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, validity);
+        return ret;
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {string} did
+     * @param {string} new_owner
+     * @returns {Promise<TransactionEndorsingData>}
+     */
+    static buildDidChangeOwnerEndorsingData(client, did, new_owner) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passStringToWasm0(did, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(new_owner, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.ethrdidregistry_buildDidChangeOwnerEndorsingData(client.__wbg_ptr, ptr0, len0, ptr1, len1);
+        return ret;
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {string} sender
+     * @param {string} did
+     * @param {string} delegate_type
+     * @param {string} delegate
+     * @returns {Promise<Transaction>}
+     */
+    static buildDidRevokeDelegateTransaction(client, sender, did, delegate_type, delegate) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passStringToWasm0(sender, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(did, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(delegate_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(delegate, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ret = wasm.ethrdidregistry_buildDidRevokeDelegateTransaction(client.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+        return ret;
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {string} sender
+     * @param {string} did
+     * @param {DidDocAttribute} attribute
+     * @returns {Promise<Transaction>}
+     */
+    static buildDidRevokeAttributeTransaction(client, sender, did, attribute) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passStringToWasm0(sender, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(did, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.ethrdidregistry_buildDidRevokeAttributeTransaction(client.__wbg_ptr, ptr0, len0, ptr1, len1, attribute);
+        return ret;
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {string} did
+     * @param {DidDocAttribute} attribute
+     * @param {bigint} validity
+     * @returns {Promise<TransactionEndorsingData>}
+     */
+    static buildDidSetAttributeEndorsingData(client, did, attribute, validity) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passStringToWasm0(did, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ethrdidregistry_buildDidSetAttributeEndorsingData(client.__wbg_ptr, ptr0, len0, attribute, validity);
+        return ret;
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {EventLog} log
+     * @returns {DidOwnerChanged}
+     */
+    static parseDidOwnerChangedEventResponse(client, log) {
+        _assertClass(client, LedgerClient);
+        const ret = wasm.ethrdidregistry_parseDidOwnerChangedEventResponse(client.__wbg_ptr, log);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {string} did
+     * @param {string} delegate_type
+     * @param {string} delegate
+     * @returns {Promise<TransactionEndorsingData>}
+     */
+    static buildDidRevokeDelegateEndorsingData(client, did, delegate_type, delegate) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passStringToWasm0(did, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(delegate_type, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(delegate, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.ethrdidregistry_buildDidRevokeDelegateEndorsingData(client.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+        return ret;
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {string} did
+     * @param {DidDocAttribute} attribute
+     * @returns {Promise<TransactionEndorsingData>}
+     */
+    static buildDidRevokeAttributeEndorsingData(client, did, attribute) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passStringToWasm0(did, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ethrdidregistry_buildDidRevokeAttributeEndorsingData(client.__wbg_ptr, ptr0, len0, attribute);
+        return ret;
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {EventLog} log
+     * @returns {DidDelegateChanged}
+     */
+    static parseDidDelegateChangedEventResponse(client, log) {
+        _assertClass(client, LedgerClient);
+        const ret = wasm.ethrdidregistry_parseDidDelegateChangedEventResponse(client.__wbg_ptr, log);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {EventLog} log
+     * @returns {DidAttributeChanged}
+     */
+    static parseDidAttributeChangedEventResponse(client, log) {
+        _assertClass(client, LedgerClient);
+        const ret = wasm.ethrdidregistry_parseDidAttributeChangedEventResponse(client.__wbg_ptr, log);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+}
+if (Symbol.dispose) EthrDidRegistry.prototype[Symbol.dispose] = EthrDidRegistry.prototype.free;
+exports.EthrDidRegistry = EthrDidRegistry;
+
+class EventQuery {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(EventQuery.prototype);
+        obj.__wbg_ptr = ptr;
+        EventQueryFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        EventQueryFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_eventquery_free(ptr, 0);
+    }
+}
+if (Symbol.dispose) EventQuery.prototype[Symbol.dispose] = EventQuery.prototype.free;
+exports.EventQuery = EventQuery;
+
+class IndyDidRegistry {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        IndyDidRegistryFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_indydidregistry_free(ptr, 0);
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {Uint8Array} bytes
+     * @returns {DidRecord}
+     */
+    static parseResolveDidResult(client, bytes) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.indydidregistry_parseResolveDidResult(client.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {string} from
+     * @param {string} did
+     * @param {DidDocument} did_doc
+     * @returns {Promise<Transaction>}
+     */
+    static buildCreateDidTransaction(client, from, did, did_doc) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passStringToWasm0(from, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(did, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.indydidregistry_buildCreateDidTransaction(client.__wbg_ptr, ptr0, len0, ptr1, len1, did_doc);
+        return ret;
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {string} from
+     * @param {string} did
+     * @param {DidDocument} did_doc
+     * @returns {Promise<Transaction>}
+     */
+    static buildUpdateDidTransaction(client, from, did, did_doc) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passStringToWasm0(from, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(did, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.indydidregistry_buildUpdateDidTransaction(client.__wbg_ptr, ptr0, len0, ptr1, len1, did_doc);
+        return ret;
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {string} did
+     * @returns {Promise<Transaction>}
+     */
+    static buildResolveDidTransaction(client, did) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passStringToWasm0(did, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.indydidregistry_buildResolveDidTransaction(client.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {string} did
+     * @param {DidDocument} did_doc
+     * @returns {Promise<TransactionEndorsingData>}
+     */
+    static buildCreateDidEndorsingData(client, did, did_doc) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passStringToWasm0(did, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.indydidregistry_buildCreateDidEndorsingData(client.__wbg_ptr, ptr0, len0, did_doc);
+        return ret;
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {string} did
+     * @param {DidDocument} did_doc
+     * @returns {Promise<TransactionEndorsingData>}
+     */
+    static buildUpdateDidEndorsingData(client, did, did_doc) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passStringToWasm0(did, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.indydidregistry_buildUpdateDidEndorsingData(client.__wbg_ptr, ptr0, len0, did_doc);
+        return ret;
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {string} from
+     * @param {string} did
+     * @returns {Promise<Transaction>}
+     */
+    static buildDeactivateDidTransaction(client, from, did) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passStringToWasm0(from, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(did, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.indydidregistry_buildDeactivateDidTransaction(client.__wbg_ptr, ptr0, len0, ptr1, len1);
+        return ret;
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {string} did
+     * @returns {Promise<TransactionEndorsingData>}
+     */
+    static buildDeactivateDidEndorsingData(client, did) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passStringToWasm0(did, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.indydidregistry_buildDeactivateDidEndorsingData(client.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+}
+if (Symbol.dispose) IndyDidRegistry.prototype[Symbol.dispose] = IndyDidRegistry.prototype.free;
+exports.IndyDidRegistry = IndyDidRegistry;
+
+class LedgerClient {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        LedgerClientFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_ledgerclient_free(ptr, 0);
+    }
+    /**
+     * @param {Uint8Array} hash
+     * @returns {Promise<string>}
+     */
+    getReceipt(hash) {
+        const ptr0 = passArray8ToWasm0(hash, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.ledgerclient_getReceipt(this.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @param {EventQuery} query
+     * @returns {Promise<EventLog[]>}
+     */
+    queryEvents(query) {
+        _assertClass(query, EventQuery);
+        const ret = wasm.ledgerclient_queryEvents(this.__wbg_ptr, query.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {Transaction} transaction
+     * @returns {Promise<number[]>}
+     */
+    submitTransaction(transaction) {
+        _assertClass(transaction, Transaction);
+        const ret = wasm.ledgerclient_submitTransaction(this.__wbg_ptr, transaction.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {number} chain_id
+     * @param {string} node_address
+     * @param {ContractConfig[]} contract_configs
+     * @param {string | null | undefined} network
+     * @param {QuorumConfig | undefined | null} quorum_config
+     */
+    constructor(chain_id, node_address, contract_configs, network, quorum_config) {
+        const ptr0 = passStringToWasm0(node_address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        var ptr1 = isLikeNone(network) ? 0 : passStringToWasm0(network, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        const ret = wasm.ledgerclient_new(chain_id, ptr0, len0, contract_configs, ptr1, len1, quorum_config);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        LedgerClientFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {Promise<PingStatus>}
+     */
+    ping() {
+        const ret = wasm.ledgerclient_ping(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) LedgerClient.prototype[Symbol.dispose] = LedgerClient.prototype.free;
+exports.LedgerClient = LedgerClient;
+
+class LegacyMappingRegistry {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        LegacyMappingRegistryFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_legacymappingregistry_free(ptr, 0);
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {Uint8Array} bytes
+     * @returns {string}
+     */
+    static parseDidMappingResult(client, bytes) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            _assertClass(client, LedgerClient);
+            const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.legacymappingregistry_parseDidMappingResult(client.__wbg_ptr, ptr0, len0);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {Uint8Array} bytes
+     * @returns {string}
+     */
+    static parseResourceMappingResult(client, bytes) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            _assertClass(client, LedgerClient);
+            const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.legacymappingregistry_parseResourceMappingResult(client.__wbg_ptr, ptr0, len0);
+            var ptr2 = ret[0];
+            var len2 = ret[1];
+            if (ret[3]) {
+                ptr2 = 0; len2 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred3_0 = ptr2;
+            deferred3_1 = len2;
+            return getStringFromWasm0(ptr2, len2);
+        } finally {
+            wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+        }
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {string} legacy_identifier
+     * @returns {Promise<Transaction>}
+     */
+    static buildGetDidMappingTransaction(client, legacy_identifier) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passStringToWasm0(legacy_identifier, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.legacymappingregistry_buildGetDidMappingTransaction(client.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {string} from
+     * @param {string} did
+     * @param {string} legacy_did
+     * @param {string} legacy_verkey
+     * @param {Uint8Array} ed25519_signature
+     * @returns {Promise<Transaction>}
+     */
+    static buildCreateDidMappingTransaction(client, from, did, legacy_did, legacy_verkey, ed25519_signature) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passStringToWasm0(from, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(did, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(legacy_did, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(legacy_verkey, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ptr4 = passArray8ToWasm0(ed25519_signature, wasm.__wbindgen_malloc);
+        const len4 = WASM_VECTOR_LEN;
+        const ret = wasm.legacymappingregistry_buildCreateDidMappingTransaction(client.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4);
+        return ret;
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {string} legacy_identifier
+     * @returns {Promise<Transaction>}
+     */
+    static buildGetResourceMappingTransaction(client, legacy_identifier) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passStringToWasm0(legacy_identifier, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.legacymappingregistry_buildGetResourceMappingTransaction(client.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {string} did
+     * @param {string} legacy_did
+     * @param {string} legacy_verkey
+     * @param {Uint8Array} ed25519_signature
+     * @returns {Promise<TransactionEndorsingData>}
+     */
+    static buildCreateDidMappingEndorsingData(client, did, legacy_did, legacy_verkey, ed25519_signature) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passStringToWasm0(did, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(legacy_did, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(legacy_verkey, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passArray8ToWasm0(ed25519_signature, wasm.__wbindgen_malloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ret = wasm.legacymappingregistry_buildCreateDidMappingEndorsingData(client.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+        return ret;
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {string} from
+     * @param {string} did
+     * @param {string} legacy_issuer_identifier
+     * @param {string} legacy_identifier
+     * @param {string} new_identifier
+     * @returns {Promise<Transaction>}
+     */
+    static buildCreateResourceMappingTransaction(client, from, did, legacy_issuer_identifier, legacy_identifier, new_identifier) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passStringToWasm0(from, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(did, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(legacy_issuer_identifier, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(legacy_identifier, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ptr4 = passStringToWasm0(new_identifier, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len4 = WASM_VECTOR_LEN;
+        const ret = wasm.legacymappingregistry_buildCreateResourceMappingTransaction(client.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4);
+        return ret;
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {string} did
+     * @param {string} legacy_issuer_identifier
+     * @param {string} legacy_identifier
+     * @param {string} new_identifier
+     * @returns {Promise<TransactionEndorsingData>}
+     */
+    static buildCreateResourceMappingEndorsingData(client, did, legacy_issuer_identifier, legacy_identifier, new_identifier) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passStringToWasm0(did, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(legacy_issuer_identifier, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(legacy_identifier, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passStringToWasm0(new_identifier, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ret = wasm.legacymappingregistry_buildCreateResourceMappingEndorsingData(client.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+        return ret;
+    }
+}
+if (Symbol.dispose) LegacyMappingRegistry.prototype[Symbol.dispose] = LegacyMappingRegistry.prototype.free;
+exports.LegacyMappingRegistry = LegacyMappingRegistry;
+
+class RevocationRegistry {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RevocationRegistryFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_revocationregistry_free(ptr, 0);
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {string} id
+     * @returns {Promise<RevocationRegistryDefinition>}
+     */
+    static resolveRevocationRegistryDefinition(client, id) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.revocationregistry_resolveRevocationRegistryDefinition(client.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {string} id
+     * @param {bigint} to_timestamp
+     * @returns {Promise<RevocationRegistryStatusList>}
+     */
+    static resolveRevocationRegistryStatusList(client, id, to_timestamp) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.revocationregistry_resolveRevocationRegistryStatusList(client.__wbg_ptr, ptr0, len0, to_timestamp);
+        return ret;
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {string} from
+     * @param {RevocationRegistryEntry} rev_reg_entry
+     * @returns {Promise<Transaction>}
+     */
+    static buildCreateRevocationRegistryEntryTransaction(client, from, rev_reg_entry) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passStringToWasm0(from, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        _assertClass(rev_reg_entry, RevocationRegistryEntry);
+        const ret = wasm.revocationregistry_buildCreateRevocationRegistryEntryTransaction(client.__wbg_ptr, ptr0, len0, rev_reg_entry.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {Uint8Array} bytes
+     * @returns {RevocationRegistryDefinitionRecord}
+     */
+    static parseResolveRevocationRegistryDefinitionResult(client, bytes) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.revocationregistry_parseResolveRevocationRegistryDefinitionResult(client.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {RevocationRegistryEntry} rev_reg_entry
+     * @returns {Promise<TransactionEndorsingData>}
+     */
+    static buildCreateRevocationRegistryEntryEndorsingData(client, rev_reg_entry) {
+        _assertClass(client, LedgerClient);
+        _assertClass(rev_reg_entry, RevocationRegistryEntry);
+        const ret = wasm.revocationregistry_buildCreateRevocationRegistryEntryEndorsingData(client.__wbg_ptr, rev_reg_entry.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {string} from
+     * @param {RevocationRegistryDefinition} rev_reg_def
+     * @returns {Promise<Transaction>}
+     */
+    static buildCreateRevocationRegistryDefinitionTransaction(client, from, rev_reg_def) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passStringToWasm0(from, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        _assertClass(rev_reg_def, RevocationRegistryDefinition);
+        const ret = wasm.revocationregistry_buildCreateRevocationRegistryDefinitionTransaction(client.__wbg_ptr, ptr0, len0, rev_reg_def.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {string} id
+     * @param {Uint8Array} revocation_registry_status_list
+     * @param {string} accumulator
+     * @returns {Promise<RevocationRegistryEntry>}
+     */
+    static buildLatestRevocationRegistryEntryFromStatusList(client, id, revocation_registry_status_list, accumulator) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passArray8ToWasm0(revocation_registry_status_list, wasm.__wbindgen_malloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(accumulator, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.revocationregistry_buildLatestRevocationRegistryEntryFromStatusList(client.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+        return ret;
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {string} id
+     * @returns {Promise<Transaction>}
+     */
+    static buildResolveRevocationRegistryDefinitionTransaction(client, id) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.revocationregistry_buildResolveRevocationRegistryDefinitionTransaction(client.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {RevocationRegistryDefinition} rev_reg_def
+     * @returns {Promise<TransactionEndorsingData>}
+     */
+    static buildCreateRevocationRegistryDefinitionEndorsingData(client, rev_reg_def) {
+        _assertClass(client, LedgerClient);
+        _assertClass(rev_reg_def, RevocationRegistryDefinition);
+        const ret = wasm.revocationregistry_buildCreateRevocationRegistryDefinitionEndorsingData(client.__wbg_ptr, rev_reg_def.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) RevocationRegistry.prototype[Symbol.dispose] = RevocationRegistry.prototype.free;
+exports.RevocationRegistry = RevocationRegistry;
+
+class RevocationRegistryDefinition {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(RevocationRegistryDefinition.prototype);
+        obj.__wbg_ptr = ptr;
+        RevocationRegistryDefinitionFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RevocationRegistryDefinitionFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_revocationregistrydefinition_free(ptr, 0);
+    }
+    /**
+     * @param {string} string
+     * @returns {RevocationRegistryDefinition}
+     */
+    static fromString(string) {
+        const ptr0 = passStringToWasm0(string, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.revocationregistrydefinition_fromString(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return RevocationRegistryDefinition.__wrap(ret[0]);
+    }
+    /**
+     * @param {string} issuer_id
+     * @param {string} cred_def_id
+     * @param {string} tag
+     * @param {RevocationRegistryDefinitionValue} value
+     */
+    constructor(issuer_id, cred_def_id, tag, value) {
+        const ptr0 = passStringToWasm0(issuer_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(cred_def_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(tag, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.revocationregistrydefinition_new(ptr0, len0, ptr1, len1, ptr2, len2, value);
+        this.__wbg_ptr = ret >>> 0;
+        RevocationRegistryDefinitionFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {string}
+     */
+    getId() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.revocationregistrydefinition_getId(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {RevocationRegistryDefinitionData}
+     */
+    asValue() {
+        const ret = wasm.revocationregistrydefinition_asValue(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {string}
+     */
+    toString() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.revocationregistrydefinition_toString(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) RevocationRegistryDefinition.prototype[Symbol.dispose] = RevocationRegistryDefinition.prototype.free;
+exports.RevocationRegistryDefinition = RevocationRegistryDefinition;
+
+class RevocationRegistryEntry {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(RevocationRegistryEntry.prototype);
+        obj.__wbg_ptr = ptr;
+        RevocationRegistryEntryFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RevocationRegistryEntryFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_revocationregistryentry_free(ptr, 0);
+    }
+    /**
+     * @param {string} issuer_id
+     * @param {string} rev_reg_def_id
+     * @param {string} current_accumulator
+     * @param {string | null} [prev_accumulator]
+     * @param {Uint32Array | null} [issued]
+     * @param {Uint32Array | null} [revoked]
+     */
+    constructor(issuer_id, rev_reg_def_id, current_accumulator, prev_accumulator, issued, revoked) {
+        const ptr0 = passStringToWasm0(issuer_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(rev_reg_def_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(current_accumulator, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        var ptr3 = isLikeNone(prev_accumulator) ? 0 : passStringToWasm0(prev_accumulator, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len3 = WASM_VECTOR_LEN;
+        var ptr4 = isLikeNone(issued) ? 0 : passArray32ToWasm0(issued, wasm.__wbindgen_malloc);
+        var len4 = WASM_VECTOR_LEN;
+        var ptr5 = isLikeNone(revoked) ? 0 : passArray32ToWasm0(revoked, wasm.__wbindgen_malloc);
+        var len5 = WASM_VECTOR_LEN;
+        const ret = wasm.revocationregistryentry_new(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3, ptr4, len4, ptr5, len5);
+        this.__wbg_ptr = ret >>> 0;
+        RevocationRegistryEntryFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {RevocationRegistryEntryValue}
+     */
+    asValue() {
+        const ret = wasm.revocationregistryentry_asValue(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {string}
+     */
+    toString() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.revocationregistryentry_toString(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) RevocationRegistryEntry.prototype[Symbol.dispose] = RevocationRegistryEntry.prototype.free;
+exports.RevocationRegistryEntry = RevocationRegistryEntry;
+
+class RevocationRegistryStatusList {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(RevocationRegistryStatusList.prototype);
+        obj.__wbg_ptr = ptr;
+        RevocationRegistryStatusListFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RevocationRegistryStatusListFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_revocationregistrystatuslist_free(ptr, 0);
+    }
+    /**
+     * @returns {RevocationStatusListData}
+     */
+    asValue() {
+        const ret = wasm.revocationregistrystatuslist_asValue(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {string}
+     */
+    toString() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.revocationregistrystatuslist_toString(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) RevocationRegistryStatusList.prototype[Symbol.dispose] = RevocationRegistryStatusList.prototype.free;
+exports.RevocationRegistryStatusList = RevocationRegistryStatusList;
+
+class RoleControl {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        RoleControlFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_rolecontrol_free(ptr, 0);
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {Uint8Array} bytes
+     * @returns {number}
+     */
+    static parseGetRoleResult(client, bytes) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.rolecontrol_parseGetRoleResult(client.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0];
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {Uint8Array} bytes
+     * @returns {boolean}
+     */
+    static parseHasRoleResult(client, bytes) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.rolecontrol_parseHasRoleResult(client.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] !== 0;
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {string} account
+     * @returns {Promise<Transaction>}
+     */
+    static buildGetRoleTransaction(client, account) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passStringToWasm0(account, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.rolecontrol_buildGetRoleTransaction(client.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {number} role
+     * @param {string} account
+     * @returns {Promise<Transaction>}
+     */
+    static buildHasRoleTransaction(client, role, account) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passStringToWasm0(account, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.rolecontrol_buildHasRoleTransaction(client.__wbg_ptr, role, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {string} from
+     * @param {number} role
+     * @param {string} account
+     * @returns {Promise<Transaction>}
+     */
+    static buildAssignRoleTransaction(client, from, role, account) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passStringToWasm0(from, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(account, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.rolecontrol_buildAssignRoleTransaction(client.__wbg_ptr, ptr0, len0, role, ptr1, len1);
+        return ret;
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {string} from
+     * @param {number} role
+     * @param {string} account
+     * @returns {Promise<Transaction>}
+     */
+    static buildRevokeRoleTransaction(client, from, role, account) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passStringToWasm0(from, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(account, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.rolecontrol_buildRevokeRoleTransaction(client.__wbg_ptr, ptr0, len0, role, ptr1, len1);
+        return ret;
+    }
+}
+if (Symbol.dispose) RoleControl.prototype[Symbol.dispose] = RoleControl.prototype.free;
+exports.RoleControl = RoleControl;
+
+class Schema {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Schema.prototype);
+        obj.__wbg_ptr = ptr;
+        SchemaFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SchemaFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_schema_free(ptr, 0);
+    }
+    /**
+     * @param {string} string
+     * @returns {Schema}
+     */
+    static fromString(string) {
+        const ptr0 = passStringToWasm0(string, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.schema_fromString(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return Schema.__wrap(ret[0]);
+    }
+    /**
+     * @param {string} issuer_id
+     * @param {string} name
+     * @param {string} version
+     * @param {string[]} attr_names
+     */
+    constructor(issuer_id, name, version, attr_names) {
+        const ptr0 = passStringToWasm0(issuer_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(version, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ptr3 = passArrayJsValueToWasm0(attr_names, wasm.__wbindgen_malloc);
+        const len3 = WASM_VECTOR_LEN;
+        const ret = wasm.schema_new(ptr0, len0, ptr1, len1, ptr2, len2, ptr3, len3);
+        this.__wbg_ptr = ret >>> 0;
+        SchemaFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {string}
+     */
+    getId() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.schema_getId(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {SchemaData}
+     */
+    asValue() {
+        const ret = wasm.schema_asValue(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {string}
+     */
+    toString() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.schema_toString(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) Schema.prototype[Symbol.dispose] = Schema.prototype.free;
+exports.Schema = Schema;
+
+class SchemaRegistry {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SchemaRegistryFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_schemaregistry_free(ptr, 0);
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {string} id
+     * @returns {Promise<Schema>}
+     */
+    static resolveSchema(client, id) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.schemaregistry_resolveSchema(client.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {Uint8Array} bytes
+     * @returns {SchemaRecord}
+     */
+    static parseResolveSchemaResult(client, bytes) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.schemaregistry_parseResolveSchemaResult(client.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {string} from
+     * @param {Schema} schema
+     * @returns {Promise<Transaction>}
+     */
+    static buildCreateSchemaTransaction(client, from, schema) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passStringToWasm0(from, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        _assertClass(schema, Schema);
+        const ret = wasm.schemaregistry_buildCreateSchemaTransaction(client.__wbg_ptr, ptr0, len0, schema.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {string} id
+     * @returns {Promise<Transaction>}
+     */
+    static buildResolveSchemaTransaction(client, id) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.schemaregistry_buildResolveSchemaTransaction(client.__wbg_ptr, ptr0, len0);
+        return ret;
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {Schema} schema
+     * @returns {Promise<TransactionEndorsingData>}
+     */
+    static buildCreateSchemaEndorsingData(client, schema) {
+        _assertClass(client, LedgerClient);
+        _assertClass(schema, Schema);
+        const ret = wasm.schemaregistry_buildCreateSchemaEndorsingData(client.__wbg_ptr, schema.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) SchemaRegistry.prototype[Symbol.dispose] = SchemaRegistry.prototype.free;
+exports.SchemaRegistry = SchemaRegistry;
+
+class Transaction {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Transaction.prototype);
+        obj.__wbg_ptr = ptr;
+        TransactionFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TransactionFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_transaction_free(ptr, 0);
+    }
+    /**
+     * @param {SignatureData} signature_data
+     */
+    setSignature(signature_data) {
+        const ret = wasm.transaction_setSignature(this.__wbg_ptr, signature_data);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    getSigningBytes() {
+        const ret = wasm.transaction_getSigningBytes(this.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+    /**
+     * @returns {string}
+     */
+    to() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.transaction_to(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) Transaction.prototype[Symbol.dispose] = Transaction.prototype.free;
+exports.Transaction = Transaction;
+
+class TransactionEndorsingData {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(TransactionEndorsingData.prototype);
+        obj.__wbg_ptr = ptr;
+        TransactionEndorsingDataFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TransactionEndorsingDataFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_transactionendorsingdata_free(ptr, 0);
+    }
+    /**
+     * @param {SignatureData} signature_data
+     */
+    setSignature(signature_data) {
+        const ret = wasm.transactionendorsingdata_setSignature(this.__wbg_ptr, signature_data);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    getSigningBytes() {
+        const ret = wasm.transactionendorsingdata_getSigningBytes(this.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+}
+if (Symbol.dispose) TransactionEndorsingData.prototype[Symbol.dispose] = TransactionEndorsingData.prototype.free;
+exports.TransactionEndorsingData = TransactionEndorsingData;
+
+class ValidatorControl {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ValidatorControlFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_validatorcontrol_free(ptr, 0);
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {Uint8Array} bytes
+     * @returns {AddressString[]}
+     */
+    static parseGetValidatorsResult(client, bytes) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.validatorcontrol_parseGetValidatorsResult(client.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {string} from
+     * @param {string} validator_address
+     * @returns {Promise<Transaction>}
+     */
+    static buildAddValidatorTransaction(client, from, validator_address) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passStringToWasm0(from, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(validator_address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.validatorcontrol_buildAddValidatorTransaction(client.__wbg_ptr, ptr0, len0, ptr1, len1);
+        return ret;
+    }
+    /**
+     * @param {LedgerClient} client
+     * @returns {Promise<Transaction>}
+     */
+    static buildGetValidatorsTransaction(client) {
+        _assertClass(client, LedgerClient);
+        const ret = wasm.validatorcontrol_buildGetValidatorsTransaction(client.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {LedgerClient} client
+     * @param {string} from
+     * @param {string} validator_address
+     * @returns {Promise<Transaction>}
+     */
+    static buildRemoveValidatorTransaction(client, from, validator_address) {
+        _assertClass(client, LedgerClient);
+        const ptr0 = passStringToWasm0(from, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(validator_address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.validatorcontrol_buildRemoveValidatorTransaction(client.__wbg_ptr, ptr0, len0, ptr1, len1);
+        return ret;
+    }
+}
+if (Symbol.dispose) ValidatorControl.prototype[Symbol.dispose] = ValidatorControl.prototype.free;
+exports.ValidatorControl = ValidatorControl;
+
+exports.__wbg_Error_52673b7de5a0ca89 = function(arg0, arg1) {
+    const ret = Error(getStringFromWasm0(arg0, arg1));
+    return ret;
+};
+
+exports.__wbg___wbindgen_bigint_get_as_i64_6e32f5e6aff02e1d = function(arg0, arg1) {
+    const v = arg1;
+    const ret = typeof(v) === 'bigint' ? v : undefined;
+    getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+};
+
+exports.__wbg___wbindgen_boolean_get_dea25b33882b895b = function(arg0) {
+    const v = arg0;
+    const ret = typeof(v) === 'boolean' ? v : undefined;
+    return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
+};
+
+exports.__wbg___wbindgen_debug_string_adfb662ae34724b6 = function(arg0, arg1) {
+    const ret = debugString(arg1);
+    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+};
+
+exports.__wbg___wbindgen_in_0d3e1e8f0c669317 = function(arg0, arg1) {
+    const ret = arg0 in arg1;
+    return ret;
+};
+
+exports.__wbg___wbindgen_is_bigint_0e1a2e3f55cfae27 = function(arg0) {
+    const ret = typeof(arg0) === 'bigint';
+    return ret;
+};
+
+exports.__wbg___wbindgen_is_function_8d400b8b1af978cd = function(arg0) {
+    const ret = typeof(arg0) === 'function';
+    return ret;
+};
+
+exports.__wbg___wbindgen_is_object_ce774f3490692386 = function(arg0) {
+    const val = arg0;
+    const ret = typeof(val) === 'object' && val !== null;
+    return ret;
+};
+
+exports.__wbg___wbindgen_is_string_704ef9c8fc131030 = function(arg0) {
+    const ret = typeof(arg0) === 'string';
+    return ret;
+};
+
+exports.__wbg___wbindgen_is_undefined_f6b95eab589e0269 = function(arg0) {
+    const ret = arg0 === undefined;
+    return ret;
+};
+
+exports.__wbg___wbindgen_jsval_eq_b6101cc9cef1fe36 = function(arg0, arg1) {
+    const ret = arg0 === arg1;
+    return ret;
+};
+
+exports.__wbg___wbindgen_jsval_loose_eq_766057600fdd1b0d = function(arg0, arg1) {
+    const ret = arg0 == arg1;
+    return ret;
+};
+
+exports.__wbg___wbindgen_number_get_9619185a74197f95 = function(arg0, arg1) {
+    const obj = arg1;
+    const ret = typeof(obj) === 'number' ? obj : undefined;
+    getDataViewMemory0().setFloat64(arg0 + 8 * 1, isLikeNone(ret) ? 0 : ret, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+};
+
+exports.__wbg___wbindgen_string_get_a2a31e16edf96e42 = function(arg0, arg1) {
+    const obj = arg1;
+    const ret = typeof(obj) === 'string' ? obj : undefined;
+    var ptr1 = isLikeNone(ret) ? 0 : passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+};
+
+exports.__wbg___wbindgen_throw_dd24417ed36fc46e = function(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+};
+
+exports.__wbg__wbg_cb_unref_87dfb5aaa0cbcea7 = function(arg0) {
+    arg0._wbg_cb_unref();
+};
+
+exports.__wbg_abort_8d4ada33948fb9ea = function(arg0) {
+    arg0.abort();
+};
+
+exports.__wbg_append_7d0ec8d7eeb807f8 = function() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+    arg0.append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
+}, arguments) };
+
+exports.__wbg_arrayBuffer_244b9be4ec34cae8 = function() { return handleError(function (arg0) {
+    const ret = arg0.arrayBuffer();
+    return ret;
+}, arguments) };
+
+exports.__wbg_call_3020136f7a2d6e44 = function() { return handleError(function (arg0, arg1, arg2) {
+    const ret = arg0.call(arg1, arg2);
+    return ret;
+}, arguments) };
+
+exports.__wbg_call_abb4ff46ce38be40 = function() { return handleError(function (arg0, arg1) {
+    const ret = arg0.call(arg1);
+    return ret;
+}, arguments) };
+
+exports.__wbg_clearTimeout_5a54f8841c30079a = function(arg0) {
+    const ret = clearTimeout(arg0);
+    return ret;
+};
+
+exports.__wbg_clearTimeout_96804de0ab838f26 = function(arg0) {
+    const ret = clearTimeout(arg0);
+    return ret;
+};
+
+exports.__wbg_credentialdefinition_new = function(arg0) {
+    const ret = CredentialDefinition.__wrap(arg0);
+    return ret;
+};
+
+exports.__wbg_done_62ea16af4ce34b24 = function(arg0) {
+    const ret = arg0.done;
+    return ret;
+};
+
+exports.__wbg_entries_83c79938054e065f = function(arg0) {
+    const ret = Object.entries(arg0);
+    return ret;
+};
+
+exports.__wbg_error_7534b8e9a36f1ab4 = function(arg0, arg1) {
+    let deferred0_0;
+    let deferred0_1;
+    try {
+        deferred0_0 = arg0;
+        deferred0_1 = arg1;
+        console.error(getStringFromWasm0(arg0, arg1));
+    } finally {
+        wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+    }
+};
+
+exports.__wbg_eventquery_new = function(arg0) {
+    const ret = EventQuery.__wrap(arg0);
+    return ret;
+};
+
+exports.__wbg_fetch_f1856afdb49415d1 = function(arg0) {
+    const ret = fetch(arg0);
+    return ret;
+};
+
+exports.__wbg_fetch_f649bd7134840205 = function(arg0, arg1) {
+    const ret = arg0.fetch(arg1);
+    return ret;
+};
+
+exports.__wbg_getTime_ad1e9878a735af08 = function(arg0) {
+    const ret = arg0.getTime();
+    return ret;
+};
+
+exports.__wbg_get_6b7bd52aca3f9671 = function(arg0, arg1) {
+    const ret = arg0[arg1 >>> 0];
+    return ret;
+};
+
+exports.__wbg_get_af9dab7e9603ea93 = function() { return handleError(function (arg0, arg1) {
+    const ret = Reflect.get(arg0, arg1);
+    return ret;
+}, arguments) };
+
+exports.__wbg_get_with_ref_key_bb8f74a92cb2e784 = function(arg0, arg1) {
+    const ret = arg0[arg1];
+    return ret;
+};
+
+exports.__wbg_has_0e670569d65d3a45 = function() { return handleError(function (arg0, arg1) {
+    const ret = Reflect.has(arg0, arg1);
+    return ret;
+}, arguments) };
+
+exports.__wbg_headers_cc3fc3b432f8aabc = function(arg0) {
+    const ret = arg0.headers;
+    return ret;
+};
+
+exports.__wbg_instanceof_ArrayBuffer_f3320d2419cd0355 = function(arg0) {
+    let result;
+    try {
+        result = arg0 instanceof ArrayBuffer;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+};
+
+exports.__wbg_instanceof_Response_d1b3f08d4983dc43 = function(arg0) {
+    let result;
+    try {
+        result = arg0 instanceof Response;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+};
+
+exports.__wbg_instanceof_Uint8Array_da54ccc9d3e09434 = function(arg0) {
+    let result;
+    try {
+        result = arg0 instanceof Uint8Array;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+};
+
+exports.__wbg_isArray_51fd9e6422c0a395 = function(arg0) {
+    const ret = Array.isArray(arg0);
+    return ret;
+};
+
+exports.__wbg_isSafeInteger_ae7d3f054d55fa16 = function(arg0) {
+    const ret = Number.isSafeInteger(arg0);
+    return ret;
+};
+
+exports.__wbg_iterator_27b7c8b35ab3e86b = function() {
+    const ret = Symbol.iterator;
+    return ret;
+};
+
+exports.__wbg_length_22ac23eaec9d8053 = function(arg0) {
+    const ret = arg0.length;
+    return ret;
+};
+
+exports.__wbg_length_d45040a40c570362 = function(arg0) {
+    const ret = arg0.length;
+    return ret;
+};
+
+exports.__wbg_new_0_23cedd11d9b40c9d = function() {
+    const ret = new Date();
+    return ret;
+};
+
+exports.__wbg_new_1ba21ce319a06297 = function() {
+    const ret = new Object();
+    return ret;
+};
+
+exports.__wbg_new_25f239778d6112b9 = function() {
+    const ret = new Array();
+    return ret;
+};
+
+exports.__wbg_new_3955c5041f5c225a = function() { return handleError(function () {
+    const ret = new AbortController();
+    return ret;
+}, arguments) };
+
+exports.__wbg_new_6421f6084cc5bc5a = function(arg0) {
+    const ret = new Uint8Array(arg0);
+    return ret;
+};
+
+exports.__wbg_new_8a6f238a6ece86ea = function() {
+    const ret = new Error();
+    return ret;
+};
+
+exports.__wbg_new_9d9027fccb1f4cb1 = function() { return handleError(function () {
+    const ret = new Headers();
+    return ret;
+}, arguments) };
+
+exports.__wbg_new_b546ae120718850e = function() {
+    const ret = new Map();
+    return ret;
+};
+
+exports.__wbg_new_df1173567d5ff028 = function(arg0, arg1) {
+    const ret = new Error(getStringFromWasm0(arg0, arg1));
+    return ret;
+};
+
+exports.__wbg_new_ff12d2b041fb48f1 = function(arg0, arg1) {
+    try {
+        var state0 = {a: arg0, b: arg1};
+        var cb0 = (arg0, arg1) => {
+            const a = state0.a;
+            state0.a = 0;
+            try {
+                return wasm_bindgen__convert__closures_____invoke__hbabdd7037359511e(a, state0.b, arg0, arg1);
+            } finally {
+                state0.a = a;
+            }
+        };
+        const ret = new Promise(cb0);
+        return ret;
+    } finally {
+        state0.a = state0.b = 0;
+    }
+};
+
+exports.__wbg_new_from_slice_f9c22b9153b26992 = function(arg0, arg1) {
+    const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
+    return ret;
+};
+
+exports.__wbg_new_no_args_cb138f77cf6151ee = function(arg0, arg1) {
+    const ret = new Function(getStringFromWasm0(arg0, arg1));
+    return ret;
+};
+
+exports.__wbg_new_with_str_and_init_80f4e7be678ad35c = function() { return handleError(function (arg0, arg1, arg2) {
+    const ret = new Request(getStringFromWasm0(arg0, arg1), arg2);
+    return ret;
+}, arguments) };
+
+exports.__wbg_next_138a17bbf04e926c = function(arg0) {
+    const ret = arg0.next;
+    return ret;
+};
+
+exports.__wbg_next_3cfe5c0fe2a4cc53 = function() { return handleError(function (arg0) {
+    const ret = arg0.next();
+    return ret;
+}, arguments) };
+
+exports.__wbg_prototypesetcall_dfe9b766cdc1f1fd = function(arg0, arg1, arg2) {
+    Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
+};
+
+exports.__wbg_queueMicrotask_5a8a9131f3f0b37b = function(arg0) {
+    const ret = arg0.queueMicrotask;
+    return ret;
+};
+
+exports.__wbg_queueMicrotask_6d79674585219521 = function(arg0) {
+    queueMicrotask(arg0);
+};
+
+exports.__wbg_resolve_fd5bfbaa4ce36e1e = function(arg0) {
+    const ret = Promise.resolve(arg0);
+    return ret;
+};
+
+exports.__wbg_revocationregistrydefinition_new = function(arg0) {
+    const ret = RevocationRegistryDefinition.__wrap(arg0);
+    return ret;
+};
+
+exports.__wbg_revocationregistryentry_new = function(arg0) {
+    const ret = RevocationRegistryEntry.__wrap(arg0);
+    return ret;
+};
+
+exports.__wbg_revocationregistrystatuslist_new = function(arg0) {
+    const ret = RevocationRegistryStatusList.__wrap(arg0);
+    return ret;
+};
+
+exports.__wbg_schema_new = function(arg0) {
+    const ret = Schema.__wrap(arg0);
+    return ret;
+};
+
+exports.__wbg_setTimeout_db2dbaeefb6f39c7 = function() { return handleError(function (arg0, arg1) {
+    const ret = setTimeout(arg0, arg1);
+    return ret;
+}, arguments) };
+
+exports.__wbg_setTimeout_eefe7f4c234b0c6b = function() { return handleError(function (arg0, arg1) {
+    const ret = setTimeout(arg0, arg1);
+    return ret;
+}, arguments) };
+
+exports.__wbg_set_3fda3bac07393de4 = function(arg0, arg1, arg2) {
+    arg0[arg1] = arg2;
+};
+
+exports.__wbg_set_7df433eea03a5c14 = function(arg0, arg1, arg2) {
+    arg0[arg1 >>> 0] = arg2;
+};
+
+exports.__wbg_set_body_e622304a359e9997 = function(arg0, arg1) {
+    arg0.body = arg1;
+};
+
+exports.__wbg_set_credentials_6c1850c906a4c7d8 = function(arg0, arg1) {
+    arg0.credentials = __wbindgen_enum_RequestCredentials[arg1];
+};
+
+exports.__wbg_set_efaaf145b9377369 = function(arg0, arg1, arg2) {
+    const ret = arg0.set(arg1, arg2);
+    return ret;
+};
+
+exports.__wbg_set_headers_37c4507b6650184a = function(arg0, arg1) {
+    arg0.headers = arg1;
+};
+
+exports.__wbg_set_method_20004624d0bb3c04 = function(arg0, arg1, arg2) {
+    arg0.method = getStringFromWasm0(arg1, arg2);
+};
+
+exports.__wbg_set_mode_cfeb23c22a98ee10 = function(arg0, arg1) {
+    arg0.mode = __wbindgen_enum_RequestMode[arg1];
+};
+
+exports.__wbg_set_signal_1c7fc807a0404525 = function(arg0, arg1) {
+    arg0.signal = arg1;
+};
+
+exports.__wbg_signal_05cd9a8401da1904 = function(arg0) {
+    const ret = arg0.signal;
+    return ret;
+};
+
+exports.__wbg_stack_0ed75d68575b0f3c = function(arg0, arg1) {
+    const ret = arg1.stack;
+    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+};
+
+exports.__wbg_static_accessor_GLOBAL_769e6b65d6557335 = function() {
+    const ret = typeof global === 'undefined' ? null : global;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+};
+
+exports.__wbg_static_accessor_GLOBAL_THIS_60cf02db4de8e1c1 = function() {
+    const ret = typeof globalThis === 'undefined' ? null : globalThis;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+};
+
+exports.__wbg_static_accessor_SELF_08f5a74c69739274 = function() {
+    const ret = typeof self === 'undefined' ? null : self;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+};
+
+exports.__wbg_static_accessor_WINDOW_a8924b26aa92d024 = function() {
+    const ret = typeof window === 'undefined' ? null : window;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+};
+
+exports.__wbg_status_0469c5287b59ffc5 = function(arg0) {
+    const ret = arg0.status;
+    return ret;
+};
+
+exports.__wbg_stringify_655a6390e1f5eb6b = function() { return handleError(function (arg0) {
+    const ret = JSON.stringify(arg0);
+    return ret;
+}, arguments) };
+
+exports.__wbg_then_429f7caf1026411d = function(arg0, arg1, arg2) {
+    const ret = arg0.then(arg1, arg2);
+    return ret;
+};
+
+exports.__wbg_then_4f95312d68691235 = function(arg0, arg1) {
+    const ret = arg0.then(arg1);
+    return ret;
+};
+
+exports.__wbg_transaction_new = function(arg0) {
+    const ret = Transaction.__wrap(arg0);
+    return ret;
+};
+
+exports.__wbg_transactionendorsingdata_new = function(arg0) {
+    const ret = TransactionEndorsingData.__wrap(arg0);
+    return ret;
+};
+
+exports.__wbg_url_0f5a9de9ca05e0eb = function(arg0, arg1) {
+    const ret = arg1.url;
+    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+};
+
+exports.__wbg_value_57b7b035e117f7ee = function(arg0) {
+    const ret = arg0.value;
+    return ret;
+};
+
+exports.__wbindgen_cast_2241b6af4c4b2941 = function(arg0, arg1) {
+    // Cast intrinsic for `Ref(String) -> Externref`.
+    const ret = getStringFromWasm0(arg0, arg1);
+    return ret;
+};
+
+exports.__wbindgen_cast_4625c577ab2ec9ee = function(arg0) {
+    // Cast intrinsic for `U64 -> Externref`.
+    const ret = BigInt.asUintN(64, arg0);
+    return ret;
+};
+
+exports.__wbindgen_cast_9ae0607507abb057 = function(arg0) {
+    // Cast intrinsic for `I64 -> Externref`.
+    const ret = arg0;
+    return ret;
+};
+
+exports.__wbindgen_cast_af28d61432eab9a8 = function(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 1190, function: Function { arguments: [], shim_idx: 1191, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h4683acde6d985fbb, wasm_bindgen__convert__closures_____invoke__h711c3930aef5dacf);
+    return ret;
+};
+
+exports.__wbindgen_cast_c47ebd1492a57180 = function(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 1181, function: Function { arguments: [], shim_idx: 1182, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__hb4256b431b7abf1e, wasm_bindgen__convert__closures_____invoke__h184b7a090947292c);
+    return ret;
+};
+
+exports.__wbindgen_cast_d6cd19b81560fd6e = function(arg0) {
+    // Cast intrinsic for `F64 -> Externref`.
+    const ret = arg0;
+    return ret;
+};
+
+exports.__wbindgen_cast_d94fdfc916fc4ce2 = function(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 1283, function: Function { arguments: [Externref], shim_idx: 1284, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__he9ff8ee1ef74c7a5, wasm_bindgen__convert__closures_____invoke__hf4d0e3d1df92b3f7);
+    return ret;
+};
+
+exports.__wbindgen_init_externref_table = function() {
+    const table = wasm.__wbindgen_externrefs;
+    const offset = table.grow(4);
+    table.set(0, undefined);
+    table.set(offset + 0, undefined);
+    table.set(offset + 1, null);
+    table.set(offset + 2, true);
+    table.set(offset + 3, false);
+};
+
+const wasmPath = `${__dirname}/indy_besu_vdr_wasm_bg.wasm`;
+const wasmBytes = require('fs').readFileSync(wasmPath);
+const wasmModule = new WebAssembly.Module(wasmBytes);
+const wasm = exports.__wasm = new WebAssembly.Instance(wasmModule, imports).exports;
+
+wasm.__wbindgen_start();