@midnightntwrk/onchain-runtime-v5 5.0.0-alpha.1

package/midnight_onchain_runtime_wasm_bg.js

@@ -0,0 +1,2880 @@
+export class ChargedState {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(ChargedState.prototype);
+        obj.__wbg_ptr = ptr;
+        ChargedStateFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ChargedStateFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_chargedstate_free(ptr, 0);
+    }
+    /**
+     * @param {StateValue} state
+     */
+    constructor(state) {
+        _assertClass(state, StateValue);
+        const ret = wasm.chargedstate_new(state.__wbg_ptr);
+        this.__wbg_ptr = ret >>> 0;
+        ChargedStateFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {StateValue}
+     */
+    get state() {
+        const ret = wasm.chargedstate_state(this.__wbg_ptr);
+        return StateValue.__wrap(ret);
+    }
+    /**
+     * @param {boolean | null} [compact]
+     * @returns {string}
+     */
+    toString(compact) {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.chargedstate_toString(this.__wbg_ptr, isLikeNone(compact) ? 0xFFFFFF : compact ? 1 : 0);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) ChargedState.prototype[Symbol.dispose] = ChargedState.prototype.free;
+
+export class ContractMaintenanceAuthority {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(ContractMaintenanceAuthority.prototype);
+        obj.__wbg_ptr = ptr;
+        ContractMaintenanceAuthorityFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ContractMaintenanceAuthorityFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_contractmaintenanceauthority_free(ptr, 0);
+    }
+    /**
+     * @returns {Array<any>}
+     */
+    get committee() {
+        const ret = wasm.contractmaintenanceauthority_committee(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {bigint}
+     */
+    get counter() {
+        const ret = wasm.contractmaintenanceauthority_counter(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {Uint8Array} raw
+     * @returns {ContractMaintenanceAuthority}
+     */
+    static deserialize(raw) {
+        const ret = wasm.contractmaintenanceauthority_deserialize(raw);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ContractMaintenanceAuthority.__wrap(ret[0]);
+    }
+    /**
+     * @param {Array<any>} committee
+     * @param {number} threshold
+     * @param {bigint | null} [counter]
+     */
+    constructor(committee, threshold, counter) {
+        const ret = wasm.contractmaintenanceauthority_new(committee, threshold, isLikeNone(counter) ? 0 : addToExternrefTable0(counter));
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        ContractMaintenanceAuthorityFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {any}
+     */
+    serialize() {
+        const ret = wasm.contractmaintenanceauthority_serialize(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {number}
+     */
+    get threshold() {
+        const ret = wasm.contractmaintenanceauthority_threshold(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @param {boolean | null} [compact]
+     * @returns {string}
+     */
+    toString(compact) {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.contractmaintenanceauthority_toString(this.__wbg_ptr, isLikeNone(compact) ? 0xFFFFFF : compact ? 1 : 0);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) ContractMaintenanceAuthority.prototype[Symbol.dispose] = ContractMaintenanceAuthority.prototype.free;
+
+export class ContractOperation {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(ContractOperation.prototype);
+        obj.__wbg_ptr = ptr;
+        ContractOperationFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ContractOperationFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_contractoperation_free(ptr, 0);
+    }
+    /**
+     * @param {Uint8Array} raw
+     * @returns {ContractOperation}
+     */
+    static deserialize(raw) {
+        const ret = wasm.contractoperation_deserialize(raw);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ContractOperation.__wrap(ret[0]);
+    }
+    constructor() {
+        const ret = wasm.contractoperation_new();
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        ContractOperationFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {any}
+     */
+    serialize() {
+        const ret = wasm.contractoperation_serialize(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {Uint8Array} key
+     */
+    set verifierKey(key) {
+        const ret = wasm.contractoperation_set_verifier_key(this.__wbg_ptr, key);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {boolean | null} [compact]
+     * @returns {string}
+     */
+    toString(compact) {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.contractoperation_toString(this.__wbg_ptr, isLikeNone(compact) ? 0xFFFFFF : compact ? 1 : 0);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {any}
+     */
+    get verifierKey() {
+        const ret = wasm.contractoperation_verifier_key(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+}
+if (Symbol.dispose) ContractOperation.prototype[Symbol.dispose] = ContractOperation.prototype.free;
+
+export class ContractState {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(ContractState.prototype);
+        obj.__wbg_ptr = ptr;
+        ContractStateFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ContractStateFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_contractstate_free(ptr, 0);
+    }
+    /**
+     * @returns {Map<any, any>}
+     */
+    get balance() {
+        const ret = wasm.contractstate_balance(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {ChargedState}
+     */
+    get data() {
+        const ret = wasm.contractstate_data(this.__wbg_ptr);
+        return ChargedState.__wrap(ret);
+    }
+    /**
+     * @param {Uint8Array} raw
+     * @returns {ContractState}
+     */
+    static deserialize(raw) {
+        const ret = wasm.contractstate_deserialize(raw);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ContractState.__wrap(ret[0]);
+    }
+    /**
+     * @returns {ContractMaintenanceAuthority}
+     */
+    get maintenanceAuthority() {
+        const ret = wasm.contractstate_maintenance_authority(this.__wbg_ptr);
+        return ContractMaintenanceAuthority.__wrap(ret);
+    }
+    constructor() {
+        const ret = wasm.contractstate_new();
+        this.__wbg_ptr = ret >>> 0;
+        ContractStateFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {any} operation
+     * @returns {ContractOperation | undefined}
+     */
+    operation(operation) {
+        const ret = wasm.contractstate_operation(this.__wbg_ptr, operation);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] === 0 ? undefined : ContractOperation.__wrap(ret[0]);
+    }
+    /**
+     * @returns {any[]}
+     */
+    operations() {
+        const ret = wasm.contractstate_operations(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * @param {any} query
+     * @param {CostModel} cost_model
+     * @returns {any}
+     */
+    query(query, cost_model) {
+        _assertClass(cost_model, CostModel);
+        const ret = wasm.contractstate_query(this.__wbg_ptr, query, cost_model.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {any}
+     */
+    serialize() {
+        const ret = wasm.contractstate_serialize(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {any} operation
+     * @param {ContractOperation} value
+     */
+    setOperation(operation, value) {
+        _assertClass(value, ContractOperation);
+        const ret = wasm.contractstate_setOperation(this.__wbg_ptr, operation, value.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {Map<any, any>} value_map
+     */
+    set balance(value_map) {
+        const ret = wasm.contractstate_set_balance(this.__wbg_ptr, value_map);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {ChargedState} data
+     */
+    set data(data) {
+        _assertClass(data, ChargedState);
+        wasm.contractstate_set_data(this.__wbg_ptr, data.__wbg_ptr);
+    }
+    /**
+     * @param {ContractMaintenanceAuthority} authority
+     */
+    set maintenanceAuthority(authority) {
+        _assertClass(authority, ContractMaintenanceAuthority);
+        wasm.contractstate_set_maintenance_authority(this.__wbg_ptr, authority.__wbg_ptr);
+    }
+    /**
+     * @param {boolean | null} [compact]
+     * @returns {string}
+     */
+    toString(compact) {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.contractstate_toString(this.__wbg_ptr, isLikeNone(compact) ? 0xFFFFFF : compact ? 1 : 0);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) ContractState.prototype[Symbol.dispose] = ContractState.prototype.free;
+
+export class CostModel {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(CostModel.prototype);
+        obj.__wbg_ptr = ptr;
+        CostModelFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        CostModelFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_costmodel_free(ptr, 0);
+    }
+    /**
+     * @returns {CostModel}
+     */
+    static initialCostModel() {
+        const ret = wasm.costmodel_initialCostModel();
+        return CostModel.__wrap(ret);
+    }
+    constructor() {
+        const ret = wasm.costmodel_new();
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        CostModelFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {boolean | null} [compact]
+     * @returns {string}
+     */
+    toString(compact) {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.costmodel_toString(this.__wbg_ptr, isLikeNone(compact) ? 0xFFFFFF : compact ? 1 : 0);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) CostModel.prototype[Symbol.dispose] = CostModel.prototype.free;
+
+export class IntoUnderlyingByteSource {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        IntoUnderlyingByteSourceFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_intounderlyingbytesource_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    get autoAllocateChunkSize() {
+        const ret = wasm.intounderlyingbytesource_autoAllocateChunkSize(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    cancel() {
+        const ptr = this.__destroy_into_raw();
+        wasm.intounderlyingbytesource_cancel(ptr);
+    }
+    /**
+     * @param {ReadableByteStreamController} controller
+     * @returns {Promise<any>}
+     */
+    pull(controller) {
+        const ret = wasm.intounderlyingbytesource_pull(this.__wbg_ptr, controller);
+        return ret;
+    }
+    /**
+     * @param {ReadableByteStreamController} controller
+     */
+    start(controller) {
+        wasm.intounderlyingbytesource_start(this.__wbg_ptr, controller);
+    }
+    /**
+     * @returns {ReadableStreamType}
+     */
+    get type() {
+        const ret = wasm.intounderlyingbytesource_type(this.__wbg_ptr);
+        return __wbindgen_enum_ReadableStreamType[ret];
+    }
+}
+if (Symbol.dispose) IntoUnderlyingByteSource.prototype[Symbol.dispose] = IntoUnderlyingByteSource.prototype.free;
+
+export class IntoUnderlyingSink {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        IntoUnderlyingSinkFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_intounderlyingsink_free(ptr, 0);
+    }
+    /**
+     * @param {any} reason
+     * @returns {Promise<any>}
+     */
+    abort(reason) {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.intounderlyingsink_abort(ptr, reason);
+        return ret;
+    }
+    /**
+     * @returns {Promise<any>}
+     */
+    close() {
+        const ptr = this.__destroy_into_raw();
+        const ret = wasm.intounderlyingsink_close(ptr);
+        return ret;
+    }
+    /**
+     * @param {any} chunk
+     * @returns {Promise<any>}
+     */
+    write(chunk) {
+        const ret = wasm.intounderlyingsink_write(this.__wbg_ptr, chunk);
+        return ret;
+    }
+}
+if (Symbol.dispose) IntoUnderlyingSink.prototype[Symbol.dispose] = IntoUnderlyingSink.prototype.free;
+
+export class IntoUnderlyingSource {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        IntoUnderlyingSourceFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_intounderlyingsource_free(ptr, 0);
+    }
+    cancel() {
+        const ptr = this.__destroy_into_raw();
+        wasm.intounderlyingsource_cancel(ptr);
+    }
+    /**
+     * @param {ReadableStreamDefaultController} controller
+     * @returns {Promise<any>}
+     */
+    pull(controller) {
+        const ret = wasm.intounderlyingsource_pull(this.__wbg_ptr, controller);
+        return ret;
+    }
+}
+if (Symbol.dispose) IntoUnderlyingSource.prototype[Symbol.dispose] = IntoUnderlyingSource.prototype.free;
+
+export class QueryContext {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(QueryContext.prototype);
+        obj.__wbg_ptr = ptr;
+        QueryContextFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        QueryContextFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_querycontext_free(ptr, 0);
+    }
+    /**
+     * @returns {string}
+     */
+    get address() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.querycontext_address(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);
+        }
+    }
+    /**
+     * @returns {any}
+     */
+    get block() {
+        const ret = wasm.querycontext_block(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {any}
+     */
+    get comIndices() {
+        const ret = wasm.querycontext_com_indices(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {any}
+     */
+    get effects() {
+        const ret = wasm.querycontext_effects(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {string} comm
+     * @param {bigint} index
+     * @returns {QueryContext}
+     */
+    insertCommitment(comm, index) {
+        const ptr0 = passStringToWasm0(comm, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.querycontext_insertCommitment(this.__wbg_ptr, ptr0, len0, index);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return QueryContext.__wrap(ret[0]);
+    }
+    /**
+     * @param {ChargedState} state
+     * @param {string} address
+     */
+    constructor(state, address) {
+        _assertClass(state, ChargedState);
+        const ptr0 = passStringToWasm0(address, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.querycontext_new(state.__wbg_ptr, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        QueryContextFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {any} coin
+     * @returns {any}
+     */
+    qualify(coin) {
+        const ret = wasm.querycontext_qualify(this.__wbg_ptr, coin);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {any} ops
+     * @param {CostModel} cost_model
+     * @param {any} gas_limit
+     * @returns {QueryResults}
+     */
+    query(ops, cost_model, gas_limit) {
+        _assertClass(cost_model, CostModel);
+        const ret = wasm.querycontext_query(this.__wbg_ptr, ops, cost_model.__wbg_ptr, gas_limit);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return QueryResults.__wrap(ret[0]);
+    }
+    /**
+     * @param {any} transcript
+     * @param {CostModel} cost_model
+     * @returns {QueryContext}
+     */
+    runTranscript(transcript, cost_model) {
+        _assertClass(cost_model, CostModel);
+        const ret = wasm.querycontext_runTranscript(this.__wbg_ptr, transcript, cost_model.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return QueryContext.__wrap(ret[0]);
+    }
+    /**
+     * @param {any} block
+     */
+    set block(block) {
+        const ret = wasm.querycontext_set_block(this.__wbg_ptr, block);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @param {any} effects
+     */
+    set effects(effects) {
+        const ret = wasm.querycontext_set_effects(this.__wbg_ptr, effects);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    /**
+     * @returns {ChargedState}
+     */
+    get state() {
+        const ret = wasm.querycontext_state(this.__wbg_ptr);
+        return ChargedState.__wrap(ret);
+    }
+    /**
+     * @param {boolean | null} [compact]
+     * @returns {string}
+     */
+    toString(compact) {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.querycontext_toString(this.__wbg_ptr, isLikeNone(compact) ? 0xFFFFFF : compact ? 1 : 0);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {VmStack}
+     */
+    toVmStack() {
+        const ret = wasm.querycontext_toVmStack(this.__wbg_ptr);
+        return VmStack.__wrap(ret);
+    }
+}
+if (Symbol.dispose) QueryContext.prototype[Symbol.dispose] = QueryContext.prototype.free;
+
+export class QueryResults {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(QueryResults.prototype);
+        obj.__wbg_ptr = ptr;
+        QueryResultsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        QueryResultsFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_queryresults_free(ptr, 0);
+    }
+    /**
+     * @returns {QueryContext}
+     */
+    get context() {
+        const ret = wasm.queryresults_context(this.__wbg_ptr);
+        return QueryContext.__wrap(ret);
+    }
+    /**
+     * @returns {any}
+     */
+    get events() {
+        const ret = wasm.queryresults_events(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {any}
+     */
+    get gasCost() {
+        const ret = wasm.queryresults_gas_cost(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    constructor() {
+        const ret = wasm.queryresults_new();
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        QueryResultsFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {boolean | null} [compact]
+     * @returns {string}
+     */
+    toString(compact) {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.queryresults_toString(this.__wbg_ptr, isLikeNone(compact) ? 0xFFFFFF : compact ? 1 : 0);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) QueryResults.prototype[Symbol.dispose] = QueryResults.prototype.free;
+
+export class StateBoundedMerkleTree {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(StateBoundedMerkleTree.prototype);
+        obj.__wbg_ptr = ptr;
+        StateBoundedMerkleTreeFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        StateBoundedMerkleTreeFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_stateboundedmerkletree_free(ptr, 0);
+    }
+    /**
+     * @param {number} height
+     */
+    constructor(height) {
+        const ret = wasm.stateboundedmerkletree_blank(height);
+        this.__wbg_ptr = ret >>> 0;
+        StateBoundedMerkleTreeFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {bigint} start
+     * @param {bigint} end
+     * @returns {StateBoundedMerkleTree}
+     */
+    collapse(start, end) {
+        const ret = wasm.stateboundedmerkletree_collapse(this.__wbg_ptr, start, end);
+        return StateBoundedMerkleTree.__wrap(ret);
+    }
+    /**
+     * @param {any} leaf
+     * @param {bigint | null} [index_start]
+     * @param {bigint | null} [index_end]
+     * @param {boolean | null} [already_hashed]
+     * @returns {any}
+     */
+    findPathForLeaf(leaf, index_start, index_end, already_hashed) {
+        const ret = wasm.stateboundedmerkletree_findPathForLeaf(this.__wbg_ptr, leaf, !isLikeNone(index_start), isLikeNone(index_start) ? BigInt(0) : index_start, !isLikeNone(index_end), isLikeNone(index_end) ? BigInt(0) : index_end, isLikeNone(already_hashed) ? 0xFFFFFF : already_hashed ? 1 : 0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {number}
+     */
+    get height() {
+        const ret = wasm.stateboundedmerkletree_height(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @param {bigint} index
+     * @param {any} leaf
+     * @returns {any}
+     */
+    pathForLeaf(index, leaf) {
+        const ret = wasm.stateboundedmerkletree_pathForLeaf(this.__wbg_ptr, index, leaf);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {StateBoundedMerkleTree}
+     */
+    rehash() {
+        const ret = wasm.stateboundedmerkletree_rehash(this.__wbg_ptr);
+        return StateBoundedMerkleTree.__wrap(ret);
+    }
+    /**
+     * @returns {any}
+     */
+    root() {
+        const ret = wasm.stateboundedmerkletree_root(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {boolean | null} [compact]
+     * @returns {string}
+     */
+    toString(compact) {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.stateboundedmerkletree_toString(this.__wbg_ptr, isLikeNone(compact) ? 0xFFFFFF : compact ? 1 : 0);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @param {bigint} index
+     * @param {any} leaf
+     * @returns {StateBoundedMerkleTree}
+     */
+    update(index, leaf) {
+        const ret = wasm.stateboundedmerkletree_update(this.__wbg_ptr, index, leaf);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return StateBoundedMerkleTree.__wrap(ret[0]);
+    }
+}
+if (Symbol.dispose) StateBoundedMerkleTree.prototype[Symbol.dispose] = StateBoundedMerkleTree.prototype.free;
+
+export class StateMap {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(StateMap.prototype);
+        obj.__wbg_ptr = ptr;
+        StateMapFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        StateMapFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_statemap_free(ptr, 0);
+    }
+    /**
+     * @param {any} key
+     * @returns {StateValue | undefined}
+     */
+    get(key) {
+        const ret = wasm.statemap_get(this.__wbg_ptr, key);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] === 0 ? undefined : StateValue.__wrap(ret[0]);
+    }
+    /**
+     * @param {any} key
+     * @param {StateValue} value
+     * @returns {StateMap}
+     */
+    insert(key, value) {
+        _assertClass(value, StateValue);
+        const ret = wasm.statemap_insert(this.__wbg_ptr, key, value.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return StateMap.__wrap(ret[0]);
+    }
+    /**
+     * @returns {any[]}
+     */
+    keys() {
+        const ret = wasm.statemap_keys(this.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    constructor() {
+        const ret = wasm.statemap_new();
+        this.__wbg_ptr = ret >>> 0;
+        StateMapFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {any} key
+     * @returns {StateMap}
+     */
+    remove(key) {
+        const ret = wasm.statemap_remove(this.__wbg_ptr, key);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return StateMap.__wrap(ret[0]);
+    }
+    /**
+     * @param {boolean | null} [compact]
+     * @returns {string}
+     */
+    toString(compact) {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.statemap_toString(this.__wbg_ptr, isLikeNone(compact) ? 0xFFFFFF : compact ? 1 : 0);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) StateMap.prototype[Symbol.dispose] = StateMap.prototype.free;
+
+export class StateValue {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(StateValue.prototype);
+        obj.__wbg_ptr = ptr;
+        StateValueFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        StateValueFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_statevalue_free(ptr, 0);
+    }
+    /**
+     * @param {StateValue} value
+     * @returns {StateValue}
+     */
+    arrayPush(value) {
+        _assertClass(value, StateValue);
+        const ret = wasm.statevalue_arrayPush(this.__wbg_ptr, value.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return StateValue.__wrap(ret[0]);
+    }
+    /**
+     * @returns {any[] | undefined}
+     */
+    asArray() {
+        const ret = wasm.statevalue_asArray(this.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        }
+        return v1;
+    }
+    /**
+     * @returns {StateBoundedMerkleTree | undefined}
+     */
+    asBoundedMerkleTree() {
+        const ret = wasm.statevalue_asBoundedMerkleTree(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] === 0 ? undefined : StateBoundedMerkleTree.__wrap(ret[0]);
+    }
+    /**
+     * @returns {any}
+     */
+    asCell() {
+        const ret = wasm.statevalue_asCell(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {StateMap | undefined}
+     */
+    asMap() {
+        const ret = wasm.statevalue_asMap(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return ret[0] === 0 ? undefined : StateMap.__wrap(ret[0]);
+    }
+    /**
+     * @param {any} value
+     * @returns {StateValue}
+     */
+    static decode(value) {
+        const ret = wasm.statevalue_decode(value);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return StateValue.__wrap(ret[0]);
+    }
+    /**
+     * @returns {any}
+     */
+    encode() {
+        const ret = wasm.statevalue_encode(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {number}
+     */
+    logSize() {
+        const ret = wasm.statevalue_logSize(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    constructor() {
+        const ret = wasm.statevalue_new();
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        StateValueFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @returns {StateValue}
+     */
+    static newArray() {
+        const ret = wasm.statevalue_newArray();
+        return StateValue.__wrap(ret);
+    }
+    /**
+     * @param {StateBoundedMerkleTree} tree
+     * @returns {StateValue}
+     */
+    static newBoundedMerkleTree(tree) {
+        _assertClass(tree, StateBoundedMerkleTree);
+        const ret = wasm.statevalue_newBoundedMerkleTree(tree.__wbg_ptr);
+        return StateValue.__wrap(ret);
+    }
+    /**
+     * @param {any} value
+     * @returns {StateValue}
+     */
+    static newCell(value) {
+        const ret = wasm.statevalue_newCell(value);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return StateValue.__wrap(ret[0]);
+    }
+    /**
+     * @param {StateMap} map
+     * @returns {StateValue}
+     */
+    static newMap(map) {
+        _assertClass(map, StateMap);
+        const ret = wasm.statevalue_newMap(map.__wbg_ptr);
+        return StateValue.__wrap(ret);
+    }
+    /**
+     * @returns {StateValue}
+     */
+    static newNull() {
+        const ret = wasm.statevalue_newNull();
+        return StateValue.__wrap(ret);
+    }
+    /**
+     * @param {boolean | null} [compact]
+     * @returns {string}
+     */
+    toString(compact) {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.statevalue_toString(this.__wbg_ptr, isLikeNone(compact) ? 0xFFFFFF : compact ? 1 : 0);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {string}
+     */
+    type() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.statevalue_type(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);
+        }
+    }
+}
+if (Symbol.dispose) StateValue.prototype[Symbol.dispose] = StateValue.prototype.free;
+
+export class VmResults {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(VmResults.prototype);
+        obj.__wbg_ptr = ptr;
+        VmResultsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        VmResultsFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_vmresults_free(ptr, 0);
+    }
+    /**
+     * @returns {any}
+     */
+    get events() {
+        const ret = wasm.vmresults_events(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @returns {any}
+     */
+    get gasCost() {
+        const ret = wasm.vmresults_gas_cost(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    constructor() {
+        const ret = wasm.vmresults_new();
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return StateValue.__wrap(ret[0]);
+    }
+    /**
+     * @returns {VmStack}
+     */
+    get stack() {
+        const ret = wasm.vmresults_stack(this.__wbg_ptr);
+        return VmStack.__wrap(ret);
+    }
+    /**
+     * @param {boolean | null} [compact]
+     * @returns {string}
+     */
+    toString(compact) {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.vmresults_toString(this.__wbg_ptr, isLikeNone(compact) ? 0xFFFFFF : compact ? 1 : 0);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) VmResults.prototype[Symbol.dispose] = VmResults.prototype.free;
+
+export class VmStack {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(VmStack.prototype);
+        obj.__wbg_ptr = ptr;
+        VmStackFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        VmStackFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_vmstack_free(ptr, 0);
+    }
+    /**
+     * @param {number} idx
+     * @returns {StateValue | undefined}
+     */
+    get(idx) {
+        const ret = wasm.vmstack_get(this.__wbg_ptr, idx);
+        return ret === 0 ? undefined : StateValue.__wrap(ret);
+    }
+    /**
+     * @param {number} idx
+     * @returns {boolean | undefined}
+     */
+    isStrong(idx) {
+        const ret = wasm.vmstack_isStrong(this.__wbg_ptr, idx);
+        return ret === 0xFFFFFF ? undefined : ret !== 0;
+    }
+    /**
+     * @returns {number}
+     */
+    length() {
+        const ret = wasm.vmstack_length(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    constructor() {
+        const ret = wasm.vmstack_new();
+        this.__wbg_ptr = ret >>> 0;
+        VmStackFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {StateValue} value
+     * @param {boolean} is_strong
+     */
+    push(value, is_strong) {
+        _assertClass(value, StateValue);
+        wasm.vmstack_push(this.__wbg_ptr, value.__wbg_ptr, is_strong);
+    }
+    removeLast() {
+        wasm.vmstack_removeLast(this.__wbg_ptr);
+    }
+    /**
+     * @param {boolean | null} [compact]
+     * @returns {string}
+     */
+    toString(compact) {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.vmstack_toString(this.__wbg_ptr, isLikeNone(compact) ? 0xFFFFFF : compact ? 1 : 0);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+}
+if (Symbol.dispose) VmStack.prototype[Symbol.dispose] = VmStack.prototype.free;
+
+/**
+ * @param {bigint} x
+ * @returns {bigint}
+ */
+export function bigIntModFr(x) {
+    const ret = wasm.bigIntModFr(x);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {bigint} x
+ * @returns {any}
+ */
+export function bigIntToValue(x) {
+    const ret = wasm.bigIntToValue(x);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {any} input
+ * @param {any} output
+ * @param {string} rand
+ * @returns {string}
+ */
+export function communicationCommitment(input, output, rand) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(rand, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.communicationCommitment(input, output, 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);
+    }
+}
+
+/**
+ * @returns {string}
+ */
+export function communicationCommitmentRandomness() {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ret = wasm.communicationCommitmentRandomness();
+        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);
+    }
+}
+
+/**
+ * @param {Uint8Array} pk
+ * @returns {string}
+ */
+export function decodeCoinPublicKey(pk) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ret = wasm.decodeCoinPublicKey(pk);
+        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);
+    }
+}
+
+/**
+ * @param {Uint8Array} addr
+ * @returns {string}
+ */
+export function decodeContractAddress(addr) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ret = wasm.decodeContractAddress(addr);
+        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);
+    }
+}
+
+/**
+ * @param {any} coin
+ * @returns {any}
+ */
+export function decodeQualifiedShieldedCoinInfo(coin) {
+    const ret = wasm.decodeQualifiedShieldedCoinInfo(coin);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {Uint8Array} tt
+ * @returns {string}
+ */
+export function decodeRawTokenType(tt) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ret = wasm.decodeRawTokenType(tt);
+        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);
+    }
+}
+
+/**
+ * @param {any} coin
+ * @returns {any}
+ */
+export function decodeShieldedCoinInfo(coin) {
+    const ret = wasm.decodeShieldedCoinInfo(coin);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {Uint8Array} addr
+ * @returns {string}
+ */
+export function decodeUserAddress(addr) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ret = wasm.decodeUserAddress(addr);
+        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);
+    }
+}
+
+/**
+ * @param {any} persistent
+ * @returns {any}
+ */
+export function degradeToTransient(persistent) {
+    const ret = wasm.degradeToTransient(persistent);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @returns {string}
+ */
+export function dummyContractAddress() {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ret = wasm.dummyContractAddress();
+        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);
+    }
+}
+
+/**
+ * @returns {string}
+ */
+export function dummyUserAddress() {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ret = wasm.dummyUserAddress();
+        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);
+    }
+}
+
+/**
+ * @param {any} a
+ * @param {any} b
+ * @returns {any}
+ */
+export function ecAdd(a, b) {
+    const ret = wasm.ecAdd(a, b);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {any} a
+ * @param {any} b
+ * @returns {any}
+ */
+export function ecMul(a, b) {
+    const ret = wasm.ecMul(a, b);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {any} val
+ * @returns {any}
+ */
+export function ecMulGenerator(val) {
+    const ret = wasm.ecMulGenerator(val);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {string} pk
+ * @returns {Uint8Array}
+ */
+export function encodeCoinPublicKey(pk) {
+    const ptr0 = passStringToWasm0(pk, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.encodeCoinPublicKey(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {string} addr
+ * @returns {Uint8Array}
+ */
+export function encodeContractAddress(addr) {
+    const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.encodeContractAddress(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {any} coin
+ * @returns {any}
+ */
+export function encodeQualifiedShieldedCoinInfo(coin) {
+    const ret = wasm.encodeQualifiedShieldedCoinInfo(coin);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {string} tt
+ * @returns {Uint8Array}
+ */
+export function encodeRawTokenType(tt) {
+    const ptr0 = passStringToWasm0(tt, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.encodeRawTokenType(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {any} coin
+ * @returns {any}
+ */
+export function encodeShieldedCoinInfo(coin) {
+    const ret = wasm.encodeShieldedCoinInfo(coin);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {string} addr
+ * @returns {Uint8Array}
+ */
+export function encodeUserAddress(addr) {
+    const ptr0 = passStringToWasm0(addr, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.encodeUserAddress(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {any} entry_point
+ * @returns {string}
+ */
+export function entryPointHash(entry_point) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ret = wasm.entryPointHash(entry_point);
+        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);
+    }
+}
+
+/**
+ * @param {any} align
+ * @param {any} val
+ * @returns {any}
+ */
+export function hashToCurve(align, val) {
+    const ret = wasm.hashToCurve(align, val);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Sample a random JubJub scalar, returned as a native field element.
+ * @returns {any}
+ */
+export function jubjubSampleScalar() {
+    const ret = wasm.jubjubSampleScalar();
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Converts a native field element (BLS12-381 scalar) to a JubJub scalar field element,
+ * reducing modulo the JubJub scalar field modulus.
+ * @param {any} native
+ * @returns {any}
+ */
+export function jubjubScalarFromNative(native) {
+    const ret = wasm.jubjubScalarFromNative(native);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {any} value
+ * @returns {any}
+ */
+export function leafHash(value) {
+    const ret = wasm.leafHash(value);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {any} alignment
+ * @returns {bigint}
+ */
+export function maxAlignedSize(alignment) {
+    const ret = wasm.maxAlignedSize(alignment);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return BigInt.asUintN(64, ret[0]);
+}
+
+/**
+ * @returns {bigint}
+ */
+export function maxField() {
+    const ret = wasm.maxField();
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Returns the largest representable JubJub scalar (i.e. the JubJub scalar field modulus minus one).
+ * @returns {bigint}
+ */
+export function maxJubjubScalar() {
+    const ret = wasm.maxJubjubScalar();
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * Converts a JubJub scalar field element to a native field element (BLS12-381 scalar).
+ * @param {any} jubjub
+ * @returns {any}
+ */
+export function nativeFromJubjubScalar(jubjub) {
+    const ret = wasm.nativeFromJubjubScalar(jubjub);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {any} align
+ * @param {any} val
+ * @param {any} opening
+ * @returns {any}
+ */
+export function persistentCommit(align, val, opening) {
+    const ret = wasm.persistentCommit(align, val, opening);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {any} align
+ * @param {any} val
+ * @returns {any}
+ */
+export function persistentHash(align, val) {
+    const ret = wasm.persistentHash(align, val);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {any} input
+ * @param {any} output
+ * @param {any} public_transcript
+ * @param {any} private_transcript_outputs
+ * @param {string | null} [key_location]
+ * @param {Uint8Array[] | null} [inner_proofs]
+ * @returns {Uint8Array}
+ */
+export function proofDataIntoSerializedPreimage(input, output, public_transcript, private_transcript_outputs, key_location, inner_proofs) {
+    var ptr0 = isLikeNone(key_location) ? 0 : passStringToWasm0(key_location, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len0 = WASM_VECTOR_LEN;
+    var ptr1 = isLikeNone(inner_proofs) ? 0 : passArrayJsValueToWasm0(inner_proofs, wasm.__wbindgen_malloc);
+    var len1 = WASM_VECTOR_LEN;
+    const ret = wasm.proofDataIntoSerializedPreimage(input, output, public_transcript, private_transcript_outputs, ptr0, len0, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {Uint8Array} domain_sep
+ * @param {string} contract
+ * @returns {string}
+ */
+export function rawTokenType(domain_sep, contract) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(contract, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.rawTokenType(domain_sep, 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 {VmStack} initial
+ * @param {any} ops
+ * @param {CostModel} cost_model
+ * @param {any} gas_limit
+ * @returns {VmResults}
+ */
+export function runProgram(initial, ops, cost_model, gas_limit) {
+    _assertClass(initial, VmStack);
+    _assertClass(cost_model, CostModel);
+    const ret = wasm.runProgram(initial.__wbg_ptr, ops, cost_model.__wbg_ptr, gas_limit);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return VmResults.__wrap(ret[0]);
+}
+
+/**
+ * @param {any} coin
+ * @param {any} recipient
+ * @returns {any}
+ */
+export function runtimeCoinCommitment(coin, recipient) {
+    const ret = wasm.runtimeCoinCommitment(coin, recipient);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {any} coin
+ * @param {any} sender_evidence
+ * @returns {any}
+ */
+export function runtimeCoinNullifier(coin, sender_evidence) {
+    const ret = wasm.runtimeCoinNullifier(coin, sender_evidence);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @returns {string}
+ */
+export function sampleContractAddress() {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ret = wasm.sampleContractAddress();
+        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);
+    }
+}
+
+/**
+ * @returns {string}
+ */
+export function sampleRawTokenType() {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ret = wasm.sampleRawTokenType();
+        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);
+    }
+}
+
+/**
+ * @param {string | null} [kind]
+ * @returns {any}
+ */
+export function sampleSigningKey(kind) {
+    var ptr0 = isLikeNone(kind) ? 0 : passStringToWasm0(kind, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len0 = WASM_VECTOR_LEN;
+    const ret = wasm.sampleSigningKey(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @returns {string}
+ */
+export function sampleUserAddress() {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ret = wasm.sampleUserAddress();
+        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);
+    }
+}
+
+/**
+ * @param {any} key
+ * @param {Uint8Array} data
+ * @returns {any}
+ */
+export function signData(key, data) {
+    const ret = wasm.signData(key, data);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {any} sk
+ * @returns {any}
+ */
+export function signatureVerifyingKey(sk) {
+    const ret = wasm.signatureVerifyingKey(sk);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {Uint8Array} bytes
+ * @returns {any}
+ */
+export function signingKeyFromBip340(bytes) {
+    const ret = wasm.signingKeyFromBip340(bytes);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {any} align
+ * @param {any} val
+ * @param {any} opening
+ * @returns {any}
+ */
+export function transientCommit(align, val, opening) {
+    const ret = wasm.transientCommit(align, val, opening);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {any} align
+ * @param {any} val
+ * @returns {any}
+ */
+export function transientHash(align, val) {
+    const ret = wasm.transientHash(align, val);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {any} transient
+ * @returns {any}
+ */
+export function upgradeFromTransient(transient) {
+    const ret = wasm.upgradeFromTransient(transient);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {any} x
+ * @returns {bigint}
+ */
+export function valueToBigInt(x) {
+    const ret = wasm.valueToBigInt(x);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return takeFromExternrefTable0(ret[0]);
+}
+
+/**
+ * @param {any} key
+ * @param {Uint8Array} data
+ * @param {any} signature
+ * @returns {boolean}
+ */
+export function verifySignature(key, data, signature) {
+    const ret = wasm.verifySignature(key, data, signature);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return ret[0] !== 0;
+}
+export function __wbg_BigInt_7ea1e749ce6b92fd() { return handleError(function (arg0) {
+    const ret = BigInt(arg0);
+    return ret;
+}, arguments); }
+export function __wbg_BigInt_b7bbccdff258c9f2(arg0) {
+    const ret = BigInt(arg0);
+    return ret;
+}
+export function __wbg_Error_8c4e43fe74559d73(arg0, arg1) {
+    const ret = Error(getStringFromWasm0(arg0, arg1));
+    return ret;
+}
+export function __wbg_Number_04624de7d0e8332d(arg0) {
+    const ret = Number(arg0);
+    return ret;
+}
+export function __wbg_String_8f0eb39a4a4c2f66(arg0, arg1) {
+    const ret = String(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);
+}
+export function __wbg___wbindgen_bigint_get_as_i64_8fcf4ce7f1ca72a2(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);
+}
+export function __wbg___wbindgen_boolean_get_bbbb1c18aa2f5e25(arg0) {
+    const v = arg0;
+    const ret = typeof(v) === 'boolean' ? v : undefined;
+    return isLikeNone(ret) ? 0xFFFFFF : ret ? 1 : 0;
+}
+export function __wbg___wbindgen_debug_string_0bc8482c6e3508ae(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);
+}
+export function __wbg___wbindgen_in_47fa6863be6f2f25(arg0, arg1) {
+    const ret = arg0 in arg1;
+    return ret;
+}
+export function __wbg___wbindgen_is_bigint_31b12575b56f32fc(arg0) {
+    const ret = typeof(arg0) === 'bigint';
+    return ret;
+}
+export function __wbg___wbindgen_is_function_0095a73b8b156f76(arg0) {
+    const ret = typeof(arg0) === 'function';
+    return ret;
+}
+export function __wbg___wbindgen_is_null_ac34f5003991759a(arg0) {
+    const ret = arg0 === null;
+    return ret;
+}
+export function __wbg___wbindgen_is_object_5ae8e5880f2c1fbd(arg0) {
+    const val = arg0;
+    const ret = typeof(val) === 'object' && val !== null;
+    return ret;
+}
+export function __wbg___wbindgen_is_string_cd444516edc5b180(arg0) {
+    const ret = typeof(arg0) === 'string';
+    return ret;
+}
+export function __wbg___wbindgen_is_undefined_9e4d92534c42d778(arg0) {
+    const ret = arg0 === undefined;
+    return ret;
+}
+export function __wbg___wbindgen_jsval_eq_11888390b0186270(arg0, arg1) {
+    const ret = arg0 === arg1;
+    return ret;
+}
+export function __wbg___wbindgen_jsval_loose_eq_9dd77d8cd6671811(arg0, arg1) {
+    const ret = arg0 == arg1;
+    return ret;
+}
+export function __wbg___wbindgen_number_get_8ff4255516ccad3e(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);
+}
+export function __wbg___wbindgen_shr_ef8e07cce709eb54(arg0, arg1) {
+    const ret = arg0 >> arg1;
+    return ret;
+}
+export function __wbg___wbindgen_string_get_72fb696202c56729(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);
+}
+export function __wbg___wbindgen_throw_be289d5034ed271b(arg0, arg1) {
+    throw new Error(getStringFromWasm0(arg0, arg1));
+}
+export function __wbg__wbg_cb_unref_d9b87ff7982e3b21(arg0) {
+    arg0._wbg_cb_unref();
+}
+export function __wbg_buffer_26d0910f3a5bc899(arg0) {
+    const ret = arg0.buffer;
+    return ret;
+}
+export function __wbg_byobRequest_80e594e6da4e1af7(arg0) {
+    const ret = arg0.byobRequest;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+}
+export function __wbg_byteLength_3417f266f4bf562a(arg0) {
+    const ret = arg0.byteLength;
+    return ret;
+}
+export function __wbg_byteOffset_f88547ca47c86358(arg0) {
+    const ret = arg0.byteOffset;
+    return ret;
+}
+export function __wbg_call_389efe28435a9388() { return handleError(function (arg0, arg1) {
+    const ret = arg0.call(arg1);
+    return ret;
+}, arguments); }
+export function __wbg_call_4708e0c13bdc8e95() { return handleError(function (arg0, arg1, arg2) {
+    const ret = arg0.call(arg1, arg2);
+    return ret;
+}, arguments); }
+export function __wbg_close_06dfa0a815b9d71f() { return handleError(function (arg0) {
+    arg0.close();
+}, arguments); }
+export function __wbg_close_a79afee31de55b36() { return handleError(function (arg0) {
+    arg0.close();
+}, arguments); }
+export function __wbg_contractstate_new(arg0) {
+    const ret = ContractState.__wrap(arg0);
+    return ret;
+}
+export function __wbg_crypto_86f2631e91b51511(arg0) {
+    const ret = arg0.crypto;
+    return ret;
+}
+export function __wbg_done_57b39ecd9addfe81(arg0) {
+    const ret = arg0.done;
+    return ret;
+}
+export function __wbg_enqueue_2c63f2044f257c3e() { return handleError(function (arg0, arg1) {
+    arg0.enqueue(arg1);
+}, arguments); }
+export function __wbg_entries_58c7934c745daac7(arg0) {
+    const ret = Object.entries(arg0);
+    return ret;
+}
+export function __wbg_from_bddd64e7d5ff6941(arg0) {
+    const ret = Array.from(arg0);
+    return ret;
+}
+export function __wbg_getRandomValues_b3f15fcbfabb0f8b() { return handleError(function (arg0, arg1) {
+    arg0.getRandomValues(arg1);
+}, arguments); }
+export function __wbg_get_9b94d73e6221f75c(arg0, arg1) {
+    const ret = arg0[arg1 >>> 0];
+    return ret;
+}
+export function __wbg_get_b3ed3ad4be2bc8ac() { return handleError(function (arg0, arg1) {
+    const ret = Reflect.get(arg0, arg1);
+    return ret;
+}, arguments); }
+export function __wbg_get_c60162cf03da5a6e(arg0, arg1) {
+    const ret = arg0.get(arg1);
+    return ret;
+}
+export function __wbg_get_with_ref_key_1dc361bd10053bfe(arg0, arg1) {
+    const ret = arg0[arg1];
+    return ret;
+}
+export function __wbg_instanceof_ArrayBuffer_c367199e2fa2aa04(arg0) {
+    let result;
+    try {
+        result = arg0 instanceof ArrayBuffer;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+}
+export function __wbg_instanceof_Map_53af74335dec57f4(arg0) {
+    let result;
+    try {
+        result = arg0 instanceof Map;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+}
+export function __wbg_instanceof_Uint8Array_9b9075935c74707c(arg0) {
+    let result;
+    try {
+        result = arg0 instanceof Uint8Array;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+}
+export function __wbg_isArray_d314bb98fcf08331(arg0) {
+    const ret = Array.isArray(arg0);
+    return ret;
+}
+export function __wbg_isSafeInteger_bfbc7332a9768d2a(arg0) {
+    const ret = Number.isSafeInteger(arg0);
+    return ret;
+}
+export function __wbg_iterator_6ff6560ca1568e55() {
+    const ret = Symbol.iterator;
+    return ret;
+}
+export function __wbg_keys_0eee252dfbfa253e(arg0) {
+    const ret = arg0.keys();
+    return ret;
+}
+export function __wbg_length_32ed9a279acd054c(arg0) {
+    const ret = arg0.length;
+    return ret;
+}
+export function __wbg_length_35a7bace40f36eac(arg0) {
+    const ret = arg0.length;
+    return ret;
+}
+export function __wbg_msCrypto_d562bbe83e0d4b91(arg0) {
+    const ret = arg0.msCrypto;
+    return ret;
+}
+export function __wbg_new_361308b2356cecd0() {
+    const ret = new Object();
+    return ret;
+}
+export function __wbg_new_3eb36ae241fe6f44() {
+    const ret = new Array();
+    return ret;
+}
+export function __wbg_new_72b49615380db768(arg0, arg1) {
+    const ret = new Error(getStringFromWasm0(arg0, arg1));
+    return ret;
+}
+export function __wbg_new_b5d9e2fb389fef91(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__h6dbac3a709519175(a, state0.b, arg0, arg1);
+            } finally {
+                state0.a = a;
+            }
+        };
+        const ret = new Promise(cb0);
+        return ret;
+    } finally {
+        state0.a = state0.b = 0;
+    }
+}
+export function __wbg_new_dca287b076112a51() {
+    const ret = new Map();
+    return ret;
+}
+export function __wbg_new_dd2b680c8bf6ae29(arg0) {
+    const ret = new Uint8Array(arg0);
+    return ret;
+}
+export function __wbg_new_from_slice_a3d2629dc1826784(arg0, arg1) {
+    const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
+    return ret;
+}
+export function __wbg_new_no_args_1c7c842f08d00ebb(arg0, arg1) {
+    const ret = new Function(getStringFromWasm0(arg0, arg1));
+    return ret;
+}
+export function __wbg_new_with_byte_offset_and_length_aa261d9c9da49eb1(arg0, arg1, arg2) {
+    const ret = new Uint8Array(arg0, arg1 >>> 0, arg2 >>> 0);
+    return ret;
+}
+export function __wbg_new_with_length_a2c39cbe88fd8ff1(arg0) {
+    const ret = new Uint8Array(arg0 >>> 0);
+    return ret;
+}
+export function __wbg_next_3482f54c49e8af19() { return handleError(function (arg0) {
+    const ret = arg0.next();
+    return ret;
+}, arguments); }
+export function __wbg_next_418f80d8f5303233(arg0) {
+    const ret = arg0.next;
+    return ret;
+}
+export function __wbg_node_e1f24f89a7336c2e(arg0) {
+    const ret = arg0.node;
+    return ret;
+}
+export function __wbg_process_3975fd6c72f520aa(arg0) {
+    const ret = arg0.process;
+    return ret;
+}
+export function __wbg_prototypesetcall_bdcdcc5842e4d77d(arg0, arg1, arg2) {
+    Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), arg2);
+}
+export function __wbg_push_8ffdcb2063340ba5(arg0, arg1) {
+    const ret = arg0.push(arg1);
+    return ret;
+}
+export function __wbg_queueMicrotask_0aa0a927f78f5d98(arg0) {
+    const ret = arg0.queueMicrotask;
+    return ret;
+}
+export function __wbg_queueMicrotask_5bb536982f78a56f(arg0) {
+    queueMicrotask(arg0);
+}
+export function __wbg_randomFillSync_f8c153b79f285817() { return handleError(function (arg0, arg1) {
+    arg0.randomFillSync(arg1);
+}, arguments); }
+export function __wbg_require_b74f47fc2d022fd6() { return handleError(function () {
+    const ret = module.require;
+    return ret;
+}, arguments); }
+export function __wbg_resolve_002c4b7d9d8f6b64(arg0) {
+    const ret = Promise.resolve(arg0);
+    return ret;
+}
+export function __wbg_respond_bf6ab10399ca8722() { return handleError(function (arg0, arg1) {
+    arg0.respond(arg1 >>> 0);
+}, arguments); }
+export function __wbg_set_1eb0999cf5d27fc8(arg0, arg1, arg2) {
+    const ret = arg0.set(arg1, arg2);
+    return ret;
+}
+export function __wbg_set_3f1d0b984ed272ed(arg0, arg1, arg2) {
+    arg0[arg1] = arg2;
+}
+export function __wbg_set_cc56eefd2dd91957(arg0, arg1, arg2) {
+    arg0.set(getArrayU8FromWasm0(arg1, arg2));
+}
+export function __wbg_set_f43e577aea94465b(arg0, arg1, arg2) {
+    arg0[arg1 >>> 0] = arg2;
+}
+export function __wbg_statevalue_new(arg0) {
+    const ret = StateValue.__wrap(arg0);
+    return ret;
+}
+export function __wbg_static_accessor_GLOBAL_12837167ad935116() {
+    const ret = typeof global === 'undefined' ? null : global;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+}
+export function __wbg_static_accessor_GLOBAL_THIS_e628e89ab3b1c95f() {
+    const ret = typeof globalThis === 'undefined' ? null : globalThis;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+}
+export function __wbg_static_accessor_SELF_a621d3dfbb60d0ce() {
+    const ret = typeof self === 'undefined' ? null : self;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+}
+export function __wbg_static_accessor_WINDOW_f8727f0cf888e0bd() {
+    const ret = typeof window === 'undefined' ? null : window;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+}
+export function __wbg_subarray_a96e1fef17ed23cb(arg0, arg1, arg2) {
+    const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
+    return ret;
+}
+export function __wbg_then_b9e7b3b5f1a9e1b5(arg0, arg1) {
+    const ret = arg0.then(arg1);
+    return ret;
+}
+export function __wbg_toString_029ac24421fd7a24(arg0) {
+    const ret = arg0.toString();
+    return ret;
+}
+export function __wbg_toString_3cadee6e7c22b39e() { return handleError(function (arg0, arg1) {
+    const ret = arg0.toString(arg1);
+    return ret;
+}, arguments); }
+export function __wbg_value_0546255b415e96c1(arg0) {
+    const ret = arg0.value;
+    return ret;
+}
+export function __wbg_versions_4e31226f5e8dc909(arg0) {
+    const ret = arg0.versions;
+    return ret;
+}
+export function __wbg_view_6c32e7184b8606ad(arg0) {
+    const ret = arg0.view;
+    return isLikeNone(ret) ? 0 : addToExternrefTable0(ret);
+}
+export function __wbindgen_cast_0000000000000001(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 733, function: Function { arguments: [Externref], shim_idx: 734, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__hcf6f807ab4e584f3, wasm_bindgen__convert__closures_____invoke__h3c02f1ea9c9c9af0);
+    return ret;
+}
+export function __wbindgen_cast_0000000000000002(arg0) {
+    // Cast intrinsic for `F64 -> Externref`.
+    const ret = arg0;
+    return ret;
+}
+export function __wbindgen_cast_0000000000000003(arg0) {
+    // Cast intrinsic for `I64 -> Externref`.
+    const ret = arg0;
+    return ret;
+}
+export function __wbindgen_cast_0000000000000004(arg0, arg1) {
+    // Cast intrinsic for `Ref(Slice(U8)) -> NamedExternref("Uint8Array")`.
+    const ret = getArrayU8FromWasm0(arg0, arg1);
+    return ret;
+}
+export function __wbindgen_cast_0000000000000005(arg0, arg1) {
+    // Cast intrinsic for `Ref(String) -> Externref`.
+    const ret = getStringFromWasm0(arg0, arg1);
+    return ret;
+}
+export function __wbindgen_cast_0000000000000006(arg0, arg1) {
+    // Cast intrinsic for `U128 -> Externref`.
+    const ret = (BigInt.asUintN(64, arg0) | (BigInt.asUintN(64, arg1) << BigInt(64)));
+    return ret;
+}
+export function __wbindgen_cast_0000000000000007(arg0) {
+    // Cast intrinsic for `U64 -> Externref`.
+    const ret = BigInt.asUintN(64, arg0);
+    return ret;
+}
+export function __wbindgen_init_externref_table() {
+    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);
+}
+function wasm_bindgen__convert__closures_____invoke__h3c02f1ea9c9c9af0(arg0, arg1, arg2) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h3c02f1ea9c9c9af0(arg0, arg1, arg2);
+}
+
+function wasm_bindgen__convert__closures_____invoke__h6dbac3a709519175(arg0, arg1, arg2, arg3) {
+    wasm.wasm_bindgen__convert__closures_____invoke__h6dbac3a709519175(arg0, arg1, arg2, arg3);
+}
+
+
+const __wbindgen_enum_ReadableStreamType = ["bytes"];
+const ChargedStateFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_chargedstate_free(ptr >>> 0, 1));
+const ContractMaintenanceAuthorityFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_contractmaintenanceauthority_free(ptr >>> 0, 1));
+const ContractOperationFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_contractoperation_free(ptr >>> 0, 1));
+const ContractStateFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_contractstate_free(ptr >>> 0, 1));
+const CostModelFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_costmodel_free(ptr >>> 0, 1));
+const IntoUnderlyingByteSourceFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_intounderlyingbytesource_free(ptr >>> 0, 1));
+const IntoUnderlyingSinkFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_intounderlyingsink_free(ptr >>> 0, 1));
+const IntoUnderlyingSourceFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_intounderlyingsource_free(ptr >>> 0, 1));
+const QueryContextFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_querycontext_free(ptr >>> 0, 1));
+const QueryResultsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_queryresults_free(ptr >>> 0, 1));
+const StateBoundedMerkleTreeFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_stateboundedmerkletree_free(ptr >>> 0, 1));
+const StateMapFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_statemap_free(ptr >>> 0, 1));
+const StateValueFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_statevalue_free(ptr >>> 0, 1));
+const VmResultsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_vmresults_free(ptr >>> 0, 1));
+const VmStackFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_vmstack_free(ptr >>> 0, 1));
+
+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 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_externrefs.get(mem.getUint32(i, true)));
+    }
+    wasm.__externref_drop_slice(ptr, len);
+    return result;
+}
+
+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 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 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();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = 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;
+
+
+let wasm;
+export function __wbg_set_wasm(val) {
+    wasm = val;
+}