pshenmic-dpp 1.0.0

package/dist/wasm/pshenmic_dpp.js

@@ -0,0 +1,1130 @@
+let wasm;
+
+function addToExternrefTable0(obj) {
+    const idx = wasm.__externref_table_alloc();
+    wasm.__wbindgen_export_2.set(idx, obj);
+    return idx;
+}
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        const idx = addToExternrefTable0(e);
+        wasm.__wbindgen_exn_store(idx);
+    }
+}
+
+const cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } );
+
+if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); };
+
+let cachedUint8ArrayMemory0 = null;
+
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+function isLikeNone(x) {
+    return x === undefined || x === null;
+}
+
+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;
+}
+
+let WASM_VECTOR_LEN = 0;
+
+const cachedTextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : { encode: () => { throw Error('TextEncoder not available') } } );
+
+const encodeString = (typeof cachedTextEncoder.encodeInto === 'function'
+    ? function (arg, view) {
+    return cachedTextEncoder.encodeInto(arg, view);
+}
+    : function (arg, view) {
+    const buf = cachedTextEncoder.encode(arg);
+    view.set(buf);
+    return {
+        read: arg.length,
+        written: buf.length
+    };
+});
+
+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 = encodeString(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+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 getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_export_2.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
+/**
+ * @param {any} object
+ * @returns {string}
+ */
+export function objectToCbor(object) {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.objectToCbor(object);
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+/**
+ * @param {string} cbor
+ * @returns {any}
+ */
+export function cborToObject(cbor) {
+    const ptr0 = passStringToWasm0(cbor, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.cborToObject(ptr0, len0);
+    return ret;
+}
+
+/**
+ * @enum {0 | 1 | 2}
+ */
+export const BatchType = Object.freeze({
+    CREATE: 0, "0": "CREATE",
+    REPLACE: 1, "1": "REPLACE",
+    DELETE: 2, "2": "DELETE",
+});
+/**
+ * @enum {0 | 1 | 2 | 3 | 4}
+ */
+export const KeyType = Object.freeze({
+    ECDSA_SECP256K1: 0, "0": "ECDSA_SECP256K1",
+    BLS12_381: 1, "1": "BLS12_381",
+    ECDSA_HASH160: 2, "2": "ECDSA_HASH160",
+    BIP13_SCRIPT_HASH: 3, "3": "BIP13_SCRIPT_HASH",
+    EDDSA_25519_HASH160: 4, "4": "EDDSA_25519_HASH160",
+});
+/**
+ * @enum {0 | 1 | 2 | 3 | 4 | 5 | 6}
+ */
+export const Purpose = Object.freeze({
+    AUTHENTICATION: 0, "0": "AUTHENTICATION",
+    ENCRYPTION: 1, "1": "ENCRYPTION",
+    DECRYPTION: 2, "2": "DECRYPTION",
+    TRANSFER: 3, "3": "TRANSFER",
+    SYSTEM: 4, "4": "SYSTEM",
+    VOTING: 5, "5": "VOTING",
+    OWNER: 6, "6": "OWNER",
+});
+/**
+ * @enum {0 | 1 | 2 | 3}
+ */
+export const SecurityLevel = Object.freeze({
+    MASTER: 0, "0": "MASTER",
+    CRITICAL: 1, "1": "CRITICAL",
+    HIGH: 2, "2": "HIGH",
+    MEDIUM: 3, "3": "MEDIUM",
+});
+
+const DocumentBatchWASMFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_documentbatchwasm_free(ptr >>> 0, 1));
+
+export class DocumentBatchWASM {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(DocumentBatchWASM.prototype);
+        obj.__wbg_ptr = ptr;
+        DocumentBatchWASMFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DocumentBatchWASMFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_documentbatchwasm_free(ptr, 0);
+    }
+    /**
+     * @param {BatchType} batch_type
+     * @param {DocumentWASM} document
+     * @param {bigint} identity_contract_nonce
+     * @returns {DocumentBatchWASM}
+     */
+    static new(batch_type, document, identity_contract_nonce) {
+        _assertClass(document, DocumentWASM);
+        var ptr0 = document.__destroy_into_raw();
+        const ret = wasm.documentbatchwasm_new(batch_type, ptr0, identity_contract_nonce);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return DocumentBatchWASM.__wrap(ret[0]);
+    }
+    /**
+     * @param {PrivateKeyWASM} private_key
+     * @param {IdentityPublicKeyWASM} public_key
+     * @returns {any}
+     */
+    sign(private_key, public_key) {
+        _assertClass(private_key, PrivateKeyWASM);
+        var ptr0 = private_key.__destroy_into_raw();
+        _assertClass(public_key, IdentityPublicKeyWASM);
+        var ptr1 = public_key.__destroy_into_raw();
+        const ret = wasm.documentbatchwasm_sign(this.__wbg_ptr, ptr0, ptr1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {PrivateKeyWASM} private_key
+     * @param {KeyType} key_type
+     * @returns {any}
+     */
+    signByPrivateKey(private_key, key_type) {
+        _assertClass(private_key, PrivateKeyWASM);
+        var ptr0 = private_key.__destroy_into_raw();
+        const ret = wasm.documentbatchwasm_signByPrivateKey(this.__wbg_ptr, ptr0, key_type);
+        return ret;
+    }
+    /**
+     * @returns {any}
+     */
+    toBuffer() {
+        const ret = wasm.documentbatchwasm_toBuffer(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} bytes
+     * @returns {DocumentBatchWASM}
+     */
+    static fromBuffer(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.documentbatchwasm_fromBuffer(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return DocumentBatchWASM.__wrap(ret[0]);
+    }
+    /**
+     * @returns {DocumentWASM}
+     */
+    getDocument() {
+        const ret = wasm.documentbatchwasm_getDocument(this.__wbg_ptr);
+        return DocumentWASM.__wrap(ret);
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    getSignature() {
+        const ret = wasm.documentbatchwasm_getSignature(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+}
+
+const DocumentWASMFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_documentwasm_free(ptr >>> 0, 1));
+
+export class DocumentWASM {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(DocumentWASM.prototype);
+        obj.__wbg_ptr = ptr;
+        DocumentWASMFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        DocumentWASMFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_documentwasm_free(ptr, 0);
+    }
+    /**
+     * @param {any} js_raw_document
+     * @param {string} js_document_type_name
+     * @param {bigint} js_revision
+     * @param {string} js_data_contract_id
+     * @param {string} js_owner_id
+     * @returns {DocumentWASM}
+     */
+    static new(js_raw_document, js_document_type_name, js_revision, js_data_contract_id, js_owner_id) {
+        const ptr0 = passStringToWasm0(js_document_type_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(js_data_contract_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ptr2 = passStringToWasm0(js_owner_id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len2 = WASM_VECTOR_LEN;
+        const ret = wasm.documentwasm_new(js_raw_document, ptr0, len0, js_revision, ptr1, len1, ptr2, len2);
+        return DocumentWASM.__wrap(ret);
+    }
+    /**
+     * @returns {any}
+     */
+    getId() {
+        const ret = wasm.documentwasm_getId(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {any}
+     */
+    getEntropy() {
+        const ret = wasm.documentwasm_getEntropy(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {any}
+     */
+    getOwnerId() {
+        const ret = wasm.documentwasm_getOwnerId(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {any}
+     */
+    getProperties() {
+        const ret = wasm.documentwasm_getProperties(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {bigint | undefined}
+     */
+    getRevision() {
+        const ret = wasm.documentwasm_getRevision(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : BigInt.asUintN(64, ret[1]);
+    }
+    /**
+     * @returns {bigint | undefined}
+     */
+    getCreatedAt() {
+        const ret = wasm.documentwasm_getCreatedAt(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : BigInt.asUintN(64, ret[1]);
+    }
+    /**
+     * @returns {bigint | undefined}
+     */
+    getUpdatedAt() {
+        const ret = wasm.documentwasm_getUpdatedAt(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : BigInt.asUintN(64, ret[1]);
+    }
+    /**
+     * @returns {bigint | undefined}
+     */
+    getTransferredAt() {
+        const ret = wasm.documentwasm_getTransferredAt(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : BigInt.asUintN(64, ret[1]);
+    }
+    /**
+     * @returns {bigint | undefined}
+     */
+    getCreatedAtBlockHeight() {
+        const ret = wasm.documentwasm_getCreatedAtBlockHeight(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : BigInt.asUintN(64, ret[1]);
+    }
+    /**
+     * @returns {bigint | undefined}
+     */
+    getUpdatedAtBlockHeight() {
+        const ret = wasm.documentwasm_getUpdatedAtBlockHeight(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : BigInt.asUintN(64, ret[1]);
+    }
+    /**
+     * @returns {bigint | undefined}
+     */
+    getTransferredAtBlockHeight() {
+        const ret = wasm.documentwasm_getTransferredAtBlockHeight(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : BigInt.asUintN(64, ret[1]);
+    }
+    /**
+     * @returns {number | undefined}
+     */
+    getCreatedAtCoreBlockHeight() {
+        const ret = wasm.documentwasm_getCreatedAtCoreBlockHeight(this.__wbg_ptr);
+        return ret === 0x100000001 ? undefined : ret;
+    }
+    /**
+     * @returns {number | undefined}
+     */
+    getUpdatedAtCoreBlockHeight() {
+        const ret = wasm.documentwasm_getUpdatedAtCoreBlockHeight(this.__wbg_ptr);
+        return ret === 0x100000001 ? undefined : ret;
+    }
+    /**
+     * @returns {number | undefined}
+     */
+    getTransferredAtCoreBlockHeight() {
+        const ret = wasm.documentwasm_getTransferredAtCoreBlockHeight(this.__wbg_ptr);
+        return ret === 0x100000001 ? undefined : ret;
+    }
+    /**
+     * @returns {string}
+     */
+    getDocumentTypeName() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.documentwasm_getDocumentTypeName(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);
+        }
+    }
+    /**
+     * @param {any} id
+     */
+    setId(id) {
+        wasm.documentwasm_setId(this.__wbg_ptr, id);
+    }
+    /**
+     * @param {any} entropy
+     */
+    setEntropy(entropy) {
+        wasm.documentwasm_setEntropy(this.__wbg_ptr, entropy);
+    }
+    /**
+     * @param {any} id
+     */
+    setOwnerId(id) {
+        wasm.documentwasm_setOwnerId(this.__wbg_ptr, id);
+    }
+    /**
+     * @param {any} properties
+     */
+    setProperties(properties) {
+        wasm.documentwasm_setProperties(this.__wbg_ptr, properties);
+    }
+    /**
+     * @param {bigint | null} [revision]
+     */
+    setRevision(revision) {
+        wasm.documentwasm_setRevision(this.__wbg_ptr, !isLikeNone(revision), isLikeNone(revision) ? BigInt(0) : revision);
+    }
+    /**
+     * @param {bigint | null} [created_at]
+     */
+    setCreatedAt(created_at) {
+        wasm.documentwasm_setCreatedAt(this.__wbg_ptr, !isLikeNone(created_at), isLikeNone(created_at) ? BigInt(0) : created_at);
+    }
+    /**
+     * @param {bigint | null} [updated_at]
+     */
+    setUpdatedAt(updated_at) {
+        wasm.documentwasm_setUpdatedAt(this.__wbg_ptr, !isLikeNone(updated_at), isLikeNone(updated_at) ? BigInt(0) : updated_at);
+    }
+    /**
+     * @param {bigint | null} [transferred_at]
+     */
+    setTransferredAt(transferred_at) {
+        wasm.documentwasm_setTransferredAt(this.__wbg_ptr, !isLikeNone(transferred_at), isLikeNone(transferred_at) ? BigInt(0) : transferred_at);
+    }
+    /**
+     * @param {bigint | null} [created_at_block_height]
+     */
+    setCreatedAtBlockHeight(created_at_block_height) {
+        wasm.documentwasm_setCreatedAtBlockHeight(this.__wbg_ptr, !isLikeNone(created_at_block_height), isLikeNone(created_at_block_height) ? BigInt(0) : created_at_block_height);
+    }
+    /**
+     * @param {bigint | null} [updated_at_block_height]
+     */
+    setUpdatedAtBlockHeight(updated_at_block_height) {
+        wasm.documentwasm_setUpdatedAtBlockHeight(this.__wbg_ptr, !isLikeNone(updated_at_block_height), isLikeNone(updated_at_block_height) ? BigInt(0) : updated_at_block_height);
+    }
+    /**
+     * @param {bigint | null} [transferred_at_block_height]
+     */
+    setTransferredAtBlockHeight(transferred_at_block_height) {
+        wasm.documentwasm_setTransferredAtBlockHeight(this.__wbg_ptr, !isLikeNone(transferred_at_block_height), isLikeNone(transferred_at_block_height) ? BigInt(0) : transferred_at_block_height);
+    }
+    /**
+     * @param {number | null} [created_at_core_block_height]
+     */
+    setCreatedAtCoreBlockHeight(created_at_core_block_height) {
+        wasm.documentwasm_setCreatedAtCoreBlockHeight(this.__wbg_ptr, isLikeNone(created_at_core_block_height) ? 0x100000001 : (created_at_core_block_height) >>> 0);
+    }
+    /**
+     * @param {number | null} [updated_at_core_block_height]
+     */
+    setUpdatedAtCoreBlockHeight(updated_at_core_block_height) {
+        wasm.documentwasm_setUpdatedAtCoreBlockHeight(this.__wbg_ptr, isLikeNone(updated_at_core_block_height) ? 0x100000001 : (updated_at_core_block_height) >>> 0);
+    }
+    /**
+     * @param {number | null} [transferred_at_core_block_height]
+     */
+    setTransferredAtCoreBlockHeight(transferred_at_core_block_height) {
+        wasm.documentwasm_setTransferredAtCoreBlockHeight(this.__wbg_ptr, isLikeNone(transferred_at_core_block_height) ? 0x100000001 : (transferred_at_core_block_height) >>> 0);
+    }
+    /**
+     * @param {string} document_type_name
+     */
+    setDocumentTypeName(document_type_name) {
+        const ptr0 = passStringToWasm0(document_type_name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.documentwasm_setDocumentTypeName(this.__wbg_ptr, ptr0, len0);
+    }
+}
+
+const IdentityPublicKeyWASMFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_identitypublickeywasm_free(ptr >>> 0, 1));
+
+export class IdentityPublicKeyWASM {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(IdentityPublicKeyWASM.prototype);
+        obj.__wbg_ptr = ptr;
+        IdentityPublicKeyWASMFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        IdentityPublicKeyWASMFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_identitypublickeywasm_free(ptr, 0);
+    }
+    /**
+     * @param {number} id
+     * @param {Purpose} purpose
+     * @param {SecurityLevel} security_level
+     * @param {KeyType} key_type
+     * @param {boolean} read_only
+     * @param {string} binary_data
+     * @param {bigint | null} [disabled_at]
+     * @returns {IdentityPublicKeyWASM}
+     */
+    static new(id, purpose, security_level, key_type, read_only, binary_data, disabled_at) {
+        const ptr0 = passStringToWasm0(binary_data, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.identitypublickeywasm_new(id, purpose, security_level, key_type, read_only, ptr0, len0, !isLikeNone(disabled_at), isLikeNone(disabled_at) ? BigInt(0) : disabled_at);
+        return IdentityPublicKeyWASM.__wrap(ret);
+    }
+    /**
+     * @returns {number}
+     */
+    getKeyId() {
+        const ret = wasm.identitypublickeywasm_getKeyId(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {Purpose}
+     */
+    getPurpose() {
+        const ret = wasm.identitypublickeywasm_getPurpose(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {SecurityLevel}
+     */
+    getSecurityLevel() {
+        const ret = wasm.identitypublickeywasm_getSecurityLevel(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {KeyType}
+     */
+    getKeyType() {
+        const ret = wasm.identitypublickeywasm_getKeyType(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {boolean}
+     */
+    getReadOnly() {
+        const ret = wasm.identitypublickeywasm_getReadOnly(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {string}
+     */
+    getData() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.identitypublickeywasm_getData(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 {bigint | undefined}
+     */
+    getDisabledAt() {
+        const ret = wasm.identitypublickeywasm_getDisabledAt(this.__wbg_ptr);
+        return ret[0] === 0 ? undefined : BigInt.asUintN(64, ret[1]);
+    }
+    /**
+     * @param {number} key_id
+     */
+    setKeyId(key_id) {
+        wasm.identitypublickeywasm_setKeyId(this.__wbg_ptr, key_id);
+    }
+    /**
+     * @param {Purpose} purpose
+     */
+    setPurpose(purpose) {
+        wasm.identitypublickeywasm_setPurpose(this.__wbg_ptr, purpose);
+    }
+    /**
+     * @param {SecurityLevel} security_level
+     */
+    setSecurityLevel(security_level) {
+        wasm.identitypublickeywasm_setSecurityLevel(this.__wbg_ptr, security_level);
+    }
+    /**
+     * @param {KeyType} key_type
+     */
+    setKeyType(key_type) {
+        wasm.identitypublickeywasm_setKeyType(this.__wbg_ptr, key_type);
+    }
+    /**
+     * @param {boolean} read_only
+     */
+    setReadOnly(read_only) {
+        wasm.identitypublickeywasm_setReadOnly(this.__wbg_ptr, read_only);
+    }
+    /**
+     * @param {string} binary_data
+     */
+    setData(binary_data) {
+        const ptr0 = passStringToWasm0(binary_data, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.identitypublickeywasm_setData(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {bigint} disabled_at
+     */
+    setDisabledAt(disabled_at) {
+        wasm.identitypublickeywasm_setDisabledAt(this.__wbg_ptr, disabled_at);
+    }
+}
+
+const PrivateKeyWASMFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_privatekeywasm_free(ptr >>> 0, 1));
+
+export class PrivateKeyWASM {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(PrivateKeyWASM.prototype);
+        obj.__wbg_ptr = ptr;
+        PrivateKeyWASMFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PrivateKeyWASMFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_privatekeywasm_free(ptr, 0);
+    }
+    /**
+     * @param {string} wif
+     * @returns {PrivateKeyWASM}
+     */
+    static new(wif) {
+        const ptr0 = passStringToWasm0(wif, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.privatekeywasm_new(ptr0, len0);
+        return PrivateKeyWASM.__wrap(ret);
+    }
+    /**
+     * @returns {string}
+     */
+    getKeyWIF() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.privatekeywasm_getKeyWIF(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);
+        }
+    }
+}
+
+async function __wbg_load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
+
+            } catch (e) {
+                if (module.headers.get('Content-Type') != 'application/wasm') {
+                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+                } else {
+                    throw e;
+                }
+            }
+        }
+
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
+
+    } else {
+        const instance = await WebAssembly.instantiate(module, imports);
+
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
+
+        } else {
+            return instance;
+        }
+    }
+}
+
+function __wbg_get_imports() {
+    const imports = {};
+    imports.wbg = {};
+    imports.wbg.__wbg_buffer_609cc3eee51ed158 = function(arg0) {
+        const ret = arg0.buffer;
+        return ret;
+    };
+    imports.wbg.__wbg_call_672a4d21634d4a24 = function() { return handleError(function (arg0, arg1) {
+        const ret = arg0.call(arg1);
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_call_7cccdd69e0791ae2 = function() { return handleError(function (arg0, arg1, arg2) {
+        const ret = arg0.call(arg1, arg2);
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_crypto_ed58b8e10a292839 = function(arg0) {
+        const ret = arg0.crypto;
+        return ret;
+    };
+    imports.wbg.__wbg_from_2a5d3e218e67aa85 = function(arg0) {
+        const ret = Array.from(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_getRandomValues_bcb4912f16000dc4 = function() { return handleError(function (arg0, arg1) {
+        arg0.getRandomValues(arg1);
+    }, arguments) };
+    imports.wbg.__wbg_msCrypto_0a36e2ec3a343d26 = function(arg0) {
+        const ret = arg0.msCrypto;
+        return ret;
+    };
+    imports.wbg.__wbg_new_405e22f390576ce2 = function() {
+        const ret = new Object();
+        return ret;
+    };
+    imports.wbg.__wbg_new_5e0be73521bc8c17 = function() {
+        const ret = new Map();
+        return ret;
+    };
+    imports.wbg.__wbg_new_78feb108b6472713 = function() {
+        const ret = new Array();
+        return ret;
+    };
+    imports.wbg.__wbg_new_a12002a7f91c75be = function(arg0) {
+        const ret = new Uint8Array(arg0);
+        return ret;
+    };
+    imports.wbg.__wbg_newnoargs_105ed471475aaf50 = function(arg0, arg1) {
+        const ret = new Function(getStringFromWasm0(arg0, arg1));
+        return ret;
+    };
+    imports.wbg.__wbg_newwithargs_ab6ffe8cd6c19c04 = function(arg0, arg1, arg2, arg3) {
+        const ret = new Function(getStringFromWasm0(arg0, arg1), getStringFromWasm0(arg2, arg3));
+        return ret;
+    };
+    imports.wbg.__wbg_newwithbyteoffsetandlength_d97e637ebe145a9a = function(arg0, arg1, arg2) {
+        const ret = new Uint8Array(arg0, arg1 >>> 0, arg2 >>> 0);
+        return ret;
+    };
+    imports.wbg.__wbg_newwithlength_a381634e90c276d4 = function(arg0) {
+        const ret = new Uint8Array(arg0 >>> 0);
+        return ret;
+    };
+    imports.wbg.__wbg_node_02999533c4ea02e3 = function(arg0) {
+        const ret = arg0.node;
+        return ret;
+    };
+    imports.wbg.__wbg_process_5c1d670bc53614b8 = function(arg0) {
+        const ret = arg0.process;
+        return ret;
+    };
+    imports.wbg.__wbg_randomFillSync_ab2cfe79ebbf2740 = function() { return handleError(function (arg0, arg1) {
+        arg0.randomFillSync(arg1);
+    }, arguments) };
+    imports.wbg.__wbg_require_79b1e9274cde3c87 = function() { return handleError(function () {
+        const ret = module.require;
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_set_37837023f3d740e8 = function(arg0, arg1, arg2) {
+        arg0[arg1 >>> 0] = arg2;
+    };
+    imports.wbg.__wbg_set_3807d5f0bfc24aa7 = function(arg0, arg1, arg2) {
+        arg0[arg1] = arg2;
+    };
+    imports.wbg.__wbg_set_65595bdd868b3009 = function(arg0, arg1, arg2) {
+        arg0.set(arg1, arg2 >>> 0);
+    };
+    imports.wbg.__wbg_set_8fc6bf8a5b1071d1 = function(arg0, arg1, arg2) {
+        const ret = arg0.set(arg1, arg2);
+        return ret;
+    };
+    imports.wbg.__wbg_static_accessor_GLOBAL_88a902d13a557d07 = function() {
+        const ret = typeof global === 'undefined' ? null : global;
+        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    };
+    imports.wbg.__wbg_static_accessor_GLOBAL_THIS_56578be7e9f832b0 = function() {
+        const ret = typeof globalThis === 'undefined' ? null : globalThis;
+        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    };
+    imports.wbg.__wbg_static_accessor_SELF_37c5d418e4bf5819 = function() {
+        const ret = typeof self === 'undefined' ? null : self;
+        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    };
+    imports.wbg.__wbg_static_accessor_WINDOW_5de37043a91a9c40 = function() {
+        const ret = typeof window === 'undefined' ? null : window;
+        return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+    };
+    imports.wbg.__wbg_stringify_b1b3844ae02664a1 = function() { return handleError(function (arg0, arg1) {
+        const ret = JSON.stringify(arg0, arg1);
+        return ret;
+    }, arguments) };
+    imports.wbg.__wbg_subarray_aa9065fa9dc5df96 = function(arg0, arg1, arg2) {
+        const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
+        return ret;
+    };
+    imports.wbg.__wbg_versions_c71aa1626a93e0a1 = function(arg0) {
+        const ret = arg0.versions;
+        return ret;
+    };
+    imports.wbg.__wbindgen_bigint_from_i128 = function(arg0, arg1) {
+        const ret = arg0 << BigInt(64) | BigInt.asUintN(64, arg1);
+        return ret;
+    };
+    imports.wbg.__wbindgen_bigint_from_i64 = function(arg0) {
+        const ret = arg0;
+        return ret;
+    };
+    imports.wbg.__wbindgen_bigint_from_u128 = function(arg0, arg1) {
+        const ret = BigInt.asUintN(64, arg0) << BigInt(64) | BigInt.asUintN(64, arg1);
+        return ret;
+    };
+    imports.wbg.__wbindgen_bigint_from_u64 = function(arg0) {
+        const ret = BigInt.asUintN(64, arg0);
+        return ret;
+    };
+    imports.wbg.__wbindgen_boolean_get = function(arg0) {
+        const v = arg0;
+        const ret = typeof(v) === 'boolean' ? (v ? 1 : 0) : 2;
+        return ret;
+    };
+    imports.wbg.__wbindgen_debug_string = 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);
+    };
+    imports.wbg.__wbindgen_error_new = function(arg0, arg1) {
+        const ret = new Error(getStringFromWasm0(arg0, arg1));
+        return ret;
+    };
+    imports.wbg.__wbindgen_init_externref_table = function() {
+        const table = wasm.__wbindgen_export_2;
+        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);
+        ;
+    };
+    imports.wbg.__wbindgen_is_function = function(arg0) {
+        const ret = typeof(arg0) === 'function';
+        return ret;
+    };
+    imports.wbg.__wbindgen_is_null = function(arg0) {
+        const ret = arg0 === null;
+        return ret;
+    };
+    imports.wbg.__wbindgen_is_object = function(arg0) {
+        const val = arg0;
+        const ret = typeof(val) === 'object' && val !== null;
+        return ret;
+    };
+    imports.wbg.__wbindgen_is_string = function(arg0) {
+        const ret = typeof(arg0) === 'string';
+        return ret;
+    };
+    imports.wbg.__wbindgen_is_undefined = function(arg0) {
+        const ret = arg0 === undefined;
+        return ret;
+    };
+    imports.wbg.__wbindgen_memory = function() {
+        const ret = wasm.memory;
+        return ret;
+    };
+    imports.wbg.__wbindgen_number_new = function(arg0) {
+        const ret = arg0;
+        return ret;
+    };
+    imports.wbg.__wbindgen_rethrow = function(arg0) {
+        throw arg0;
+    };
+    imports.wbg.__wbindgen_string_get = 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);
+    };
+    imports.wbg.__wbindgen_string_new = function(arg0, arg1) {
+        const ret = getStringFromWasm0(arg0, arg1);
+        return ret;
+    };
+    imports.wbg.__wbindgen_throw = function(arg0, arg1) {
+        throw new Error(getStringFromWasm0(arg0, arg1));
+    };
+    imports.wbg.__wbindgen_uint8_array_new = function(arg0, arg1) {
+        var v0 = getArrayU8FromWasm0(arg0, arg1).slice();
+        wasm.__wbindgen_free(arg0, arg1 * 1, 1);
+        const ret = v0;
+        return ret;
+    };
+
+    return imports;
+}
+
+function __wbg_init_memory(imports, memory) {
+
+}
+
+function __wbg_finalize_init(instance, module) {
+    wasm = instance.exports;
+    __wbg_init.__wbindgen_wasm_module = module;
+    cachedDataViewMemory0 = null;
+    cachedUint8ArrayMemory0 = null;
+
+
+    wasm.__wbindgen_start();
+    return wasm;
+}
+
+function initSync(module) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (typeof module !== 'undefined') {
+        if (Object.getPrototypeOf(module) === Object.prototype) {
+            ({module} = module)
+        } else {
+            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
+        }
+    }
+
+    const imports = __wbg_get_imports();
+
+    __wbg_init_memory(imports);
+
+    if (!(module instanceof WebAssembly.Module)) {
+        module = new WebAssembly.Module(module);
+    }
+
+    const instance = new WebAssembly.Instance(module, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+async function __wbg_init(module_or_path) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (typeof module_or_path !== 'undefined') {
+        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+            ({module_or_path} = module_or_path)
+        } else {
+            console.warn('using deprecated parameters for the initialization function; pass a single object instead')
+        }
+    }
+
+
+    const imports = __wbg_get_imports();
+
+    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
+        module_or_path = fetch(module_or_path);
+    }
+
+    __wbg_init_memory(imports);
+
+    const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+export { initSync };
+export default __wbg_init;