@crypticdot/defituna-core 3.2.7 → 3.3.1

package/dist/browser/defituna_core_js_bindings_bg.js

@@ -191,11 +191,6 @@ function handleError(f, args) {
     }
 }
 
-function getArrayU8FromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
-}
-
 function dropObject(idx) {
     if (idx < 132) return;
     heap[idx] = heap_next;
@@ -207,6 +202,66 @@ function takeObject(idx) {
     dropObject(idx);
     return ret;
 }
+
+function getArrayU8FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
+}
+
+const CLOSURE_DTORS = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(state => state.dtor(state.a, state.b));
+
+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 _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
+    }
+}
+
+function passArrayJsValueToWasm0(array, malloc) {
+    const ptr = malloc(array.length * 4, 4) >>> 0;
+    const mem = getDataViewMemory0();
+    for (let i = 0; i < array.length; i++) {
+        mem.setUint32(ptr + 4 * i, addHeapObject(array[i]), true);
+    }
+    WASM_VECTOR_LEN = array.length;
+    return ptr;
+}
+
+function passArray8ToWasm0(arg, malloc) {
+    const ptr = malloc(arg.length * 1, 1) >>> 0;
+    getUint8ArrayMemory0().set(arg, ptr / 1);
+    WASM_VECTOR_LEN = arg.length;
+    return ptr;
+}
 /**
  * Get the first tick index in the tick array that contains the specified tick index.
  *
@@ -1436,12 +1491,6 @@ export function _PROTOCOL_FEE_RATE_MUL_VALUE() {
     return ret;
 }
 
-function passArray8ToWasm0(arg, malloc) {
-    const ptr = malloc(arg.length * 1, 1) >>> 0;
-    getUint8ArrayMemory0().set(arg, ptr / 1);
-    WASM_VECTOR_LEN = arg.length;
-    return ptr;
-}
 /**
  * Get the first unoccupied position in a bundle
  *
@@ -1606,18 +1655,6 @@ export function swapQuoteByOutputToken(token_out, specified_token_a, slippage_to
     }
 }
 
-export function _INVALID_ARGUMENTS() {
-    try {
-        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm._INVALID_ARGUMENTS(retptr);
-        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-        return getStringFromWasm0(r0, r1);
-    } finally {
-        wasm.__wbindgen_add_to_stack_pointer(16);
-    }
-}
-
 /**
  * Spot position increase quote
  *
@@ -1629,26 +1666,21 @@ export function _INVALID_ARGUMENTS() {
  * - `slippage_tolerance_bps`: An optional slippage tolerance in basis points. Defaults to the global slippage tolerance if not provided.
  * - `protocol_fee_rate`: Protocol fee rate from a market account represented as hundredths of a basis point (0.01% = 100).
  * - `protocol_fee_rate_on_collateral`: Protocol fee rate from a market account represented as hundredths of a basis point (0.01% = 100).
+ * - `mint_a`: Token A mint address
+ * - `mint_b`: Token B mint address
  * - `fusion_pool`: Fusion pool.
- * - `tick_arrays`: Five tick arrays around the current pool price.
+ * - `tick_arrays`: Optional five tick arrays around the current pool price. If not provided, the quote will be calculated using the Jupiter Aggregator.
  *
  * # Returns
  * - `IncreaseSpotPositionQuoteResult`: quote result
  */
-export function getIncreaseSpotPositionQuote(increase_amount, collateral_token, position_token, leverage, slippage_tolerance_bps, protocol_fee_rate, protocol_fee_rate_on_collateral, fusion_pool, tick_arrays) {
-    try {
-        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.getIncreaseSpotPositionQuote(retptr, increase_amount, collateral_token, position_token, leverage, isLikeNone(slippage_tolerance_bps) ? 0xFFFFFF : slippage_tolerance_bps, protocol_fee_rate, protocol_fee_rate_on_collateral, addHeapObject(fusion_pool), addHeapObject(tick_arrays));
-        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-        if (r2) {
-            throw takeObject(r1);
-        }
-        return takeObject(r0);
-    } finally {
-        wasm.__wbindgen_add_to_stack_pointer(16);
-    }
+export function getIncreaseSpotPositionQuote(increase_amount, collateral_token, position_token, leverage, slippage_tolerance_bps, protocol_fee_rate, protocol_fee_rate_on_collateral, mint_a, mint_b, fusion_pool, tick_arrays) {
+    _assertClass(mint_a, Pubkey);
+    var ptr0 = mint_a.__destroy_into_raw();
+    _assertClass(mint_b, Pubkey);
+    var ptr1 = mint_b.__destroy_into_raw();
+    const ret = wasm.getIncreaseSpotPositionQuote(increase_amount, collateral_token, position_token, leverage, isLikeNone(slippage_tolerance_bps) ? 0xFFFFFF : slippage_tolerance_bps, protocol_fee_rate, protocol_fee_rate_on_collateral, ptr0, ptr1, addHeapObject(fusion_pool), isLikeNone(tick_arrays) ? 0 : addHeapObject(tick_arrays));
+    return takeObject(ret);
 }
 
 /**
@@ -1658,33 +1690,23 @@ export function getIncreaseSpotPositionQuote(increase_amount, collateral_token,
  * - `decrease_amount`: Position total decrease size in the collateral_token.
  * - `collateral_token`: Collateral token.
  * - `leverage`: Leverage (1.0 or higher).
- * - `reduce_only`: Only allow reducing the existing position.
  * - `slippage_tolerance_bps`: An optional slippage tolerance in basis points. Defaults to the global slippage tolerance if not provided.
  * - `position_token`: Token of the existing position.
  * - `position_amount`: Existing position amount in the position_token.
  * - `position_debt`: Existing position debt in the token opposite to the position_token.
- * - `protocol_fee_rate`: Protocol fee rate from a market account represented as hundredths of a basis point (0.01% = 100).
- * - `protocol_fee_rate_on_collateral`: Protocol fee rate from a market account represented as hundredths of a basis point (0.01% = 100).
  * - `fusion_pool`: Fusion pool.
- * - `tick_arrays`: Five tick arrays around the current pool price.
+ * - `tick_arrays`: Optional five tick arrays around the current pool price. If not provided, the quote will be calculated using the Jupiter Aggregator.
  *
  * # Returns
  * - `DecreaseSpotPositionQuoteResult`: quote result
  */
-export function getDecreaseSpotPositionQuote(decrease_amount, collateral_token, leverage, reduce_only, slippage_tolerance_bps, position_token, position_amount, position_debt, protocol_fee_rate, protocol_fee_rate_on_collateral, fusion_pool, tick_arrays) {
-    try {
-        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.getDecreaseSpotPositionQuote(retptr, decrease_amount, collateral_token, leverage, reduce_only, isLikeNone(slippage_tolerance_bps) ? 0xFFFFFF : slippage_tolerance_bps, position_token, position_amount, position_debt, protocol_fee_rate, protocol_fee_rate_on_collateral, addHeapObject(fusion_pool), addHeapObject(tick_arrays));
-        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
-        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
-        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
-        if (r2) {
-            throw takeObject(r1);
-        }
-        return takeObject(r0);
-    } finally {
-        wasm.__wbindgen_add_to_stack_pointer(16);
-    }
+export function getDecreaseSpotPositionQuote(decrease_amount, collateral_token, leverage, slippage_tolerance_bps, position_token, position_amount, position_debt, mint_a, mint_b, fusion_pool, tick_arrays) {
+    _assertClass(mint_a, Pubkey);
+    var ptr0 = mint_a.__destroy_into_raw();
+    _assertClass(mint_b, Pubkey);
+    var ptr1 = mint_b.__destroy_into_raw();
+    const ret = wasm.getDecreaseSpotPositionQuote(decrease_amount, collateral_token, leverage, isLikeNone(slippage_tolerance_bps) ? 0xFFFFFF : slippage_tolerance_bps, position_token, position_amount, position_debt, ptr0, ptr1, addHeapObject(fusion_pool), isLikeNone(tick_arrays) ? 0 : addHeapObject(tick_arrays));
+    return takeObject(ret);
 }
 
 /**
@@ -1722,23 +1744,20 @@ export function getLiquidationPrice(position_token, amount, debt, liquidation_th
  * - `collateral_token`: Collateral token.
  * - `available_balance`: Available wallet balance in the collateral_token.
  * - `leverage`: Leverage (1.0 or higher).
- * - `new_position_token`: Token of the new position.
  * - `position_token`: Token of the existing position. Should be set to new_position_token if position_amount is zero.
  * - `position_amount`: Existing position amount in the position_token.
- * - `position_debt`: Existing position debt in the token opposite to the position_token.
- * - `reduce_only`: Only allow reducing the existing position.///
  * - `protocol_fee_rate`: Protocol fee rate from a market account represented as hundredths of a basis point (0.01% = 100).
  * - `protocol_fee_rate_on_collateral`: Protocol fee rate from a market account represented as hundredths of a basis point (0.01% = 100).
  * - `fusion_pool`: Fusion pool.
- * - `tick_arrays`: Five tick arrays around the current pool price.
+ * - `increase`: true if increasing the position
  *
  * # Returns
  * - `u64`: the maximum tradable amount
  */
-export function getTradableAmount(collateral_token, available_balance, leverage, new_position_token, reduce_only, position_token, position_amount, position_debt, protocol_fee_rate, protocol_fee_rate_on_collateral, fusion_pool, tick_arrays) {
+export function getTradableAmount(collateral_token, available_balance, leverage, position_token, position_amount, protocol_fee_rate, protocol_fee_rate_on_collateral, fusion_pool, increase) {
     try {
         const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
-        wasm.getTradableAmount(retptr, collateral_token, available_balance, leverage, new_position_token, reduce_only, position_token, position_amount, position_debt, protocol_fee_rate, protocol_fee_rate_on_collateral, addHeapObject(fusion_pool), addHeapObject(tick_arrays));
+        wasm.getTradableAmount(retptr, collateral_token, available_balance, leverage, position_token, position_amount, protocol_fee_rate, protocol_fee_rate_on_collateral, addHeapObject(fusion_pool), increase);
         var r0 = getDataViewMemory0().getBigInt64(retptr + 8 * 0, true);
         var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
         var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
@@ -1756,6 +1775,908 @@ export function calculateTunaProtocolFee(collateral_token, borrowed_token, colla
     return takeObject(ret);
 }
 
+export function _INVALID_ARGUMENTS() {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm._INVALID_ARGUMENTS(retptr);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+export function _JUPITER_QUOTE_REQUEST_ERROR() {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm._JUPITER_QUOTE_REQUEST_ERROR(retptr);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+export function _JUPITER_SWAP_INSTRUCTIONS_REQUEST_ERROR() {
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm._JUPITER_SWAP_INSTRUCTIONS_REQUEST_ERROR(retptr);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+    }
+}
+
+/**
+ * Initialize Javascript logging and panic handler
+ */
+export function solana_program_init() {
+    wasm.solana_program_init();
+}
+
+function __wasm_bindgen_func_elem_3203(arg0, arg1, arg2) {
+    wasm.__wasm_bindgen_func_elem_3203(arg0, arg1, addHeapObject(arg2));
+}
+
+function __wasm_bindgen_func_elem_3097(arg0, arg1) {
+    wasm.__wasm_bindgen_func_elem_3097(arg0, arg1);
+}
+
+function __wasm_bindgen_func_elem_480(arg0, arg1, arg2, arg3) {
+    wasm.__wasm_bindgen_func_elem_480(arg0, arg1, addHeapObject(arg2), addHeapObject(arg3));
+}
+
+const __wbindgen_enum_RequestCache = ["default", "no-store", "reload", "no-cache", "force-cache", "only-if-cached"];
+
+const __wbindgen_enum_RequestCredentials = ["omit", "same-origin", "include"];
+
+const __wbindgen_enum_RequestMode = ["same-origin", "no-cors", "cors", "navigate"];
+
+const HashFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_hash_free(ptr >>> 0, 1));
+/**
+ * A hash; the 32-byte output of a hashing algorithm.
+ *
+ * This struct is used most often in `solana-sdk` and related crates to contain
+ * a [SHA-256] hash, but may instead contain a [blake3] hash.
+ *
+ * [SHA-256]: https://en.wikipedia.org/wiki/SHA-2
+ * [blake3]: https://github.com/BLAKE3-team/BLAKE3
+ */
+export class Hash {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Hash.prototype);
+        obj.__wbg_ptr = ptr;
+        HashFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        HashFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_hash_free(ptr, 0);
+    }
+    /**
+     * Create a new Hash object
+     *
+     * * `value` - optional hash as a base58 encoded string, `Uint8Array`, `[number]`
+     * @param {any} value
+     */
+    constructor(value) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.hash_constructor(retptr, addHeapObject(value));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0 >>> 0;
+            HashFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Return the base58 string representation of the hash
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.hash_toString(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Checks if two `Hash`s are equal
+     * @param {Hash} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        _assertClass(other, Hash);
+        const ret = wasm.hash_equals(this.__wbg_ptr, other.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Return the `Uint8Array` representation of the hash
+     * @returns {Uint8Array}
+     */
+    toBytes() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.hash_toBytes(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+}
+if (Symbol.dispose) Hash.prototype[Symbol.dispose] = Hash.prototype.free;
+
+const InstructionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_instruction_free(ptr >>> 0, 1));
+/**
+ * wasm-bindgen version of the Instruction struct.
+ * This duplication is required until https://github.com/rustwasm/wasm-bindgen/issues/3671
+ * is fixed. This must not diverge from the regular non-wasm Instruction struct.
+ */
+export class Instruction {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Instruction.prototype);
+        obj.__wbg_ptr = ptr;
+        InstructionFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        InstructionFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_instruction_free(ptr, 0);
+    }
+}
+if (Symbol.dispose) Instruction.prototype[Symbol.dispose] = Instruction.prototype.free;
+
+const InstructionsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_instructions_free(ptr >>> 0, 1));
+
+export class Instructions {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        InstructionsFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_instructions_free(ptr, 0);
+    }
+    constructor() {
+        const ret = wasm.instructions_constructor();
+        this.__wbg_ptr = ret >>> 0;
+        InstructionsFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {Instruction} instruction
+     */
+    push(instruction) {
+        _assertClass(instruction, Instruction);
+        var ptr0 = instruction.__destroy_into_raw();
+        wasm.instructions_push(this.__wbg_ptr, ptr0);
+    }
+}
+if (Symbol.dispose) Instructions.prototype[Symbol.dispose] = Instructions.prototype.free;
+
+const KeypairFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_keypair_free(ptr >>> 0, 1));
+/**
+ * A vanilla Ed25519 key pair
+ */
+export class Keypair {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Keypair.prototype);
+        obj.__wbg_ptr = ptr;
+        KeypairFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        KeypairFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_keypair_free(ptr, 0);
+    }
+    /**
+     * Create a new `Keypair `
+     */
+    constructor() {
+        const ret = wasm.keypair_constructor();
+        this.__wbg_ptr = ret >>> 0;
+        KeypairFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Convert a `Keypair` to a `Uint8Array`
+     * @returns {Uint8Array}
+     */
+    toBytes() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.keypair_toBytes(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Recover a `Keypair` from a `Uint8Array`
+     * @param {Uint8Array} bytes
+     * @returns {Keypair}
+     */
+    static fromBytes(bytes) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.keypair_fromBytes(retptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Keypair.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Return the `Pubkey` for this `Keypair`
+     * @returns {Pubkey}
+     */
+    pubkey() {
+        const ret = wasm.keypair_pubkey(this.__wbg_ptr);
+        return Pubkey.__wrap(ret);
+    }
+}
+if (Symbol.dispose) Keypair.prototype[Symbol.dispose] = Keypair.prototype.free;
+
+const MessageFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_message_free(ptr >>> 0, 1));
+/**
+ * wasm-bindgen version of the Message struct.
+ * This duplication is required until https://github.com/rustwasm/wasm-bindgen/issues/3671
+ * is fixed. This must not diverge from the regular non-wasm Message struct.
+ */
+export class Message {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Message.prototype);
+        obj.__wbg_ptr = ptr;
+        MessageFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        MessageFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_message_free(ptr, 0);
+    }
+    /**
+     * The id of a recent ledger entry.
+     * @returns {Hash}
+     */
+    get recent_blockhash() {
+        const ret = wasm.__wbg_get_message_recent_blockhash(this.__wbg_ptr);
+        return Hash.__wrap(ret);
+    }
+    /**
+     * The id of a recent ledger entry.
+     * @param {Hash} arg0
+     */
+    set recent_blockhash(arg0) {
+        _assertClass(arg0, Hash);
+        var ptr0 = arg0.__destroy_into_raw();
+        wasm.__wbg_set_message_recent_blockhash(this.__wbg_ptr, ptr0);
+    }
+}
+if (Symbol.dispose) Message.prototype[Symbol.dispose] = Message.prototype.free;
+
+const PubkeyFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_pubkey_free(ptr >>> 0, 1));
+/**
+ * The address of a [Solana account][acc].
+ *
+ * Some account addresses are [ed25519] public keys, with corresponding secret
+ * keys that are managed off-chain. Often, though, account addresses do not
+ * have corresponding secret keys &mdash; as with [_program derived
+ * addresses_][pdas] &mdash; or the secret key is not relevant to the operation
+ * of a program, and may have even been disposed of. As running Solana programs
+ * can not safely create or manage secret keys, the full [`Keypair`] is not
+ * defined in `solana-program` but in `solana-sdk`.
+ *
+ * [acc]: https://solana.com/docs/core/accounts
+ * [ed25519]: https://ed25519.cr.yp.to/
+ * [pdas]: https://solana.com/docs/core/cpi#program-derived-addresses
+ * [`Keypair`]: https://docs.rs/solana-sdk/latest/solana_sdk/signer/keypair/struct.Keypair.html
+ */
+export class Pubkey {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Pubkey.prototype);
+        obj.__wbg_ptr = ptr;
+        PubkeyFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PubkeyFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_pubkey_free(ptr, 0);
+    }
+    /**
+     * Create a new Pubkey object
+     *
+     * * `value` - optional public key as a base58 encoded string, `Uint8Array`, `[number]`
+     * @param {any} value
+     */
+    constructor(value) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.pubkey_constructor(retptr, addHeapObject(value));
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            this.__wbg_ptr = r0 >>> 0;
+            PubkeyFinalization.register(this, this.__wbg_ptr, this);
+            return this;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Return the base58 string representation of the public key
+     * @returns {string}
+     */
+    toString() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.pubkey_toString(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            deferred1_0 = r0;
+            deferred1_1 = r1;
+            return getStringFromWasm0(r0, r1);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+            wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * Check if a `Pubkey` is on the ed25519 curve.
+     * @returns {boolean}
+     */
+    isOnCurve() {
+        const ret = wasm.pubkey_isOnCurve(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Checks if two `Pubkey`s are equal
+     * @param {Pubkey} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        _assertClass(other, Pubkey);
+        const ret = wasm.pubkey_equals(this.__wbg_ptr, other.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * Return the `Uint8Array` representation of the public key
+     * @returns {Uint8Array}
+     */
+    toBytes() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.pubkey_toBytes(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Derive a Pubkey from another Pubkey, string seed, and a program id
+     * @param {Pubkey} base
+     * @param {string} seed
+     * @param {Pubkey} owner
+     * @returns {Pubkey}
+     */
+    static createWithSeed(base, seed, owner) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            _assertClass(base, Pubkey);
+            const ptr0 = passStringToWasm0(seed, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            _assertClass(owner, Pubkey);
+            wasm.pubkey_createWithSeed(retptr, base.__wbg_ptr, ptr0, len0, owner.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Pubkey.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Derive a program address from seeds and a program id
+     * @param {any[]} seeds
+     * @param {Pubkey} program_id
+     * @returns {Pubkey}
+     */
+    static createProgramAddress(seeds, program_id) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayJsValueToWasm0(seeds, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            _assertClass(program_id, Pubkey);
+            wasm.pubkey_createProgramAddress(retptr, ptr0, len0, program_id.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Pubkey.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Find a valid program address
+     *
+     * Returns:
+     * * `[PubKey, number]` - the program address and bump seed
+     * @param {any[]} seeds
+     * @param {Pubkey} program_id
+     * @returns {any}
+     */
+    static findProgramAddress(seeds, program_id) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArrayJsValueToWasm0(seeds, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            _assertClass(program_id, Pubkey);
+            wasm.pubkey_findProgramAddress(retptr, ptr0, len0, program_id.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return takeObject(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+}
+if (Symbol.dispose) Pubkey.prototype[Symbol.dispose] = Pubkey.prototype.free;
+
+const SystemInstructionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_systeminstruction_free(ptr >>> 0, 1));
+
+export class SystemInstruction {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SystemInstructionFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_systeminstruction_free(ptr, 0);
+    }
+    /**
+     * @param {Pubkey} from_pubkey
+     * @param {Pubkey} to_pubkey
+     * @param {bigint} lamports
+     * @param {bigint} space
+     * @param {Pubkey} owner
+     * @returns {Instruction}
+     */
+    static createAccount(from_pubkey, to_pubkey, lamports, space, owner) {
+        _assertClass(from_pubkey, Pubkey);
+        _assertClass(to_pubkey, Pubkey);
+        _assertClass(owner, Pubkey);
+        const ret = wasm.systeminstruction_createAccount(from_pubkey.__wbg_ptr, to_pubkey.__wbg_ptr, lamports, space, owner.__wbg_ptr);
+        return Instruction.__wrap(ret);
+    }
+    /**
+     * @param {Pubkey} from_pubkey
+     * @param {Pubkey} to_pubkey
+     * @param {Pubkey} base
+     * @param {string} seed
+     * @param {bigint} lamports
+     * @param {bigint} space
+     * @param {Pubkey} owner
+     * @returns {Instruction}
+     */
+    static createAccountWithSeed(from_pubkey, to_pubkey, base, seed, lamports, space, owner) {
+        _assertClass(from_pubkey, Pubkey);
+        _assertClass(to_pubkey, Pubkey);
+        _assertClass(base, Pubkey);
+        const ptr0 = passStringToWasm0(seed, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        _assertClass(owner, Pubkey);
+        const ret = wasm.systeminstruction_createAccountWithSeed(from_pubkey.__wbg_ptr, to_pubkey.__wbg_ptr, base.__wbg_ptr, ptr0, len0, lamports, space, owner.__wbg_ptr);
+        return Instruction.__wrap(ret);
+    }
+    /**
+     * @param {Pubkey} pubkey
+     * @param {Pubkey} owner
+     * @returns {Instruction}
+     */
+    static assign(pubkey, owner) {
+        _assertClass(pubkey, Pubkey);
+        _assertClass(owner, Pubkey);
+        const ret = wasm.systeminstruction_assign(pubkey.__wbg_ptr, owner.__wbg_ptr);
+        return Instruction.__wrap(ret);
+    }
+    /**
+     * @param {Pubkey} pubkey
+     * @param {Pubkey} base
+     * @param {string} seed
+     * @param {Pubkey} owner
+     * @returns {Instruction}
+     */
+    static assignWithSeed(pubkey, base, seed, owner) {
+        _assertClass(pubkey, Pubkey);
+        _assertClass(base, Pubkey);
+        const ptr0 = passStringToWasm0(seed, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        _assertClass(owner, Pubkey);
+        const ret = wasm.systeminstruction_assignWithSeed(pubkey.__wbg_ptr, base.__wbg_ptr, ptr0, len0, owner.__wbg_ptr);
+        return Instruction.__wrap(ret);
+    }
+    /**
+     * @param {Pubkey} from_pubkey
+     * @param {Pubkey} to_pubkey
+     * @param {bigint} lamports
+     * @returns {Instruction}
+     */
+    static transfer(from_pubkey, to_pubkey, lamports) {
+        _assertClass(from_pubkey, Pubkey);
+        _assertClass(to_pubkey, Pubkey);
+        const ret = wasm.systeminstruction_transfer(from_pubkey.__wbg_ptr, to_pubkey.__wbg_ptr, lamports);
+        return Instruction.__wrap(ret);
+    }
+    /**
+     * @param {Pubkey} from_pubkey
+     * @param {Pubkey} from_base
+     * @param {string} from_seed
+     * @param {Pubkey} from_owner
+     * @param {Pubkey} to_pubkey
+     * @param {bigint} lamports
+     * @returns {Instruction}
+     */
+    static transferWithSeed(from_pubkey, from_base, from_seed, from_owner, to_pubkey, lamports) {
+        _assertClass(from_pubkey, Pubkey);
+        _assertClass(from_base, Pubkey);
+        const ptr0 = passStringToWasm0(from_seed, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        _assertClass(from_owner, Pubkey);
+        _assertClass(to_pubkey, Pubkey);
+        const ret = wasm.systeminstruction_transferWithSeed(from_pubkey.__wbg_ptr, from_base.__wbg_ptr, ptr0, len0, from_owner.__wbg_ptr, to_pubkey.__wbg_ptr, lamports);
+        return Instruction.__wrap(ret);
+    }
+    /**
+     * @param {Pubkey} pubkey
+     * @param {bigint} space
+     * @returns {Instruction}
+     */
+    static allocate(pubkey, space) {
+        _assertClass(pubkey, Pubkey);
+        const ret = wasm.systeminstruction_allocate(pubkey.__wbg_ptr, space);
+        return Instruction.__wrap(ret);
+    }
+    /**
+     * @param {Pubkey} address
+     * @param {Pubkey} base
+     * @param {string} seed
+     * @param {bigint} space
+     * @param {Pubkey} owner
+     * @returns {Instruction}
+     */
+    static allocateWithSeed(address, base, seed, space, owner) {
+        _assertClass(address, Pubkey);
+        _assertClass(base, Pubkey);
+        const ptr0 = passStringToWasm0(seed, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+        const len0 = WASM_VECTOR_LEN;
+        _assertClass(owner, Pubkey);
+        const ret = wasm.systeminstruction_allocateWithSeed(address.__wbg_ptr, base.__wbg_ptr, ptr0, len0, space, owner.__wbg_ptr);
+        return Instruction.__wrap(ret);
+    }
+    /**
+     * @param {Pubkey} from_pubkey
+     * @param {Pubkey} nonce_pubkey
+     * @param {Pubkey} authority
+     * @param {bigint} lamports
+     * @returns {Array<any>}
+     */
+    static createNonceAccount(from_pubkey, nonce_pubkey, authority, lamports) {
+        _assertClass(from_pubkey, Pubkey);
+        _assertClass(nonce_pubkey, Pubkey);
+        _assertClass(authority, Pubkey);
+        const ret = wasm.systeminstruction_createNonceAccount(from_pubkey.__wbg_ptr, nonce_pubkey.__wbg_ptr, authority.__wbg_ptr, lamports);
+        return takeObject(ret);
+    }
+    /**
+     * @param {Pubkey} nonce_pubkey
+     * @param {Pubkey} authorized_pubkey
+     * @returns {Instruction}
+     */
+    static advanceNonceAccount(nonce_pubkey, authorized_pubkey) {
+        _assertClass(nonce_pubkey, Pubkey);
+        _assertClass(authorized_pubkey, Pubkey);
+        const ret = wasm.systeminstruction_advanceNonceAccount(nonce_pubkey.__wbg_ptr, authorized_pubkey.__wbg_ptr);
+        return Instruction.__wrap(ret);
+    }
+    /**
+     * @param {Pubkey} nonce_pubkey
+     * @param {Pubkey} authorized_pubkey
+     * @param {Pubkey} to_pubkey
+     * @param {bigint} lamports
+     * @returns {Instruction}
+     */
+    static withdrawNonceAccount(nonce_pubkey, authorized_pubkey, to_pubkey, lamports) {
+        _assertClass(nonce_pubkey, Pubkey);
+        _assertClass(authorized_pubkey, Pubkey);
+        _assertClass(to_pubkey, Pubkey);
+        const ret = wasm.systeminstruction_withdrawNonceAccount(nonce_pubkey.__wbg_ptr, authorized_pubkey.__wbg_ptr, to_pubkey.__wbg_ptr, lamports);
+        return Instruction.__wrap(ret);
+    }
+    /**
+     * @param {Pubkey} nonce_pubkey
+     * @param {Pubkey} authorized_pubkey
+     * @param {Pubkey} new_authority
+     * @returns {Instruction}
+     */
+    static authorizeNonceAccount(nonce_pubkey, authorized_pubkey, new_authority) {
+        _assertClass(nonce_pubkey, Pubkey);
+        _assertClass(authorized_pubkey, Pubkey);
+        _assertClass(new_authority, Pubkey);
+        const ret = wasm.systeminstruction_authorizeNonceAccount(nonce_pubkey.__wbg_ptr, authorized_pubkey.__wbg_ptr, new_authority.__wbg_ptr);
+        return Instruction.__wrap(ret);
+    }
+}
+if (Symbol.dispose) SystemInstruction.prototype[Symbol.dispose] = SystemInstruction.prototype.free;
+
+const TransactionFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_transaction_free(ptr >>> 0, 1));
+/**
+ * wasm-bindgen version of the Transaction struct.
+ * This duplication is required until https://github.com/rustwasm/wasm-bindgen/issues/3671
+ * is fixed. This must not diverge from the regular non-wasm Transaction struct.
+ */
+export class Transaction {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Transaction.prototype);
+        obj.__wbg_ptr = ptr;
+        TransactionFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        TransactionFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_transaction_free(ptr, 0);
+    }
+    /**
+     * Create a new `Transaction`
+     * @param {Instructions} instructions
+     * @param {Pubkey | null} [payer]
+     */
+    constructor(instructions, payer) {
+        _assertClass(instructions, Instructions);
+        var ptr0 = instructions.__destroy_into_raw();
+        let ptr1 = 0;
+        if (!isLikeNone(payer)) {
+            _assertClass(payer, Pubkey);
+            ptr1 = payer.__destroy_into_raw();
+        }
+        const ret = wasm.transaction_constructor(ptr0, ptr1);
+        this.__wbg_ptr = ret >>> 0;
+        TransactionFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * Return a message containing all data that should be signed.
+     * @returns {Message}
+     */
+    message() {
+        const ret = wasm.transaction_message(this.__wbg_ptr);
+        return Message.__wrap(ret);
+    }
+    /**
+     * Return the serialized message data to sign.
+     * @returns {Uint8Array}
+     */
+    messageData() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.transaction_messageData(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * Verify the transaction
+     */
+    verify() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.transaction_verify(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @param {Keypair} keypair
+     * @param {Hash} recent_blockhash
+     */
+    partialSign(keypair, recent_blockhash) {
+        _assertClass(keypair, Keypair);
+        _assertClass(recent_blockhash, Hash);
+        wasm.transaction_partialSign(this.__wbg_ptr, keypair.__wbg_ptr, recent_blockhash.__wbg_ptr);
+    }
+    /**
+     * @returns {boolean}
+     */
+    isSigned() {
+        const ret = wasm.transaction_isSigned(this.__wbg_ptr);
+        return ret !== 0;
+    }
+    /**
+     * @returns {Uint8Array}
+     */
+    toBytes() {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            wasm.transaction_toBytes(retptr, this.__wbg_ptr);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var v1 = getArrayU8FromWasm0(r0, r1).slice();
+            wasm.__wbindgen_export4(r0, r1 * 1, 1);
+            return v1;
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+    /**
+     * @param {Uint8Array} bytes
+     * @returns {Transaction}
+     */
+    static fromBytes(bytes) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_export);
+            const len0 = WASM_VECTOR_LEN;
+            wasm.transaction_fromBytes(retptr, ptr0, len0);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+            if (r2) {
+                throw takeObject(r1);
+            }
+            return Transaction.__wrap(r0);
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
+}
+if (Symbol.dispose) Transaction.prototype[Symbol.dispose] = Transaction.prototype.free;
+
 export function __wbg_Error_e83987f665cf5504(arg0, arg1) {
     const ret = Error(getStringFromWasm0(arg0, arg1));
     return addHeapObject(ret);
@@ -1856,16 +2777,91 @@ export function __wbg___wbindgen_throw_b855445ff6a94295(arg0, arg1) {
     throw new Error(getStringFromWasm0(arg0, arg1));
 };
 
+export function __wbg__wbg_cb_unref_2454a539ea5790d9(arg0) {
+    getObject(arg0)._wbg_cb_unref();
+};
+
+export function __wbg_abort_28ad55c5825b004d(arg0, arg1) {
+    getObject(arg0).abort(getObject(arg1));
+};
+
+export function __wbg_abort_e7eb059f72f9ed0c(arg0) {
+    getObject(arg0).abort();
+};
+
+export function __wbg_append_b577eb3a177bc0fa() { return handleError(function (arg0, arg1, arg2, arg3, arg4) {
+    getObject(arg0).append(getStringFromWasm0(arg1, arg2), getStringFromWasm0(arg3, arg4));
+}, arguments) };
+
+export function __wbg_arrayBuffer_b375eccb84b4ddf3() { return handleError(function (arg0) {
+    const ret = getObject(arg0).arrayBuffer();
+    return addHeapObject(ret);
+}, arguments) };
+
+export function __wbg_call_525440f72fbfc0ea() { return handleError(function (arg0, arg1, arg2) {
+    const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
+    return addHeapObject(ret);
+}, arguments) };
+
 export function __wbg_call_e762c39fa8ea36bf() { return handleError(function (arg0, arg1) {
     const ret = getObject(arg0).call(getObject(arg1));
     return addHeapObject(ret);
 }, arguments) };
 
+export function __wbg_clearTimeout_7a42b49784aea641(arg0) {
+    const ret = clearTimeout(takeObject(arg0));
+    return addHeapObject(ret);
+};
+
+export function __wbg_crypto_038798f665f985e2(arg0) {
+    const ret = getObject(arg0).crypto;
+    return addHeapObject(ret);
+};
+
+export function __wbg_debug_f4b0c59db649db48(arg0) {
+    console.debug(getObject(arg0));
+};
+
 export function __wbg_done_2042aa2670fb1db1(arg0) {
     const ret = getObject(arg0).done;
     return ret;
 };
 
+export function __wbg_error_7534b8e9a36f1ab4(arg0, arg1) {
+    let deferred0_0;
+    let deferred0_1;
+    try {
+        deferred0_0 = arg0;
+        deferred0_1 = arg1;
+        console.error(getStringFromWasm0(arg0, arg1));
+    } finally {
+        wasm.__wbindgen_export4(deferred0_0, deferred0_1, 1);
+    }
+};
+
+export function __wbg_error_a7f8fbb0523dae15(arg0) {
+    console.error(getObject(arg0));
+};
+
+export function __wbg_fetch_74a3e84ebd2c9a0e(arg0) {
+    const ret = fetch(getObject(arg0));
+    return addHeapObject(ret);
+};
+
+export function __wbg_fetch_f8ba0e29a9d6de0d(arg0, arg1) {
+    const ret = getObject(arg0).fetch(getObject(arg1));
+    return addHeapObject(ret);
+};
+
+export function __wbg_getRandomValues_371e7ade8bd92088(arg0, arg1) {
+    getObject(arg0).getRandomValues(getObject(arg1));
+};
+
+export function __wbg_getRandomValues_7dfe5bd1b67c9ca1(arg0) {
+    const ret = getObject(arg0).getRandomValues;
+    return addHeapObject(ret);
+};
+
 export function __wbg_get_7bed016f185add81(arg0, arg1) {
     const ret = getObject(arg0)[arg1 >>> 0];
     return addHeapObject(ret);
@@ -1886,6 +2882,20 @@ export function __wbg_get_with_ref_key_6550b2c093d2eb18(arg0, arg1) {
     return addHeapObject(ret);
 };
 
+export function __wbg_has_787fafc980c3ccdb() { return handleError(function (arg0, arg1) {
+    const ret = Reflect.has(getObject(arg0), getObject(arg1));
+    return ret;
+}, arguments) };
+
+export function __wbg_headers_b87d7eaba61c3278(arg0) {
+    const ret = getObject(arg0).headers;
+    return addHeapObject(ret);
+};
+
+export function __wbg_info_e674a11f4f50cc0c(arg0) {
+    console.info(getObject(arg0));
+};
+
 export function __wbg_instanceof_ArrayBuffer_70beb1189ca63b38(arg0) {
     let result;
     try {
@@ -1897,6 +2907,17 @@ export function __wbg_instanceof_ArrayBuffer_70beb1189ca63b38(arg0) {
     return ret;
 };
 
+export function __wbg_instanceof_Response_f4f3e87e07f3135c(arg0) {
+    let result;
+    try {
+        result = getObject(arg0) instanceof Response;
+    } catch (_) {
+        result = false;
+    }
+    const ret = result;
+    return ret;
+};
+
 export function __wbg_instanceof_Uint8Array_20c8e73002f7af98(arg0) {
     let result;
     try {
@@ -1908,6 +2929,11 @@ export function __wbg_instanceof_Uint8Array_20c8e73002f7af98(arg0) {
     return ret;
 };
 
+export function __wbg_instruction_new(arg0) {
+    const ret = Instruction.__wrap(arg0);
+    return addHeapObject(ret);
+};
+
 export function __wbg_isArray_643fafc484312e19(arg0) {
     const ret = Array.isArray(getObject(arg0));
     return ret;
@@ -1938,16 +2964,89 @@ export function __wbg_length_cdd215e10d9dd507(arg0) {
     return ret;
 };
 
+export function __wbg_log_8cec76766b8c0e33(arg0) {
+    console.log(getObject(arg0));
+};
+
+export function __wbg_msCrypto_ff35fce085fab2a3(arg0) {
+    const ret = getObject(arg0).msCrypto;
+    return addHeapObject(ret);
+};
+
 export function __wbg_new_1acc0b6eea89d040() {
     const ret = new Object();
     return addHeapObject(ret);
 };
 
+export function __wbg_new_2531773dac38ebb3() { return handleError(function () {
+    const ret = new AbortController();
+    return addHeapObject(ret);
+}, arguments) };
+
+export function __wbg_new_3c3d849046688a66(arg0, arg1) {
+    try {
+        var state0 = {a: arg0, b: arg1};
+        var cb0 = (arg0, arg1) => {
+            const a = state0.a;
+            state0.a = 0;
+            try {
+                return __wasm_bindgen_func_elem_480(a, state0.b, arg0, arg1);
+            } finally {
+                state0.a = a;
+            }
+        };
+        const ret = new Promise(cb0);
+        return addHeapObject(ret);
+    } finally {
+        state0.a = state0.b = 0;
+    }
+};
+
 export function __wbg_new_5a79be3ab53b8aa5(arg0) {
     const ret = new Uint8Array(getObject(arg0));
     return addHeapObject(ret);
 };
 
+export function __wbg_new_8a6f238a6ece86ea() {
+    const ret = new Error();
+    return addHeapObject(ret);
+};
+
+export function __wbg_new_9edf9838a2def39c() { return handleError(function () {
+    const ret = new Headers();
+    return addHeapObject(ret);
+}, arguments) };
+
+export function __wbg_new_e17d9f43105b08be() {
+    const ret = new Array();
+    return addHeapObject(ret);
+};
+
+export function __wbg_new_from_slice_92f4d78ca282a2d2(arg0, arg1) {
+    const ret = new Uint8Array(getArrayU8FromWasm0(arg0, arg1));
+    return addHeapObject(ret);
+};
+
+export function __wbg_new_no_args_ee98eee5275000a4(arg0, arg1) {
+    const ret = new Function(getStringFromWasm0(arg0, arg1));
+    return addHeapObject(ret);
+};
+
+export function __wbg_new_with_length_01aa0dc35aa13543(arg0) {
+    const ret = new Uint8Array(arg0 >>> 0);
+    return addHeapObject(ret);
+};
+
+export function __wbg_new_with_length_31d2669cb75c5215(arg0) {
+    const ret = new Array(arg0 >>> 0);
+    return addHeapObject(ret);
+};
+
+export function __wbg_new_with_str_and_init_0ae7728b6ec367b1() { return handleError(function (arg0, arg1, arg2) {
+    const ret = new Request(getStringFromWasm0(arg0, arg1), getObject(arg2));
+    return addHeapObject(ret);
+}, arguments) };
+
 export function __wbg_next_020810e0ae8ebcb0() { return handleError(function (arg0) {
     const ret = getObject(arg0).next();
     return addHeapObject(ret);
@@ -1962,15 +3061,179 @@ export function __wbg_prototypesetcall_2a6620b6922694b2(arg0, arg1, arg2) {
     Uint8Array.prototype.set.call(getArrayU8FromWasm0(arg0, arg1), getObject(arg2));
 };
 
+export function __wbg_pubkey_new(arg0) {
+    const ret = Pubkey.__wrap(arg0);
+    return addHeapObject(ret);
+};
+
+export function __wbg_push_df81a39d04db858c(arg0, arg1) {
+    const ret = getObject(arg0).push(getObject(arg1));
+    return ret;
+};
+
+export function __wbg_queueMicrotask_34d692c25c47d05b(arg0) {
+    const ret = getObject(arg0).queueMicrotask;
+    return addHeapObject(ret);
+};
+
+export function __wbg_queueMicrotask_9d76cacb20c84d58(arg0) {
+    queueMicrotask(getObject(arg0));
+};
+
+export function __wbg_randomFillSync_994ac6d9ade7a695(arg0, arg1, arg2) {
+    getObject(arg0).randomFillSync(getArrayU8FromWasm0(arg1, arg2));
+};
+
+export function __wbg_require_0d6aeaec3c042c88(arg0, arg1, arg2) {
+    const ret = getObject(arg0).require(getStringFromWasm0(arg1, arg2));
+    return addHeapObject(ret);
+};
+
+export function __wbg_resolve_caf97c30b83f7053(arg0) {
+    const ret = Promise.resolve(getObject(arg0));
+    return addHeapObject(ret);
+};
+
+export function __wbg_self_25aabeb5a7b41685() { return handleError(function () {
+    const ret = self.self;
+    return addHeapObject(ret);
+}, arguments) };
+
+export function __wbg_setTimeout_7bb3429662ab1e70(arg0, arg1) {
+    const ret = setTimeout(getObject(arg0), arg1);
+    return addHeapObject(ret);
+};
+
 export function __wbg_set_3807d5f0bfc24aa7(arg0, arg1, arg2) {
     getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
 };
 
+export function __wbg_set_3f1d0b984ed272ed(arg0, arg1, arg2) {
+    getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
+};
+
+export function __wbg_set_body_3c365989753d61f4(arg0, arg1) {
+    getObject(arg0).body = getObject(arg1);
+};
+
+export function __wbg_set_c213c871859d6500(arg0, arg1, arg2) {
+    getObject(arg0)[arg1 >>> 0] = takeObject(arg2);
+};
+
+export function __wbg_set_cache_2f9deb19b92b81e3(arg0, arg1) {
+    getObject(arg0).cache = __wbindgen_enum_RequestCache[arg1];
+};
+
+export function __wbg_set_credentials_f621cd2d85c0c228(arg0, arg1) {
+    getObject(arg0).credentials = __wbindgen_enum_RequestCredentials[arg1];
+};
+
+export function __wbg_set_headers_6926da238cd32ee4(arg0, arg1) {
+    getObject(arg0).headers = getObject(arg1);
+};
+
+export function __wbg_set_method_c02d8cbbe204ac2d(arg0, arg1, arg2) {
+    getObject(arg0).method = getStringFromWasm0(arg1, arg2);
+};
+
+export function __wbg_set_mode_52ef73cfa79639cb(arg0, arg1) {
+    getObject(arg0).mode = __wbindgen_enum_RequestMode[arg1];
+};
+
+export function __wbg_set_signal_dda2cf7ccb6bee0f(arg0, arg1) {
+    getObject(arg0).signal = getObject(arg1);
+};
+
+export function __wbg_signal_4db5aa055bf9eb9a(arg0) {
+    const ret = getObject(arg0).signal;
+    return addHeapObject(ret);
+};
+
+export function __wbg_stack_0ed75d68575b0f3c(arg0, arg1) {
+    const ret = getObject(arg1).stack;
+    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+};
+
+export function __wbg_static_accessor_GLOBAL_89e1d9ac6a1b250e() {
+    const ret = typeof global === 'undefined' ? null : global;
+    return isLikeNone(ret) ? 0 : addHeapObject(ret);
+};
+
+export function __wbg_static_accessor_GLOBAL_THIS_8b530f326a9e48ac() {
+    const ret = typeof globalThis === 'undefined' ? null : globalThis;
+    return isLikeNone(ret) ? 0 : addHeapObject(ret);
+};
+
+export function __wbg_static_accessor_MODULE_ef3aa2eb251158a5() {
+    const ret = module;
+    return addHeapObject(ret);
+};
+
+export function __wbg_static_accessor_SELF_6fdf4b64710cc91b() {
+    const ret = typeof self === 'undefined' ? null : self;
+    return isLikeNone(ret) ? 0 : addHeapObject(ret);
+};
+
+export function __wbg_static_accessor_WINDOW_b45bfc5a37f6cfa2() {
+    const ret = typeof window === 'undefined' ? null : window;
+    return isLikeNone(ret) ? 0 : addHeapObject(ret);
+};
+
+export function __wbg_status_de7eed5a7a5bfd5d(arg0) {
+    const ret = getObject(arg0).status;
+    return ret;
+};
+
+export function __wbg_stringify_b5fb28f6465d9c3e() { return handleError(function (arg0) {
+    const ret = JSON.stringify(getObject(arg0));
+    return addHeapObject(ret);
+}, arguments) };
+
+export function __wbg_subarray_480600f3d6a9f26c(arg0, arg1, arg2) {
+    const ret = getObject(arg0).subarray(arg1 >>> 0, arg2 >>> 0);
+    return addHeapObject(ret);
+};
+
+export function __wbg_text_dc33c15c17bdfb52() { return handleError(function (arg0) {
+    const ret = getObject(arg0).text();
+    return addHeapObject(ret);
+}, arguments) };
+
+export function __wbg_then_4f46f6544e6b4a28(arg0, arg1) {
+    const ret = getObject(arg0).then(getObject(arg1));
+    return addHeapObject(ret);
+};
+
+export function __wbg_then_70d05cf780a18d77(arg0, arg1, arg2) {
+    const ret = getObject(arg0).then(getObject(arg1), getObject(arg2));
+    return addHeapObject(ret);
+};
+
+export function __wbg_url_b36d2a5008eb056f(arg0, arg1) {
+    const ret = getObject(arg1).url;
+    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+};
+
 export function __wbg_value_692627309814bb8c(arg0) {
     const ret = getObject(arg0).value;
     return addHeapObject(ret);
 };
 
+export function __wbg_values_58a781304289144d(arg0) {
+    const ret = getObject(arg0).values();
+    return addHeapObject(ret);
+};
+
+export function __wbg_warn_1d74dddbe2fd1dbb(arg0) {
+    console.warn(getObject(arg0));
+};
+
 export function __wbindgen_cast_2241b6af4c4b2941(arg0, arg1) {
     // Cast intrinsic for `Ref(String) -> Externref`.
     const ret = getStringFromWasm0(arg0, arg1);
@@ -1983,12 +3246,24 @@ export function __wbindgen_cast_4625c577ab2ec9ee(arg0) {
     return addHeapObject(ret);
 };
 
+export function __wbindgen_cast_7f6d2ab049d5d8fd(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 334, function: Function { arguments: [], shim_idx: 335, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_3093, __wasm_bindgen_func_elem_3097);
+    return addHeapObject(ret);
+};
+
 export function __wbindgen_cast_9ae0607507abb057(arg0) {
     // Cast intrinsic for `I64 -> Externref`.
     const ret = arg0;
     return addHeapObject(ret);
 };
 
+export function __wbindgen_cast_b2b7ff753c8c06bb(arg0, arg1) {
+    // Cast intrinsic for `Closure(Closure { dtor_idx: 366, function: Function { arguments: [Externref], shim_idx: 361, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+    const ret = makeMutClosure(arg0, arg1, wasm.__wasm_bindgen_func_elem_3222, __wasm_bindgen_func_elem_3203);
+    return addHeapObject(ret);
+};
+
 export function __wbindgen_cast_d6cd19b81560fd6e(arg0) {
     // Cast intrinsic for `F64 -> Externref`.
     const ret = arg0;