@secondts/bark-react-native 0.1.0-beta.6

package/lib/module/generated/bark.js

@@ -0,0 +1,3164 @@
+"use strict";
+
+// This file was autogenerated by some hot garbage in the `uniffi-bindgen-react-native` crate.
+// Trust me, you don't want to mess with it!
+import nativeModule from "./bark-ffi.js";
+import { AbstractFfiConverterByteArray, FfiConverterArray, FfiConverterBool, FfiConverterCallback, FfiConverterInt32, FfiConverterInt64, FfiConverterObject, FfiConverterOptional, FfiConverterUInt16, FfiConverterUInt32, FfiConverterUInt64, UniffiAbstractObject, UniffiError, UniffiInternalError, UniffiResult, UniffiRustCaller, destructorGuardSymbol, pointerLiteralSymbol, uniffiCreateFfiConverterString, uniffiCreateRecord, uniffiTraitInterfaceCallWithError, uniffiTypeNameSymbol } from "uniffi-bindgen-react-native";
+
+// Get converters from the other files, if any.
+const uniffiCaller = new UniffiRustCaller(() => ({
+  code: 0
+}));
+const uniffiIsDebug =
+// @ts-ignore -- The process global might not be defined
+typeof process !== "object" ||
+// @ts-ignore -- The process global might not be defined
+process?.env?.NODE_ENV !== "production" || false;
+// Public interface members begin here.
+
+export function extractTxFromPsbt(psbtBase64) /*throws*/{
+  return FfiConverterString.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+    return nativeModule().ubrn_uniffi_bark_ffi_fn_func_extract_tx_from_psbt(FfiConverterString.lower(psbtBase64), callStatus);
+  }, /*liftString:*/FfiConverterString.lift));
+}
+export function generateMnemonic() /*throws*/{
+  return FfiConverterString.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+    return nativeModule().ubrn_uniffi_bark_ffi_fn_func_generate_mnemonic(callStatus);
+  }, /*liftString:*/FfiConverterString.lift));
+}
+export function validateArkAddress(address) /*throws*/{
+  return FfiConverterBool.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+    return nativeModule().ubrn_uniffi_bark_ffi_fn_func_validate_ark_address(FfiConverterString.lower(address), callStatus);
+  }, /*liftString:*/FfiConverterString.lift));
+}
+export function validateMnemonic(mnemonic) /*throws*/{
+  return FfiConverterBool.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+    return nativeModule().ubrn_uniffi_bark_ffi_fn_func_validate_mnemonic(FfiConverterString.lower(mnemonic), callStatus);
+  }, /*liftString:*/FfiConverterString.lift));
+}
+
+/**
+ * Callback interface for custom onchain wallet implementations
+ *
+ * Implement this interface in Dart/Swift/Kotlin to provide your own wallet.
+ */
+
+// Put the implementation in a struct so we don't pollute the top-level namespace
+const uniffiCallbackInterfaceCustomOnchainWalletCallbacks = {
+  // Create the VTable using a series of closures.
+  // ts automatically converts these into C callback functions.
+  vtable: {
+    getBalance: uniffiHandle => {
+      const uniffiMakeCall = () => {
+        const jsCallback = FfiConverterTypeCustomOnchainWalletCallbacks.lift(uniffiHandle);
+        return jsCallback.getBalance();
+      };
+      const uniffiResult = UniffiResult.ready();
+      const uniffiHandleSuccess = obj => {
+        UniffiResult.writeSuccess(uniffiResult, FfiConverterUInt64.lower(obj));
+      };
+      const uniffiHandleError = (code, errBuf) => {
+        UniffiResult.writeError(uniffiResult, code, errBuf);
+      };
+      uniffiTraitInterfaceCallWithError(/*makeCall:*/uniffiMakeCall, /*handleSuccess:*/uniffiHandleSuccess, /*handleError:*/uniffiHandleError, /*isErrorType:*/BarkError.instanceOf, /*lowerError:*/FfiConverterTypeBarkError.lower.bind(FfiConverterTypeBarkError), /*lowerString:*/FfiConverterString.lower);
+      return uniffiResult;
+    },
+    prepareTx: (uniffiHandle, destinations, feeRateSatPerVb) => {
+      const uniffiMakeCall = () => {
+        const jsCallback = FfiConverterTypeCustomOnchainWalletCallbacks.lift(uniffiHandle);
+        return jsCallback.prepareTx(FfiConverterArrayTypeDestination.lift(destinations), FfiConverterUInt64.lift(feeRateSatPerVb));
+      };
+      const uniffiResult = UniffiResult.ready();
+      const uniffiHandleSuccess = obj => {
+        UniffiResult.writeSuccess(uniffiResult, FfiConverterString.lower(obj));
+      };
+      const uniffiHandleError = (code, errBuf) => {
+        UniffiResult.writeError(uniffiResult, code, errBuf);
+      };
+      uniffiTraitInterfaceCallWithError(/*makeCall:*/uniffiMakeCall, /*handleSuccess:*/uniffiHandleSuccess, /*handleError:*/uniffiHandleError, /*isErrorType:*/BarkError.instanceOf, /*lowerError:*/FfiConverterTypeBarkError.lower.bind(FfiConverterTypeBarkError), /*lowerString:*/FfiConverterString.lower);
+      return uniffiResult;
+    },
+    prepareDrainTx: (uniffiHandle, address, feeRateSatPerVb) => {
+      const uniffiMakeCall = () => {
+        const jsCallback = FfiConverterTypeCustomOnchainWalletCallbacks.lift(uniffiHandle);
+        return jsCallback.prepareDrainTx(FfiConverterString.lift(address), FfiConverterUInt64.lift(feeRateSatPerVb));
+      };
+      const uniffiResult = UniffiResult.ready();
+      const uniffiHandleSuccess = obj => {
+        UniffiResult.writeSuccess(uniffiResult, FfiConverterString.lower(obj));
+      };
+      const uniffiHandleError = (code, errBuf) => {
+        UniffiResult.writeError(uniffiResult, code, errBuf);
+      };
+      uniffiTraitInterfaceCallWithError(/*makeCall:*/uniffiMakeCall, /*handleSuccess:*/uniffiHandleSuccess, /*handleError:*/uniffiHandleError, /*isErrorType:*/BarkError.instanceOf, /*lowerError:*/FfiConverterTypeBarkError.lower.bind(FfiConverterTypeBarkError), /*lowerString:*/FfiConverterString.lower);
+      return uniffiResult;
+    },
+    finishTx: (uniffiHandle, psbtBase64) => {
+      const uniffiMakeCall = () => {
+        const jsCallback = FfiConverterTypeCustomOnchainWalletCallbacks.lift(uniffiHandle);
+        return jsCallback.finishTx(FfiConverterString.lift(psbtBase64));
+      };
+      const uniffiResult = UniffiResult.ready();
+      const uniffiHandleSuccess = obj => {
+        UniffiResult.writeSuccess(uniffiResult, FfiConverterString.lower(obj));
+      };
+      const uniffiHandleError = (code, errBuf) => {
+        UniffiResult.writeError(uniffiResult, code, errBuf);
+      };
+      uniffiTraitInterfaceCallWithError(/*makeCall:*/uniffiMakeCall, /*handleSuccess:*/uniffiHandleSuccess, /*handleError:*/uniffiHandleError, /*isErrorType:*/BarkError.instanceOf, /*lowerError:*/FfiConverterTypeBarkError.lower.bind(FfiConverterTypeBarkError), /*lowerString:*/FfiConverterString.lower);
+      return uniffiResult;
+    },
+    getWalletTx: (uniffiHandle, txid) => {
+      const uniffiMakeCall = () => {
+        const jsCallback = FfiConverterTypeCustomOnchainWalletCallbacks.lift(uniffiHandle);
+        return jsCallback.getWalletTx(FfiConverterString.lift(txid));
+      };
+      const uniffiResult = UniffiResult.ready();
+      const uniffiHandleSuccess = obj => {
+        UniffiResult.writeSuccess(uniffiResult, FfiConverterOptionalString.lower(obj));
+      };
+      const uniffiHandleError = (code, errBuf) => {
+        UniffiResult.writeError(uniffiResult, code, errBuf);
+      };
+      uniffiTraitInterfaceCallWithError(/*makeCall:*/uniffiMakeCall, /*handleSuccess:*/uniffiHandleSuccess, /*handleError:*/uniffiHandleError, /*isErrorType:*/BarkError.instanceOf, /*lowerError:*/FfiConverterTypeBarkError.lower.bind(FfiConverterTypeBarkError), /*lowerString:*/FfiConverterString.lower);
+      return uniffiResult;
+    },
+    getWalletTxConfirmedBlock: (uniffiHandle, txid) => {
+      const uniffiMakeCall = () => {
+        const jsCallback = FfiConverterTypeCustomOnchainWalletCallbacks.lift(uniffiHandle);
+        return jsCallback.getWalletTxConfirmedBlock(FfiConverterString.lift(txid));
+      };
+      const uniffiResult = UniffiResult.ready();
+      const uniffiHandleSuccess = obj => {
+        UniffiResult.writeSuccess(uniffiResult, FfiConverterOptionalTypeBlockRef.lower(obj));
+      };
+      const uniffiHandleError = (code, errBuf) => {
+        UniffiResult.writeError(uniffiResult, code, errBuf);
+      };
+      uniffiTraitInterfaceCallWithError(/*makeCall:*/uniffiMakeCall, /*handleSuccess:*/uniffiHandleSuccess, /*handleError:*/uniffiHandleError, /*isErrorType:*/BarkError.instanceOf, /*lowerError:*/FfiConverterTypeBarkError.lower.bind(FfiConverterTypeBarkError), /*lowerString:*/FfiConverterString.lower);
+      return uniffiResult;
+    },
+    getSpendingTx: (uniffiHandle, outpoint) => {
+      const uniffiMakeCall = () => {
+        const jsCallback = FfiConverterTypeCustomOnchainWalletCallbacks.lift(uniffiHandle);
+        return jsCallback.getSpendingTx(FfiConverterTypeOutPoint.lift(outpoint));
+      };
+      const uniffiResult = UniffiResult.ready();
+      const uniffiHandleSuccess = obj => {
+        UniffiResult.writeSuccess(uniffiResult, FfiConverterOptionalString.lower(obj));
+      };
+      const uniffiHandleError = (code, errBuf) => {
+        UniffiResult.writeError(uniffiResult, code, errBuf);
+      };
+      uniffiTraitInterfaceCallWithError(/*makeCall:*/uniffiMakeCall, /*handleSuccess:*/uniffiHandleSuccess, /*handleError:*/uniffiHandleError, /*isErrorType:*/BarkError.instanceOf, /*lowerError:*/FfiConverterTypeBarkError.lower.bind(FfiConverterTypeBarkError), /*lowerString:*/FfiConverterString.lower);
+      return uniffiResult;
+    },
+    makeSignedP2aCpfp: (uniffiHandle, params) => {
+      const uniffiMakeCall = () => {
+        const jsCallback = FfiConverterTypeCustomOnchainWalletCallbacks.lift(uniffiHandle);
+        return jsCallback.makeSignedP2aCpfp(FfiConverterTypeCpfpParams.lift(params));
+      };
+      const uniffiResult = UniffiResult.ready();
+      const uniffiHandleSuccess = obj => {
+        UniffiResult.writeSuccess(uniffiResult, FfiConverterString.lower(obj));
+      };
+      const uniffiHandleError = (code, errBuf) => {
+        UniffiResult.writeError(uniffiResult, code, errBuf);
+      };
+      uniffiTraitInterfaceCallWithError(/*makeCall:*/uniffiMakeCall, /*handleSuccess:*/uniffiHandleSuccess, /*handleError:*/uniffiHandleError, /*isErrorType:*/BarkError.instanceOf, /*lowerError:*/FfiConverterTypeBarkError.lower.bind(FfiConverterTypeBarkError), /*lowerString:*/FfiConverterString.lower);
+      return uniffiResult;
+    },
+    storeSignedP2aCpfp: (uniffiHandle, txHex) => {
+      const uniffiMakeCall = () => {
+        const jsCallback = FfiConverterTypeCustomOnchainWalletCallbacks.lift(uniffiHandle);
+        return jsCallback.storeSignedP2aCpfp(FfiConverterString.lift(txHex));
+      };
+      const uniffiResult = UniffiResult.ready();
+      const uniffiHandleSuccess = obj => {};
+      const uniffiHandleError = (code, errBuf) => {
+        UniffiResult.writeError(uniffiResult, code, errBuf);
+      };
+      uniffiTraitInterfaceCallWithError(/*makeCall:*/uniffiMakeCall, /*handleSuccess:*/uniffiHandleSuccess, /*handleError:*/uniffiHandleError, /*isErrorType:*/BarkError.instanceOf, /*lowerError:*/FfiConverterTypeBarkError.lower.bind(FfiConverterTypeBarkError), /*lowerString:*/FfiConverterString.lower);
+      return uniffiResult;
+    },
+    uniffiFree: uniffiHandle => {
+      // CustomOnchainWalletCallbacks: this will throw a stale handle error if the handle isn't found.
+      FfiConverterTypeCustomOnchainWalletCallbacks.drop(uniffiHandle);
+    }
+  },
+  register: () => {
+    nativeModule().ubrn_uniffi_bark_ffi_fn_init_callback_vtable_customonchainwalletcallbacks(uniffiCallbackInterfaceCustomOnchainWalletCallbacks.vtable);
+  }
+};
+
+// FfiConverter protocol for callback interfaces
+const FfiConverterTypeCustomOnchainWalletCallbacks = new FfiConverterCallback();
+
+/**
+ * An Ark address with its derivation index
+ */
+
+/**
+ * Generated factory for {@link AddressWithIndex} record objects.
+ */
+export const AddressWithIndex = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link AddressWithIndex}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    create,
+    /**
+     * Create a frozen instance of {@link AddressWithIndex}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    new: create,
+    /**
+     * Defaults specified in the {@link bark} crate.
+     */
+    defaults: () => Object.freeze(defaults())
+  });
+})();
+const FfiConverterTypeAddressWithIndex = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    read(from) {
+      return {
+        address: FfiConverterString.read(from),
+        index: FfiConverterUInt32.read(from)
+      };
+    }
+    write(value, into) {
+      FfiConverterString.write(value.address, into);
+      FfiConverterUInt32.write(value.index, into);
+    }
+    allocationSize(value) {
+      return FfiConverterString.allocationSize(value.address) + FfiConverterUInt32.allocationSize(value.index);
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * Ark server configuration information
+ */
+
+/**
+ * Generated factory for {@link ArkInfo} record objects.
+ */
+export const ArkInfo = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link ArkInfo}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    create,
+    /**
+     * Create a frozen instance of {@link ArkInfo}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    new: create,
+    /**
+     * Defaults specified in the {@link bark} crate.
+     */
+    defaults: () => Object.freeze(defaults())
+  });
+})();
+const FfiConverterTypeArkInfo = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    read(from) {
+      return {
+        network: FfiConverterTypeNetwork.read(from),
+        serverPubkey: FfiConverterString.read(from),
+        roundIntervalSecs: FfiConverterUInt64.read(from),
+        nbRoundNonces: FfiConverterUInt32.read(from),
+        vtxoExitDelta: FfiConverterUInt32.read(from),
+        vtxoExpiryDelta: FfiConverterUInt32.read(from),
+        htlcSendExpiryDelta: FfiConverterUInt32.read(from),
+        htlcExpiryDelta: FfiConverterUInt32.read(from),
+        maxVtxoAmountSats: FfiConverterOptionalUInt64.read(from),
+        requiredBoardConfirmations: FfiConverterUInt32.read(from),
+        maxUserInvoiceCltvDelta: FfiConverterUInt16.read(from),
+        minBoardAmountSats: FfiConverterUInt64.read(from),
+        offboardFeerateSatPerVb: FfiConverterUInt64.read(from),
+        lnReceiveAntiDosRequired: FfiConverterBool.read(from)
+      };
+    }
+    write(value, into) {
+      FfiConverterTypeNetwork.write(value.network, into);
+      FfiConverterString.write(value.serverPubkey, into);
+      FfiConverterUInt64.write(value.roundIntervalSecs, into);
+      FfiConverterUInt32.write(value.nbRoundNonces, into);
+      FfiConverterUInt32.write(value.vtxoExitDelta, into);
+      FfiConverterUInt32.write(value.vtxoExpiryDelta, into);
+      FfiConverterUInt32.write(value.htlcSendExpiryDelta, into);
+      FfiConverterUInt32.write(value.htlcExpiryDelta, into);
+      FfiConverterOptionalUInt64.write(value.maxVtxoAmountSats, into);
+      FfiConverterUInt32.write(value.requiredBoardConfirmations, into);
+      FfiConverterUInt16.write(value.maxUserInvoiceCltvDelta, into);
+      FfiConverterUInt64.write(value.minBoardAmountSats, into);
+      FfiConverterUInt64.write(value.offboardFeerateSatPerVb, into);
+      FfiConverterBool.write(value.lnReceiveAntiDosRequired, into);
+    }
+    allocationSize(value) {
+      return FfiConverterTypeNetwork.allocationSize(value.network) + FfiConverterString.allocationSize(value.serverPubkey) + FfiConverterUInt64.allocationSize(value.roundIntervalSecs) + FfiConverterUInt32.allocationSize(value.nbRoundNonces) + FfiConverterUInt32.allocationSize(value.vtxoExitDelta) + FfiConverterUInt32.allocationSize(value.vtxoExpiryDelta) + FfiConverterUInt32.allocationSize(value.htlcSendExpiryDelta) + FfiConverterUInt32.allocationSize(value.htlcExpiryDelta) + FfiConverterOptionalUInt64.allocationSize(value.maxVtxoAmountSats) + FfiConverterUInt32.allocationSize(value.requiredBoardConfirmations) + FfiConverterUInt16.allocationSize(value.maxUserInvoiceCltvDelta) + FfiConverterUInt64.allocationSize(value.minBoardAmountSats) + FfiConverterUInt64.allocationSize(value.offboardFeerateSatPerVb) + FfiConverterBool.allocationSize(value.lnReceiveAntiDosRequired);
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * Detailed balance breakdown of the wallet
+ */
+
+/**
+ * Generated factory for {@link Balance} record objects.
+ */
+export const Balance = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link Balance}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    create,
+    /**
+     * Create a frozen instance of {@link Balance}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    new: create,
+    /**
+     * Defaults specified in the {@link bark} crate.
+     */
+    defaults: () => Object.freeze(defaults())
+  });
+})();
+const FfiConverterTypeBalance = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    read(from) {
+      return {
+        spendableSats: FfiConverterUInt64.read(from),
+        pendingInRoundSats: FfiConverterUInt64.read(from),
+        pendingExitSats: FfiConverterUInt64.read(from),
+        pendingLightningSendSats: FfiConverterUInt64.read(from),
+        claimableLightningReceiveSats: FfiConverterUInt64.read(from),
+        pendingBoardSats: FfiConverterUInt64.read(from)
+      };
+    }
+    write(value, into) {
+      FfiConverterUInt64.write(value.spendableSats, into);
+      FfiConverterUInt64.write(value.pendingInRoundSats, into);
+      FfiConverterUInt64.write(value.pendingExitSats, into);
+      FfiConverterUInt64.write(value.pendingLightningSendSats, into);
+      FfiConverterUInt64.write(value.claimableLightningReceiveSats, into);
+      FfiConverterUInt64.write(value.pendingBoardSats, into);
+    }
+    allocationSize(value) {
+      return FfiConverterUInt64.allocationSize(value.spendableSats) + FfiConverterUInt64.allocationSize(value.pendingInRoundSats) + FfiConverterUInt64.allocationSize(value.pendingExitSats) + FfiConverterUInt64.allocationSize(value.pendingLightningSendSats) + FfiConverterUInt64.allocationSize(value.claimableLightningReceiveSats) + FfiConverterUInt64.allocationSize(value.pendingBoardSats);
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * Reference to a block in the blockchain
+ */
+
+/**
+ * Generated factory for {@link BlockRef} record objects.
+ */
+export const BlockRef = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link BlockRef}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    create,
+    /**
+     * Create a frozen instance of {@link BlockRef}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    new: create,
+    /**
+     * Defaults specified in the {@link bark} crate.
+     */
+    defaults: () => Object.freeze(defaults())
+  });
+})();
+const FfiConverterTypeBlockRef = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    read(from) {
+      return {
+        height: FfiConverterUInt32.read(from),
+        hash: FfiConverterString.read(from)
+      };
+    }
+    write(value, into) {
+      FfiConverterUInt32.write(value.height, into);
+      FfiConverterString.write(value.hash, into);
+    }
+    allocationSize(value) {
+      return FfiConverterUInt32.allocationSize(value.height) + FfiConverterString.allocationSize(value.hash);
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * Configuration for creating/opening a Bark wallet
+ */
+
+/**
+ * Generated factory for {@link Config} record objects.
+ */
+export const Config = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link Config}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    create,
+    /**
+     * Create a frozen instance of {@link Config}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    new: create,
+    /**
+     * Defaults specified in the {@link bark} crate.
+     */
+    defaults: () => Object.freeze(defaults())
+  });
+})();
+const FfiConverterTypeConfig = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    read(from) {
+      return {
+        serverAddress: FfiConverterString.read(from),
+        esploraAddress: FfiConverterOptionalString.read(from),
+        bitcoindAddress: FfiConverterOptionalString.read(from),
+        bitcoindCookiefile: FfiConverterOptionalString.read(from),
+        bitcoindUser: FfiConverterOptionalString.read(from),
+        bitcoindPass: FfiConverterOptionalString.read(from),
+        network: FfiConverterTypeNetwork.read(from),
+        vtxoRefreshExpiryThreshold: FfiConverterOptionalUInt32.read(from),
+        vtxoExitMargin: FfiConverterOptionalUInt16.read(from),
+        htlcRecvClaimDelta: FfiConverterOptionalUInt16.read(from),
+        fallbackFeeRate: FfiConverterOptionalUInt64.read(from),
+        roundTxRequiredConfirmations: FfiConverterOptionalUInt32.read(from)
+      };
+    }
+    write(value, into) {
+      FfiConverterString.write(value.serverAddress, into);
+      FfiConverterOptionalString.write(value.esploraAddress, into);
+      FfiConverterOptionalString.write(value.bitcoindAddress, into);
+      FfiConverterOptionalString.write(value.bitcoindCookiefile, into);
+      FfiConverterOptionalString.write(value.bitcoindUser, into);
+      FfiConverterOptionalString.write(value.bitcoindPass, into);
+      FfiConverterTypeNetwork.write(value.network, into);
+      FfiConverterOptionalUInt32.write(value.vtxoRefreshExpiryThreshold, into);
+      FfiConverterOptionalUInt16.write(value.vtxoExitMargin, into);
+      FfiConverterOptionalUInt16.write(value.htlcRecvClaimDelta, into);
+      FfiConverterOptionalUInt64.write(value.fallbackFeeRate, into);
+      FfiConverterOptionalUInt32.write(value.roundTxRequiredConfirmations, into);
+    }
+    allocationSize(value) {
+      return FfiConverterString.allocationSize(value.serverAddress) + FfiConverterOptionalString.allocationSize(value.esploraAddress) + FfiConverterOptionalString.allocationSize(value.bitcoindAddress) + FfiConverterOptionalString.allocationSize(value.bitcoindCookiefile) + FfiConverterOptionalString.allocationSize(value.bitcoindUser) + FfiConverterOptionalString.allocationSize(value.bitcoindPass) + FfiConverterTypeNetwork.allocationSize(value.network) + FfiConverterOptionalUInt32.allocationSize(value.vtxoRefreshExpiryThreshold) + FfiConverterOptionalUInt16.allocationSize(value.vtxoExitMargin) + FfiConverterOptionalUInt16.allocationSize(value.htlcRecvClaimDelta) + FfiConverterOptionalUInt64.allocationSize(value.fallbackFeeRate) + FfiConverterOptionalUInt32.allocationSize(value.roundTxRequiredConfirmations);
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * Parameters for creating a CPFP (Child Pays For Parent) transaction
+ */
+
+/**
+ * Generated factory for {@link CpfpParams} record objects.
+ */
+export const CpfpParams = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link CpfpParams}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    create,
+    /**
+     * Create a frozen instance of {@link CpfpParams}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    new: create,
+    /**
+     * Defaults specified in the {@link bark} crate.
+     */
+    defaults: () => Object.freeze(defaults())
+  });
+})();
+const FfiConverterTypeCpfpParams = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    read(from) {
+      return {
+        txHex: FfiConverterString.read(from),
+        feesType: FfiConverterString.read(from),
+        effectiveFeeRateSatPerVb: FfiConverterUInt64.read(from),
+        currentPackageFeeSats: FfiConverterOptionalUInt64.read(from)
+      };
+    }
+    write(value, into) {
+      FfiConverterString.write(value.txHex, into);
+      FfiConverterString.write(value.feesType, into);
+      FfiConverterUInt64.write(value.effectiveFeeRateSatPerVb, into);
+      FfiConverterOptionalUInt64.write(value.currentPackageFeeSats, into);
+    }
+    allocationSize(value) {
+      return FfiConverterString.allocationSize(value.txHex) + FfiConverterString.allocationSize(value.feesType) + FfiConverterUInt64.allocationSize(value.effectiveFeeRateSatPerVb) + FfiConverterOptionalUInt64.allocationSize(value.currentPackageFeeSats);
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * A Bitcoin transaction output destination
+ */
+
+/**
+ * Generated factory for {@link Destination} record objects.
+ */
+export const Destination = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link Destination}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    create,
+    /**
+     * Create a frozen instance of {@link Destination}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    new: create,
+    /**
+     * Defaults specified in the {@link bark} crate.
+     */
+    defaults: () => Object.freeze(defaults())
+  });
+})();
+const FfiConverterTypeDestination = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    read(from) {
+      return {
+        address: FfiConverterString.read(from),
+        amountSats: FfiConverterUInt64.read(from)
+      };
+    }
+    write(value, into) {
+      FfiConverterString.write(value.address, into);
+      FfiConverterUInt64.write(value.amountSats, into);
+    }
+    allocationSize(value) {
+      return FfiConverterString.allocationSize(value.address) + FfiConverterUInt64.allocationSize(value.amountSats);
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * Claim transaction for exited funds
+ */
+
+/**
+ * Generated factory for {@link ExitClaimTransaction} record objects.
+ */
+export const ExitClaimTransaction = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link ExitClaimTransaction}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    create,
+    /**
+     * Create a frozen instance of {@link ExitClaimTransaction}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    new: create,
+    /**
+     * Defaults specified in the {@link bark} crate.
+     */
+    defaults: () => Object.freeze(defaults())
+  });
+})();
+const FfiConverterTypeExitClaimTransaction = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    read(from) {
+      return {
+        psbtBase64: FfiConverterString.read(from),
+        feeSats: FfiConverterUInt64.read(from)
+      };
+    }
+    write(value, into) {
+      FfiConverterString.write(value.psbtBase64, into);
+      FfiConverterUInt64.write(value.feeSats, into);
+    }
+    allocationSize(value) {
+      return FfiConverterString.allocationSize(value.psbtBase64) + FfiConverterUInt64.allocationSize(value.feeSats);
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * Status of an exit progression
+ */
+
+/**
+ * Generated factory for {@link ExitProgressStatus} record objects.
+ */
+export const ExitProgressStatus = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link ExitProgressStatus}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    create,
+    /**
+     * Create a frozen instance of {@link ExitProgressStatus}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    new: create,
+    /**
+     * Defaults specified in the {@link bark} crate.
+     */
+    defaults: () => Object.freeze(defaults())
+  });
+})();
+const FfiConverterTypeExitProgressStatus = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    read(from) {
+      return {
+        vtxoId: FfiConverterString.read(from),
+        state: FfiConverterString.read(from),
+        error: FfiConverterOptionalString.read(from)
+      };
+    }
+    write(value, into) {
+      FfiConverterString.write(value.vtxoId, into);
+      FfiConverterString.write(value.state, into);
+      FfiConverterOptionalString.write(value.error, into);
+    }
+    allocationSize(value) {
+      return FfiConverterString.allocationSize(value.vtxoId) + FfiConverterString.allocationSize(value.state) + FfiConverterOptionalString.allocationSize(value.error);
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * Detailed status of an exit transaction
+ */
+
+/**
+ * Generated factory for {@link ExitTransactionStatus} record objects.
+ */
+export const ExitTransactionStatus = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link ExitTransactionStatus}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    create,
+    /**
+     * Create a frozen instance of {@link ExitTransactionStatus}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    new: create,
+    /**
+     * Defaults specified in the {@link bark} crate.
+     */
+    defaults: () => Object.freeze(defaults())
+  });
+})();
+const FfiConverterTypeExitTransactionStatus = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    read(from) {
+      return {
+        vtxoId: FfiConverterString.read(from),
+        state: FfiConverterString.read(from),
+        history: FfiConverterOptionalArrayString.read(from),
+        transactionCount: FfiConverterUInt32.read(from)
+      };
+    }
+    write(value, into) {
+      FfiConverterString.write(value.vtxoId, into);
+      FfiConverterString.write(value.state, into);
+      FfiConverterOptionalArrayString.write(value.history, into);
+      FfiConverterUInt32.write(value.transactionCount, into);
+    }
+    allocationSize(value) {
+      return FfiConverterString.allocationSize(value.vtxoId) + FfiConverterString.allocationSize(value.state) + FfiConverterOptionalArrayString.allocationSize(value.history) + FfiConverterUInt32.allocationSize(value.transactionCount);
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * A VTXO in the exit process
+ */
+
+/**
+ * Generated factory for {@link ExitVtxo} record objects.
+ */
+export const ExitVtxo = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link ExitVtxo}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    create,
+    /**
+     * Create a frozen instance of {@link ExitVtxo}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    new: create,
+    /**
+     * Defaults specified in the {@link bark} crate.
+     */
+    defaults: () => Object.freeze(defaults())
+  });
+})();
+const FfiConverterTypeExitVtxo = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    read(from) {
+      return {
+        vtxoId: FfiConverterString.read(from),
+        amountSats: FfiConverterUInt64.read(from),
+        state: FfiConverterString.read(from),
+        isClaimable: FfiConverterBool.read(from)
+      };
+    }
+    write(value, into) {
+      FfiConverterString.write(value.vtxoId, into);
+      FfiConverterUInt64.write(value.amountSats, into);
+      FfiConverterString.write(value.state, into);
+      FfiConverterBool.write(value.isClaimable, into);
+    }
+    allocationSize(value) {
+      return FfiConverterString.allocationSize(value.vtxoId) + FfiConverterUInt64.allocationSize(value.amountSats) + FfiConverterString.allocationSize(value.state) + FfiConverterBool.allocationSize(value.isClaimable);
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * Result of creating a BOLT11 invoice
+ */
+
+/**
+ * Generated factory for {@link LightningInvoice} record objects.
+ */
+export const LightningInvoice = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link LightningInvoice}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    create,
+    /**
+     * Create a frozen instance of {@link LightningInvoice}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    new: create,
+    /**
+     * Defaults specified in the {@link bark} crate.
+     */
+    defaults: () => Object.freeze(defaults())
+  });
+})();
+const FfiConverterTypeLightningInvoice = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    read(from) {
+      return {
+        invoice: FfiConverterString.read(from),
+        amountSats: FfiConverterUInt64.read(from)
+      };
+    }
+    write(value, into) {
+      FfiConverterString.write(value.invoice, into);
+      FfiConverterUInt64.write(value.amountSats, into);
+    }
+    allocationSize(value) {
+      return FfiConverterString.allocationSize(value.invoice) + FfiConverterUInt64.allocationSize(value.amountSats);
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * Status of a pending Lightning receive
+ */
+
+/**
+ * Generated factory for {@link LightningReceive} record objects.
+ */
+export const LightningReceive = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link LightningReceive}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    create,
+    /**
+     * Create a frozen instance of {@link LightningReceive}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    new: create,
+    /**
+     * Defaults specified in the {@link bark} crate.
+     */
+    defaults: () => Object.freeze(defaults())
+  });
+})();
+const FfiConverterTypeLightningReceive = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    read(from) {
+      return {
+        paymentHash: FfiConverterString.read(from),
+        invoice: FfiConverterString.read(from),
+        amountSats: FfiConverterUInt64.read(from),
+        hasHtlcVtxos: FfiConverterBool.read(from),
+        preimageRevealed: FfiConverterBool.read(from)
+      };
+    }
+    write(value, into) {
+      FfiConverterString.write(value.paymentHash, into);
+      FfiConverterString.write(value.invoice, into);
+      FfiConverterUInt64.write(value.amountSats, into);
+      FfiConverterBool.write(value.hasHtlcVtxos, into);
+      FfiConverterBool.write(value.preimageRevealed, into);
+    }
+    allocationSize(value) {
+      return FfiConverterString.allocationSize(value.paymentHash) + FfiConverterString.allocationSize(value.invoice) + FfiConverterUInt64.allocationSize(value.amountSats) + FfiConverterBool.allocationSize(value.hasHtlcVtxos) + FfiConverterBool.allocationSize(value.preimageRevealed);
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * Lightning send payment information
+ */
+
+/**
+ * Generated factory for {@link LightningSend} record objects.
+ */
+export const LightningSend = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link LightningSend}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    create,
+    /**
+     * Create a frozen instance of {@link LightningSend}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    new: create,
+    /**
+     * Defaults specified in the {@link bark} crate.
+     */
+    defaults: () => Object.freeze(defaults())
+  });
+})();
+const FfiConverterTypeLightningSend = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    read(from) {
+      return {
+        invoice: FfiConverterString.read(from),
+        amountSats: FfiConverterUInt64.read(from),
+        htlcVtxoCount: FfiConverterUInt32.read(from),
+        preimage: FfiConverterOptionalString.read(from)
+      };
+    }
+    write(value, into) {
+      FfiConverterString.write(value.invoice, into);
+      FfiConverterUInt64.write(value.amountSats, into);
+      FfiConverterUInt32.write(value.htlcVtxoCount, into);
+      FfiConverterOptionalString.write(value.preimage, into);
+    }
+    allocationSize(value) {
+      return FfiConverterString.allocationSize(value.invoice) + FfiConverterUInt64.allocationSize(value.amountSats) + FfiConverterUInt32.allocationSize(value.htlcVtxoCount) + FfiConverterOptionalString.allocationSize(value.preimage);
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * Wallet movement/transaction record
+ */
+
+/**
+ * Generated factory for {@link Movement} record objects.
+ */
+export const Movement = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link Movement}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    create,
+    /**
+     * Create a frozen instance of {@link Movement}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    new: create,
+    /**
+     * Defaults specified in the {@link bark} crate.
+     */
+    defaults: () => Object.freeze(defaults())
+  });
+})();
+const FfiConverterTypeMovement = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    read(from) {
+      return {
+        id: FfiConverterUInt32.read(from),
+        status: FfiConverterString.read(from),
+        subsystemName: FfiConverterString.read(from),
+        subsystemKind: FfiConverterString.read(from),
+        metadataJson: FfiConverterString.read(from),
+        intendedBalanceSats: FfiConverterInt64.read(from),
+        effectiveBalanceSats: FfiConverterInt64.read(from),
+        offchainFeeSats: FfiConverterUInt64.read(from),
+        sentToAddresses: FfiConverterArrayString.read(from),
+        receivedOnAddresses: FfiConverterArrayString.read(from),
+        inputVtxoIds: FfiConverterArrayString.read(from),
+        outputVtxoIds: FfiConverterArrayString.read(from),
+        exitedVtxoIds: FfiConverterArrayString.read(from),
+        createdAt: FfiConverterString.read(from),
+        updatedAt: FfiConverterString.read(from),
+        completedAt: FfiConverterOptionalString.read(from)
+      };
+    }
+    write(value, into) {
+      FfiConverterUInt32.write(value.id, into);
+      FfiConverterString.write(value.status, into);
+      FfiConverterString.write(value.subsystemName, into);
+      FfiConverterString.write(value.subsystemKind, into);
+      FfiConverterString.write(value.metadataJson, into);
+      FfiConverterInt64.write(value.intendedBalanceSats, into);
+      FfiConverterInt64.write(value.effectiveBalanceSats, into);
+      FfiConverterUInt64.write(value.offchainFeeSats, into);
+      FfiConverterArrayString.write(value.sentToAddresses, into);
+      FfiConverterArrayString.write(value.receivedOnAddresses, into);
+      FfiConverterArrayString.write(value.inputVtxoIds, into);
+      FfiConverterArrayString.write(value.outputVtxoIds, into);
+      FfiConverterArrayString.write(value.exitedVtxoIds, into);
+      FfiConverterString.write(value.createdAt, into);
+      FfiConverterString.write(value.updatedAt, into);
+      FfiConverterOptionalString.write(value.completedAt, into);
+    }
+    allocationSize(value) {
+      return FfiConverterUInt32.allocationSize(value.id) + FfiConverterString.allocationSize(value.status) + FfiConverterString.allocationSize(value.subsystemName) + FfiConverterString.allocationSize(value.subsystemKind) + FfiConverterString.allocationSize(value.metadataJson) + FfiConverterInt64.allocationSize(value.intendedBalanceSats) + FfiConverterInt64.allocationSize(value.effectiveBalanceSats) + FfiConverterUInt64.allocationSize(value.offchainFeeSats) + FfiConverterArrayString.allocationSize(value.sentToAddresses) + FfiConverterArrayString.allocationSize(value.receivedOnAddresses) + FfiConverterArrayString.allocationSize(value.inputVtxoIds) + FfiConverterArrayString.allocationSize(value.outputVtxoIds) + FfiConverterArrayString.allocationSize(value.exitedVtxoIds) + FfiConverterString.allocationSize(value.createdAt) + FfiConverterString.allocationSize(value.updatedAt) + FfiConverterOptionalString.allocationSize(value.completedAt);
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * Result of an offboard operation
+ */
+
+/**
+ * Generated factory for {@link OffboardResult} record objects.
+ */
+export const OffboardResult = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link OffboardResult}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    create,
+    /**
+     * Create a frozen instance of {@link OffboardResult}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    new: create,
+    /**
+     * Defaults specified in the {@link bark} crate.
+     */
+    defaults: () => Object.freeze(defaults())
+  });
+})();
+const FfiConverterTypeOffboardResult = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    read(from) {
+      return {
+        roundId: FfiConverterString.read(from)
+      };
+    }
+    write(value, into) {
+      FfiConverterString.write(value.roundId, into);
+    }
+    allocationSize(value) {
+      return FfiConverterString.allocationSize(value.roundId);
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * Onchain Bitcoin wallet balance
+ */
+
+/**
+ * Generated factory for {@link OnchainBalance} record objects.
+ */
+export const OnchainBalance = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link OnchainBalance}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    create,
+    /**
+     * Create a frozen instance of {@link OnchainBalance}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    new: create,
+    /**
+     * Defaults specified in the {@link bark} crate.
+     */
+    defaults: () => Object.freeze(defaults())
+  });
+})();
+const FfiConverterTypeOnchainBalance = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    read(from) {
+      return {
+        confirmedSats: FfiConverterUInt64.read(from),
+        pendingSats: FfiConverterUInt64.read(from),
+        totalSats: FfiConverterUInt64.read(from)
+      };
+    }
+    write(value, into) {
+      FfiConverterUInt64.write(value.confirmedSats, into);
+      FfiConverterUInt64.write(value.pendingSats, into);
+      FfiConverterUInt64.write(value.totalSats, into);
+    }
+    allocationSize(value) {
+      return FfiConverterUInt64.allocationSize(value.confirmedSats) + FfiConverterUInt64.allocationSize(value.pendingSats) + FfiConverterUInt64.allocationSize(value.totalSats);
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * A Bitcoin transaction outpoint (reference to a previous output)
+ */
+
+/**
+ * Generated factory for {@link OutPoint} record objects.
+ */
+export const OutPoint = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link OutPoint}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    create,
+    /**
+     * Create a frozen instance of {@link OutPoint}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    new: create,
+    /**
+     * Defaults specified in the {@link bark} crate.
+     */
+    defaults: () => Object.freeze(defaults())
+  });
+})();
+const FfiConverterTypeOutPoint = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    read(from) {
+      return {
+        txid: FfiConverterString.read(from),
+        vout: FfiConverterUInt32.read(from)
+      };
+    }
+    write(value, into) {
+      FfiConverterString.write(value.txid, into);
+      FfiConverterUInt32.write(value.vout, into);
+    }
+    allocationSize(value) {
+      return FfiConverterString.allocationSize(value.txid) + FfiConverterUInt32.allocationSize(value.vout);
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * Pending board transaction information
+ */
+
+/**
+ * Generated factory for {@link PendingBoard} record objects.
+ */
+export const PendingBoard = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link PendingBoard}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    create,
+    /**
+     * Create a frozen instance of {@link PendingBoard}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    new: create,
+    /**
+     * Defaults specified in the {@link bark} crate.
+     */
+    defaults: () => Object.freeze(defaults())
+  });
+})();
+const FfiConverterTypePendingBoard = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    read(from) {
+      return {
+        vtxoId: FfiConverterString.read(from),
+        amountSats: FfiConverterUInt64.read(from),
+        txid: FfiConverterString.read(from)
+      };
+    }
+    write(value, into) {
+      FfiConverterString.write(value.vtxoId, into);
+      FfiConverterUInt64.write(value.amountSats, into);
+      FfiConverterString.write(value.txid, into);
+    }
+    allocationSize(value) {
+      return FfiConverterString.allocationSize(value.vtxoId) + FfiConverterUInt64.allocationSize(value.amountSats) + FfiConverterString.allocationSize(value.txid);
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * A pending round state
+ */
+
+/**
+ * Generated factory for {@link RoundState} record objects.
+ */
+export const RoundState = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link RoundState}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    create,
+    /**
+     * Create a frozen instance of {@link RoundState}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    new: create,
+    /**
+     * Defaults specified in the {@link bark} crate.
+     */
+    defaults: () => Object.freeze(defaults())
+  });
+})();
+const FfiConverterTypeRoundState = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    read(from) {
+      return {
+        id: FfiConverterUInt32.read(from),
+        ongoing: FfiConverterBool.read(from)
+      };
+    }
+    write(value, into) {
+      FfiConverterUInt32.write(value.id, into);
+      FfiConverterBool.write(value.ongoing, into);
+    }
+    allocationSize(value) {
+      return FfiConverterUInt32.allocationSize(value.id) + FfiConverterBool.allocationSize(value.ongoing);
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * Simplified view of a VTXO
+ */
+
+/**
+ * Generated factory for {@link Vtxo} record objects.
+ */
+export const Vtxo = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link Vtxo}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    create,
+    /**
+     * Create a frozen instance of {@link Vtxo}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    new: create,
+    /**
+     * Defaults specified in the {@link bark} crate.
+     */
+    defaults: () => Object.freeze(defaults())
+  });
+})();
+const FfiConverterTypeVtxo = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    read(from) {
+      return {
+        id: FfiConverterString.read(from),
+        amountSats: FfiConverterUInt64.read(from),
+        expiryHeight: FfiConverterUInt32.read(from),
+        kind: FfiConverterString.read(from),
+        state: FfiConverterString.read(from)
+      };
+    }
+    write(value, into) {
+      FfiConverterString.write(value.id, into);
+      FfiConverterUInt64.write(value.amountSats, into);
+      FfiConverterUInt32.write(value.expiryHeight, into);
+      FfiConverterString.write(value.kind, into);
+      FfiConverterString.write(value.state, into);
+    }
+    allocationSize(value) {
+      return FfiConverterString.allocationSize(value.id) + FfiConverterUInt64.allocationSize(value.amountSats) + FfiConverterUInt32.allocationSize(value.expiryHeight) + FfiConverterString.allocationSize(value.kind) + FfiConverterString.allocationSize(value.state);
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * Read-only properties of the wallet
+ */
+
+/**
+ * Generated factory for {@link WalletProperties} record objects.
+ */
+export const WalletProperties = (() => {
+  const defaults = () => ({});
+  const create = (() => {
+    return uniffiCreateRecord(defaults);
+  })();
+  return Object.freeze({
+    /**
+     * Create a frozen instance of {@link WalletProperties}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    create,
+    /**
+     * Create a frozen instance of {@link WalletProperties}, with defaults specified
+     * in Rust, in the {@link bark} crate.
+     */
+    new: create,
+    /**
+     * Defaults specified in the {@link bark} crate.
+     */
+    defaults: () => Object.freeze(defaults())
+  });
+})();
+const FfiConverterTypeWalletProperties = (() => {
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    read(from) {
+      return {
+        network: FfiConverterTypeNetwork.read(from),
+        fingerprint: FfiConverterString.read(from)
+      };
+    }
+    write(value, into) {
+      FfiConverterTypeNetwork.write(value.network, into);
+      FfiConverterString.write(value.fingerprint, into);
+    }
+    allocationSize(value) {
+      return FfiConverterTypeNetwork.allocationSize(value.network) + FfiConverterString.allocationSize(value.fingerprint);
+    }
+  }
+  return new FFIConverter();
+})();
+const stringConverter = {
+  stringToBytes: s => uniffiCaller.rustCall(status => nativeModule().ubrn_uniffi_internal_fn_func_ffi__string_to_arraybuffer(s, status)),
+  bytesToString: ab => uniffiCaller.rustCall(status => nativeModule().ubrn_uniffi_internal_fn_func_ffi__arraybuffer_to_string(ab, status)),
+  stringByteLength: s => uniffiCaller.rustCall(status => nativeModule().ubrn_uniffi_internal_fn_func_ffi__string_to_byte_length(s, status))
+};
+const FfiConverterString = uniffiCreateFfiConverterString(stringConverter);
+
+// Error type: BarkError
+
+// Enum: BarkError
+export let BarkError_Tags = /*#__PURE__*/function (BarkError_Tags) {
+  BarkError_Tags["Network"] = "Network";
+  BarkError_Tags["Database"] = "Database";
+  BarkError_Tags["InvalidMnemonic"] = "InvalidMnemonic";
+  BarkError_Tags["InvalidAddress"] = "InvalidAddress";
+  BarkError_Tags["InvalidInvoice"] = "InvalidInvoice";
+  BarkError_Tags["InvalidPsbt"] = "InvalidPsbt";
+  BarkError_Tags["InvalidTransaction"] = "InvalidTransaction";
+  BarkError_Tags["InsufficientFunds"] = "InsufficientFunds";
+  BarkError_Tags["NotFound"] = "NotFound";
+  BarkError_Tags["ServerConnection"] = "ServerConnection";
+  BarkError_Tags["Internal"] = "Internal";
+  BarkError_Tags["OnchainWalletRequired"] = "OnchainWalletRequired";
+  return BarkError_Tags;
+}({});
+/**
+ * Error types that can occur when using the Bark wallet
+ */
+export const BarkError = (() => {
+  class Network_ extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "BarkError";
+    tag = BarkError_Tags.Network;
+    constructor(inner) {
+      super("BarkError", "Network");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new Network_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === BarkError_Tags.Network;
+    }
+    static hasInner(obj) {
+      return Network_.instanceOf(obj);
+    }
+    static getInner(obj) {
+      return obj.inner;
+    }
+  }
+  class Database_ extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "BarkError";
+    tag = BarkError_Tags.Database;
+    constructor(inner) {
+      super("BarkError", "Database");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new Database_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === BarkError_Tags.Database;
+    }
+    static hasInner(obj) {
+      return Database_.instanceOf(obj);
+    }
+    static getInner(obj) {
+      return obj.inner;
+    }
+  }
+  class InvalidMnemonic_ extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "BarkError";
+    tag = BarkError_Tags.InvalidMnemonic;
+    constructor(inner) {
+      super("BarkError", "InvalidMnemonic");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new InvalidMnemonic_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === BarkError_Tags.InvalidMnemonic;
+    }
+    static hasInner(obj) {
+      return InvalidMnemonic_.instanceOf(obj);
+    }
+    static getInner(obj) {
+      return obj.inner;
+    }
+  }
+  class InvalidAddress_ extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "BarkError";
+    tag = BarkError_Tags.InvalidAddress;
+    constructor(inner) {
+      super("BarkError", "InvalidAddress");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new InvalidAddress_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === BarkError_Tags.InvalidAddress;
+    }
+    static hasInner(obj) {
+      return InvalidAddress_.instanceOf(obj);
+    }
+    static getInner(obj) {
+      return obj.inner;
+    }
+  }
+  class InvalidInvoice_ extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "BarkError";
+    tag = BarkError_Tags.InvalidInvoice;
+    constructor(inner) {
+      super("BarkError", "InvalidInvoice");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new InvalidInvoice_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === BarkError_Tags.InvalidInvoice;
+    }
+    static hasInner(obj) {
+      return InvalidInvoice_.instanceOf(obj);
+    }
+    static getInner(obj) {
+      return obj.inner;
+    }
+  }
+  class InvalidPsbt_ extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "BarkError";
+    tag = BarkError_Tags.InvalidPsbt;
+    constructor(inner) {
+      super("BarkError", "InvalidPsbt");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new InvalidPsbt_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === BarkError_Tags.InvalidPsbt;
+    }
+    static hasInner(obj) {
+      return InvalidPsbt_.instanceOf(obj);
+    }
+    static getInner(obj) {
+      return obj.inner;
+    }
+  }
+  class InvalidTransaction_ extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "BarkError";
+    tag = BarkError_Tags.InvalidTransaction;
+    constructor(inner) {
+      super("BarkError", "InvalidTransaction");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new InvalidTransaction_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === BarkError_Tags.InvalidTransaction;
+    }
+    static hasInner(obj) {
+      return InvalidTransaction_.instanceOf(obj);
+    }
+    static getInner(obj) {
+      return obj.inner;
+    }
+  }
+  class InsufficientFunds_ extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "BarkError";
+    tag = BarkError_Tags.InsufficientFunds;
+    constructor(inner) {
+      super("BarkError", "InsufficientFunds");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new InsufficientFunds_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === BarkError_Tags.InsufficientFunds;
+    }
+    static hasInner(obj) {
+      return InsufficientFunds_.instanceOf(obj);
+    }
+    static getInner(obj) {
+      return obj.inner;
+    }
+  }
+  class NotFound_ extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "BarkError";
+    tag = BarkError_Tags.NotFound;
+    constructor(inner) {
+      super("BarkError", "NotFound");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new NotFound_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === BarkError_Tags.NotFound;
+    }
+    static hasInner(obj) {
+      return NotFound_.instanceOf(obj);
+    }
+    static getInner(obj) {
+      return obj.inner;
+    }
+  }
+  class ServerConnection_ extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "BarkError";
+    tag = BarkError_Tags.ServerConnection;
+    constructor(inner) {
+      super("BarkError", "ServerConnection");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new ServerConnection_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === BarkError_Tags.ServerConnection;
+    }
+    static hasInner(obj) {
+      return ServerConnection_.instanceOf(obj);
+    }
+    static getInner(obj) {
+      return obj.inner;
+    }
+  }
+  class Internal_ extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "BarkError";
+    tag = BarkError_Tags.Internal;
+    constructor(inner) {
+      super("BarkError", "Internal");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new Internal_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === BarkError_Tags.Internal;
+    }
+    static hasInner(obj) {
+      return Internal_.instanceOf(obj);
+    }
+    static getInner(obj) {
+      return obj.inner;
+    }
+  }
+  class OnchainWalletRequired_ extends UniffiError {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
+    [uniffiTypeNameSymbol] = "BarkError";
+    tag = BarkError_Tags.OnchainWalletRequired;
+    constructor(inner) {
+      super("BarkError", "OnchainWalletRequired");
+      this.inner = Object.freeze(inner);
+    }
+    static new(inner) {
+      return new OnchainWalletRequired_(inner);
+    }
+    static instanceOf(obj) {
+      return obj.tag === BarkError_Tags.OnchainWalletRequired;
+    }
+    static hasInner(obj) {
+      return OnchainWalletRequired_.instanceOf(obj);
+    }
+    static getInner(obj) {
+      return obj.inner;
+    }
+  }
+  function instanceOf(obj) {
+    return obj[uniffiTypeNameSymbol] === "BarkError";
+  }
+  return Object.freeze({
+    instanceOf,
+    Network: Network_,
+    Database: Database_,
+    InvalidMnemonic: InvalidMnemonic_,
+    InvalidAddress: InvalidAddress_,
+    InvalidInvoice: InvalidInvoice_,
+    InvalidPsbt: InvalidPsbt_,
+    InvalidTransaction: InvalidTransaction_,
+    InsufficientFunds: InsufficientFunds_,
+    NotFound: NotFound_,
+    ServerConnection: ServerConnection_,
+    Internal: Internal_,
+    OnchainWalletRequired: OnchainWalletRequired_
+  });
+})();
+
+/**
+ * Error types that can occur when using the Bark wallet
+ */
+
+// FfiConverter for enum BarkError
+const FfiConverterTypeBarkError = (() => {
+  const ordinalConverter = FfiConverterInt32;
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    read(from) {
+      switch (ordinalConverter.read(from)) {
+        case 1:
+          return new BarkError.Network({
+            errorMessage: FfiConverterString.read(from)
+          });
+        case 2:
+          return new BarkError.Database({
+            errorMessage: FfiConverterString.read(from)
+          });
+        case 3:
+          return new BarkError.InvalidMnemonic({
+            errorMessage: FfiConverterString.read(from)
+          });
+        case 4:
+          return new BarkError.InvalidAddress({
+            errorMessage: FfiConverterString.read(from)
+          });
+        case 5:
+          return new BarkError.InvalidInvoice({
+            errorMessage: FfiConverterString.read(from)
+          });
+        case 6:
+          return new BarkError.InvalidPsbt({
+            errorMessage: FfiConverterString.read(from)
+          });
+        case 7:
+          return new BarkError.InvalidTransaction({
+            errorMessage: FfiConverterString.read(from)
+          });
+        case 8:
+          return new BarkError.InsufficientFunds({
+            errorMessage: FfiConverterString.read(from)
+          });
+        case 9:
+          return new BarkError.NotFound({
+            errorMessage: FfiConverterString.read(from)
+          });
+        case 10:
+          return new BarkError.ServerConnection({
+            errorMessage: FfiConverterString.read(from)
+          });
+        case 11:
+          return new BarkError.Internal({
+            errorMessage: FfiConverterString.read(from)
+          });
+        case 12:
+          return new BarkError.OnchainWalletRequired({
+            errorMessage: FfiConverterString.read(from)
+          });
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    write(value, into) {
+      switch (value.tag) {
+        case BarkError_Tags.Network:
+          {
+            ordinalConverter.write(1, into);
+            const inner = value.inner;
+            FfiConverterString.write(inner.errorMessage, into);
+            return;
+          }
+        case BarkError_Tags.Database:
+          {
+            ordinalConverter.write(2, into);
+            const inner = value.inner;
+            FfiConverterString.write(inner.errorMessage, into);
+            return;
+          }
+        case BarkError_Tags.InvalidMnemonic:
+          {
+            ordinalConverter.write(3, into);
+            const inner = value.inner;
+            FfiConverterString.write(inner.errorMessage, into);
+            return;
+          }
+        case BarkError_Tags.InvalidAddress:
+          {
+            ordinalConverter.write(4, into);
+            const inner = value.inner;
+            FfiConverterString.write(inner.errorMessage, into);
+            return;
+          }
+        case BarkError_Tags.InvalidInvoice:
+          {
+            ordinalConverter.write(5, into);
+            const inner = value.inner;
+            FfiConverterString.write(inner.errorMessage, into);
+            return;
+          }
+        case BarkError_Tags.InvalidPsbt:
+          {
+            ordinalConverter.write(6, into);
+            const inner = value.inner;
+            FfiConverterString.write(inner.errorMessage, into);
+            return;
+          }
+        case BarkError_Tags.InvalidTransaction:
+          {
+            ordinalConverter.write(7, into);
+            const inner = value.inner;
+            FfiConverterString.write(inner.errorMessage, into);
+            return;
+          }
+        case BarkError_Tags.InsufficientFunds:
+          {
+            ordinalConverter.write(8, into);
+            const inner = value.inner;
+            FfiConverterString.write(inner.errorMessage, into);
+            return;
+          }
+        case BarkError_Tags.NotFound:
+          {
+            ordinalConverter.write(9, into);
+            const inner = value.inner;
+            FfiConverterString.write(inner.errorMessage, into);
+            return;
+          }
+        case BarkError_Tags.ServerConnection:
+          {
+            ordinalConverter.write(10, into);
+            const inner = value.inner;
+            FfiConverterString.write(inner.errorMessage, into);
+            return;
+          }
+        case BarkError_Tags.Internal:
+          {
+            ordinalConverter.write(11, into);
+            const inner = value.inner;
+            FfiConverterString.write(inner.errorMessage, into);
+            return;
+          }
+        case BarkError_Tags.OnchainWalletRequired:
+          {
+            ordinalConverter.write(12, into);
+            const inner = value.inner;
+            FfiConverterString.write(inner.errorMessage, into);
+            return;
+          }
+        default:
+          // Throwing from here means that BarkError_Tags hasn't matched an ordinal.
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    allocationSize(value) {
+      switch (value.tag) {
+        case BarkError_Tags.Network:
+          {
+            const inner = value.inner;
+            let size = ordinalConverter.allocationSize(1);
+            size += FfiConverterString.allocationSize(inner.errorMessage);
+            return size;
+          }
+        case BarkError_Tags.Database:
+          {
+            const inner = value.inner;
+            let size = ordinalConverter.allocationSize(2);
+            size += FfiConverterString.allocationSize(inner.errorMessage);
+            return size;
+          }
+        case BarkError_Tags.InvalidMnemonic:
+          {
+            const inner = value.inner;
+            let size = ordinalConverter.allocationSize(3);
+            size += FfiConverterString.allocationSize(inner.errorMessage);
+            return size;
+          }
+        case BarkError_Tags.InvalidAddress:
+          {
+            const inner = value.inner;
+            let size = ordinalConverter.allocationSize(4);
+            size += FfiConverterString.allocationSize(inner.errorMessage);
+            return size;
+          }
+        case BarkError_Tags.InvalidInvoice:
+          {
+            const inner = value.inner;
+            let size = ordinalConverter.allocationSize(5);
+            size += FfiConverterString.allocationSize(inner.errorMessage);
+            return size;
+          }
+        case BarkError_Tags.InvalidPsbt:
+          {
+            const inner = value.inner;
+            let size = ordinalConverter.allocationSize(6);
+            size += FfiConverterString.allocationSize(inner.errorMessage);
+            return size;
+          }
+        case BarkError_Tags.InvalidTransaction:
+          {
+            const inner = value.inner;
+            let size = ordinalConverter.allocationSize(7);
+            size += FfiConverterString.allocationSize(inner.errorMessage);
+            return size;
+          }
+        case BarkError_Tags.InsufficientFunds:
+          {
+            const inner = value.inner;
+            let size = ordinalConverter.allocationSize(8);
+            size += FfiConverterString.allocationSize(inner.errorMessage);
+            return size;
+          }
+        case BarkError_Tags.NotFound:
+          {
+            const inner = value.inner;
+            let size = ordinalConverter.allocationSize(9);
+            size += FfiConverterString.allocationSize(inner.errorMessage);
+            return size;
+          }
+        case BarkError_Tags.ServerConnection:
+          {
+            const inner = value.inner;
+            let size = ordinalConverter.allocationSize(10);
+            size += FfiConverterString.allocationSize(inner.errorMessage);
+            return size;
+          }
+        case BarkError_Tags.Internal:
+          {
+            const inner = value.inner;
+            let size = ordinalConverter.allocationSize(11);
+            size += FfiConverterString.allocationSize(inner.errorMessage);
+            return size;
+          }
+        case BarkError_Tags.OnchainWalletRequired:
+          {
+            const inner = value.inner;
+            let size = ordinalConverter.allocationSize(12);
+            size += FfiConverterString.allocationSize(inner.errorMessage);
+            return size;
+          }
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * Bitcoin network types
+ */
+export let Network = /*#__PURE__*/function (Network) {
+  Network[Network["Bitcoin"] = 0] = "Bitcoin";
+  Network[Network["Testnet"] = 1] = "Testnet";
+  Network[Network["Signet"] = 2] = "Signet";
+  Network[Network["Regtest"] = 3] = "Regtest";
+  return Network;
+}({});
+const FfiConverterTypeNetwork = (() => {
+  const ordinalConverter = FfiConverterInt32;
+  class FFIConverter extends AbstractFfiConverterByteArray {
+    read(from) {
+      switch (ordinalConverter.read(from)) {
+        case 1:
+          return Network.Bitcoin;
+        case 2:
+          return Network.Testnet;
+        case 3:
+          return Network.Signet;
+        case 4:
+          return Network.Regtest;
+        default:
+          throw new UniffiInternalError.UnexpectedEnumCase();
+      }
+    }
+    write(value, into) {
+      switch (value) {
+        case Network.Bitcoin:
+          return ordinalConverter.write(1, into);
+        case Network.Testnet:
+          return ordinalConverter.write(2, into);
+        case Network.Signet:
+          return ordinalConverter.write(3, into);
+        case Network.Regtest:
+          return ordinalConverter.write(4, into);
+      }
+    }
+    allocationSize(value) {
+      return ordinalConverter.allocationSize(0);
+    }
+  }
+  return new FFIConverter();
+})();
+
+/**
+ * Onchain Bitcoin wallet for boarding and exits
+ *
+ * Supports two implementations:
+ * - Default: BDK-based wallet (built-in)
+ * - Custom: Your own wallet implementation via callbacks
+ */
+
+/**
+ * Onchain Bitcoin wallet for boarding and exits
+ *
+ * Supports two implementations:
+ * - Default: BDK-based wallet (built-in)
+ * - Custom: Your own wallet implementation via callbacks
+ */
+export class OnchainWallet extends UniffiAbstractObject {
+  [uniffiTypeNameSymbol] = "OnchainWallet";
+  // No primary constructor declared for this class.
+  constructor(pointer) {
+    super();
+    this[pointerLiteralSymbol] = pointer;
+    this[destructorGuardSymbol] = uniffiTypeOnchainWalletObjectFactory.bless(pointer);
+  }
+
+  /**
+   * Create an onchain wallet using a custom implementation
+   *
+   * Use this when you have an existing wallet implementation in your language
+   * (Dart/Swift/Kotlin) and want to integrate it with Bark for boarding and exits.
+   * Your implementation must handle all wallet operations via the callbacks interface.
+   */
+  static custom(callbacks) /*throws*/{
+    return FfiConverterTypeOnchainWallet.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_constructor_onchainwallet_custom(FfiConverterTypeCustomOnchainWalletCallbacks.lower(callbacks), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+
+  /**
+   * Create or load an onchain wallet using a default BDK implementation shipped with Bark
+   *
+   * The wallet uses BDK for onchain operations
+   * and the same chain source configuration as the Bark wallet (esplora_address or bitcoind_*).
+   */
+  static default_(mnemonic, config, datadir) /*throws*/{
+    return FfiConverterTypeOnchainWallet.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_constructor_onchainwallet_default(FfiConverterString.lower(mnemonic), FfiConverterTypeConfig.lower(config), FfiConverterString.lower(datadir), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+
+  /**
+   * Get the onchain wallet balance
+   */
+  balance() /*throws*/{
+    return FfiConverterTypeOnchainBalance.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_method_onchainwallet_balance(uniffiTypeOnchainWalletObjectFactory.clonePointer(this), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+
+  /**
+   * Generate a new Bitcoin address
+   */
+  newAddress() /*throws*/{
+    return FfiConverterString.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_method_onchainwallet_new_address(uniffiTypeOnchainWalletObjectFactory.clonePointer(this), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+
+  /**
+   * Send Bitcoin to an address
+   * Returns the transaction ID
+   */
+  send(address, amountSats, feeRateSatPerVb) /*throws*/{
+    return FfiConverterString.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_method_onchainwallet_send(uniffiTypeOnchainWalletObjectFactory.clonePointer(this), FfiConverterString.lower(address), FfiConverterUInt64.lower(amountSats), FfiConverterUInt64.lower(feeRateSatPerVb), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+
+  /**
+   * Sync the onchain wallet with the blockchain
+   * Returns the amount synced in satoshis
+   */
+  sync() /*throws*/{
+    return FfiConverterUInt64.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_method_onchainwallet_sync(uniffiTypeOnchainWalletObjectFactory.clonePointer(this), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+
+  /**
+   * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
+   */
+  uniffiDestroy() {
+    const ptr = this[destructorGuardSymbol];
+    if (ptr !== undefined) {
+      const pointer = uniffiTypeOnchainWalletObjectFactory.pointer(this);
+      uniffiTypeOnchainWalletObjectFactory.freePointer(pointer);
+      uniffiTypeOnchainWalletObjectFactory.unbless(ptr);
+      delete this[destructorGuardSymbol];
+    }
+  }
+  static instanceOf(obj) {
+    return uniffiTypeOnchainWalletObjectFactory.isConcreteType(obj);
+  }
+}
+const uniffiTypeOnchainWalletObjectFactory = (() => {
+  return {
+    create(pointer) {
+      const instance = Object.create(OnchainWallet.prototype);
+      instance[pointerLiteralSymbol] = pointer;
+      instance[destructorGuardSymbol] = this.bless(pointer);
+      instance[uniffiTypeNameSymbol] = "OnchainWallet";
+      return instance;
+    },
+    bless(p) {
+      return uniffiCaller.rustCall(/*caller:*/status => nativeModule().ubrn_uniffi_internal_fn_method_onchainwallet_ffi__bless_pointer(p, status), /*liftString:*/FfiConverterString.lift);
+    },
+    unbless(ptr) {
+      ptr.markDestroyed();
+    },
+    pointer(obj) {
+      if (obj[destructorGuardSymbol] === undefined) {
+        throw new UniffiInternalError.UnexpectedNullPointer();
+      }
+      return obj[pointerLiteralSymbol];
+    },
+    clonePointer(obj) {
+      const pointer = this.pointer(obj);
+      return uniffiCaller.rustCall(/*caller:*/callStatus => nativeModule().ubrn_uniffi_bark_ffi_fn_clone_onchainwallet(pointer, callStatus), /*liftString:*/FfiConverterString.lift);
+    },
+    freePointer(pointer) {
+      uniffiCaller.rustCall(/*caller:*/callStatus => nativeModule().ubrn_uniffi_bark_ffi_fn_free_onchainwallet(pointer, callStatus), /*liftString:*/FfiConverterString.lift);
+    },
+    isConcreteType(obj) {
+      return obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === "OnchainWallet";
+    }
+  };
+})();
+// FfiConverter for OnchainWalletInterface
+const FfiConverterTypeOnchainWallet = new FfiConverterObject(uniffiTypeOnchainWalletObjectFactory);
+
+/**
+ * The main Bark wallet interface for Ark operations
+ */
+
+/**
+ * The main Bark wallet interface for Ark operations
+ */
+export class Wallet extends UniffiAbstractObject {
+  [uniffiTypeNameSymbol] = "Wallet";
+  // No primary constructor declared for this class.
+  constructor(pointer) {
+    super();
+    this[pointerLiteralSymbol] = pointer;
+    this[destructorGuardSymbol] = uniffiTypeWalletObjectFactory.bless(pointer);
+  }
+
+  /**
+   * Create a new Bark wallet
+   */
+  static create(mnemonic, config, datadir, forceRescan) /*throws*/{
+    return FfiConverterTypeWallet.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_constructor_wallet_create(FfiConverterString.lower(mnemonic), FfiConverterTypeConfig.lower(config), FfiConverterString.lower(datadir), FfiConverterBool.lower(forceRescan), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+
+  /**
+   * Create a new Bark wallet WITH onchain capabilities
+   */
+  static createWithOnchain(mnemonic, config, datadir, onchainWallet, forceRescan) /*throws*/{
+    return FfiConverterTypeWallet.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_constructor_wallet_create_with_onchain(FfiConverterString.lower(mnemonic), FfiConverterTypeConfig.lower(config), FfiConverterString.lower(datadir), FfiConverterTypeOnchainWallet.lower(onchainWallet), FfiConverterBool.lower(forceRescan), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+
+  /**
+   * Open an existing Bark wallet
+   */
+  static open(mnemonic, config, datadir) /*throws*/{
+    return FfiConverterTypeWallet.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_constructor_wallet_open(FfiConverterString.lower(mnemonic), FfiConverterTypeConfig.lower(config), FfiConverterString.lower(datadir), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+
+  /**
+   * Open an existing Bark wallet WITH onchain capabilities
+   */
+  static openWithOnchain(mnemonic, config, datadir, onchainWallet) /*throws*/{
+    return FfiConverterTypeWallet.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_constructor_wallet_open_with_onchain(FfiConverterString.lower(mnemonic), FfiConverterTypeConfig.lower(config), FfiConverterString.lower(datadir), FfiConverterTypeOnchainWallet.lower(onchainWallet), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+
+  /**
+   * Get earliest block height when all exits will be claimable
+   *
+   * Returns null if no exits or any exit has undetermined claimability.
+   */
+  allExitsClaimableAtHeight() /*throws*/{
+    return FfiConverterOptionalUInt32.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_all_exits_claimable_at_height(uniffiTypeWalletObjectFactory.clonePointer(this), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+
+  /**
+   * Get all VTXOs (including spent)
+   */
+  allVtxos() /*throws*/{
+    return FfiConverterArrayTypeVtxo.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_all_vtxos(uniffiTypeWalletObjectFactory.clonePointer(this), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+
+  /**
+   * Get Ark server info (null if not connected)
+   */
+  arkInfo() {
+    return FfiConverterOptionalTypeArkInfo.lift(uniffiCaller.rustCall(/*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_ark_info(uniffiTypeWalletObjectFactory.clonePointer(this), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+  balance() /*throws*/{
+    return FfiConverterTypeBalance.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_balance(uniffiTypeWalletObjectFactory.clonePointer(this), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+
+  /**
+   * Board all funds from onchain wallet into Ark
+   */
+  boardAll(onchainWallet) /*throws*/{
+    return FfiConverterTypePendingBoard.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_board_all(uniffiTypeWalletObjectFactory.clonePointer(this), FfiConverterTypeOnchainWallet.lower(onchainWallet), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+
+  /**
+   * Board a specific amount from onchain wallet into Ark
+   */
+  boardAmount(onchainWallet, amountSats) /*throws*/{
+    return FfiConverterTypePendingBoard.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_board_amount(uniffiTypeWalletObjectFactory.clonePointer(this), FfiConverterTypeOnchainWallet.lower(onchainWallet), FfiConverterUInt64.lower(amountSats), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+  bolt11Invoice(amountSats) /*throws*/{
+    return FfiConverterTypeLightningInvoice.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_bolt11_invoice(uniffiTypeWalletObjectFactory.clonePointer(this), FfiConverterUInt64.lower(amountSats), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+
+  /**
+   * Broadcast a signed transaction to the Bitcoin network
+   *
+   * Takes a hex-encoded transaction and broadcasts it via the wallet's chain source.
+   * This is useful after extracting a transaction from a PSBT using extract_tx_from_psbt.
+   *
+   * # Arguments
+   *
+   * * `tx_hex` - Hex-encoded signed transaction
+   *
+   * Returns the transaction ID (txid) of the broadcasted transaction
+   */
+  broadcastTx(txHex) /*throws*/{
+    return FfiConverterString.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_broadcast_tx(uniffiTypeWalletObjectFactory.clonePointer(this), FfiConverterString.lower(txHex), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+
+  /**
+   * Cancel all pending rounds
+   */
+  cancelAllPendingRounds() /*throws*/{
+    uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_cancel_all_pending_rounds(uniffiTypeWalletObjectFactory.clonePointer(this), callStatus);
+    }, /*liftString:*/FfiConverterString.lift);
+  }
+
+  /**
+   * Cancel a specific pending round
+   */
+  cancelPendingRound(roundId) /*throws*/{
+    uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_cancel_pending_round(uniffiTypeWalletObjectFactory.clonePointer(this), FfiConverterUInt32.lower(roundId), callStatus);
+    }, /*liftString:*/FfiConverterString.lift);
+  }
+
+  /**
+   * Check lightning payment status by payment hash
+   *
+   * # Arguments
+   *
+   * * `payment_hash` - Payment hash as hex string
+   * * `wait` - Whether to wait for the payment to complete
+   *
+   * Returns the preimage if payment is successful, null if still pending
+   */
+  checkLightningPayment(paymentHash, wait) /*throws*/{
+    return FfiConverterOptionalString.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_check_lightning_payment(uniffiTypeWalletObjectFactory.clonePointer(this), FfiConverterString.lower(paymentHash), FfiConverterBool.lower(wait), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+
+  /**
+   * Get claimable lightning receive balance
+   */
+  claimableLightningReceiveBalanceSats() /*throws*/{
+    return FfiConverterUInt64.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_claimable_lightning_receive_balance_sats(uniffiTypeWalletObjectFactory.clonePointer(this), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+
+  /**
+   * Get wallet config
+   */
+  config() {
+    return FfiConverterTypeConfig.lift(uniffiCaller.rustCall(/*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_config(uniffiTypeWalletObjectFactory.clonePointer(this), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+
+  /**
+   * Drain claimable exits to an address
+   *
+   * Builds a signed PSBT that claims exited funds and sends them to the address.
+   * The PSBT can be broadcast directly or modified before broadcasting.
+   *
+   * # Arguments
+   *
+   * * `vtxo_ids` - List of claimable VTXO IDs to drain (empty = drain all)
+   * * `address` - Bitcoin address to send claimed funds to
+   * * `fee_rate_sat_per_vb` - Optional fee rate override in sats/vB
+   */
+  drainExits(vtxoIds, address, feeRateSatPerVb) /*throws*/{
+    return FfiConverterTypeExitClaimTransaction.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_drain_exits(uniffiTypeWalletObjectFactory.clonePointer(this), FfiConverterArrayString.lower(vtxoIds), FfiConverterString.lower(address), FfiConverterOptionalUInt64.lower(feeRateSatPerVb), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+
+  /**
+   * Get detailed exit status for a specific VTXO
+   *
+   * Returns detailed status including current state, history, and transactions.
+   *
+   * # Arguments
+   *
+   * * `vtxo_id` - The VTXO ID to check
+   * * `include_history` - Whether to include full state machine history
+   * * `include_transactions` - Whether to include transaction details
+   */
+  getExitStatus(vtxoId, includeHistory, includeTransactions) /*throws*/{
+    return FfiConverterOptionalTypeExitTransactionStatus.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_get_exit_status(uniffiTypeWalletObjectFactory.clonePointer(this), FfiConverterString.lower(vtxoId), FfiConverterBool.lower(includeHistory), FfiConverterBool.lower(includeTransactions), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+
+  /**
+   * Get all VTXOs currently in exit process
+   */
+  getExitVtxos() /*throws*/{
+    return FfiConverterArrayTypeExitVtxo.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_get_exit_vtxos(uniffiTypeWalletObjectFactory.clonePointer(this), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+
+  /**
+   * Get VTXOs expiring within threshold blocks
+   */
+  getExpiringVtxos(thresholdBlocks) /*throws*/{
+    return FfiConverterArrayTypeVtxo.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_get_expiring_vtxos(uniffiTypeWalletObjectFactory.clonePointer(this), FfiConverterUInt32.lower(thresholdBlocks), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+
+  /**
+   * Get the block height of the first expiring VTXO
+   *
+   * Returns null if there are no spendable VTXOs.
+   */
+  getFirstExpiringVtxoBlockheight() /*throws*/{
+    return FfiConverterOptionalUInt32.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_get_first_expiring_vtxo_blockheight(uniffiTypeWalletObjectFactory.clonePointer(this), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+
+  /**
+   * Get the next block height when a refresh should be performed
+   *
+   * This is calculated as the first expiring VTXO height minus the refresh threshold.
+   * Returns null if there are no VTXOs to refresh.
+   */
+  getNextRequiredRefreshBlockheight() /*throws*/{
+    return FfiConverterOptionalUInt32.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_get_next_required_refresh_blockheight(uniffiTypeWalletObjectFactory.clonePointer(this), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+
+  /**
+   * Get a specific VTXO by ID
+   */
+  getVtxoById(vtxoId) /*throws*/{
+    return FfiConverterTypeVtxo.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_get_vtxo_by_id(uniffiTypeWalletObjectFactory.clonePointer(this), FfiConverterString.lower(vtxoId), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+
+  /**
+   * Get VTXOs that should be refreshed
+   */
+  getVtxosToRefresh() /*throws*/{
+    return FfiConverterArrayTypeVtxo.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_get_vtxos_to_refresh(uniffiTypeWalletObjectFactory.clonePointer(this), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+
+  /**
+   * Check if any exits are pending
+   */
+  hasPendingExits() /*throws*/{
+    return FfiConverterBool.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_has_pending_exits(uniffiTypeWalletObjectFactory.clonePointer(this), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+
+  /**
+   * Get all wallet movements (transaction history)
+   */
+  history() /*throws*/{
+    return FfiConverterArrayTypeMovement.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_history(uniffiTypeWalletObjectFactory.clonePointer(this), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+
+  /**
+   * Get lightning receive status by payment hash
+   *
+   * # Arguments
+   *
+   * * `payment_hash` - Payment hash as hex string
+   */
+  lightningReceiveStatus(paymentHash) /*throws*/{
+    return FfiConverterOptionalTypeLightningReceive.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_lightning_receive_status(uniffiTypeWalletObjectFactory.clonePointer(this), FfiConverterString.lower(paymentHash), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+
+  /**
+   * List all exits that are claimable
+   *
+   * Returns exits ready to be drained to onchain wallet.
+   */
+  listClaimableExits() /*throws*/{
+    return FfiConverterArrayTypeExitVtxo.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_list_claimable_exits(uniffiTypeWalletObjectFactory.clonePointer(this), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+  maintenance() /*throws*/{
+    uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_maintenance(uniffiTypeWalletObjectFactory.clonePointer(this), callStatus);
+    }, /*liftString:*/FfiConverterString.lift);
+  }
+
+  /**
+   * Perform maintenance refresh
+   */
+  maintenanceRefresh() /*throws*/{
+    return FfiConverterOptionalString.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_maintenance_refresh(uniffiTypeWalletObjectFactory.clonePointer(this), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+
+  /**
+   * Full maintenance including onchain wallet sync
+   *
+   * More thorough than maintenance() - also syncs onchain wallet and exits.
+   */
+  maintenanceWithOnchain(onchainWallet) /*throws*/{
+    uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_maintenance_with_onchain(uniffiTypeWalletObjectFactory.clonePointer(this), FfiConverterTypeOnchainWallet.lower(onchainWallet), callStatus);
+    }, /*liftString:*/FfiConverterString.lift);
+  }
+
+  /**
+   * Schedule a maintenance refresh if VTXOs need refreshing
+   *
+   * Returns the round ID if a refresh was scheduled, null otherwise.
+   */
+  maybeScheduleMaintenanceRefresh() /*throws*/{
+    return FfiConverterOptionalUInt32.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_maybe_schedule_maintenance_refresh(uniffiTypeWalletObjectFactory.clonePointer(this), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+  newAddress() /*throws*/{
+    return FfiConverterString.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_new_address(uniffiTypeWalletObjectFactory.clonePointer(this), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+
+  /**
+   * Generate a new address and return it with its index
+   */
+  newAddressWithIndex() /*throws*/{
+    return FfiConverterTypeAddressWithIndex.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_new_address_with_index(uniffiTypeWalletObjectFactory.clonePointer(this), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+  offboardAll(bitcoinAddress) /*throws*/{
+    return FfiConverterTypeOffboardResult.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_offboard_all(uniffiTypeWalletObjectFactory.clonePointer(this), FfiConverterString.lower(bitcoinAddress), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+
+  /**
+   * Offboard specific VTXOs to a Bitcoin address
+   */
+  offboardVtxos(vtxoIds, bitcoinAddress) /*throws*/{
+    return FfiConverterString.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_offboard_vtxos(uniffiTypeWalletObjectFactory.clonePointer(this), FfiConverterArrayString.lower(vtxoIds), FfiConverterString.lower(bitcoinAddress), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+  payLightningAddress(lightningAddress, amountSats, comment) /*throws*/{
+    return FfiConverterTypeLightningSend.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_pay_lightning_address(uniffiTypeWalletObjectFactory.clonePointer(this), FfiConverterString.lower(lightningAddress), FfiConverterUInt64.lower(amountSats), FfiConverterOptionalString.lower(comment), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+  payLightningInvoice(invoice, amountSats) /*throws*/{
+    return FfiConverterTypeLightningSend.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_pay_lightning_invoice(uniffiTypeWalletObjectFactory.clonePointer(this), FfiConverterString.lower(invoice), FfiConverterOptionalUInt64.lower(amountSats), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+
+  /**
+   * Pay a BOLT12 lightning offer
+   *
+   * # Arguments
+   *
+   * * `offer` - BOLT12 offer string
+   * * `amount_sats` - Optional amount in sats (required if offer doesn't specify amount)
+   */
+  payLightningOffer(offer, amountSats) /*throws*/{
+    return FfiConverterTypeLightningSend.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_pay_lightning_offer(uniffiTypeWalletObjectFactory.clonePointer(this), FfiConverterString.lower(offer), FfiConverterOptionalUInt64.lower(amountSats), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+
+  /**
+   * Peek at an address at a specific index
+   */
+  peakAddress(index) /*throws*/{
+    return FfiConverterString.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_peak_address(uniffiTypeWalletObjectFactory.clonePointer(this), FfiConverterUInt32.lower(index), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+
+  /**
+   * Get total amount in pending exits (sats)
+   */
+  pendingExitsTotalSats() /*throws*/{
+    return FfiConverterUInt64.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_pending_exits_total_sats(uniffiTypeWalletObjectFactory.clonePointer(this), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+
+  /**
+   * Get all pending lightning receives
+   */
+  pendingLightningReceives() /*throws*/{
+    return FfiConverterArrayTypeLightningReceive.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_pending_lightning_receives(uniffiTypeWalletObjectFactory.clonePointer(this), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+
+  /**
+   * Get all pending lightning sends
+   */
+  pendingLightningSends() /*throws*/{
+    return FfiConverterArrayTypeLightningSend.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_pending_lightning_sends(uniffiTypeWalletObjectFactory.clonePointer(this), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+
+  /**
+   * Get all pending round states
+   */
+  pendingRoundStates() /*throws*/{
+    return FfiConverterArrayTypeRoundState.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_pending_round_states(uniffiTypeWalletObjectFactory.clonePointer(this), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+
+  /**
+   * Progress unilateral exits (broadcast, fee bump, advance state machine)
+   *
+   * This is the critical method for actually moving exits forward.
+   * Call periodically after starting exits.
+   *
+   * # Arguments
+   *
+   * * `onchain_wallet` - Onchain wallet for building exit transactions
+   * * `fee_rate_sat_per_vb` - Optional fee rate override in sats/vB
+   */
+  progressExits(onchainWallet, feeRateSatPerVb) /*throws*/{
+    return FfiConverterArrayTypeExitProgressStatus.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_progress_exits(uniffiTypeWalletObjectFactory.clonePointer(this), FfiConverterTypeOnchainWallet.lower(onchainWallet), FfiConverterOptionalUInt64.lower(feeRateSatPerVb), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+
+  /**
+   * Progress pending rounds
+   *
+   * Advances the state of all pending rounds. Call periodically.
+   */
+  progressPendingRounds() /*throws*/{
+    uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_progress_pending_rounds(uniffiTypeWalletObjectFactory.clonePointer(this), callStatus);
+    }, /*liftString:*/FfiConverterString.lift);
+  }
+  properties() /*throws*/{
+    return FfiConverterTypeWalletProperties.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_properties(uniffiTypeWalletObjectFactory.clonePointer(this), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+
+  /**
+   * Refresh the Ark server connection
+   *
+   * Re-establishes connection if it was lost.
+   */
+  refreshServer() /*throws*/{
+    uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_refresh_server(uniffiTypeWalletObjectFactory.clonePointer(this), callStatus);
+    }, /*liftString:*/FfiConverterString.lift);
+  }
+
+  /**
+   * Refresh specific VTXOs
+   */
+  refreshVtxos(vtxoIds) /*throws*/{
+    return FfiConverterOptionalString.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_refresh_vtxos(uniffiTypeWalletObjectFactory.clonePointer(this), FfiConverterArrayString.lower(vtxoIds), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+  sendArkoorPayment(arkAddress, amountSats) /*throws*/{
+    return FfiConverterString.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_send_arkoor_payment(uniffiTypeWalletObjectFactory.clonePointer(this), FfiConverterString.lower(arkAddress), FfiConverterUInt64.lower(amountSats), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+
+  /**
+   * Send an onchain payment during a round
+   */
+  sendRoundOnchainPayment(address, amountSats) /*throws*/{
+    return FfiConverterString.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_send_round_onchain_payment(uniffiTypeWalletObjectFactory.clonePointer(this), FfiConverterString.lower(address), FfiConverterUInt64.lower(amountSats), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+
+  /**
+   * Sign exit claim inputs in an external PSBT
+   *
+   * This is useful if you want to combine exit claims with other inputs
+   * in a single transaction.
+   *
+   * # Arguments
+   *
+   * * `psbt_base64` - Base64-encoded PSBT to sign
+   *
+   * Returns the signed PSBT
+   */
+  signExitClaimInputs(psbtBase64) /*throws*/{
+    return FfiConverterString.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_sign_exit_claim_inputs(uniffiTypeWalletObjectFactory.clonePointer(this), FfiConverterString.lower(psbtBase64), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+
+  /**
+   * Get all spendable VTXOs
+   */
+  spendableVtxos() /*throws*/{
+    return FfiConverterArrayTypeVtxo.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_spendable_vtxos(uniffiTypeWalletObjectFactory.clonePointer(this), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+
+  /**
+   * Start unilateral exit for the entire wallet
+   */
+  startExitForEntireWallet() /*throws*/{
+    uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_start_exit_for_entire_wallet(uniffiTypeWalletObjectFactory.clonePointer(this), callStatus);
+    }, /*liftString:*/FfiConverterString.lift);
+  }
+
+  /**
+   * Start unilateral exit for specific VTXOs
+   *
+   * Marks specific VTXOs for exit. Call progress_exits() to actually advance them.
+   */
+  startExitForVtxos(vtxoIds) /*throws*/{
+    uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_start_exit_for_vtxos(uniffiTypeWalletObjectFactory.clonePointer(this), FfiConverterArrayString.lower(vtxoIds), callStatus);
+    }, /*liftString:*/FfiConverterString.lift);
+  }
+
+  /**
+   * Lightweight sync with Ark server and blockchain
+   * Note: Bark's sync() handles errors internally with logging.
+   * The Throws annotation is for forward compatibility only.
+   */
+  sync() /*throws*/{
+    uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_sync(uniffiTypeWalletObjectFactory.clonePointer(this), callStatus);
+    }, /*liftString:*/FfiConverterString.lift);
+  }
+
+  /**
+   * Sync exit state (checks status but doesn't progress)
+   */
+  syncExits(onchainWallet) /*throws*/{
+    uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_sync_exits(uniffiTypeWalletObjectFactory.clonePointer(this), FfiConverterTypeOnchainWallet.lower(onchainWallet), callStatus);
+    }, /*liftString:*/FfiConverterString.lift);
+  }
+
+  /**
+   * Sync pending board transactions
+   */
+  syncPendingBoards() /*throws*/{
+    uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_sync_pending_boards(uniffiTypeWalletObjectFactory.clonePointer(this), callStatus);
+    }, /*liftString:*/FfiConverterString.lift);
+  }
+  tryClaimAllLightningReceives(wait) /*throws*/{
+    uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_try_claim_all_lightning_receives(uniffiTypeWalletObjectFactory.clonePointer(this), FfiConverterBool.lower(wait), callStatus);
+    }, /*liftString:*/FfiConverterString.lift);
+  }
+
+  /**
+   * Try to claim a specific lightning receive by payment hash
+   *
+   * # Arguments
+   *
+   * * `payment_hash` - Payment hash as hex string
+   * * `wait` - Whether to wait for claim to complete
+   */
+  tryClaimLightningReceive(paymentHash, wait) /*throws*/{
+    uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_try_claim_lightning_receive(uniffiTypeWalletObjectFactory.clonePointer(this), FfiConverterString.lower(paymentHash), FfiConverterBool.lower(wait), callStatus);
+    }, /*liftString:*/FfiConverterString.lift);
+  }
+
+  /**
+   * Validate an Ark address against the connected server
+   *
+   * This performs full validation including checking if the address
+   * belongs to the currently connected Ark server.
+   * For basic format validation only, use validate_ark_address() instead.
+   */
+  validateArkoorAddress(address) /*throws*/{
+    return FfiConverterBool.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_validate_arkoor_address(uniffiTypeWalletObjectFactory.clonePointer(this), FfiConverterString.lower(address), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+  vtxos() /*throws*/{
+    return FfiConverterArrayTypeVtxo.lift(uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeBarkError.lift.bind(FfiConverterTypeBarkError), /*caller:*/callStatus => {
+      return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_vtxos(uniffiTypeWalletObjectFactory.clonePointer(this), callStatus);
+    }, /*liftString:*/FfiConverterString.lift));
+  }
+
+  /**
+   * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
+   */
+  uniffiDestroy() {
+    const ptr = this[destructorGuardSymbol];
+    if (ptr !== undefined) {
+      const pointer = uniffiTypeWalletObjectFactory.pointer(this);
+      uniffiTypeWalletObjectFactory.freePointer(pointer);
+      uniffiTypeWalletObjectFactory.unbless(ptr);
+      delete this[destructorGuardSymbol];
+    }
+  }
+  static instanceOf(obj) {
+    return uniffiTypeWalletObjectFactory.isConcreteType(obj);
+  }
+}
+const uniffiTypeWalletObjectFactory = (() => {
+  return {
+    create(pointer) {
+      const instance = Object.create(Wallet.prototype);
+      instance[pointerLiteralSymbol] = pointer;
+      instance[destructorGuardSymbol] = this.bless(pointer);
+      instance[uniffiTypeNameSymbol] = "Wallet";
+      return instance;
+    },
+    bless(p) {
+      return uniffiCaller.rustCall(/*caller:*/status => nativeModule().ubrn_uniffi_internal_fn_method_wallet_ffi__bless_pointer(p, status), /*liftString:*/FfiConverterString.lift);
+    },
+    unbless(ptr) {
+      ptr.markDestroyed();
+    },
+    pointer(obj) {
+      if (obj[destructorGuardSymbol] === undefined) {
+        throw new UniffiInternalError.UnexpectedNullPointer();
+      }
+      return obj[pointerLiteralSymbol];
+    },
+    clonePointer(obj) {
+      const pointer = this.pointer(obj);
+      return uniffiCaller.rustCall(/*caller:*/callStatus => nativeModule().ubrn_uniffi_bark_ffi_fn_clone_wallet(pointer, callStatus), /*liftString:*/FfiConverterString.lift);
+    },
+    freePointer(pointer) {
+      uniffiCaller.rustCall(/*caller:*/callStatus => nativeModule().ubrn_uniffi_bark_ffi_fn_free_wallet(pointer, callStatus), /*liftString:*/FfiConverterString.lift);
+    },
+    isConcreteType(obj) {
+      return obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === "Wallet";
+    }
+  };
+})();
+// FfiConverter for WalletInterface
+const FfiConverterTypeWallet = new FfiConverterObject(uniffiTypeWalletObjectFactory);
+
+// FfiConverter for ArkInfo | undefined
+const FfiConverterOptionalTypeArkInfo = new FfiConverterOptional(FfiConverterTypeArkInfo);
+
+// FfiConverter for BlockRef | undefined
+const FfiConverterOptionalTypeBlockRef = new FfiConverterOptional(FfiConverterTypeBlockRef);
+
+// FfiConverter for ExitTransactionStatus | undefined
+const FfiConverterOptionalTypeExitTransactionStatus = new FfiConverterOptional(FfiConverterTypeExitTransactionStatus);
+
+// FfiConverter for LightningReceive | undefined
+const FfiConverterOptionalTypeLightningReceive = new FfiConverterOptional(FfiConverterTypeLightningReceive);
+
+// FfiConverter for string | undefined
+const FfiConverterOptionalString = new FfiConverterOptional(FfiConverterString);
+
+// FfiConverter for /*u16*/number | undefined
+const FfiConverterOptionalUInt16 = new FfiConverterOptional(FfiConverterUInt16);
+
+// FfiConverter for /*u32*/number | undefined
+const FfiConverterOptionalUInt32 = new FfiConverterOptional(FfiConverterUInt32);
+
+// FfiConverter for /*u64*/bigint | undefined
+const FfiConverterOptionalUInt64 = new FfiConverterOptional(FfiConverterUInt64);
+
+// FfiConverter for Array<Destination>
+const FfiConverterArrayTypeDestination = new FfiConverterArray(FfiConverterTypeDestination);
+
+// FfiConverter for Array<ExitProgressStatus>
+const FfiConverterArrayTypeExitProgressStatus = new FfiConverterArray(FfiConverterTypeExitProgressStatus);
+
+// FfiConverter for Array<ExitVtxo>
+const FfiConverterArrayTypeExitVtxo = new FfiConverterArray(FfiConverterTypeExitVtxo);
+
+// FfiConverter for Array<LightningReceive>
+const FfiConverterArrayTypeLightningReceive = new FfiConverterArray(FfiConverterTypeLightningReceive);
+
+// FfiConverter for Array<LightningSend>
+const FfiConverterArrayTypeLightningSend = new FfiConverterArray(FfiConverterTypeLightningSend);
+
+// FfiConverter for Array<Movement>
+const FfiConverterArrayTypeMovement = new FfiConverterArray(FfiConverterTypeMovement);
+
+// FfiConverter for Array<RoundState>
+const FfiConverterArrayTypeRoundState = new FfiConverterArray(FfiConverterTypeRoundState);
+
+// FfiConverter for Array<Vtxo>
+const FfiConverterArrayTypeVtxo = new FfiConverterArray(FfiConverterTypeVtxo);
+
+// FfiConverter for Array<string>
+const FfiConverterArrayString = new FfiConverterArray(FfiConverterString);
+
+// FfiConverter for Array<string> | undefined
+const FfiConverterOptionalArrayString = new FfiConverterOptional(FfiConverterArrayString);
+
+/**
+ * This should be called before anything else.
+ *
+ * It is likely that this is being done for you by the library's `index.ts`.
+ *
+ * It checks versions of uniffi between when the Rust scaffolding was generated
+ * and when the bindings were generated.
+ *
+ * It also initializes the machinery to enable Rust to talk back to Javascript.
+ */
+function uniffiEnsureInitialized() {
+  // Get the bindings contract version from our ComponentInterface
+  const bindingsContractVersion = 29;
+  // Get the scaffolding contract version by calling the into the dylib
+  const scaffoldingContractVersion = nativeModule().ubrn_ffi_bark_ffi_uniffi_contract_version();
+  if (bindingsContractVersion !== scaffoldingContractVersion) {
+    throw new UniffiInternalError.ContractVersionMismatch(scaffoldingContractVersion, bindingsContractVersion);
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_func_extract_tx_from_psbt() !== 6799) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_func_extract_tx_from_psbt");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_func_generate_mnemonic() !== 49933) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_func_generate_mnemonic");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_func_validate_ark_address() !== 49932) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_func_validate_ark_address");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_func_validate_mnemonic() !== 2707) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_func_validate_mnemonic");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_onchainwallet_balance() !== 43979) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_onchainwallet_balance");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_onchainwallet_new_address() !== 25417) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_onchainwallet_new_address");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_onchainwallet_send() !== 10499) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_onchainwallet_send");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_onchainwallet_sync() !== 16855) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_onchainwallet_sync");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_all_exits_claimable_at_height() !== 30496) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_all_exits_claimable_at_height");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_all_vtxos() !== 36339) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_all_vtxos");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_ark_info() !== 6789) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_ark_info");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_balance() !== 50185) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_balance");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_board_all() !== 9249) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_board_all");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_board_amount() !== 6984) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_board_amount");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_bolt11_invoice() !== 50261) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_bolt11_invoice");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_broadcast_tx() !== 14471) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_broadcast_tx");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_cancel_all_pending_rounds() !== 18107) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_cancel_all_pending_rounds");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_cancel_pending_round() !== 4859) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_cancel_pending_round");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_check_lightning_payment() !== 8903) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_check_lightning_payment");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_claimable_lightning_receive_balance_sats() !== 47596) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_claimable_lightning_receive_balance_sats");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_config() !== 63421) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_config");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_drain_exits() !== 63428) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_drain_exits");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_get_exit_status() !== 13877) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_get_exit_status");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_get_exit_vtxos() !== 55034) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_get_exit_vtxos");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_get_expiring_vtxos() !== 151) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_get_expiring_vtxos");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_get_first_expiring_vtxo_blockheight() !== 58234) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_get_first_expiring_vtxo_blockheight");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_get_next_required_refresh_blockheight() !== 59124) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_get_next_required_refresh_blockheight");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_get_vtxo_by_id() !== 45689) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_get_vtxo_by_id");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_get_vtxos_to_refresh() !== 24989) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_get_vtxos_to_refresh");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_has_pending_exits() !== 60454) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_has_pending_exits");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_history() !== 4822) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_history");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_lightning_receive_status() !== 14282) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_lightning_receive_status");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_list_claimable_exits() !== 51047) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_list_claimable_exits");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_maintenance() !== 21349) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_maintenance");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_maintenance_refresh() !== 17108) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_maintenance_refresh");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_maintenance_with_onchain() !== 13241) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_maintenance_with_onchain");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_maybe_schedule_maintenance_refresh() !== 30042) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_maybe_schedule_maintenance_refresh");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_new_address() !== 23909) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_new_address");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_new_address_with_index() !== 42180) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_new_address_with_index");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_offboard_all() !== 9225) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_offboard_all");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_offboard_vtxos() !== 53819) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_offboard_vtxos");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_pay_lightning_address() !== 14966) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_pay_lightning_address");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_pay_lightning_invoice() !== 10704) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_pay_lightning_invoice");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_pay_lightning_offer() !== 32875) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_pay_lightning_offer");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_peak_address() !== 9176) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_peak_address");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_pending_exits_total_sats() !== 50026) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_pending_exits_total_sats");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_pending_lightning_receives() !== 22341) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_pending_lightning_receives");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_pending_lightning_sends() !== 363) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_pending_lightning_sends");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_pending_round_states() !== 20536) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_pending_round_states");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_progress_exits() !== 4371) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_progress_exits");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_progress_pending_rounds() !== 13446) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_progress_pending_rounds");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_properties() !== 49722) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_properties");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_refresh_server() !== 25816) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_refresh_server");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_refresh_vtxos() !== 19664) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_refresh_vtxos");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_send_arkoor_payment() !== 56067) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_send_arkoor_payment");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_send_round_onchain_payment() !== 47652) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_send_round_onchain_payment");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_sign_exit_claim_inputs() !== 19527) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_sign_exit_claim_inputs");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_spendable_vtxos() !== 44569) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_spendable_vtxos");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_start_exit_for_entire_wallet() !== 56070) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_start_exit_for_entire_wallet");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_start_exit_for_vtxos() !== 34429) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_start_exit_for_vtxos");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_sync() !== 44981) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_sync");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_sync_exits() !== 40932) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_sync_exits");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_sync_pending_boards() !== 23775) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_sync_pending_boards");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_try_claim_all_lightning_receives() !== 44879) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_try_claim_all_lightning_receives");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_try_claim_lightning_receive() !== 57107) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_try_claim_lightning_receive");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_validate_arkoor_address() !== 45893) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_validate_arkoor_address");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_vtxos() !== 21445) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_vtxos");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_constructor_onchainwallet_custom() !== 33851) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_constructor_onchainwallet_custom");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_constructor_onchainwallet_default() !== 27781) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_constructor_onchainwallet_default");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_constructor_wallet_create() !== 28953) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_constructor_wallet_create");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_constructor_wallet_create_with_onchain() !== 8743) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_constructor_wallet_create_with_onchain");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_constructor_wallet_open() !== 34910) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_constructor_wallet_open");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_constructor_wallet_open_with_onchain() !== 2455) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_constructor_wallet_open_with_onchain");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_get_balance() !== 59833) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_get_balance");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_prepare_tx() !== 7923) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_prepare_tx");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_prepare_drain_tx() !== 35049) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_prepare_drain_tx");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_finish_tx() !== 13359) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_finish_tx");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_get_wallet_tx() !== 30315) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_get_wallet_tx");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_get_wallet_tx_confirmed_block() !== 45270) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_get_wallet_tx_confirmed_block");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_get_spending_tx() !== 32028) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_get_spending_tx");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_make_signed_p2a_cpfp() !== 48670) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_make_signed_p2a_cpfp");
+  }
+  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_store_signed_p2a_cpfp() !== 57492) {
+    throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_store_signed_p2a_cpfp");
+  }
+  uniffiCallbackInterfaceCustomOnchainWalletCallbacks.register();
+}
+export default Object.freeze({
+  initialize: uniffiEnsureInitialized,
+  converters: {
+    FfiConverterTypeAddressWithIndex,
+    FfiConverterTypeArkInfo,
+    FfiConverterTypeBalance,
+    FfiConverterTypeBarkError,
+    FfiConverterTypeBlockRef,
+    FfiConverterTypeConfig,
+    FfiConverterTypeCpfpParams,
+    FfiConverterTypeDestination,
+    FfiConverterTypeExitClaimTransaction,
+    FfiConverterTypeExitProgressStatus,
+    FfiConverterTypeExitTransactionStatus,
+    FfiConverterTypeExitVtxo,
+    FfiConverterTypeLightningInvoice,
+    FfiConverterTypeLightningReceive,
+    FfiConverterTypeLightningSend,
+    FfiConverterTypeMovement,
+    FfiConverterTypeNetwork,
+    FfiConverterTypeOffboardResult,
+    FfiConverterTypeOnchainBalance,
+    FfiConverterTypeOnchainWallet,
+    FfiConverterTypeOutPoint,
+    FfiConverterTypePendingBoard,
+    FfiConverterTypeRoundState,
+    FfiConverterTypeVtxo,
+    FfiConverterTypeWallet,
+    FfiConverterTypeWalletProperties
+  }
+});
+//# sourceMappingURL=bark.js.map