pshenmic-dpp 1.0.0 → 1.0.2

package/dist/wasm/pshenmic_dpp.js

@@ -172,12 +172,6 @@ function getArrayU8FromWasm0(ptr, len) {
     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);
@@ -190,6 +184,23 @@ function passArray8ToWasm0(arg, malloc) {
     WASM_VECTOR_LEN = arg.length;
     return ptr;
 }
+
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
+
+function getArrayJsValueFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    const mem = getDataViewMemory0();
+    const result = [];
+    for (let i = ptr; i < ptr + 4 * len; i += 4) {
+        result.push(wasm.__wbindgen_export_2.get(mem.getUint32(i, true)));
+    }
+    wasm.__externref_drop_slice(ptr, len);
+    return result;
+}
 /**
  * @param {any} object
  * @returns {string}
@@ -299,50 +310,43 @@ export class DocumentBatchWASM {
         return DocumentBatchWASM.__wrap(ret[0]);
     }
     /**
-     * @param {PrivateKeyWASM} private_key
-     * @param {IdentityPublicKeyWASM} public_key
+     * @returns {StateTransitionWASM}
+     */
+    toStateTransition() {
+        const ret = wasm.documentbatchwasm_toStateTransition(this.__wbg_ptr);
+        return StateTransitionWASM.__wrap(ret);
+    }
+    /**
      * @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);
+    toBuffer() {
+        const ret = wasm.documentbatchwasm_toBuffer(this.__wbg_ptr);
         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}
+     * @param {StateTransitionWASM} state_transition
+     * @returns {DocumentBatchWASM}
      */
-    toBuffer() {
-        const ret = wasm.documentbatchwasm_toBuffer(this.__wbg_ptr);
+    static fromStateTransition(state_transition) {
+        _assertClass(state_transition, StateTransitionWASM);
+        var ptr0 = state_transition.__destroy_into_raw();
+        const ret = wasm.documentbatchwasm_fromStateTransition(ptr0);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
-        return takeFromExternrefTable0(ret[0]);
+        return DocumentBatchWASM.__wrap(ret[0]);
     }
     /**
      * @param {Uint8Array} bytes
      * @returns {DocumentBatchWASM}
      */
-    static fromBuffer(bytes) {
+    static from_buffer(bytes) {
         const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
-        const ret = wasm.documentbatchwasm_fromBuffer(ptr0, len0);
+        const ret = wasm.documentbatchwasm_from_buffer(ptr0, len0);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -616,6 +620,254 @@ export class DocumentWASM {
     }
 }
 
+const IdentityCreateTransitionWASMFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_identitycreatetransitionwasm_free(ptr >>> 0, 1));
+
+export class IdentityCreateTransitionWASM {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(IdentityCreateTransitionWASM.prototype);
+        obj.__wbg_ptr = ptr;
+        IdentityCreateTransitionWASMFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        IdentityCreateTransitionWASMFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_identitycreatetransitionwasm_free(ptr, 0);
+    }
+    /**
+     * @param {number} platform_version
+     */
+    constructor(platform_version) {
+        const ret = wasm.identitycreatetransitionwasm_new(platform_version);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        IdentityCreateTransitionWASMFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {IdentityPublicKeyInCreationWASM[]}
+     */
+    defaultVersioned() {
+        const ret = wasm.identitycreatetransitionwasm_defaultVersioned(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * @returns {string}
+     */
+    getIdentifier() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.identitycreatetransitionwasm_getIdentifier(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 {number}
+     */
+    getUserFeeIncrease() {
+        const ret = wasm.identitycreatetransitionwasm_getUserFeeIncrease(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {StateTransitionWASM}
+     */
+    toStateTransition() {
+        const ret = wasm.identitycreatetransitionwasm_toStateTransition(this.__wbg_ptr);
+        return StateTransitionWASM.__wrap(ret);
+    }
+    /**
+     * @returns {any}
+     */
+    toBuffer() {
+        const ret = wasm.identitycreatetransitionwasm_toBuffer(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {StateTransitionWASM} st
+     * @returns {IdentityCreateTransitionWASM}
+     */
+    static fromStateTransition(st) {
+        _assertClass(st, StateTransitionWASM);
+        var ptr0 = st.__destroy_into_raw();
+        const ret = wasm.identitycreatetransitionwasm_fromStateTransition(ptr0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return IdentityCreateTransitionWASM.__wrap(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} bytes
+     * @returns {IdentityCreateTransitionWASM}
+     */
+    static fromBuffer(bytes) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.identitycreatetransitionwasm_fromBuffer(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return IdentityCreateTransitionWASM.__wrap(ret[0]);
+    }
+}
+
+const IdentityPublicKeyInCreationWASMFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_identitypublickeyincreationwasm_free(ptr >>> 0, 1));
+
+export class IdentityPublicKeyInCreationWASM {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(IdentityPublicKeyInCreationWASM.prototype);
+        obj.__wbg_ptr = ptr;
+        IdentityPublicKeyInCreationWASMFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        IdentityPublicKeyInCreationWASMFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_identitypublickeyincreationwasm_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 {string} signature
+     */
+    constructor(id, purpose, security_level, key_type, read_only, binary_data, signature) {
+        const ptr0 = passStringToWasm0(binary_data, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(signature, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.identitypublickeyincreationwasm_new(id, purpose, security_level, key_type, read_only, ptr0, len0, ptr1, len1);
+        this.__wbg_ptr = ret >>> 0;
+        IdentityPublicKeyInCreationWASMFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {IdentityPublicKeyWASM}
+     */
+    toIdentityPublicKey() {
+        const ret = wasm.identitypublickeyincreationwasm_toIdentityPublicKey(this.__wbg_ptr);
+        return IdentityPublicKeyWASM.__wrap(ret);
+    }
+    /**
+     * @returns {number}
+     */
+    getKeyId() {
+        const ret = wasm.identitypublickeyincreationwasm_getKeyId(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {Purpose}
+     */
+    getPurpose() {
+        const ret = wasm.identitypublickeyincreationwasm_getPurpose(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {SecurityLevel}
+     */
+    getSecurityLevel() {
+        const ret = wasm.identitypublickeyincreationwasm_getSecurityLevel(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {KeyType}
+     */
+    getKeyType() {
+        const ret = wasm.identitypublickeyincreationwasm_getKeyType(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {boolean}
+     */
+    getReadOnly() {
+        const ret = wasm.identitypublickeyincreationwasm_getReadOnly(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {string}
+     */
+    getData() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.identitypublickeyincreationwasm_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);
+        }
+    }
+    /**
+     * @param {number} key_id
+     */
+    setKeyId(key_id) {
+        wasm.identitypublickeyincreationwasm_setKeyId(this.__wbg_ptr, key_id);
+    }
+    /**
+     * @param {Purpose} purpose
+     */
+    setPurpose(purpose) {
+        wasm.identitypublickeyincreationwasm_setPurpose(this.__wbg_ptr, purpose);
+    }
+    /**
+     * @param {SecurityLevel} security_level
+     */
+    setSecurityLevel(security_level) {
+        wasm.identitypublickeyincreationwasm_setSecurityLevel(this.__wbg_ptr, security_level);
+    }
+    /**
+     * @param {boolean} read_only
+     */
+    setReadOnly(read_only) {
+        wasm.identitypublickeyincreationwasm_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.identitypublickeyincreationwasm_setData(this.__wbg_ptr, ptr0, len0);
+    }
+}
+
 const IdentityPublicKeyWASMFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_identitypublickeywasm_free(ptr >>> 0, 1));
@@ -649,13 +901,14 @@ export class IdentityPublicKeyWASM {
      * @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) {
+    constructor(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);
+        this.__wbg_ptr = ret >>> 0;
+        IdentityPublicKeyWASMFinalization.register(this, this.__wbg_ptr, this);
+        return this;
     }
     /**
      * @returns {number}
@@ -758,6 +1011,133 @@ export class IdentityPublicKeyWASM {
     setDisabledAt(disabled_at) {
         wasm.identitypublickeywasm_setDisabledAt(this.__wbg_ptr, disabled_at);
     }
+    /**
+     * @returns {Uint8Array}
+     */
+    toBuffer() {
+        const ret = wasm.identitypublickeywasm_toBuffer(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;
+    }
+    /**
+     * @param {Uint8Array} buffer
+     * @returns {IdentityPublicKeyWASM}
+     */
+    static fromBuffer(buffer) {
+        const ptr0 = passArray8ToWasm0(buffer, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.identitypublickeywasm_fromBuffer(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return IdentityPublicKeyWASM.__wrap(ret[0]);
+    }
+}
+
+const IdentityWASMFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_identitywasm_free(ptr >>> 0, 1));
+
+export class IdentityWASM {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        IdentityWASMFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_identitywasm_free(ptr, 0);
+    }
+    /**
+     * @param {string} js_identifier
+     */
+    constructor(js_identifier) {
+        const ptr0 = passStringToWasm0(js_identifier, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.identitywasm_new(ptr0, len0);
+        this.__wbg_ptr = ret >>> 0;
+        IdentityWASMFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {string} js_identifier
+     */
+    setId(js_identifier) {
+        const ptr0 = passStringToWasm0(js_identifier, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.identitywasm_setId(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @param {bigint} balance
+     */
+    setBalance(balance) {
+        wasm.identitywasm_setBalance(this.__wbg_ptr, balance);
+    }
+    /**
+     * @param {bigint} revision
+     */
+    setRevision(revision) {
+        wasm.identitywasm_setRevision(this.__wbg_ptr, revision);
+    }
+    /**
+     * @param {IdentityPublicKeyWASM} public_key
+     */
+    addPublicKey(public_key) {
+        _assertClass(public_key, IdentityPublicKeyWASM);
+        var ptr0 = public_key.__destroy_into_raw();
+        wasm.identitywasm_addPublicKey(this.__wbg_ptr, ptr0);
+    }
+    /**
+     * @returns {string}
+     */
+    getId() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.identitywasm_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 {bigint}
+     */
+    getBalance() {
+        const ret = wasm.identitywasm_getBalance(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * @returns {bigint}
+     */
+    getRevision() {
+        const ret = wasm.identitywasm_getRevision(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * @param {number} key_id
+     * @returns {IdentityPublicKeyWASM}
+     */
+    getPublicKeyById(key_id) {
+        const ret = wasm.identitywasm_getPublicKeyById(this.__wbg_ptr, key_id);
+        return IdentityPublicKeyWASM.__wrap(ret);
+    }
+    /**
+     * @returns {any}
+     */
+    getPublicKeys() {
+        const ret = wasm.identitywasm_getPublicKeys(this.__wbg_ptr);
+        return ret;
+    }
 }
 
 const PrivateKeyWASMFinalization = (typeof FinalizationRegistry === 'undefined')
@@ -793,7 +1173,10 @@ export class PrivateKeyWASM {
         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);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return PrivateKeyWASM.__wrap(ret[0]);
     }
     /**
      * @returns {string}
@@ -810,6 +1193,92 @@ export class PrivateKeyWASM {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * @returns {Uint8Array}
+     */
+    getKeyBytes() {
+        const ret = wasm.privatekeywasm_getKeyBytes(this.__wbg_ptr);
+        var v1 = getArrayU8FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        return v1;
+    }
+}
+
+const StateTransitionWASMFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_statetransitionwasm_free(ptr >>> 0, 1));
+
+export class StateTransitionWASM {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(StateTransitionWASM.prototype);
+        obj.__wbg_ptr = ptr;
+        StateTransitionWASMFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        StateTransitionWASMFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_statetransitionwasm_free(ptr, 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.statetransitionwasm_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.statetransitionwasm_signByPrivateKey(this.__wbg_ptr, ptr0, key_type);
+        return ret;
+    }
+    /**
+     * @returns {any}
+     */
+    toBuffer() {
+        const ret = wasm.statetransitionwasm_toBuffer(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} buffer
+     * @returns {StateTransitionWASM}
+     */
+    static from_buffer(buffer) {
+        const ptr0 = passArray8ToWasm0(buffer, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.statetransitionwasm_from_buffer(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return StateTransitionWASM.__wrap(ret[0]);
+    }
 }
 
 async function __wbg_load(module, imports) {
@@ -869,6 +1338,10 @@ function __wbg_get_imports() {
     imports.wbg.__wbg_getRandomValues_bcb4912f16000dc4 = function() { return handleError(function (arg0, arg1) {
         arg0.getRandomValues(arg1);
     }, arguments) };
+    imports.wbg.__wbg_identitypublickeyincreationwasm_new = function(arg0) {
+        const ret = IdentityPublicKeyInCreationWASM.__wrap(arg0);
+        return ret;
+    };
     imports.wbg.__wbg_msCrypto_0a36e2ec3a343d26 = function(arg0) {
         const ret = arg0.msCrypto;
         return ret;
@@ -977,11 +1450,6 @@ function __wbg_get_imports() {
         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);