@xstoicunicornx/payjoin_test 0.1.7 → 0.1.8

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

@@ -144,6 +144,30 @@ class ForeignFutureCompleteI8 {
 if (Symbol.dispose) ForeignFutureCompleteI8.prototype[Symbol.dispose] = ForeignFutureCompleteI8.prototype.free;
 exports.ForeignFutureCompleteI8 = ForeignFutureCompleteI8;
 
+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;
+exports.ForeignFutureCompletePointer = ForeignFutureCompletePointer;
+
 class ForeignFutureCompleteRustBuffer {
     static __wrap(ptr) {
         ptr = ptr >>> 0;
@@ -405,6 +429,14 @@ function ubrn_ffi_payjoin_ffi_rust_future_cancel_i8(handle) {
 }
 exports.ubrn_ffi_payjoin_ffi_rust_future_cancel_i8 = ubrn_ffi_payjoin_ffi_rust_future_cancel_i8;
 
+/**
+ * @param {bigint} handle
+ */
+function ubrn_ffi_payjoin_ffi_rust_future_cancel_pointer(handle) {
+    wasm.ubrn_ffi_payjoin_ffi_rust_future_cancel_pointer(handle);
+}
+exports.ubrn_ffi_payjoin_ffi_rust_future_cancel_pointer = ubrn_ffi_payjoin_ffi_rust_future_cancel_pointer;
+
 /**
  * @param {bigint} handle
  */
@@ -525,6 +557,18 @@ function ubrn_ffi_payjoin_ffi_rust_future_complete_i8(handle, f_status_) {
 }
 exports.ubrn_ffi_payjoin_ffi_rust_future_complete_i8 = ubrn_ffi_payjoin_ffi_rust_future_complete_i8;
 
+/**
+ * @param {bigint} handle
+ * @param {RustCallStatus} f_status_
+ * @returns {bigint}
+ */
+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);
+}
+exports.ubrn_ffi_payjoin_ffi_rust_future_complete_pointer = ubrn_ffi_payjoin_ffi_rust_future_complete_pointer;
+
 /**
  * @param {bigint} handle
  * @param {RustCallStatus} f_status_
@@ -645,6 +689,14 @@ function ubrn_ffi_payjoin_ffi_rust_future_free_i8(handle) {
 }
 exports.ubrn_ffi_payjoin_ffi_rust_future_free_i8 = ubrn_ffi_payjoin_ffi_rust_future_free_i8;
 
+/**
+ * @param {bigint} handle
+ */
+function ubrn_ffi_payjoin_ffi_rust_future_free_pointer(handle) {
+    wasm.ubrn_ffi_payjoin_ffi_rust_future_free_pointer(handle);
+}
+exports.ubrn_ffi_payjoin_ffi_rust_future_free_pointer = ubrn_ffi_payjoin_ffi_rust_future_free_pointer;
+
 /**
  * @param {bigint} handle
  */
@@ -753,6 +805,16 @@ function ubrn_ffi_payjoin_ffi_rust_future_poll_i8(handle, callback, callback_dat
 }
 exports.ubrn_ffi_payjoin_ffi_rust_future_poll_i8 = ubrn_ffi_payjoin_ffi_rust_future_poll_i8;
 
+/**
+ * @param {bigint} handle
+ * @param {any} callback
+ * @param {bigint} callback_data
+ */
+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);
+}
+exports.ubrn_ffi_payjoin_ffi_rust_future_poll_pointer = ubrn_ffi_payjoin_ffi_rust_future_poll_pointer;
+
 /**
  * @param {bigint} handle
  * @param {any} callback
@@ -2164,1021 +2226,1021 @@ function ubrn_uniffi_payjoin_ffi_checksum_method_withreplykeytransition_save_asy
 exports.ubrn_uniffi_payjoin_ffi_checksum_method_withreplykeytransition_save_async = ubrn_uniffi_payjoin_ffi_checksum_method_withreplykeytransition_save_async;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_addressparseerror(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_addressparseerror(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_addressparseerror(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_addressparseerror(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_addressparseerror = ubrn_uniffi_payjoin_ffi_fn_clone_addressparseerror;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_assumeinteractivetransition(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_assumeinteractivetransition(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_assumeinteractivetransition(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_assumeinteractivetransition(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_assumeinteractivetransition = ubrn_uniffi_payjoin_ffi_fn_clone_assumeinteractivetransition;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_buildsendererror(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_buildsendererror(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_buildsendererror(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_buildsendererror(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_buildsendererror = ubrn_uniffi_payjoin_ffi_fn_clone_buildsendererror;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_canbroadcast(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_canbroadcast(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_canbroadcast(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_canbroadcast(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_canbroadcast = ubrn_uniffi_payjoin_ffi_fn_clone_canbroadcast;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_canceltransition(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_canceltransition(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_canceltransition(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_canceltransition(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_canceltransition = ubrn_uniffi_payjoin_ffi_fn_clone_canceltransition;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_clientresponse(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_clientresponse(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_clientresponse(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_clientresponse(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_clientresponse = ubrn_uniffi_payjoin_ffi_fn_clone_clientresponse;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_createrequesterror(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_createrequesterror(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_createrequesterror(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_createrequesterror(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_createrequesterror = ubrn_uniffi_payjoin_ffi_fn_clone_createrequesterror;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_encapsulationerror(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_encapsulationerror(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_encapsulationerror(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_encapsulationerror(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_encapsulationerror = ubrn_uniffi_payjoin_ffi_fn_clone_encapsulationerror;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_feerateerror(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_feerateerror(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_feerateerror(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_feerateerror(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_feerateerror = ubrn_uniffi_payjoin_ffi_fn_clone_feerateerror;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_hasreplyableerror(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_hasreplyableerror(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_hasreplyableerror(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_hasreplyableerror(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_hasreplyableerror = ubrn_uniffi_payjoin_ffi_fn_clone_hasreplyableerror;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_hasreplyableerrortransition(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_hasreplyableerrortransition(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_hasreplyableerrortransition(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_hasreplyableerrortransition(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_hasreplyableerrortransition = ubrn_uniffi_payjoin_ffi_fn_clone_hasreplyableerrortransition;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_implementationerror(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_implementationerror(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_implementationerror(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_implementationerror(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_implementationerror = ubrn_uniffi_payjoin_ffi_fn_clone_implementationerror;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_initialized(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_initialized(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_initialized(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_initialized(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_initialized = ubrn_uniffi_payjoin_ffi_fn_clone_initialized;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_initializedtransition(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_initializedtransition(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_initializedtransition(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_initializedtransition(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_initializedtransition = ubrn_uniffi_payjoin_ffi_fn_clone_initializedtransition;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_initialreceivetransition(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_initialreceivetransition(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_initialreceivetransition(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_initialreceivetransition(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_initialreceivetransition = ubrn_uniffi_payjoin_ffi_fn_clone_initialreceivetransition;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_initialsendtransition(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_initialsendtransition(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_initialsendtransition(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_initialsendtransition(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_initialsendtransition = ubrn_uniffi_payjoin_ffi_fn_clone_initialsendtransition;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_inputcontributionerror(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_inputcontributionerror(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_inputcontributionerror(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_inputcontributionerror(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_inputcontributionerror = ubrn_uniffi_payjoin_ffi_fn_clone_inputcontributionerror;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_inputpair(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_inputpair(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_inputpair(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_inputpair(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_inputpair = ubrn_uniffi_payjoin_ffi_fn_clone_inputpair;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_intourlerror(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_intourlerror(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_intourlerror(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_intourlerror(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_intourlerror = ubrn_uniffi_payjoin_ffi_fn_clone_intourlerror;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_isoutputknown(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_isoutputknown(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_isoutputknown(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_isoutputknown(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_isoutputknown = ubrn_uniffi_payjoin_ffi_fn_clone_isoutputknown;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_isscriptowned(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_isscriptowned(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_isscriptowned(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_isscriptowned(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_isscriptowned = ubrn_uniffi_payjoin_ffi_fn_clone_isscriptowned;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_jsonreceiversessionpersister(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_jsonreceiversessionpersister(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_jsonreceiversessionpersister(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_jsonreceiversessionpersister(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_jsonreceiversessionpersister = ubrn_uniffi_payjoin_ffi_fn_clone_jsonreceiversessionpersister;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_jsonreceiversessionpersisterasync(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_jsonreceiversessionpersisterasync(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_jsonreceiversessionpersisterasync(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_jsonreceiversessionpersisterasync(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_jsonreceiversessionpersisterasync = ubrn_uniffi_payjoin_ffi_fn_clone_jsonreceiversessionpersisterasync;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_jsonreply(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_jsonreply(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_jsonreply(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_jsonreply(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_jsonreply = ubrn_uniffi_payjoin_ffi_fn_clone_jsonreply;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_jsonsendersessionpersister(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_jsonsendersessionpersister(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_jsonsendersessionpersister(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_jsonsendersessionpersister(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_jsonsendersessionpersister = ubrn_uniffi_payjoin_ffi_fn_clone_jsonsendersessionpersister;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_jsonsendersessionpersisterasync(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_jsonsendersessionpersisterasync(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_jsonsendersessionpersisterasync(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_jsonsendersessionpersisterasync(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_jsonsendersessionpersisterasync = ubrn_uniffi_payjoin_ffi_fn_clone_jsonsendersessionpersisterasync;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_maybeinputsowned(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_maybeinputsowned(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_maybeinputsowned(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_maybeinputsowned(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_maybeinputsowned = ubrn_uniffi_payjoin_ffi_fn_clone_maybeinputsowned;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_maybeinputsownedtransition(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_maybeinputsownedtransition(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_maybeinputsownedtransition(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_maybeinputsownedtransition(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_maybeinputsownedtransition = ubrn_uniffi_payjoin_ffi_fn_clone_maybeinputsownedtransition;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_maybeinputsseen(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_maybeinputsseen(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_maybeinputsseen(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_maybeinputsseen(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_maybeinputsseen = ubrn_uniffi_payjoin_ffi_fn_clone_maybeinputsseen;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_maybeinputsseentransition(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_maybeinputsseentransition(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_maybeinputsseentransition(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_maybeinputsseentransition(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_maybeinputsseentransition = ubrn_uniffi_payjoin_ffi_fn_clone_maybeinputsseentransition;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_monitor(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_monitor(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_monitor(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_monitor(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_monitor = ubrn_uniffi_payjoin_ffi_fn_clone_monitor;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_monitortransition(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_monitortransition(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_monitortransition(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_monitortransition(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_monitortransition = ubrn_uniffi_payjoin_ffi_fn_clone_monitortransition;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_ohttperror(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_ohttperror(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_ohttperror(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_ohttperror(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_ohttperror = ubrn_uniffi_payjoin_ffi_fn_clone_ohttperror;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_ohttpkeys(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_ohttpkeys(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_ohttpkeys(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_ohttpkeys(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_ohttpkeys = ubrn_uniffi_payjoin_ffi_fn_clone_ohttpkeys;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_outputsubstitutionprotocolerror(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_outputsubstitutionprotocolerror(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_outputsubstitutionprotocolerror(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_outputsubstitutionprotocolerror(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_outputsubstitutionprotocolerror = ubrn_uniffi_payjoin_ffi_fn_clone_outputsubstitutionprotocolerror;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_outputsunknown(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_outputsunknown(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_outputsunknown(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_outputsunknown(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_outputsunknown = ubrn_uniffi_payjoin_ffi_fn_clone_outputsunknown;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_outputsunknowntransition(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_outputsunknowntransition(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_outputsunknowntransition(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_outputsunknowntransition(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_outputsunknowntransition = ubrn_uniffi_payjoin_ffi_fn_clone_outputsunknowntransition;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_payjoinproposal(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_payjoinproposal(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_payjoinproposal(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_payjoinproposal(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_payjoinproposal = ubrn_uniffi_payjoin_ffi_fn_clone_payjoinproposal;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_payjoinproposaltransition(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_payjoinproposaltransition(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_payjoinproposaltransition(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_payjoinproposaltransition(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_payjoinproposaltransition = ubrn_uniffi_payjoin_ffi_fn_clone_payjoinproposaltransition;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_pjnotsupported(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_pjnotsupported(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_pjnotsupported(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_pjnotsupported(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_pjnotsupported = ubrn_uniffi_payjoin_ffi_fn_clone_pjnotsupported;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_pjparam(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_pjparam(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_pjparam(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_pjparam(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_pjparam = ubrn_uniffi_payjoin_ffi_fn_clone_pjparam;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_pjparseerror(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_pjparseerror(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_pjparseerror(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_pjparseerror(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_pjparseerror = ubrn_uniffi_payjoin_ffi_fn_clone_pjparseerror;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_pjuri(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_pjuri(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_pjuri(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_pjuri(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_pjuri = ubrn_uniffi_payjoin_ffi_fn_clone_pjuri;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_pollingforproposal(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_pollingforproposal(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_pollingforproposal(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_pollingforproposal(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_pollingforproposal = ubrn_uniffi_payjoin_ffi_fn_clone_pollingforproposal;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_pollingforproposaltransition(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_pollingforproposaltransition(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_pollingforproposaltransition(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_pollingforproposaltransition(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_pollingforproposaltransition = ubrn_uniffi_payjoin_ffi_fn_clone_pollingforproposaltransition;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_processpsbt(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_processpsbt(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_processpsbt(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_processpsbt(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_processpsbt = ubrn_uniffi_payjoin_ffi_fn_clone_processpsbt;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_protocolerror(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_protocolerror(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_protocolerror(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_protocolerror(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_protocolerror = ubrn_uniffi_payjoin_ffi_fn_clone_protocolerror;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_provisionalproposal(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_provisionalproposal(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_provisionalproposal(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_provisionalproposal(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_provisionalproposal = ubrn_uniffi_payjoin_ffi_fn_clone_provisionalproposal;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_provisionalproposaltransition(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_provisionalproposaltransition(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_provisionalproposaltransition(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_provisionalproposaltransition(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_provisionalproposaltransition = ubrn_uniffi_payjoin_ffi_fn_clone_provisionalproposaltransition;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_psbtinputerror(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_psbtinputerror(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_psbtinputerror(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_psbtinputerror(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_psbtinputerror = ubrn_uniffi_payjoin_ffi_fn_clone_psbtinputerror;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_receiverbuilder(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_receiverbuilder(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_receiverbuilder(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_receiverbuilder(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_receiverbuilder = ubrn_uniffi_payjoin_ffi_fn_clone_receiverbuilder;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_receiverreplayerror(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_receiverreplayerror(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_receiverreplayerror(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_receiverreplayerror(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_receiverreplayerror = ubrn_uniffi_payjoin_ffi_fn_clone_receiverreplayerror;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_receiversessionevent(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_receiversessionevent(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_receiversessionevent(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_receiversessionevent(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_receiversessionevent = ubrn_uniffi_payjoin_ffi_fn_clone_receiversessionevent;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_receiversessionhistory(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_receiversessionhistory(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_receiversessionhistory(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_receiversessionhistory(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_receiversessionhistory = ubrn_uniffi_payjoin_ffi_fn_clone_receiversessionhistory;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_receiversessionoutcome(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_receiversessionoutcome(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_receiversessionoutcome(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_receiversessionoutcome(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_receiversessionoutcome = ubrn_uniffi_payjoin_ffi_fn_clone_receiversessionoutcome;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_receiversessionstatus(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_receiversessionstatus(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_receiversessionstatus(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_receiversessionstatus(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_receiversessionstatus = ubrn_uniffi_payjoin_ffi_fn_clone_receiversessionstatus;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_replayresult(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_replayresult(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_replayresult(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_replayresult(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_replayresult = ubrn_uniffi_payjoin_ffi_fn_clone_replayresult;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_selectionerror(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_selectionerror(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_selectionerror(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_selectionerror(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_selectionerror = ubrn_uniffi_payjoin_ffi_fn_clone_selectionerror;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_senderbuilder(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_senderbuilder(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_senderbuilder(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_senderbuilder(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_senderbuilder = ubrn_uniffi_payjoin_ffi_fn_clone_senderbuilder;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_sendercanceltransition(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_sendercanceltransition(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_sendercanceltransition(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_sendercanceltransition(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_sendercanceltransition = ubrn_uniffi_payjoin_ffi_fn_clone_sendercanceltransition;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_senderreplayerror(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_senderreplayerror(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_senderreplayerror(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_senderreplayerror(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_senderreplayerror = ubrn_uniffi_payjoin_ffi_fn_clone_senderreplayerror;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_senderreplayresult(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_senderreplayresult(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_senderreplayresult(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_senderreplayresult(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_senderreplayresult = ubrn_uniffi_payjoin_ffi_fn_clone_senderreplayresult;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_sendersessionevent(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_sendersessionevent(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_sendersessionevent(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_sendersessionevent(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_sendersessionevent = ubrn_uniffi_payjoin_ffi_fn_clone_sendersessionevent;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_sendersessionhistory(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_sendersessionhistory(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_sendersessionhistory(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_sendersessionhistory(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_sendersessionhistory = ubrn_uniffi_payjoin_ffi_fn_clone_sendersessionhistory;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_sendersessionoutcome(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_sendersessionoutcome(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_sendersessionoutcome(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_sendersessionoutcome(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_sendersessionoutcome = ubrn_uniffi_payjoin_ffi_fn_clone_sendersessionoutcome;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_sendersessionstatus(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_sendersessionstatus(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_sendersessionstatus(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_sendersessionstatus(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_sendersessionstatus = ubrn_uniffi_payjoin_ffi_fn_clone_sendersessionstatus;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_serdejsonerror(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_serdejsonerror(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_serdejsonerror(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_serdejsonerror(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_serdejsonerror = ubrn_uniffi_payjoin_ffi_fn_clone_serdejsonerror;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_sessionerror(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_sessionerror(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_sessionerror(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_sessionerror(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_sessionerror = ubrn_uniffi_payjoin_ffi_fn_clone_sessionerror;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_transactionexists(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_transactionexists(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_transactionexists(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_transactionexists(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_transactionexists = ubrn_uniffi_payjoin_ffi_fn_clone_transactionexists;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_uncheckedoriginalpayload(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_uncheckedoriginalpayload(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_uncheckedoriginalpayload(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_uncheckedoriginalpayload(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_uncheckedoriginalpayload = ubrn_uniffi_payjoin_ffi_fn_clone_uncheckedoriginalpayload;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_uncheckedoriginalpayloadtransition(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_uncheckedoriginalpayloadtransition(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_uncheckedoriginalpayloadtransition(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_uncheckedoriginalpayloadtransition(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_uncheckedoriginalpayloadtransition = ubrn_uniffi_payjoin_ffi_fn_clone_uncheckedoriginalpayloadtransition;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_uri(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_uri(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_uri(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_uri(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_uri = ubrn_uniffi_payjoin_ffi_fn_clone_uri;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_url(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_url(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_url(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_url(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_url = ubrn_uniffi_payjoin_ffi_fn_clone_url;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_urlparseerror(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_urlparseerror(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_urlparseerror(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_urlparseerror(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_urlparseerror = ubrn_uniffi_payjoin_ffi_fn_clone_urlparseerror;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_v1context(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_v1context(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_v1context(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_v1context(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_v1context = ubrn_uniffi_payjoin_ffi_fn_clone_v1context;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_validationerror(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_validationerror(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_validationerror(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_validationerror(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_validationerror = ubrn_uniffi_payjoin_ffi_fn_clone_validationerror;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_wantsfeerange(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_wantsfeerange(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_wantsfeerange(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_wantsfeerange(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_wantsfeerange = ubrn_uniffi_payjoin_ffi_fn_clone_wantsfeerange;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_wantsfeerangetransition(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_wantsfeerangetransition(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_wantsfeerangetransition(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_wantsfeerangetransition(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_wantsfeerangetransition = ubrn_uniffi_payjoin_ffi_fn_clone_wantsfeerangetransition;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_wantsinputs(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_wantsinputs(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_wantsinputs(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_wantsinputs(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_wantsinputs = ubrn_uniffi_payjoin_ffi_fn_clone_wantsinputs;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_wantsinputstransition(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_wantsinputstransition(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_wantsinputstransition(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_wantsinputstransition(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_wantsinputstransition = ubrn_uniffi_payjoin_ffi_fn_clone_wantsinputstransition;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_wantsoutputs(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_wantsoutputs(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_wantsoutputs(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_wantsoutputs(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_wantsoutputs = ubrn_uniffi_payjoin_ffi_fn_clone_wantsoutputs;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_wantsoutputstransition(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_wantsoutputstransition(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_wantsoutputstransition(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_wantsoutputstransition(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_wantsoutputstransition = ubrn_uniffi_payjoin_ffi_fn_clone_wantsoutputstransition;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_wellknownerror(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_wellknownerror(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_wellknownerror(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_wellknownerror(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_wellknownerror = ubrn_uniffi_payjoin_ffi_fn_clone_wellknownerror;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_withreplykey(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_withreplykey(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_withreplykey(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_withreplykey(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_withreplykey = ubrn_uniffi_payjoin_ffi_fn_clone_withreplykey;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  * @returns {bigint}
  */
-function ubrn_uniffi_payjoin_ffi_fn_clone_withreplykeytransition(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_clone_withreplykeytransition(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_withreplykeytransition(handle, f_status_.__wbg_ptr);
+    const ret = wasm.ubrn_uniffi_payjoin_ffi_fn_clone_withreplykeytransition(ptr, f_status_.__wbg_ptr);
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_clone_withreplykeytransition = ubrn_uniffi_payjoin_ffi_fn_clone_withreplykeytransition;
@@ -3307,852 +3369,852 @@ function ubrn_uniffi_payjoin_ffi_fn_constructor_url_parse(input, f_status_) {
 exports.ubrn_uniffi_payjoin_ffi_fn_constructor_url_parse = ubrn_uniffi_payjoin_ffi_fn_constructor_url_parse;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_addressparseerror(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_addressparseerror(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_addressparseerror(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_addressparseerror(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_addressparseerror = ubrn_uniffi_payjoin_ffi_fn_free_addressparseerror;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_assumeinteractivetransition(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_assumeinteractivetransition(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_assumeinteractivetransition(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_assumeinteractivetransition(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_assumeinteractivetransition = ubrn_uniffi_payjoin_ffi_fn_free_assumeinteractivetransition;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_buildsendererror(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_buildsendererror(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_buildsendererror(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_buildsendererror(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_buildsendererror = ubrn_uniffi_payjoin_ffi_fn_free_buildsendererror;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_canbroadcast(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_canbroadcast(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_canbroadcast(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_canbroadcast(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_canbroadcast = ubrn_uniffi_payjoin_ffi_fn_free_canbroadcast;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_canceltransition(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_canceltransition(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_canceltransition(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_canceltransition(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_canceltransition = ubrn_uniffi_payjoin_ffi_fn_free_canceltransition;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_clientresponse(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_clientresponse(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_clientresponse(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_clientresponse(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_clientresponse = ubrn_uniffi_payjoin_ffi_fn_free_clientresponse;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_createrequesterror(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_createrequesterror(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_createrequesterror(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_createrequesterror(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_createrequesterror = ubrn_uniffi_payjoin_ffi_fn_free_createrequesterror;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_encapsulationerror(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_encapsulationerror(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_encapsulationerror(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_encapsulationerror(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_encapsulationerror = ubrn_uniffi_payjoin_ffi_fn_free_encapsulationerror;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_feerateerror(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_feerateerror(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_feerateerror(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_feerateerror(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_feerateerror = ubrn_uniffi_payjoin_ffi_fn_free_feerateerror;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_hasreplyableerror(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_hasreplyableerror(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_hasreplyableerror(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_hasreplyableerror(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_hasreplyableerror = ubrn_uniffi_payjoin_ffi_fn_free_hasreplyableerror;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_hasreplyableerrortransition(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_hasreplyableerrortransition(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_hasreplyableerrortransition(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_hasreplyableerrortransition(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_hasreplyableerrortransition = ubrn_uniffi_payjoin_ffi_fn_free_hasreplyableerrortransition;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_implementationerror(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_implementationerror(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_implementationerror(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_implementationerror(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_implementationerror = ubrn_uniffi_payjoin_ffi_fn_free_implementationerror;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_initialized(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_initialized(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_initialized(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_initialized(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_initialized = ubrn_uniffi_payjoin_ffi_fn_free_initialized;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_initializedtransition(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_initializedtransition(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_initializedtransition(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_initializedtransition(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_initializedtransition = ubrn_uniffi_payjoin_ffi_fn_free_initializedtransition;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_initialreceivetransition(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_initialreceivetransition(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_initialreceivetransition(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_initialreceivetransition(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_initialreceivetransition = ubrn_uniffi_payjoin_ffi_fn_free_initialreceivetransition;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_initialsendtransition(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_initialsendtransition(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_initialsendtransition(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_initialsendtransition(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_initialsendtransition = ubrn_uniffi_payjoin_ffi_fn_free_initialsendtransition;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_inputcontributionerror(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_inputcontributionerror(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_inputcontributionerror(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_inputcontributionerror(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_inputcontributionerror = ubrn_uniffi_payjoin_ffi_fn_free_inputcontributionerror;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_inputpair(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_inputpair(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_inputpair(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_inputpair(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_inputpair = ubrn_uniffi_payjoin_ffi_fn_free_inputpair;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_intourlerror(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_intourlerror(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_intourlerror(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_intourlerror(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_intourlerror = ubrn_uniffi_payjoin_ffi_fn_free_intourlerror;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_isoutputknown(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_isoutputknown(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_isoutputknown(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_isoutputknown(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_isoutputknown = ubrn_uniffi_payjoin_ffi_fn_free_isoutputknown;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_isscriptowned(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_isscriptowned(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_isscriptowned(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_isscriptowned(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_isscriptowned = ubrn_uniffi_payjoin_ffi_fn_free_isscriptowned;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_jsonreceiversessionpersister(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_jsonreceiversessionpersister(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_jsonreceiversessionpersister(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_jsonreceiversessionpersister(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_jsonreceiversessionpersister = ubrn_uniffi_payjoin_ffi_fn_free_jsonreceiversessionpersister;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_jsonreceiversessionpersisterasync(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_jsonreceiversessionpersisterasync(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_jsonreceiversessionpersisterasync(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_jsonreceiversessionpersisterasync(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_jsonreceiversessionpersisterasync = ubrn_uniffi_payjoin_ffi_fn_free_jsonreceiversessionpersisterasync;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_jsonreply(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_jsonreply(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_jsonreply(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_jsonreply(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_jsonreply = ubrn_uniffi_payjoin_ffi_fn_free_jsonreply;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_jsonsendersessionpersister(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_jsonsendersessionpersister(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_jsonsendersessionpersister(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_jsonsendersessionpersister(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_jsonsendersessionpersister = ubrn_uniffi_payjoin_ffi_fn_free_jsonsendersessionpersister;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_jsonsendersessionpersisterasync(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_jsonsendersessionpersisterasync(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_jsonsendersessionpersisterasync(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_jsonsendersessionpersisterasync(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_jsonsendersessionpersisterasync = ubrn_uniffi_payjoin_ffi_fn_free_jsonsendersessionpersisterasync;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_maybeinputsowned(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_maybeinputsowned(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_maybeinputsowned(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_maybeinputsowned(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_maybeinputsowned = ubrn_uniffi_payjoin_ffi_fn_free_maybeinputsowned;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_maybeinputsownedtransition(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_maybeinputsownedtransition(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_maybeinputsownedtransition(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_maybeinputsownedtransition(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_maybeinputsownedtransition = ubrn_uniffi_payjoin_ffi_fn_free_maybeinputsownedtransition;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_maybeinputsseen(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_maybeinputsseen(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_maybeinputsseen(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_maybeinputsseen(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_maybeinputsseen = ubrn_uniffi_payjoin_ffi_fn_free_maybeinputsseen;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_maybeinputsseentransition(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_maybeinputsseentransition(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_maybeinputsseentransition(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_maybeinputsseentransition(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_maybeinputsseentransition = ubrn_uniffi_payjoin_ffi_fn_free_maybeinputsseentransition;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_monitor(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_monitor(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_monitor(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_monitor(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_monitor = ubrn_uniffi_payjoin_ffi_fn_free_monitor;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_monitortransition(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_monitortransition(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_monitortransition(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_monitortransition(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_monitortransition = ubrn_uniffi_payjoin_ffi_fn_free_monitortransition;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_ohttperror(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_ohttperror(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_ohttperror(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_ohttperror(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_ohttperror = ubrn_uniffi_payjoin_ffi_fn_free_ohttperror;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_ohttpkeys(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_ohttpkeys(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_ohttpkeys(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_ohttpkeys(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_ohttpkeys = ubrn_uniffi_payjoin_ffi_fn_free_ohttpkeys;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_outputsubstitutionprotocolerror(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_outputsubstitutionprotocolerror(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_outputsubstitutionprotocolerror(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_outputsubstitutionprotocolerror(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_outputsubstitutionprotocolerror = ubrn_uniffi_payjoin_ffi_fn_free_outputsubstitutionprotocolerror;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_outputsunknown(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_outputsunknown(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_outputsunknown(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_outputsunknown(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_outputsunknown = ubrn_uniffi_payjoin_ffi_fn_free_outputsunknown;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_outputsunknowntransition(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_outputsunknowntransition(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_outputsunknowntransition(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_outputsunknowntransition(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_outputsunknowntransition = ubrn_uniffi_payjoin_ffi_fn_free_outputsunknowntransition;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_payjoinproposal(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_payjoinproposal(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_payjoinproposal(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_payjoinproposal(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_payjoinproposal = ubrn_uniffi_payjoin_ffi_fn_free_payjoinproposal;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_payjoinproposaltransition(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_payjoinproposaltransition(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_payjoinproposaltransition(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_payjoinproposaltransition(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_payjoinproposaltransition = ubrn_uniffi_payjoin_ffi_fn_free_payjoinproposaltransition;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_pjnotsupported(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_pjnotsupported(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_pjnotsupported(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_pjnotsupported(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_pjnotsupported = ubrn_uniffi_payjoin_ffi_fn_free_pjnotsupported;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_pjparam(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_pjparam(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_pjparam(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_pjparam(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_pjparam = ubrn_uniffi_payjoin_ffi_fn_free_pjparam;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_pjparseerror(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_pjparseerror(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_pjparseerror(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_pjparseerror(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_pjparseerror = ubrn_uniffi_payjoin_ffi_fn_free_pjparseerror;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_pjuri(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_pjuri(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_pjuri(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_pjuri(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_pjuri = ubrn_uniffi_payjoin_ffi_fn_free_pjuri;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_pollingforproposal(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_pollingforproposal(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_pollingforproposal(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_pollingforproposal(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_pollingforproposal = ubrn_uniffi_payjoin_ffi_fn_free_pollingforproposal;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_pollingforproposaltransition(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_pollingforproposaltransition(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_pollingforproposaltransition(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_pollingforproposaltransition(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_pollingforproposaltransition = ubrn_uniffi_payjoin_ffi_fn_free_pollingforproposaltransition;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_processpsbt(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_processpsbt(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_processpsbt(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_processpsbt(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_processpsbt = ubrn_uniffi_payjoin_ffi_fn_free_processpsbt;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_protocolerror(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_protocolerror(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_protocolerror(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_protocolerror(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_protocolerror = ubrn_uniffi_payjoin_ffi_fn_free_protocolerror;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_provisionalproposal(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_provisionalproposal(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_provisionalproposal(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_provisionalproposal(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_provisionalproposal = ubrn_uniffi_payjoin_ffi_fn_free_provisionalproposal;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_provisionalproposaltransition(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_provisionalproposaltransition(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_provisionalproposaltransition(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_provisionalproposaltransition(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_provisionalproposaltransition = ubrn_uniffi_payjoin_ffi_fn_free_provisionalproposaltransition;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_psbtinputerror(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_psbtinputerror(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_psbtinputerror(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_psbtinputerror(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_psbtinputerror = ubrn_uniffi_payjoin_ffi_fn_free_psbtinputerror;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_receiverbuilder(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_receiverbuilder(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_receiverbuilder(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_receiverbuilder(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_receiverbuilder = ubrn_uniffi_payjoin_ffi_fn_free_receiverbuilder;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_receiverreplayerror(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_receiverreplayerror(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_receiverreplayerror(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_receiverreplayerror(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_receiverreplayerror = ubrn_uniffi_payjoin_ffi_fn_free_receiverreplayerror;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_receiversessionevent(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_receiversessionevent(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_receiversessionevent(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_receiversessionevent(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_receiversessionevent = ubrn_uniffi_payjoin_ffi_fn_free_receiversessionevent;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_receiversessionhistory(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_receiversessionhistory(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_receiversessionhistory(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_receiversessionhistory(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_receiversessionhistory = ubrn_uniffi_payjoin_ffi_fn_free_receiversessionhistory;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_receiversessionoutcome(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_receiversessionoutcome(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_receiversessionoutcome(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_receiversessionoutcome(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_receiversessionoutcome = ubrn_uniffi_payjoin_ffi_fn_free_receiversessionoutcome;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_receiversessionstatus(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_receiversessionstatus(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_receiversessionstatus(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_receiversessionstatus(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_receiversessionstatus = ubrn_uniffi_payjoin_ffi_fn_free_receiversessionstatus;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_replayresult(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_replayresult(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_replayresult(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_replayresult(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_replayresult = ubrn_uniffi_payjoin_ffi_fn_free_replayresult;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_selectionerror(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_selectionerror(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_selectionerror(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_selectionerror(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_selectionerror = ubrn_uniffi_payjoin_ffi_fn_free_selectionerror;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_senderbuilder(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_senderbuilder(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_senderbuilder(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_senderbuilder(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_senderbuilder = ubrn_uniffi_payjoin_ffi_fn_free_senderbuilder;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_sendercanceltransition(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_sendercanceltransition(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_sendercanceltransition(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_sendercanceltransition(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_sendercanceltransition = ubrn_uniffi_payjoin_ffi_fn_free_sendercanceltransition;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_senderreplayerror(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_senderreplayerror(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_senderreplayerror(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_senderreplayerror(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_senderreplayerror = ubrn_uniffi_payjoin_ffi_fn_free_senderreplayerror;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_senderreplayresult(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_senderreplayresult(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_senderreplayresult(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_senderreplayresult(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_senderreplayresult = ubrn_uniffi_payjoin_ffi_fn_free_senderreplayresult;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_sendersessionevent(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_sendersessionevent(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_sendersessionevent(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_sendersessionevent(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_sendersessionevent = ubrn_uniffi_payjoin_ffi_fn_free_sendersessionevent;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_sendersessionhistory(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_sendersessionhistory(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_sendersessionhistory(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_sendersessionhistory(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_sendersessionhistory = ubrn_uniffi_payjoin_ffi_fn_free_sendersessionhistory;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_sendersessionoutcome(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_sendersessionoutcome(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_sendersessionoutcome(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_sendersessionoutcome(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_sendersessionoutcome = ubrn_uniffi_payjoin_ffi_fn_free_sendersessionoutcome;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_sendersessionstatus(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_sendersessionstatus(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_sendersessionstatus(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_sendersessionstatus(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_sendersessionstatus = ubrn_uniffi_payjoin_ffi_fn_free_sendersessionstatus;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_serdejsonerror(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_serdejsonerror(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_serdejsonerror(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_serdejsonerror(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_serdejsonerror = ubrn_uniffi_payjoin_ffi_fn_free_serdejsonerror;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_sessionerror(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_sessionerror(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_sessionerror(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_sessionerror(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_sessionerror = ubrn_uniffi_payjoin_ffi_fn_free_sessionerror;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_transactionexists(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_transactionexists(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_transactionexists(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_transactionexists(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_transactionexists = ubrn_uniffi_payjoin_ffi_fn_free_transactionexists;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_uncheckedoriginalpayload(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_uncheckedoriginalpayload(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_uncheckedoriginalpayload(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_uncheckedoriginalpayload(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_uncheckedoriginalpayload = ubrn_uniffi_payjoin_ffi_fn_free_uncheckedoriginalpayload;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_uncheckedoriginalpayloadtransition(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_uncheckedoriginalpayloadtransition(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_uncheckedoriginalpayloadtransition(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_uncheckedoriginalpayloadtransition(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_uncheckedoriginalpayloadtransition = ubrn_uniffi_payjoin_ffi_fn_free_uncheckedoriginalpayloadtransition;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_uri(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_uri(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_uri(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_uri(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_uri = ubrn_uniffi_payjoin_ffi_fn_free_uri;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_url(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_url(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_url(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_url(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_url = ubrn_uniffi_payjoin_ffi_fn_free_url;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_urlparseerror(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_urlparseerror(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_urlparseerror(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_urlparseerror(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_urlparseerror = ubrn_uniffi_payjoin_ffi_fn_free_urlparseerror;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_v1context(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_v1context(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_v1context(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_v1context(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_v1context = ubrn_uniffi_payjoin_ffi_fn_free_v1context;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_validationerror(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_validationerror(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_validationerror(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_validationerror(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_validationerror = ubrn_uniffi_payjoin_ffi_fn_free_validationerror;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_wantsfeerange(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_wantsfeerange(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_wantsfeerange(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_wantsfeerange(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_wantsfeerange = ubrn_uniffi_payjoin_ffi_fn_free_wantsfeerange;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_wantsfeerangetransition(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_wantsfeerangetransition(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_wantsfeerangetransition(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_wantsfeerangetransition(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_wantsfeerangetransition = ubrn_uniffi_payjoin_ffi_fn_free_wantsfeerangetransition;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_wantsinputs(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_wantsinputs(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_wantsinputs(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_wantsinputs(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_wantsinputs = ubrn_uniffi_payjoin_ffi_fn_free_wantsinputs;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_wantsinputstransition(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_wantsinputstransition(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_wantsinputstransition(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_wantsinputstransition(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_wantsinputstransition = ubrn_uniffi_payjoin_ffi_fn_free_wantsinputstransition;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_wantsoutputs(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_wantsoutputs(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_wantsoutputs(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_wantsoutputs(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_wantsoutputs = ubrn_uniffi_payjoin_ffi_fn_free_wantsoutputs;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_wantsoutputstransition(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_wantsoutputstransition(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_wantsoutputstransition(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_wantsoutputstransition(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_wantsoutputstransition = ubrn_uniffi_payjoin_ffi_fn_free_wantsoutputstransition;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_wellknownerror(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_wellknownerror(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_wellknownerror(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_wellknownerror(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_wellknownerror = ubrn_uniffi_payjoin_ffi_fn_free_wellknownerror;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_withreplykey(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_withreplykey(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_withreplykey(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_withreplykey(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_withreplykey = ubrn_uniffi_payjoin_ffi_fn_free_withreplykey;
 
 /**
- * @param {bigint} handle
+ * @param {bigint} ptr
  * @param {RustCallStatus} f_status_
  */
-function ubrn_uniffi_payjoin_ffi_fn_free_withreplykeytransition(handle, f_status_) {
+function ubrn_uniffi_payjoin_ffi_fn_free_withreplykeytransition(ptr, f_status_) {
     _assertClass(f_status_, RustCallStatus);
-    wasm.ubrn_uniffi_payjoin_ffi_fn_free_withreplykeytransition(handle, f_status_.__wbg_ptr);
+    wasm.ubrn_uniffi_payjoin_ffi_fn_free_withreplykeytransition(ptr, f_status_.__wbg_ptr);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_free_withreplykeytransition = ubrn_uniffi_payjoin_ffi_fn_free_withreplykeytransition;
 
@@ -6806,6 +6868,10 @@ function ubrn_uniffi_payjoin_ffi_fn_method_withreplykeytransition_save_async(ptr
     return BigInt.asUintN(64, ret);
 }
 exports.ubrn_uniffi_payjoin_ffi_fn_method_withreplykeytransition_save_async = ubrn_uniffi_payjoin_ffi_fn_method_withreplykeytransition_save_async;
+const import1 = require("env");
+const import2 = require("env");
+const import3 = require("env");
+const import4 = require("env");
 
 function __wbg_get_imports() {
     const import0 = {
@@ -6852,14 +6918,16 @@ 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;
@@ -6870,6 +6938,10 @@ 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);
         },
@@ -6882,6 +6954,10 @@ 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);
@@ -6898,20 +6974,6 @@ 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;
@@ -6920,15 +6982,15 @@ function __wbg_get_imports() {
             const ret = arg0.close;
             return ret;
         },
-        __wbg_code_344daf1474f2c3b8: function(arg0) {
+        __wbg_code_1cd552759a833fa4: function(arg0) {
             const ret = arg0.code;
             return ret;
         },
-        __wbg_code_79f223f362626b35: function(arg0) {
+        __wbg_code_b4177582d95904f8: function(arg0) {
             const ret = arg0.code;
             return ret;
         },
-        __wbg_code_aece538fe8c0f3ea: function(arg0) {
+        __wbg_code_ea007b857f96560b: function(arg0) {
             const ret = arg0.code;
             return ret;
         },
@@ -6936,21 +6998,21 @@ function __wbg_get_imports() {
             const ret = arg0.crypto;
             return ret;
         },
-        __wbg_error_buf_147588f0cf30ca52: function(arg0, arg1) {
+        __wbg_error_buf_1101076ebe43f3e2: 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_291b7b70d6231cb2: function(arg0, arg1) {
+        __wbg_error_buf_c08f558fde2921eb: 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_5b46ac0664325e3b: function(arg0, arg1) {
+        __wbg_error_buf_c5460c6eb928df0a: function(arg0, arg1) {
             const ret = arg1.errorBuf;
             var ptr1 = isLikeNone(ret) ? 0 : passArray8ToWasm0(ret, wasm.__wbindgen_malloc);
             var len1 = WASM_VECTOR_LEN;
@@ -6996,14 +7058,14 @@ function __wbg_get_imports() {
             const ret = Date.now();
             return ret;
         },
-        __wbg_pointee_79d2358b4bd75a4e: function(arg0, arg1) {
+        __wbg_pointee_350ad57f547d0a2b: 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_8b29a091693b1155: function(arg0) {
+        __wbg_pointee_7f12d1c53c5fc79b: function(arg0) {
             const ret = arg0.pointee;
             return isLikeNone(ret) ? 0xFFFFFF : ret;
         },
@@ -7061,6 +7123,10 @@ 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);
@@ -7092,10 +7158,6 @@ 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;
@@ -7127,6 +7189,10 @@ function __wbg_get_imports() {
     return {
         __proto__: null,
         "./index_bg.js": import0,
+        "env": import1,
+        "env": import2,
+        "env": import3,
+        "env": import4,
     };
 }
 
@@ -7148,6 +7214,9 @@ 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));