pshenmic-dpp 1.0.0 → 1.0.1

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);

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "pshenmic-dpp",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "main": "dist/wasm/pshenmic_dpp.js",
   "repository": {
     "type": "git",
-    "url": "https://github.com/owl352/pshemic-dpp"
+    "url": "https://github.com/owl352/pshenmic-dpp"
   },
   "scripts": {
     "tsc": "tsc",
@@ -20,6 +20,5 @@
     "babel": "^6.23.0",
     "babel-cli": "^6.26.0",
     "typescript": "^5.8.2"
-  },
-  "packageManager": "yarn@1.22.19+sha1.4ba7fc5c6e704fce2066ecbfb0b0d8976fe62447"
+  }
 }

package/packages/cbor-conversation/Cargo.toml

@@ -9,9 +9,13 @@ crate-type = ["cdylib", "lib"]
 [dependencies]
 wasm-bindgen = { version = "=0.2.100", features = ["serde-serialize"] }
 dpp = { git = "https://github.com/dashpay/platform", branch = "master", default-features = false, features = [
-    "cbor"
+    "cbor",
 ]}
 pshenmic_dpp_utils = {path = "../utils"}
 base64 = "0.22.1"
-ciborium = "0.2.0"
+ciborium = "0.2.2"
 serde-wasm-bindgen = { git = "https://github.com/QuantumExplorer/serde-wasm-bindgen", branch = "feat/not_human_readable" }
+
+[profile.release]
+lto = true
+opt-level = 'z'

package/packages/cbor-conversation/src/lib.rs

@@ -1,7 +1,5 @@
 use base64::Engine;
 use base64::prelude::BASE64_STANDARD;
-use ciborium;
-use ciborium::Value;
 use dpp::util::cbor_serializer::serializable_value_to_cbor;
 use pshenmic_dpp_utils::with_serde_to_platform_value;
 use wasm_bindgen::JsValue;
@@ -20,7 +18,7 @@ pub fn object_to_cbor(object: &JsValue) -> String {
 pub fn cbor_to_object(cbor: String) -> JsValue {
     let base64_bytes = BASE64_STANDARD.decode(cbor).unwrap();
 
-    let cbor: Value = ciborium::de::from_reader(base64_bytes.as_slice()).expect("REASON");
+    let cbor: ciborium::Value = ciborium::de::from_reader(base64_bytes.as_slice()).expect("REASON");
 
     serde_wasm_bindgen::to_value(&cbor).unwrap()
 }

package/packages/document/Cargo.toml

@@ -13,3 +13,7 @@ dpp = { git = "https://github.com/dashpay/platform", branch = "master", default-
     "document-json-conversion"
 ]}
 serde-wasm-bindgen = { git = "https://github.com/QuantumExplorer/serde-wasm-bindgen", branch = "feat/not_human_readable" }
+
+[profile.release]
+lto = true
+opt-level = 'z'