@xstoicunicornx/payjoin_test 0.1.8 → 0.1.9

package/dist/web/{bindings → generated}/wasm-bindgen/index.js

@@ -138,29 +138,6 @@ export class ForeignFutureCompleteI8 {
 }
 if (Symbol.dispose) ForeignFutureCompleteI8.prototype[Symbol.dispose] = ForeignFutureCompleteI8.prototype.free;
 
-export class ForeignFutureCompletePointer {
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        ForeignFutureCompletePointerFinalization.unregister(this);
-        return ptr;
-    }
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_foreignfuturecompletepointer_free(ptr, 0);
-    }
-    /**
-     * @param {ForeignFutureCompletePointer} _ctx
-     * @param {bigint} callback_data
-     * @param {any} result
-     */
-    call(_ctx, callback_data, result) {
-        _assertClass(_ctx, ForeignFutureCompletePointer);
-        wasm.foreignfuturecompletepointer_call(this.__wbg_ptr, _ctx.__wbg_ptr, callback_data, result);
-    }
-}
-if (Symbol.dispose) ForeignFutureCompletePointer.prototype[Symbol.dispose] = ForeignFutureCompletePointer.prototype.free;
-
 export class ForeignFutureCompleteRustBuffer {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
@@ -409,13 +386,6 @@ export function ubrn_ffi_payjoin_ffi_rust_future_cancel_i8(handle) {
     wasm.ubrn_ffi_payjoin_ffi_rust_future_cancel_i8(handle);
 }
 
-/**
- * @param {bigint} handle
- */
-export function ubrn_ffi_payjoin_ffi_rust_future_cancel_pointer(handle) {
-    wasm.ubrn_ffi_payjoin_ffi_rust_future_cancel_pointer(handle);
-}
-
 /**
  * @param {bigint} handle
  */
@@ -524,17 +494,6 @@ export function ubrn_ffi_payjoin_ffi_rust_future_complete_i8(handle, f_status_)
     return ret;
 }
 
-/**
- * @param {bigint} handle
- * @param {RustCallStatus} f_status_
- * @returns {bigint}
- */
-export function ubrn_ffi_payjoin_ffi_rust_future_complete_pointer(handle, f_status_) {
-    _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_ffi_payjoin_ffi_rust_future_complete_pointer(handle, f_status_.__wbg_ptr);
-    return BigInt.asUintN(64, ret);
-}
-
 /**
  * @param {bigint} handle
  * @param {RustCallStatus} f_status_
@@ -643,13 +602,6 @@ export function ubrn_ffi_payjoin_ffi_rust_future_free_i8(handle) {
     wasm.ubrn_ffi_payjoin_ffi_rust_future_free_i8(handle);
 }
 
-/**
- * @param {bigint} handle
- */
-export function ubrn_ffi_payjoin_ffi_rust_future_free_pointer(handle) {
-    wasm.ubrn_ffi_payjoin_ffi_rust_future_free_pointer(handle);
-}
-
 /**
  * @param {bigint} handle
  */
@@ -746,15 +698,6 @@ export function ubrn_ffi_payjoin_ffi_rust_future_poll_i8(handle, callback, callb
     wasm.ubrn_ffi_payjoin_ffi_rust_future_poll_i8(handle, callback, callback_data);
 }
 
-/**
- * @param {bigint} handle
- * @param {any} callback
- * @param {bigint} callback_data
- */
-export function ubrn_ffi_payjoin_ffi_rust_future_poll_pointer(handle, callback, callback_data) {
-    wasm.ubrn_ffi_payjoin_ffi_rust_future_poll_pointer(handle, callback, callback_data);
-}
-
 /**
  * @param {bigint} handle
  * @param {any} callback
@@ -2010,937 +1953,937 @@ export function ubrn_uniffi_payjoin_ffi_checksum_method_withreplykeytransition_s
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_addressparseerror(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_addressparseerror(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_addressparseerror(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_addressparseerror(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_assumeinteractivetransition(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_assumeinteractivetransition(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_assumeinteractivetransition(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_assumeinteractivetransition(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_buildsendererror(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_buildsendererror(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_buildsendererror(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_buildsendererror(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_canbroadcast(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_canbroadcast(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_canbroadcast(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_canbroadcast(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_canceltransition(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_canceltransition(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_canceltransition(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_canceltransition(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_clientresponse(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_clientresponse(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_clientresponse(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_clientresponse(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_createrequesterror(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_createrequesterror(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_createrequesterror(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_createrequesterror(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_encapsulationerror(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_encapsulationerror(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_encapsulationerror(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_encapsulationerror(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_feerateerror(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_feerateerror(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_feerateerror(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_feerateerror(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_hasreplyableerror(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_hasreplyableerror(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_hasreplyableerror(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_hasreplyableerror(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_hasreplyableerrortransition(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_hasreplyableerrortransition(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_hasreplyableerrortransition(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_hasreplyableerrortransition(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_implementationerror(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_implementationerror(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_implementationerror(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_implementationerror(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_initialized(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_initialized(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_initialized(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_initialized(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_initializedtransition(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_initializedtransition(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_initializedtransition(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_initializedtransition(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_initialreceivetransition(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_initialreceivetransition(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_initialreceivetransition(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_initialreceivetransition(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_initialsendtransition(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_initialsendtransition(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_initialsendtransition(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_initialsendtransition(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_inputcontributionerror(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_inputcontributionerror(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_inputcontributionerror(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_inputcontributionerror(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_inputpair(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_inputpair(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_inputpair(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_inputpair(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_intourlerror(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_intourlerror(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_intourlerror(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_intourlerror(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_isoutputknown(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_isoutputknown(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_isoutputknown(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_isoutputknown(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_isscriptowned(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_isscriptowned(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_isscriptowned(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_isscriptowned(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_jsonreceiversessionpersister(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_jsonreceiversessionpersister(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_jsonreceiversessionpersister(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_jsonreceiversessionpersister(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_jsonreceiversessionpersisterasync(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_jsonreceiversessionpersisterasync(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_jsonreceiversessionpersisterasync(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_jsonreceiversessionpersisterasync(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_jsonreply(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_jsonreply(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_jsonreply(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_jsonreply(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_jsonsendersessionpersister(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_jsonsendersessionpersister(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_jsonsendersessionpersister(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_jsonsendersessionpersister(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_jsonsendersessionpersisterasync(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_jsonsendersessionpersisterasync(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_jsonsendersessionpersisterasync(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_jsonsendersessionpersisterasync(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_maybeinputsowned(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_maybeinputsowned(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_maybeinputsowned(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_maybeinputsowned(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_maybeinputsownedtransition(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_maybeinputsownedtransition(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_maybeinputsownedtransition(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_maybeinputsownedtransition(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_maybeinputsseen(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_maybeinputsseen(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_maybeinputsseen(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_maybeinputsseen(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_maybeinputsseentransition(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_maybeinputsseentransition(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_maybeinputsseentransition(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_maybeinputsseentransition(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_monitor(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_monitor(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_monitor(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_monitor(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_monitortransition(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_monitortransition(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_monitortransition(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_monitortransition(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_ohttperror(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_ohttperror(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_ohttperror(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_ohttperror(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_ohttpkeys(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_ohttpkeys(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_ohttpkeys(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_ohttpkeys(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_outputsubstitutionprotocolerror(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_outputsubstitutionprotocolerror(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_outputsubstitutionprotocolerror(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_outputsubstitutionprotocolerror(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_outputsunknown(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_outputsunknown(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_outputsunknown(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_outputsunknown(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_outputsunknowntransition(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_outputsunknowntransition(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_outputsunknowntransition(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_outputsunknowntransition(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_payjoinproposal(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_payjoinproposal(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_payjoinproposal(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_payjoinproposal(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_payjoinproposaltransition(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_payjoinproposaltransition(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_payjoinproposaltransition(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_payjoinproposaltransition(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_pjnotsupported(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_pjnotsupported(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_pjnotsupported(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_pjnotsupported(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_pjparam(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_pjparam(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_pjparam(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_pjparam(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_pjparseerror(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_pjparseerror(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_pjparseerror(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_pjparseerror(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_pjuri(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_pjuri(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_pjuri(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_pjuri(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_pollingforproposal(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_pollingforproposal(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_pollingforproposal(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_pollingforproposal(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_pollingforproposaltransition(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_pollingforproposaltransition(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_pollingforproposaltransition(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_pollingforproposaltransition(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_processpsbt(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_processpsbt(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_processpsbt(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_processpsbt(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_protocolerror(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_protocolerror(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_protocolerror(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_protocolerror(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_provisionalproposal(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_provisionalproposal(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_provisionalproposal(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_provisionalproposal(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_provisionalproposaltransition(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_provisionalproposaltransition(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_provisionalproposaltransition(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_provisionalproposaltransition(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_psbtinputerror(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_psbtinputerror(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_psbtinputerror(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_psbtinputerror(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_receiverbuilder(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_receiverbuilder(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_receiverbuilder(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_receiverbuilder(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_receiverreplayerror(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_receiverreplayerror(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_receiverreplayerror(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_receiverreplayerror(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_receiversessionevent(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_receiversessionevent(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_receiversessionevent(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_receiversessionevent(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_receiversessionhistory(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_receiversessionhistory(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_receiversessionhistory(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_receiversessionhistory(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_receiversessionoutcome(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_receiversessionoutcome(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_receiversessionoutcome(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_receiversessionoutcome(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_receiversessionstatus(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_receiversessionstatus(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_receiversessionstatus(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_receiversessionstatus(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_replayresult(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_replayresult(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_replayresult(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_replayresult(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_selectionerror(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_selectionerror(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_selectionerror(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_selectionerror(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_senderbuilder(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_senderbuilder(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_senderbuilder(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_senderbuilder(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_sendercanceltransition(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_sendercanceltransition(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_sendercanceltransition(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_sendercanceltransition(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_senderreplayerror(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_senderreplayerror(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_senderreplayerror(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_senderreplayerror(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_senderreplayresult(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_senderreplayresult(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_senderreplayresult(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_senderreplayresult(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_sendersessionevent(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_sendersessionevent(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_sendersessionevent(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_sendersessionevent(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_sendersessionhistory(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_sendersessionhistory(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_sendersessionhistory(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_sendersessionhistory(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_sendersessionoutcome(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_sendersessionoutcome(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_sendersessionoutcome(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_sendersessionoutcome(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_sendersessionstatus(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_sendersessionstatus(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_sendersessionstatus(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_sendersessionstatus(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_serdejsonerror(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_serdejsonerror(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_serdejsonerror(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_serdejsonerror(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_sessionerror(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_sessionerror(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_sessionerror(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_sessionerror(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_transactionexists(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_transactionexists(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_transactionexists(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_transactionexists(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_uncheckedoriginalpayload(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_uncheckedoriginalpayload(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_uncheckedoriginalpayload(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_uncheckedoriginalpayload(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_uncheckedoriginalpayloadtransition(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_uncheckedoriginalpayloadtransition(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_uncheckedoriginalpayloadtransition(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_uncheckedoriginalpayloadtransition(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_uri(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_uri(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_uri(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_uri(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_url(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_url(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_url(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_url(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_urlparseerror(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_urlparseerror(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_urlparseerror(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_urlparseerror(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_v1context(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_v1context(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_v1context(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_v1context(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_validationerror(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_validationerror(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_validationerror(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_validationerror(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_wantsfeerange(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_wantsfeerange(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_wantsfeerange(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_wantsfeerange(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_wantsfeerangetransition(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_wantsfeerangetransition(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_wantsfeerangetransition(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_wantsfeerangetransition(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_wantsinputs(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_wantsinputs(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_wantsinputs(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_wantsinputs(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_wantsinputstransition(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_wantsinputstransition(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_wantsinputstransition(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_wantsinputstransition(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_wantsoutputs(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_wantsoutputs(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_wantsoutputs(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_wantsoutputs(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_wantsoutputstransition(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_wantsoutputstransition(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_wantsoutputstransition(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_wantsoutputstransition(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_wellknownerror(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_wellknownerror(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_wellknownerror(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_wellknownerror(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_withreplykey(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_withreplykey(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_withreplykey(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_withreplykey(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-export function ubrn_uniffi_payjoin_ffi_fn_clone_withreplykeytransition(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_clone_withreplykeytransition(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_withreplykeytransition(ptr, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_withreplykeytransition(handle, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 
@@ -3060,768 +3003,768 @@ export function ubrn_uniffi_payjoin_ffi_fn_constructor_url_parse(input, f_status
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_addressparseerror(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_addressparseerror(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_addressparseerror(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_addressparseerror(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_assumeinteractivetransition(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_assumeinteractivetransition(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_assumeinteractivetransition(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_assumeinteractivetransition(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_buildsendererror(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_buildsendererror(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_buildsendererror(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_buildsendererror(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_canbroadcast(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_canbroadcast(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_canbroadcast(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_canbroadcast(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_canceltransition(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_canceltransition(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_canceltransition(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_canceltransition(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_clientresponse(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_clientresponse(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_clientresponse(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_clientresponse(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_createrequesterror(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_createrequesterror(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_createrequesterror(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_createrequesterror(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_encapsulationerror(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_encapsulationerror(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_encapsulationerror(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_encapsulationerror(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_feerateerror(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_feerateerror(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_feerateerror(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_feerateerror(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_hasreplyableerror(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_hasreplyableerror(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_hasreplyableerror(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_hasreplyableerror(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_hasreplyableerrortransition(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_hasreplyableerrortransition(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_hasreplyableerrortransition(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_hasreplyableerrortransition(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_implementationerror(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_implementationerror(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_implementationerror(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_implementationerror(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_initialized(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_initialized(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_initialized(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_initialized(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_initializedtransition(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_initializedtransition(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_initializedtransition(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_initializedtransition(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_initialreceivetransition(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_initialreceivetransition(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_initialreceivetransition(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_initialreceivetransition(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_initialsendtransition(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_initialsendtransition(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_initialsendtransition(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_initialsendtransition(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_inputcontributionerror(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_inputcontributionerror(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_inputcontributionerror(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_inputcontributionerror(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_inputpair(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_inputpair(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_inputpair(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_inputpair(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_intourlerror(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_intourlerror(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_intourlerror(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_intourlerror(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_isoutputknown(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_isoutputknown(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_isoutputknown(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_isoutputknown(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_isscriptowned(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_isscriptowned(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_isscriptowned(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_isscriptowned(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_jsonreceiversessionpersister(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_jsonreceiversessionpersister(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_jsonreceiversessionpersister(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_jsonreceiversessionpersister(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_jsonreceiversessionpersisterasync(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_jsonreceiversessionpersisterasync(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_jsonreceiversessionpersisterasync(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_jsonreceiversessionpersisterasync(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_jsonreply(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_jsonreply(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_jsonreply(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_jsonreply(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_jsonsendersessionpersister(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_jsonsendersessionpersister(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_jsonsendersessionpersister(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_jsonsendersessionpersister(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_jsonsendersessionpersisterasync(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_jsonsendersessionpersisterasync(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_jsonsendersessionpersisterasync(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_jsonsendersessionpersisterasync(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_maybeinputsowned(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_maybeinputsowned(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_maybeinputsowned(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_maybeinputsowned(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_maybeinputsownedtransition(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_maybeinputsownedtransition(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_maybeinputsownedtransition(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_maybeinputsownedtransition(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_maybeinputsseen(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_maybeinputsseen(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_maybeinputsseen(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_maybeinputsseen(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_maybeinputsseentransition(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_maybeinputsseentransition(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_maybeinputsseentransition(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_maybeinputsseentransition(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_monitor(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_monitor(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_monitor(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_monitor(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_monitortransition(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_monitortransition(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_monitortransition(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_monitortransition(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_ohttperror(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_ohttperror(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_ohttperror(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_ohttperror(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_ohttpkeys(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_ohttpkeys(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_ohttpkeys(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_ohttpkeys(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_outputsubstitutionprotocolerror(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_outputsubstitutionprotocolerror(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_outputsubstitutionprotocolerror(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_outputsubstitutionprotocolerror(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_outputsunknown(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_outputsunknown(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_outputsunknown(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_outputsunknown(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_outputsunknowntransition(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_outputsunknowntransition(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_outputsunknowntransition(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_outputsunknowntransition(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_payjoinproposal(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_payjoinproposal(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_payjoinproposal(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_payjoinproposal(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_payjoinproposaltransition(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_payjoinproposaltransition(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_payjoinproposaltransition(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_payjoinproposaltransition(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_pjnotsupported(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_pjnotsupported(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_pjnotsupported(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_pjnotsupported(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_pjparam(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_pjparam(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_pjparam(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_pjparam(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_pjparseerror(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_pjparseerror(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_pjparseerror(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_pjparseerror(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_pjuri(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_pjuri(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_pjuri(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_pjuri(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_pollingforproposal(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_pollingforproposal(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_pollingforproposal(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_pollingforproposal(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_pollingforproposaltransition(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_pollingforproposaltransition(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_pollingforproposaltransition(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_pollingforproposaltransition(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_processpsbt(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_processpsbt(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_processpsbt(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_processpsbt(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_protocolerror(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_protocolerror(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_protocolerror(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_protocolerror(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_provisionalproposal(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_provisionalproposal(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_provisionalproposal(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_provisionalproposal(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_provisionalproposaltransition(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_provisionalproposaltransition(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_provisionalproposaltransition(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_provisionalproposaltransition(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_psbtinputerror(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_psbtinputerror(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_psbtinputerror(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_psbtinputerror(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_receiverbuilder(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_receiverbuilder(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_receiverbuilder(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_receiverbuilder(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_receiverreplayerror(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_receiverreplayerror(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_receiverreplayerror(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_receiverreplayerror(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_receiversessionevent(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_receiversessionevent(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_receiversessionevent(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_receiversessionevent(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_receiversessionhistory(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_receiversessionhistory(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_receiversessionhistory(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_receiversessionhistory(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_receiversessionoutcome(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_receiversessionoutcome(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_receiversessionoutcome(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_receiversessionoutcome(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_receiversessionstatus(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_receiversessionstatus(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_receiversessionstatus(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_receiversessionstatus(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_replayresult(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_replayresult(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_replayresult(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_replayresult(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_selectionerror(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_selectionerror(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_selectionerror(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_selectionerror(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_senderbuilder(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_senderbuilder(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_senderbuilder(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_senderbuilder(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_sendercanceltransition(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_sendercanceltransition(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_sendercanceltransition(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_sendercanceltransition(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_senderreplayerror(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_senderreplayerror(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_senderreplayerror(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_senderreplayerror(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_senderreplayresult(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_senderreplayresult(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_senderreplayresult(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_senderreplayresult(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_sendersessionevent(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_sendersessionevent(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_sendersessionevent(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_sendersessionevent(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_sendersessionhistory(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_sendersessionhistory(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_sendersessionhistory(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_sendersessionhistory(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_sendersessionoutcome(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_sendersessionoutcome(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_sendersessionoutcome(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_sendersessionoutcome(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_sendersessionstatus(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_sendersessionstatus(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_sendersessionstatus(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_sendersessionstatus(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_serdejsonerror(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_serdejsonerror(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_serdejsonerror(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_serdejsonerror(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_sessionerror(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_sessionerror(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_sessionerror(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_sessionerror(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_transactionexists(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_transactionexists(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_transactionexists(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_transactionexists(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_uncheckedoriginalpayload(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_uncheckedoriginalpayload(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_uncheckedoriginalpayload(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_uncheckedoriginalpayload(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_uncheckedoriginalpayloadtransition(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_uncheckedoriginalpayloadtransition(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_uncheckedoriginalpayloadtransition(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_uncheckedoriginalpayloadtransition(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_uri(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_uri(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_uri(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_uri(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_url(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_url(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_url(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_url(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_urlparseerror(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_urlparseerror(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_urlparseerror(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_urlparseerror(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_v1context(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_v1context(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_v1context(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_v1context(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_validationerror(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_validationerror(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_validationerror(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_validationerror(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_wantsfeerange(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_wantsfeerange(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_wantsfeerange(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_wantsfeerange(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_wantsfeerangetransition(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_wantsfeerangetransition(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_wantsfeerangetransition(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_wantsfeerangetransition(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_wantsinputs(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_wantsinputs(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_wantsinputs(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_wantsinputs(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_wantsinputstransition(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_wantsinputstransition(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_wantsinputstransition(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_wantsinputstransition(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_wantsoutputs(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_wantsoutputs(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_wantsoutputs(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_wantsoutputs(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_wantsoutputstransition(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_wantsoutputstransition(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_wantsoutputstransition(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_wantsoutputstransition(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_wellknownerror(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_wellknownerror(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_wellknownerror(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_wellknownerror(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_withreplykey(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_withreplykey(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_withreplykey(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_withreplykey(handle, f_status_.__wbg_ptr);
 }
 
 /**
- * @param {bigint} ptr
+ * @param {bigint} handle
  * @param {RustCallStatus} f_status_
  */
-export function ubrn_uniffi_payjoin_ffi_fn_free_withreplykeytransition(ptr, f_status_) {
+export function ubrn_uniffi_payjoin_ffi_fn_free_withreplykeytransition(handle, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_withreplykeytransition(ptr, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_withreplykeytransition(handle, f_status_.__wbg_ptr);
 }
 
 /**
@@ -6271,10 +6214,6 @@ export function ubrn_uniffi_payjoin_ffi_fn_method_withreplykeytransition_save_as
     const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_method_withreplykeytransition_save_async(ptr, persister);
     return BigInt.asUintN(64, ret);
 }
-import * as import1 from "env"
-import * as import2 from "env"
-import * as import3 from "env"
-import * as import4 from "env"
 
 function __wbg_get_imports() {
     const import0 = {
@@ -6321,16 +6260,14 @@ function __wbg_get_imports() {
             const ret = arg0.call(arg1, BigInt.asUintN(64, arg2), v0);
             return ret;
         },
+        __wbg_call_2b04ddb0e45697f9: function(arg0, arg1, arg2) {
+            const ret = arg0.call(arg1, BigInt.asUintN(64, arg2));
+            return ret;
+        },
         __wbg_call_389efe28435a9388: function() { return handleError(function (arg0, arg1) {
             const ret = arg0.call(arg1);
             return ret;
         }, arguments); },
-        __wbg_call_3b1302a526c332d8: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
-            var v0 = getArrayU8FromWasm0(arg3, arg4).slice();
-            wasm.__wbindgen_free(arg3, arg4 * 1, 1);
-            const ret = arg0.call(arg1, BigInt.asUintN(64, arg2), v0, ForeignFutureCompleteVoid.__wrap(arg5), BigInt.asUintN(64, arg6));
-            return ret;
-        },
         __wbg_call_4708e0c13bdc8e95: function() { return handleError(function (arg0, arg1, arg2) {
             const ret = arg0.call(arg1, arg2);
             return ret;
@@ -6341,10 +6278,6 @@ function __wbg_get_imports() {
             const ret = arg0.call(arg1, BigInt.asUintN(64, arg2), v0);
             return ret;
         },
-        __wbg_call_57b7c69fd65ce852: function(arg0, arg1, arg2, arg3, arg4) {
-            const ret = arg0.call(arg1, BigInt.asUintN(64, arg2), ForeignFutureCompleteRustBuffer.__wrap(arg3), BigInt.asUintN(64, arg4));
-            return ret;
-        },
         __wbg_call_6362fb4c0b4c79c8: function(arg0, arg1, arg2, arg3) {
             arg0.call(arg1, BigInt.asUintN(64, arg2), arg3);
         },
@@ -6357,10 +6290,6 @@ function __wbg_get_imports() {
             const ret = arg0.call(arg1, BigInt.asUintN(64, arg2), v0);
             return ret;
         },
-        __wbg_call_9bb391b2693be863: function(arg0, arg1, arg2, arg3, arg4) {
-            const ret = arg0.call(arg1, BigInt.asUintN(64, arg2), ForeignFutureCompleteVoid.__wrap(arg3), BigInt.asUintN(64, arg4));
-            return ret;
-        },
         __wbg_call_9c352dc5f80e5c52: function(arg0, arg1, arg2, arg3, arg4) {
             var v0 = getArrayU8FromWasm0(arg3, arg4).slice();
             wasm.__wbindgen_free(arg3, arg4 * 1, 1);
@@ -6377,6 +6306,20 @@ function __wbg_get_imports() {
             const ret = arg0.call(arg1, BigInt.asUintN(64, arg2));
             return ret;
         },
+        __wbg_call_ed747798eb0f4919: function(arg0, arg1, arg2, arg3, arg4) {
+            const ret = arg0.call(arg1, BigInt.asUintN(64, arg2), ForeignFutureCompleteRustBuffer.__wrap(arg3), BigInt.asUintN(64, arg4));
+            return ret;
+        },
+        __wbg_call_f80a608954f40dc5: function(arg0, arg1, arg2, arg3, arg4) {
+            const ret = arg0.call(arg1, BigInt.asUintN(64, arg2), ForeignFutureCompleteVoid.__wrap(arg3), BigInt.asUintN(64, arg4));
+            return ret;
+        },
+        __wbg_call_fad062d7db09e3be: function(arg0, arg1, arg2, arg3, arg4, arg5, arg6) {
+            var v0 = getArrayU8FromWasm0(arg3, arg4).slice();
+            wasm.__wbindgen_free(arg3, arg4 * 1, 1);
+            const ret = arg0.call(arg1, BigInt.asUintN(64, arg2), v0, ForeignFutureCompleteVoid.__wrap(arg5), BigInt.asUintN(64, arg6));
+            return ret;
+        },
         __wbg_callback_dce5d7a7bd5ba5ab: function(arg0) {
             const ret = arg0.callback;
             return ret;
@@ -6385,15 +6328,15 @@ function __wbg_get_imports() {
             const ret = arg0.close;
             return ret;
         },
-        __wbg_code_1cd552759a833fa4: function(arg0) {
+        __wbg_code_344daf1474f2c3b8: function(arg0) {
             const ret = arg0.code;
             return ret;
         },
-        __wbg_code_b4177582d95904f8: function(arg0) {
+        __wbg_code_79f223f362626b35: function(arg0) {
             const ret = arg0.code;
             return ret;
         },
-        __wbg_code_ea007b857f96560b: function(arg0) {
+        __wbg_code_aece538fe8c0f3ea: function(arg0) {
             const ret = arg0.code;
             return ret;
         },
@@ -6401,21 +6344,21 @@ function __wbg_get_imports() {
             const ret = arg0.crypto;
             return ret;
         },
-        __wbg_error_buf_1101076ebe43f3e2: function(arg0, arg1) {
+        __wbg_error_buf_147588f0cf30ca52: function(arg0, arg1) {
             const ret = arg1.errorBuf;
             var ptr1 = isLikeNone(ret) ? 0 : passArray8ToWasm0(ret, wasm.__wbindgen_malloc);
             var len1 = WASM_VECTOR_LEN;
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
-        __wbg_error_buf_c08f558fde2921eb: function(arg0, arg1) {
+        __wbg_error_buf_291b7b70d6231cb2: function(arg0, arg1) {
             const ret = arg1.errorBuf;
             var ptr1 = isLikeNone(ret) ? 0 : passArray8ToWasm0(ret, wasm.__wbindgen_malloc);
             var len1 = WASM_VECTOR_LEN;
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
-        __wbg_error_buf_c5460c6eb928df0a: function(arg0, arg1) {
+        __wbg_error_buf_5b46ac0664325e3b: function(arg0, arg1) {
             const ret = arg1.errorBuf;
             var ptr1 = isLikeNone(ret) ? 0 : passArray8ToWasm0(ret, wasm.__wbindgen_malloc);
             var len1 = WASM_VECTOR_LEN;
@@ -6461,14 +6404,14 @@ function __wbg_get_imports() {
             const ret = Date.now();
             return ret;
         },
-        __wbg_pointee_350ad57f547d0a2b: function(arg0, arg1) {
+        __wbg_pointee_79d2358b4bd75a4e: function(arg0, arg1) {
             const ret = arg1.pointee;
             var ptr1 = isLikeNone(ret) ? 0 : passArray8ToWasm0(ret, wasm.__wbindgen_malloc);
             var len1 = WASM_VECTOR_LEN;
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
-        __wbg_pointee_7f12d1c53c5fc79b: function(arg0) {
+        __wbg_pointee_8b29a091693b1155: function(arg0) {
             const ret = arg0.pointee;
             return isLikeNone(ret) ? 0xFFFFFF : ret;
         },
@@ -6526,10 +6469,6 @@ function __wbg_get_imports() {
             const ret = arg0.returnValue;
             return ret;
         },
-        __wbg_returnValue_caacf939eca02d6b: function(arg0) {
-            const ret = arg0.returnValue;
-            return ret;
-        },
         __wbg_returnValue_d79bde54a86437de: function(arg0, arg1) {
             const ret = arg1.returnValue;
             const ptr1 = passArray8ToWasm0(ret, wasm.__wbindgen_malloc);
@@ -6561,6 +6500,10 @@ function __wbg_get_imports() {
             const ret = arg0.subarray(arg1 >>> 0, arg2 >>> 0);
             return ret;
         },
+        __wbg_uniffiClone_1675d398b1f7fbbf: function(arg0) {
+            const ret = arg0.uniffiClone;
+            return ret;
+        },
         __wbg_uniffiFree_6cc0d2110d0ded17: function(arg0) {
             const ret = arg0.uniffiFree;
             return ret;
@@ -6592,10 +6535,6 @@ function __wbg_get_imports() {
     return {
         __proto__: null,
         "./index_bg.js": import0,
-        "env": import1,
-        "env": import2,
-        "env": import3,
-        "env": import4,
     };
 }
 
@@ -6617,9 +6556,6 @@ const ForeignFutureCompleteI64Finalization = (typeof FinalizationRegistry === 'u
 const ForeignFutureCompleteI8Finalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_foreignfuturecompletei8_free(ptr >>> 0, 1));
-const ForeignFutureCompletePointerFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_foreignfuturecompletepointer_free(ptr >>> 0, 1));
 const ForeignFutureCompleteRustBufferFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_foreignfuturecompleterustbuffer_free(ptr >>> 0, 1));