@secondts/bark-react-native 0.3.3 → 0.4.0

package/src/generated/bark.ts

@@ -546,21 +546,8 @@ export const AddressWithIndex = (() => {
     );
   })();
   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()) as Partial<AddressWithIndex>,
   });
 })();
@@ -627,7 +614,7 @@ export type ArkInfo = {
   /**
    * Maximum amount of a VTXO in sats (null if no limit)
    */
-  maxVtxoAmountSats: /*u64*/ bigint | undefined;
+  maxVtxoAmountSats?: /*u64*/ bigint;
   /**
    * The number of confirmations required to register a board vtxo
    */
@@ -665,21 +652,8 @@ export const ArkInfo = (() => {
     return uniffiCreateRecord<ArkInfo, ReturnType<typeof defaults>>(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()) as Partial<ArkInfo>,
   });
 })();
@@ -787,21 +761,8 @@ export const Balance = (() => {
     return uniffiCreateRecord<Balance, ReturnType<typeof defaults>>(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()) as Partial<Balance>,
   });
 })();
@@ -858,21 +819,8 @@ export const BlockRef = (() => {
     return uniffiCreateRecord<BlockRef, ReturnType<typeof defaults>>(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()) as Partial<BlockRef>,
   });
 })();
@@ -908,26 +856,30 @@ export type Config = {
    * Ark server address
    */
   serverAddress: string;
+  /**
+   * Access token for private Ark servers (sent as `ark-access-token` HTTP header)
+   */
+  serverAccessToken?: string;
   /**
    * Esplora HTTP REST server address
    */
-  esploraAddress: string | undefined;
+  esploraAddress?: string;
   /**
    * Bitcoind RPC server address
    */
-  bitcoindAddress: string | undefined;
+  bitcoindAddress?: string;
   /**
    * Bitcoind RPC cookie file path
    */
-  bitcoindCookiefile: string | undefined;
+  bitcoindCookiefile?: string;
   /**
    * Bitcoind RPC username
    */
-  bitcoindUser: string | undefined;
+  bitcoindUser?: string;
   /**
    * Bitcoind RPC password
    */
-  bitcoindPass: string | undefined;
+  bitcoindPass?: string;
   /**
    * Bitcoin network
    */
@@ -935,31 +887,31 @@ export type Config = {
   /**
    * Number of blocks before expiration to refresh VTXOs
    */
-  vtxoRefreshExpiryThreshold: /*u32*/ number | undefined;
+  vtxoRefreshExpiryThreshold?: /*u32*/ number;
   /**
    * Upper limit of blocks needed to safely exit VTXOs
    */
-  vtxoExitMargin: /*u16*/ number | undefined;
+  vtxoExitMargin?: /*u16*/ number;
   /**
    * Number of blocks to claim a HTLC-recv VTXO
    */
-  htlcRecvClaimDelta: /*u16*/ number | undefined;
+  htlcRecvClaimDelta?: /*u16*/ number;
   /**
    * Fallback fee rate in sat/kWu
    */
-  fallbackFeeRate: /*u64*/ bigint | undefined;
+  fallbackFeeRate?: /*u64*/ bigint;
   /**
    * Confirmations required before considering a round tx fully confirmed
    */
-  roundTxRequiredConfirmations: /*u32*/ number | undefined;
+  roundTxRequiredConfirmations?: /*u32*/ number;
   /**
    * Fast sync interval for daemon tasks (lightning sync) in seconds
    */
-  daemonFastSyncIntervalSecs: /*u64*/ bigint | undefined;
+  daemonFastSyncIntervalSecs?: /*u64*/ bigint;
   /**
    * Slow sync interval for daemon tasks (onchain, exits, boards, etc.) in seconds
    */
-  daemonSlowSyncIntervalSecs: /*u64*/ bigint | undefined;
+  daemonSlowSyncIntervalSecs?: /*u64*/ bigint;
 };
 
 /**
@@ -971,21 +923,8 @@ export const Config = (() => {
     return uniffiCreateRecord<Config, ReturnType<typeof defaults>>(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()) as Partial<Config>,
   });
 })();
@@ -996,6 +935,7 @@ const FfiConverterTypeConfig = (() => {
     read(from: RustBuffer): TypeName {
       return {
         serverAddress: FfiConverterString.read(from),
+        serverAccessToken: FfiConverterOptionalString.read(from),
         esploraAddress: FfiConverterOptionalString.read(from),
         bitcoindAddress: FfiConverterOptionalString.read(from),
         bitcoindCookiefile: FfiConverterOptionalString.read(from),
@@ -1013,6 +953,7 @@ const FfiConverterTypeConfig = (() => {
     }
     write(value: TypeName, into: RustBuffer): void {
       FfiConverterString.write(value.serverAddress, into);
+      FfiConverterOptionalString.write(value.serverAccessToken, into);
       FfiConverterOptionalString.write(value.esploraAddress, into);
       FfiConverterOptionalString.write(value.bitcoindAddress, into);
       FfiConverterOptionalString.write(value.bitcoindCookiefile, into);
@@ -1033,6 +974,7 @@ const FfiConverterTypeConfig = (() => {
     allocationSize(value: TypeName): number {
       return (
         FfiConverterString.allocationSize(value.serverAddress) +
+        FfiConverterOptionalString.allocationSize(value.serverAccessToken) +
         FfiConverterOptionalString.allocationSize(value.esploraAddress) +
         FfiConverterOptionalString.allocationSize(value.bitcoindAddress) +
         FfiConverterOptionalString.allocationSize(value.bitcoindCookiefile) +
@@ -1079,7 +1021,7 @@ export type CpfpParams = {
   /**
    * Current package fee in sats (only required for RBF)
    */
-  currentPackageFeeSats: /*u64*/ bigint | undefined;
+  currentPackageFeeSats?: /*u64*/ bigint;
 };
 
 /**
@@ -1093,21 +1035,8 @@ export const CpfpParams = (() => {
     );
   })();
   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()) as Partial<CpfpParams>,
   });
 })();
@@ -1160,21 +1089,8 @@ export const Destination = (() => {
     );
   })();
   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()) as Partial<Destination>,
   });
 })();
@@ -1228,21 +1144,8 @@ export const ExitClaimTransaction = (() => {
     >(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()) as Partial<ExitClaimTransaction>,
   });
 })();
@@ -1285,7 +1188,7 @@ export type ExitProgressStatus = {
   /**
    * Error if any occurred
    */
-  error: string | undefined;
+  error?: string;
 };
 
 /**
@@ -1299,21 +1202,8 @@ export const ExitProgressStatus = (() => {
     );
   })();
   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()) as Partial<ExitProgressStatus>,
   });
 })();
@@ -1359,7 +1249,7 @@ export type ExitTransactionStatus = {
   /**
    * State history (if requested)
    */
-  history: Array<string> | undefined;
+  history?: Array<string>;
   /**
    * Number of transactions
    */
@@ -1378,21 +1268,8 @@ export const ExitTransactionStatus = (() => {
     >(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()) as Partial<ExitTransactionStatus>,
   });
 })();
@@ -1457,21 +1334,8 @@ export const ExitVtxo = (() => {
     return uniffiCreateRecord<ExitVtxo, ReturnType<typeof defaults>>(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()) as Partial<ExitVtxo>,
   });
 })();
@@ -1540,21 +1404,8 @@ export const FeeEstimate = (() => {
     );
   })();
   return Object.freeze({
-    /**
-     * Create a frozen instance of {@link FeeEstimate}, with defaults specified
-     * in Rust, in the {@link bark} crate.
-     */
     create,
-
-    /**
-     * Create a frozen instance of {@link FeeEstimate}, with defaults specified
-     * in Rust, in the {@link bark} crate.
-     */
     new: create,
-
-    /**
-     * Defaults specified in the {@link bark} crate.
-     */
     defaults: () => Object.freeze(defaults()) as Partial<FeeEstimate>,
   });
 })();
@@ -1613,21 +1464,8 @@ export const LightningInvoice = (() => {
     );
   })();
   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()) as Partial<LightningInvoice>,
   });
 })();
@@ -1692,21 +1530,8 @@ export const LightningReceive = (() => {
     );
   })();
   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()) as Partial<LightningReceive>,
   });
 })();
@@ -1762,7 +1587,7 @@ export type LightningSend = {
   /**
    * Payment preimage (only present if payment completed)
    */
-  preimage: string | undefined;
+  preimage?: string;
 };
 
 /**
@@ -1776,21 +1601,8 @@ export const LightningSend = (() => {
     );
   })();
   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()) as Partial<LightningSend>,
   });
 })();
@@ -1891,7 +1703,7 @@ export type Movement = {
   /**
    * Completed at timestamp (null if not completed)
    */
-  completedAt: string | undefined;
+  completedAt?: string;
 };
 
 /**
@@ -1903,21 +1715,8 @@ export const Movement = (() => {
     return uniffiCreateRecord<Movement, ReturnType<typeof defaults>>(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()) as Partial<Movement>,
   });
 })();
@@ -2008,21 +1807,8 @@ export const OffboardResult = (() => {
     );
   })();
   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()) as Partial<OffboardResult>,
   });
 })();
@@ -2074,21 +1860,8 @@ export const OnchainBalance = (() => {
     );
   })();
   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()) as Partial<OnchainBalance>,
   });
 })();
@@ -2136,21 +1909,8 @@ export const OutPoint = (() => {
     return uniffiCreateRecord<OutPoint, ReturnType<typeof defaults>>(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()) as Partial<OutPoint>,
   });
 })();
@@ -2207,21 +1967,8 @@ export const PendingBoard = (() => {
     );
   })();
   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()) as Partial<PendingBoard>,
   });
 })();
@@ -2277,21 +2024,8 @@ export const RoundState = (() => {
     );
   })();
   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()) as Partial<RoundState>,
   });
 })();
@@ -2354,21 +2088,8 @@ export const Vtxo = (() => {
     return uniffiCreateRecord<Vtxo, ReturnType<typeof defaults>>(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()) as Partial<Vtxo>,
   });
 })();
@@ -2424,21 +2145,8 @@ export const WalletProperties = (() => {
     );
   })();
   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()) as Partial<WalletProperties>,
   });
 })();
@@ -2515,25 +2223,29 @@ export enum BarkError_Tags {
  */
 export const BarkError = (() => {
   type Network__interface = {
-    type: BarkError_Tags.Network;
-    errorMessage: string;
+    tag: BarkError_Tags.Network;
+    inner: Readonly<{ errorMessage: string }>;
   };
 
   class Network_ extends UniffiError implements Network__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
     readonly [uniffiTypeNameSymbol] = "BarkError";
-    readonly type = BarkError_Tags.Network;
-    readonly errorMessage: string;
-    constructor({ errorMessage }: { errorMessage: string }) {
+    readonly tag = BarkError_Tags.Network;
+    readonly inner: Readonly<{ errorMessage: string }>;
+    constructor(inner: { errorMessage: string }) {
       super("BarkError", "Network");
-      this.errorMessage = errorMessage;
+      this.inner = Object.freeze(inner);
     }
 
-    static new({ errorMessage }: { errorMessage: string }): Network_ {
-      return new Network_({ errorMessage });
+    static new(inner: { errorMessage: string }): Network_ {
+      return new Network_(inner);
     }
 
     static instanceOf(obj: any): obj is Network_ {
-      return obj.type === BarkError_Tags.Network;
+      return obj.tag === BarkError_Tags.Network;
     }
 
     static hasInner(obj: any): obj is Network_ {
@@ -2541,30 +2253,34 @@ export const BarkError = (() => {
     }
 
     static getInner(obj: Network_): Readonly<{ errorMessage: string }> {
-      return Object.freeze({ errorMessage: obj.errorMessage });
+      return obj.inner;
     }
   }
 
   type Database__interface = {
-    type: BarkError_Tags.Database;
-    errorMessage: string;
+    tag: BarkError_Tags.Database;
+    inner: Readonly<{ errorMessage: string }>;
   };
 
   class Database_ extends UniffiError implements Database__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
     readonly [uniffiTypeNameSymbol] = "BarkError";
-    readonly type = BarkError_Tags.Database;
-    readonly errorMessage: string;
-    constructor({ errorMessage }: { errorMessage: string }) {
+    readonly tag = BarkError_Tags.Database;
+    readonly inner: Readonly<{ errorMessage: string }>;
+    constructor(inner: { errorMessage: string }) {
       super("BarkError", "Database");
-      this.errorMessage = errorMessage;
+      this.inner = Object.freeze(inner);
     }
 
-    static new({ errorMessage }: { errorMessage: string }): Database_ {
-      return new Database_({ errorMessage });
+    static new(inner: { errorMessage: string }): Database_ {
+      return new Database_(inner);
     }
 
     static instanceOf(obj: any): obj is Database_ {
-      return obj.type === BarkError_Tags.Database;
+      return obj.tag === BarkError_Tags.Database;
     }
 
     static hasInner(obj: any): obj is Database_ {
@@ -2572,33 +2288,37 @@ export const BarkError = (() => {
     }
 
     static getInner(obj: Database_): Readonly<{ errorMessage: string }> {
-      return Object.freeze({ errorMessage: obj.errorMessage });
+      return obj.inner;
     }
   }
 
   type InvalidMnemonic__interface = {
-    type: BarkError_Tags.InvalidMnemonic;
-    errorMessage: string;
+    tag: BarkError_Tags.InvalidMnemonic;
+    inner: Readonly<{ errorMessage: string }>;
   };
 
   class InvalidMnemonic_
     extends UniffiError
     implements InvalidMnemonic__interface
   {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
     readonly [uniffiTypeNameSymbol] = "BarkError";
-    readonly type = BarkError_Tags.InvalidMnemonic;
-    readonly errorMessage: string;
-    constructor({ errorMessage }: { errorMessage: string }) {
+    readonly tag = BarkError_Tags.InvalidMnemonic;
+    readonly inner: Readonly<{ errorMessage: string }>;
+    constructor(inner: { errorMessage: string }) {
       super("BarkError", "InvalidMnemonic");
-      this.errorMessage = errorMessage;
+      this.inner = Object.freeze(inner);
     }
 
-    static new({ errorMessage }: { errorMessage: string }): InvalidMnemonic_ {
-      return new InvalidMnemonic_({ errorMessage });
+    static new(inner: { errorMessage: string }): InvalidMnemonic_ {
+      return new InvalidMnemonic_(inner);
     }
 
     static instanceOf(obj: any): obj is InvalidMnemonic_ {
-      return obj.type === BarkError_Tags.InvalidMnemonic;
+      return obj.tag === BarkError_Tags.InvalidMnemonic;
     }
 
     static hasInner(obj: any): obj is InvalidMnemonic_ {
@@ -2606,33 +2326,37 @@ export const BarkError = (() => {
     }
 
     static getInner(obj: InvalidMnemonic_): Readonly<{ errorMessage: string }> {
-      return Object.freeze({ errorMessage: obj.errorMessage });
+      return obj.inner;
     }
   }
 
   type InvalidAddress__interface = {
-    type: BarkError_Tags.InvalidAddress;
-    errorMessage: string;
+    tag: BarkError_Tags.InvalidAddress;
+    inner: Readonly<{ errorMessage: string }>;
   };
 
   class InvalidAddress_
     extends UniffiError
     implements InvalidAddress__interface
   {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
     readonly [uniffiTypeNameSymbol] = "BarkError";
-    readonly type = BarkError_Tags.InvalidAddress;
-    readonly errorMessage: string;
-    constructor({ errorMessage }: { errorMessage: string }) {
+    readonly tag = BarkError_Tags.InvalidAddress;
+    readonly inner: Readonly<{ errorMessage: string }>;
+    constructor(inner: { errorMessage: string }) {
       super("BarkError", "InvalidAddress");
-      this.errorMessage = errorMessage;
+      this.inner = Object.freeze(inner);
     }
 
-    static new({ errorMessage }: { errorMessage: string }): InvalidAddress_ {
-      return new InvalidAddress_({ errorMessage });
+    static new(inner: { errorMessage: string }): InvalidAddress_ {
+      return new InvalidAddress_(inner);
     }
 
     static instanceOf(obj: any): obj is InvalidAddress_ {
-      return obj.type === BarkError_Tags.InvalidAddress;
+      return obj.tag === BarkError_Tags.InvalidAddress;
     }
 
     static hasInner(obj: any): obj is InvalidAddress_ {
@@ -2640,33 +2364,37 @@ export const BarkError = (() => {
     }
 
     static getInner(obj: InvalidAddress_): Readonly<{ errorMessage: string }> {
-      return Object.freeze({ errorMessage: obj.errorMessage });
+      return obj.inner;
     }
   }
 
   type InvalidInvoice__interface = {
-    type: BarkError_Tags.InvalidInvoice;
-    errorMessage: string;
+    tag: BarkError_Tags.InvalidInvoice;
+    inner: Readonly<{ errorMessage: string }>;
   };
 
   class InvalidInvoice_
     extends UniffiError
     implements InvalidInvoice__interface
   {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
     readonly [uniffiTypeNameSymbol] = "BarkError";
-    readonly type = BarkError_Tags.InvalidInvoice;
-    readonly errorMessage: string;
-    constructor({ errorMessage }: { errorMessage: string }) {
+    readonly tag = BarkError_Tags.InvalidInvoice;
+    readonly inner: Readonly<{ errorMessage: string }>;
+    constructor(inner: { errorMessage: string }) {
       super("BarkError", "InvalidInvoice");
-      this.errorMessage = errorMessage;
+      this.inner = Object.freeze(inner);
     }
 
-    static new({ errorMessage }: { errorMessage: string }): InvalidInvoice_ {
-      return new InvalidInvoice_({ errorMessage });
+    static new(inner: { errorMessage: string }): InvalidInvoice_ {
+      return new InvalidInvoice_(inner);
     }
 
     static instanceOf(obj: any): obj is InvalidInvoice_ {
-      return obj.type === BarkError_Tags.InvalidInvoice;
+      return obj.tag === BarkError_Tags.InvalidInvoice;
     }
 
     static hasInner(obj: any): obj is InvalidInvoice_ {
@@ -2674,30 +2402,34 @@ export const BarkError = (() => {
     }
 
     static getInner(obj: InvalidInvoice_): Readonly<{ errorMessage: string }> {
-      return Object.freeze({ errorMessage: obj.errorMessage });
+      return obj.inner;
     }
   }
 
   type InvalidPsbt__interface = {
-    type: BarkError_Tags.InvalidPsbt;
-    errorMessage: string;
+    tag: BarkError_Tags.InvalidPsbt;
+    inner: Readonly<{ errorMessage: string }>;
   };
 
   class InvalidPsbt_ extends UniffiError implements InvalidPsbt__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
     readonly [uniffiTypeNameSymbol] = "BarkError";
-    readonly type = BarkError_Tags.InvalidPsbt;
-    readonly errorMessage: string;
-    constructor({ errorMessage }: { errorMessage: string }) {
+    readonly tag = BarkError_Tags.InvalidPsbt;
+    readonly inner: Readonly<{ errorMessage: string }>;
+    constructor(inner: { errorMessage: string }) {
       super("BarkError", "InvalidPsbt");
-      this.errorMessage = errorMessage;
+      this.inner = Object.freeze(inner);
     }
 
-    static new({ errorMessage }: { errorMessage: string }): InvalidPsbt_ {
-      return new InvalidPsbt_({ errorMessage });
+    static new(inner: { errorMessage: string }): InvalidPsbt_ {
+      return new InvalidPsbt_(inner);
     }
 
     static instanceOf(obj: any): obj is InvalidPsbt_ {
-      return obj.type === BarkError_Tags.InvalidPsbt;
+      return obj.tag === BarkError_Tags.InvalidPsbt;
     }
 
     static hasInner(obj: any): obj is InvalidPsbt_ {
@@ -2705,37 +2437,37 @@ export const BarkError = (() => {
     }
 
     static getInner(obj: InvalidPsbt_): Readonly<{ errorMessage: string }> {
-      return Object.freeze({ errorMessage: obj.errorMessage });
+      return obj.inner;
     }
   }
 
   type InvalidTransaction__interface = {
-    type: BarkError_Tags.InvalidTransaction;
-    errorMessage: string;
+    tag: BarkError_Tags.InvalidTransaction;
+    inner: Readonly<{ errorMessage: string }>;
   };
 
   class InvalidTransaction_
     extends UniffiError
     implements InvalidTransaction__interface
   {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
     readonly [uniffiTypeNameSymbol] = "BarkError";
-    readonly type = BarkError_Tags.InvalidTransaction;
-    readonly errorMessage: string;
-    constructor({ errorMessage }: { errorMessage: string }) {
+    readonly tag = BarkError_Tags.InvalidTransaction;
+    readonly inner: Readonly<{ errorMessage: string }>;
+    constructor(inner: { errorMessage: string }) {
       super("BarkError", "InvalidTransaction");
-      this.errorMessage = errorMessage;
+      this.inner = Object.freeze(inner);
     }
 
-    static new({
-      errorMessage,
-    }: {
-      errorMessage: string;
-    }): InvalidTransaction_ {
-      return new InvalidTransaction_({ errorMessage });
+    static new(inner: { errorMessage: string }): InvalidTransaction_ {
+      return new InvalidTransaction_(inner);
     }
 
     static instanceOf(obj: any): obj is InvalidTransaction_ {
-      return obj.type === BarkError_Tags.InvalidTransaction;
+      return obj.tag === BarkError_Tags.InvalidTransaction;
     }
 
     static hasInner(obj: any): obj is InvalidTransaction_ {
@@ -2745,33 +2477,37 @@ export const BarkError = (() => {
     static getInner(
       obj: InvalidTransaction_
     ): Readonly<{ errorMessage: string }> {
-      return Object.freeze({ errorMessage: obj.errorMessage });
+      return obj.inner;
     }
   }
 
   type InsufficientFunds__interface = {
-    type: BarkError_Tags.InsufficientFunds;
-    errorMessage: string;
+    tag: BarkError_Tags.InsufficientFunds;
+    inner: Readonly<{ errorMessage: string }>;
   };
 
   class InsufficientFunds_
     extends UniffiError
     implements InsufficientFunds__interface
   {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
     readonly [uniffiTypeNameSymbol] = "BarkError";
-    readonly type = BarkError_Tags.InsufficientFunds;
-    readonly errorMessage: string;
-    constructor({ errorMessage }: { errorMessage: string }) {
+    readonly tag = BarkError_Tags.InsufficientFunds;
+    readonly inner: Readonly<{ errorMessage: string }>;
+    constructor(inner: { errorMessage: string }) {
       super("BarkError", "InsufficientFunds");
-      this.errorMessage = errorMessage;
+      this.inner = Object.freeze(inner);
     }
 
-    static new({ errorMessage }: { errorMessage: string }): InsufficientFunds_ {
-      return new InsufficientFunds_({ errorMessage });
+    static new(inner: { errorMessage: string }): InsufficientFunds_ {
+      return new InsufficientFunds_(inner);
     }
 
     static instanceOf(obj: any): obj is InsufficientFunds_ {
-      return obj.type === BarkError_Tags.InsufficientFunds;
+      return obj.tag === BarkError_Tags.InsufficientFunds;
     }
 
     static hasInner(obj: any): obj is InsufficientFunds_ {
@@ -2781,30 +2517,34 @@ export const BarkError = (() => {
     static getInner(
       obj: InsufficientFunds_
     ): Readonly<{ errorMessage: string }> {
-      return Object.freeze({ errorMessage: obj.errorMessage });
+      return obj.inner;
     }
   }
 
   type NotFound__interface = {
-    type: BarkError_Tags.NotFound;
-    errorMessage: string;
+    tag: BarkError_Tags.NotFound;
+    inner: Readonly<{ errorMessage: string }>;
   };
 
   class NotFound_ extends UniffiError implements NotFound__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
     readonly [uniffiTypeNameSymbol] = "BarkError";
-    readonly type = BarkError_Tags.NotFound;
-    readonly errorMessage: string;
-    constructor({ errorMessage }: { errorMessage: string }) {
+    readonly tag = BarkError_Tags.NotFound;
+    readonly inner: Readonly<{ errorMessage: string }>;
+    constructor(inner: { errorMessage: string }) {
       super("BarkError", "NotFound");
-      this.errorMessage = errorMessage;
+      this.inner = Object.freeze(inner);
     }
 
-    static new({ errorMessage }: { errorMessage: string }): NotFound_ {
-      return new NotFound_({ errorMessage });
+    static new(inner: { errorMessage: string }): NotFound_ {
+      return new NotFound_(inner);
     }
 
     static instanceOf(obj: any): obj is NotFound_ {
-      return obj.type === BarkError_Tags.NotFound;
+      return obj.tag === BarkError_Tags.NotFound;
     }
 
     static hasInner(obj: any): obj is NotFound_ {
@@ -2812,33 +2552,37 @@ export const BarkError = (() => {
     }
 
     static getInner(obj: NotFound_): Readonly<{ errorMessage: string }> {
-      return Object.freeze({ errorMessage: obj.errorMessage });
+      return obj.inner;
     }
   }
 
   type ServerConnection__interface = {
-    type: BarkError_Tags.ServerConnection;
-    errorMessage: string;
+    tag: BarkError_Tags.ServerConnection;
+    inner: Readonly<{ errorMessage: string }>;
   };
 
   class ServerConnection_
     extends UniffiError
     implements ServerConnection__interface
   {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
     readonly [uniffiTypeNameSymbol] = "BarkError";
-    readonly type = BarkError_Tags.ServerConnection;
-    readonly errorMessage: string;
-    constructor({ errorMessage }: { errorMessage: string }) {
+    readonly tag = BarkError_Tags.ServerConnection;
+    readonly inner: Readonly<{ errorMessage: string }>;
+    constructor(inner: { errorMessage: string }) {
       super("BarkError", "ServerConnection");
-      this.errorMessage = errorMessage;
+      this.inner = Object.freeze(inner);
     }
 
-    static new({ errorMessage }: { errorMessage: string }): ServerConnection_ {
-      return new ServerConnection_({ errorMessage });
+    static new(inner: { errorMessage: string }): ServerConnection_ {
+      return new ServerConnection_(inner);
     }
 
     static instanceOf(obj: any): obj is ServerConnection_ {
-      return obj.type === BarkError_Tags.ServerConnection;
+      return obj.tag === BarkError_Tags.ServerConnection;
     }
 
     static hasInner(obj: any): obj is ServerConnection_ {
@@ -2848,30 +2592,34 @@ export const BarkError = (() => {
     static getInner(
       obj: ServerConnection_
     ): Readonly<{ errorMessage: string }> {
-      return Object.freeze({ errorMessage: obj.errorMessage });
+      return obj.inner;
     }
   }
 
   type Internal__interface = {
-    type: BarkError_Tags.Internal;
-    errorMessage: string;
+    tag: BarkError_Tags.Internal;
+    inner: Readonly<{ errorMessage: string }>;
   };
 
   class Internal_ extends UniffiError implements Internal__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
     readonly [uniffiTypeNameSymbol] = "BarkError";
-    readonly type = BarkError_Tags.Internal;
-    readonly errorMessage: string;
-    constructor({ errorMessage }: { errorMessage: string }) {
+    readonly tag = BarkError_Tags.Internal;
+    readonly inner: Readonly<{ errorMessage: string }>;
+    constructor(inner: { errorMessage: string }) {
       super("BarkError", "Internal");
-      this.errorMessage = errorMessage;
+      this.inner = Object.freeze(inner);
     }
 
-    static new({ errorMessage }: { errorMessage: string }): Internal_ {
-      return new Internal_({ errorMessage });
+    static new(inner: { errorMessage: string }): Internal_ {
+      return new Internal_(inner);
     }
 
     static instanceOf(obj: any): obj is Internal_ {
-      return obj.type === BarkError_Tags.Internal;
+      return obj.tag === BarkError_Tags.Internal;
     }
 
     static hasInner(obj: any): obj is Internal_ {
@@ -2879,37 +2627,37 @@ export const BarkError = (() => {
     }
 
     static getInner(obj: Internal_): Readonly<{ errorMessage: string }> {
-      return Object.freeze({ errorMessage: obj.errorMessage });
+      return obj.inner;
     }
   }
 
   type OnchainWalletRequired__interface = {
-    type: BarkError_Tags.OnchainWalletRequired;
-    errorMessage: string;
+    tag: BarkError_Tags.OnchainWalletRequired;
+    inner: Readonly<{ errorMessage: string }>;
   };
 
   class OnchainWalletRequired_
     extends UniffiError
     implements OnchainWalletRequired__interface
   {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
     readonly [uniffiTypeNameSymbol] = "BarkError";
-    readonly type = BarkError_Tags.OnchainWalletRequired;
-    readonly errorMessage: string;
-    constructor({ errorMessage }: { errorMessage: string }) {
+    readonly tag = BarkError_Tags.OnchainWalletRequired;
+    readonly inner: Readonly<{ errorMessage: string }>;
+    constructor(inner: { errorMessage: string }) {
       super("BarkError", "OnchainWalletRequired");
-      this.errorMessage = errorMessage;
+      this.inner = Object.freeze(inner);
     }
 
-    static new({
-      errorMessage,
-    }: {
-      errorMessage: string;
-    }): OnchainWalletRequired_ {
-      return new OnchainWalletRequired_({ errorMessage });
+    static new(inner: { errorMessage: string }): OnchainWalletRequired_ {
+      return new OnchainWalletRequired_(inner);
     }
 
     static instanceOf(obj: any): obj is OnchainWalletRequired_ {
-      return obj.type === BarkError_Tags.OnchainWalletRequired;
+      return obj.tag === BarkError_Tags.OnchainWalletRequired;
     }
 
     static hasInner(obj: any): obj is OnchainWalletRequired_ {
@@ -2919,30 +2667,34 @@ export const BarkError = (() => {
     static getInner(
       obj: OnchainWalletRequired_
     ): Readonly<{ errorMessage: string }> {
-      return Object.freeze({ errorMessage: obj.errorMessage });
+      return obj.inner;
     }
   }
 
   type InvalidVtxoId__interface = {
-    type: BarkError_Tags.InvalidVtxoId;
-    errorMessage: string;
+    tag: BarkError_Tags.InvalidVtxoId;
+    inner: Readonly<{ errorMessage: string }>;
   };
 
   class InvalidVtxoId_ extends UniffiError implements InvalidVtxoId__interface {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
     readonly [uniffiTypeNameSymbol] = "BarkError";
-    readonly type = BarkError_Tags.InvalidVtxoId;
-    readonly errorMessage: string;
-    constructor({ errorMessage }: { errorMessage: string }) {
+    readonly tag = BarkError_Tags.InvalidVtxoId;
+    readonly inner: Readonly<{ errorMessage: string }>;
+    constructor(inner: { errorMessage: string }) {
       super("BarkError", "InvalidVtxoId");
-      this.errorMessage = errorMessage;
+      this.inner = Object.freeze(inner);
     }
 
-    static new({ errorMessage }: { errorMessage: string }): InvalidVtxoId_ {
-      return new InvalidVtxoId_({ errorMessage });
+    static new(inner: { errorMessage: string }): InvalidVtxoId_ {
+      return new InvalidVtxoId_(inner);
     }
 
     static instanceOf(obj: any): obj is InvalidVtxoId_ {
-      return obj.type === BarkError_Tags.InvalidVtxoId;
+      return obj.tag === BarkError_Tags.InvalidVtxoId;
     }
 
     static hasInner(obj: any): obj is InvalidVtxoId_ {
@@ -2950,37 +2702,37 @@ export const BarkError = (() => {
     }
 
     static getInner(obj: InvalidVtxoId_): Readonly<{ errorMessage: string }> {
-      return Object.freeze({ errorMessage: obj.errorMessage });
+      return obj.inner;
     }
   }
 
   type ServerPubkeyChanged__interface = {
-    type: BarkError_Tags.ServerPubkeyChanged;
-    errorMessage: string;
+    tag: BarkError_Tags.ServerPubkeyChanged;
+    inner: Readonly<{ errorMessage: string }>;
   };
 
   class ServerPubkeyChanged_
     extends UniffiError
     implements ServerPubkeyChanged__interface
   {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
     readonly [uniffiTypeNameSymbol] = "BarkError";
-    readonly type = BarkError_Tags.ServerPubkeyChanged;
-    readonly errorMessage: string;
-    constructor({ errorMessage }: { errorMessage: string }) {
+    readonly tag = BarkError_Tags.ServerPubkeyChanged;
+    readonly inner: Readonly<{ errorMessage: string }>;
+    constructor(inner: { errorMessage: string }) {
       super("BarkError", "ServerPubkeyChanged");
-      this.errorMessage = errorMessage;
+      this.inner = Object.freeze(inner);
     }
 
-    static new({
-      errorMessage,
-    }: {
-      errorMessage: string;
-    }): ServerPubkeyChanged_ {
-      return new ServerPubkeyChanged_({ errorMessage });
+    static new(inner: { errorMessage: string }): ServerPubkeyChanged_ {
+      return new ServerPubkeyChanged_(inner);
     }
 
     static instanceOf(obj: any): obj is ServerPubkeyChanged_ {
-      return obj.type === BarkError_Tags.ServerPubkeyChanged;
+      return obj.tag === BarkError_Tags.ServerPubkeyChanged;
     }
 
     static hasInner(obj: any): obj is ServerPubkeyChanged_ {
@@ -2990,7 +2742,7 @@ export const BarkError = (() => {
     static getInner(
       obj: ServerPubkeyChanged_
     ): Readonly<{ errorMessage: string }> {
-      return Object.freeze({ errorMessage: obj.errorMessage });
+      return obj.inner;
     }
   }
 
@@ -3093,75 +2845,89 @@ const FfiConverterTypeBarkError = (() => {
       }
     }
     write(value: TypeName, into: RustBuffer): void {
-      switch (value.type) {
+      switch (value.tag) {
         case BarkError_Tags.Network: {
           ordinalConverter.write(1, into);
-          FfiConverterString.write(value.errorMessage, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.errorMessage, into);
           return;
         }
         case BarkError_Tags.Database: {
           ordinalConverter.write(2, into);
-          FfiConverterString.write(value.errorMessage, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.errorMessage, into);
           return;
         }
         case BarkError_Tags.InvalidMnemonic: {
           ordinalConverter.write(3, into);
-          FfiConverterString.write(value.errorMessage, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.errorMessage, into);
           return;
         }
         case BarkError_Tags.InvalidAddress: {
           ordinalConverter.write(4, into);
-          FfiConverterString.write(value.errorMessage, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.errorMessage, into);
           return;
         }
         case BarkError_Tags.InvalidInvoice: {
           ordinalConverter.write(5, into);
-          FfiConverterString.write(value.errorMessage, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.errorMessage, into);
           return;
         }
         case BarkError_Tags.InvalidPsbt: {
           ordinalConverter.write(6, into);
-          FfiConverterString.write(value.errorMessage, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.errorMessage, into);
           return;
         }
         case BarkError_Tags.InvalidTransaction: {
           ordinalConverter.write(7, into);
-          FfiConverterString.write(value.errorMessage, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.errorMessage, into);
           return;
         }
         case BarkError_Tags.InsufficientFunds: {
           ordinalConverter.write(8, into);
-          FfiConverterString.write(value.errorMessage, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.errorMessage, into);
           return;
         }
         case BarkError_Tags.NotFound: {
           ordinalConverter.write(9, into);
-          FfiConverterString.write(value.errorMessage, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.errorMessage, into);
           return;
         }
         case BarkError_Tags.ServerConnection: {
           ordinalConverter.write(10, into);
-          FfiConverterString.write(value.errorMessage, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.errorMessage, into);
           return;
         }
         case BarkError_Tags.Internal: {
           ordinalConverter.write(11, into);
-          FfiConverterString.write(value.errorMessage, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.errorMessage, into);
           return;
         }
         case BarkError_Tags.OnchainWalletRequired: {
           ordinalConverter.write(12, into);
-          FfiConverterString.write(value.errorMessage, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.errorMessage, into);
           return;
         }
         case BarkError_Tags.InvalidVtxoId: {
           ordinalConverter.write(13, into);
-          FfiConverterString.write(value.errorMessage, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.errorMessage, into);
           return;
         }
         case BarkError_Tags.ServerPubkeyChanged: {
           ordinalConverter.write(14, into);
-          FfiConverterString.write(value.errorMessage, into);
+          const inner = value.inner;
+          FfiConverterString.write(inner.errorMessage, into);
           return;
         }
         default:
@@ -3170,75 +2936,89 @@ const FfiConverterTypeBarkError = (() => {
       }
     }
     allocationSize(value: TypeName): number {
-      switch (value.type) {
+      switch (value.tag) {
         case BarkError_Tags.Network: {
+          const inner = value.inner;
           let size = ordinalConverter.allocationSize(1);
-          size += FfiConverterString.allocationSize(value.errorMessage);
+          size += FfiConverterString.allocationSize(inner.errorMessage);
           return size;
         }
         case BarkError_Tags.Database: {
+          const inner = value.inner;
           let size = ordinalConverter.allocationSize(2);
-          size += FfiConverterString.allocationSize(value.errorMessage);
+          size += FfiConverterString.allocationSize(inner.errorMessage);
           return size;
         }
         case BarkError_Tags.InvalidMnemonic: {
+          const inner = value.inner;
           let size = ordinalConverter.allocationSize(3);
-          size += FfiConverterString.allocationSize(value.errorMessage);
+          size += FfiConverterString.allocationSize(inner.errorMessage);
           return size;
         }
         case BarkError_Tags.InvalidAddress: {
+          const inner = value.inner;
           let size = ordinalConverter.allocationSize(4);
-          size += FfiConverterString.allocationSize(value.errorMessage);
+          size += FfiConverterString.allocationSize(inner.errorMessage);
           return size;
         }
         case BarkError_Tags.InvalidInvoice: {
+          const inner = value.inner;
           let size = ordinalConverter.allocationSize(5);
-          size += FfiConverterString.allocationSize(value.errorMessage);
+          size += FfiConverterString.allocationSize(inner.errorMessage);
           return size;
         }
         case BarkError_Tags.InvalidPsbt: {
+          const inner = value.inner;
           let size = ordinalConverter.allocationSize(6);
-          size += FfiConverterString.allocationSize(value.errorMessage);
+          size += FfiConverterString.allocationSize(inner.errorMessage);
           return size;
         }
         case BarkError_Tags.InvalidTransaction: {
+          const inner = value.inner;
           let size = ordinalConverter.allocationSize(7);
-          size += FfiConverterString.allocationSize(value.errorMessage);
+          size += FfiConverterString.allocationSize(inner.errorMessage);
           return size;
         }
         case BarkError_Tags.InsufficientFunds: {
+          const inner = value.inner;
           let size = ordinalConverter.allocationSize(8);
-          size += FfiConverterString.allocationSize(value.errorMessage);
+          size += FfiConverterString.allocationSize(inner.errorMessage);
           return size;
         }
         case BarkError_Tags.NotFound: {
+          const inner = value.inner;
           let size = ordinalConverter.allocationSize(9);
-          size += FfiConverterString.allocationSize(value.errorMessage);
+          size += FfiConverterString.allocationSize(inner.errorMessage);
           return size;
         }
         case BarkError_Tags.ServerConnection: {
+          const inner = value.inner;
           let size = ordinalConverter.allocationSize(10);
-          size += FfiConverterString.allocationSize(value.errorMessage);
+          size += FfiConverterString.allocationSize(inner.errorMessage);
           return size;
         }
         case BarkError_Tags.Internal: {
+          const inner = value.inner;
           let size = ordinalConverter.allocationSize(11);
-          size += FfiConverterString.allocationSize(value.errorMessage);
+          size += FfiConverterString.allocationSize(inner.errorMessage);
           return size;
         }
         case BarkError_Tags.OnchainWalletRequired: {
+          const inner = value.inner;
           let size = ordinalConverter.allocationSize(12);
-          size += FfiConverterString.allocationSize(value.errorMessage);
+          size += FfiConverterString.allocationSize(inner.errorMessage);
           return size;
         }
         case BarkError_Tags.InvalidVtxoId: {
+          const inner = value.inner;
           let size = ordinalConverter.allocationSize(13);
-          size += FfiConverterString.allocationSize(value.errorMessage);
+          size += FfiConverterString.allocationSize(inner.errorMessage);
           return size;
         }
         case BarkError_Tags.ServerPubkeyChanged: {
+          const inner = value.inner;
           let size = ordinalConverter.allocationSize(14);
-          size += FfiConverterString.allocationSize(value.errorMessage);
+          size += FfiConverterString.allocationSize(inner.errorMessage);
           return size;
         }
         default:
@@ -3307,8 +3087,8 @@ export enum WalletNotification_Tags {
  */
 export const WalletNotification = (() => {
   type MovementCreated__interface = {
-    type: WalletNotification_Tags.MovementCreated;
-    movement: Movement;
+    tag: WalletNotification_Tags.MovementCreated;
+    inner: Readonly<{ movement: Movement }>;
   };
 
   /**
@@ -3318,26 +3098,30 @@ export const WalletNotification = (() => {
     extends UniffiEnum
     implements MovementCreated__interface
   {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
     readonly [uniffiTypeNameSymbol] = "WalletNotification";
-    readonly type = WalletNotification_Tags.MovementCreated;
-    readonly movement: Movement;
-    constructor({ movement }: { movement: Movement }) {
+    readonly tag = WalletNotification_Tags.MovementCreated;
+    readonly inner: Readonly<{ movement: Movement }>;
+    constructor(inner: { movement: Movement }) {
       super("WalletNotification", "MovementCreated");
-      this.movement = movement;
+      this.inner = Object.freeze(inner);
     }
 
-    static new({ movement }: { movement: Movement }): MovementCreated_ {
-      return new MovementCreated_({ movement });
+    static new(inner: { movement: Movement }): MovementCreated_ {
+      return new MovementCreated_(inner);
     }
 
     static instanceOf(obj: any): obj is MovementCreated_ {
-      return obj.type === WalletNotification_Tags.MovementCreated;
+      return obj.tag === WalletNotification_Tags.MovementCreated;
     }
   }
 
   type MovementUpdated__interface = {
-    type: WalletNotification_Tags.MovementUpdated;
-    movement: Movement;
+    tag: WalletNotification_Tags.MovementUpdated;
+    inner: Readonly<{ movement: Movement }>;
   };
 
   /**
@@ -3347,25 +3131,29 @@ export const WalletNotification = (() => {
     extends UniffiEnum
     implements MovementUpdated__interface
   {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
     readonly [uniffiTypeNameSymbol] = "WalletNotification";
-    readonly type = WalletNotification_Tags.MovementUpdated;
-    readonly movement: Movement;
-    constructor({ movement }: { movement: Movement }) {
+    readonly tag = WalletNotification_Tags.MovementUpdated;
+    readonly inner: Readonly<{ movement: Movement }>;
+    constructor(inner: { movement: Movement }) {
       super("WalletNotification", "MovementUpdated");
-      this.movement = movement;
+      this.inner = Object.freeze(inner);
     }
 
-    static new({ movement }: { movement: Movement }): MovementUpdated_ {
-      return new MovementUpdated_({ movement });
+    static new(inner: { movement: Movement }): MovementUpdated_ {
+      return new MovementUpdated_(inner);
     }
 
     static instanceOf(obj: any): obj is MovementUpdated_ {
-      return obj.type === WalletNotification_Tags.MovementUpdated;
+      return obj.tag === WalletNotification_Tags.MovementUpdated;
     }
   }
 
   type ChannelLagging__interface = {
-    type: WalletNotification_Tags.ChannelLagging;
+    tag: WalletNotification_Tags.ChannelLagging;
   };
 
   /**
@@ -3375,8 +3163,12 @@ export const WalletNotification = (() => {
     extends UniffiEnum
     implements ChannelLagging__interface
   {
+    /**
+     * @private
+     * This field is private and should not be used, use `tag` instead.
+     */
     readonly [uniffiTypeNameSymbol] = "WalletNotification";
-    readonly type = WalletNotification_Tags.ChannelLagging;
+    readonly tag = WalletNotification_Tags.ChannelLagging;
     constructor() {
       super("WalletNotification", "ChannelLagging");
     }
@@ -3386,7 +3178,7 @@ export const WalletNotification = (() => {
     }
 
     static instanceOf(obj: any): obj is ChannelLagging_ {
-      return obj.type === WalletNotification_Tags.ChannelLagging;
+      return obj.tag === WalletNotification_Tags.ChannelLagging;
     }
   }
 
@@ -3435,15 +3227,17 @@ const FfiConverterTypeWalletNotification = (() => {
       }
     }
     write(value: TypeName, into: RustBuffer): void {
-      switch (value.type) {
+      switch (value.tag) {
         case WalletNotification_Tags.MovementCreated: {
           ordinalConverter.write(1, into);
-          FfiConverterTypeMovement.write(value.movement, into);
+          const inner = value.inner;
+          FfiConverterTypeMovement.write(inner.movement, into);
           return;
         }
         case WalletNotification_Tags.MovementUpdated: {
           ordinalConverter.write(2, into);
-          FfiConverterTypeMovement.write(value.movement, into);
+          const inner = value.inner;
+          FfiConverterTypeMovement.write(inner.movement, into);
           return;
         }
         case WalletNotification_Tags.ChannelLagging: {
@@ -3456,15 +3250,17 @@ const FfiConverterTypeWalletNotification = (() => {
       }
     }
     allocationSize(value: TypeName): number {
-      switch (value.type) {
+      switch (value.tag) {
         case WalletNotification_Tags.MovementCreated: {
+          const inner = value.inner;
           let size = ordinalConverter.allocationSize(1);
-          size += FfiConverterTypeMovement.allocationSize(value.movement);
+          size += FfiConverterTypeMovement.allocationSize(inner.movement);
           return size;
         }
         case WalletNotification_Tags.MovementUpdated: {
+          const inner = value.inner;
           let size = ordinalConverter.allocationSize(2);
-          size += FfiConverterTypeMovement.allocationSize(value.movement);
+          size += FfiConverterTypeMovement.allocationSize(inner.movement);
           return size;
         }
         case WalletNotification_Tags.ChannelLagging: {
@@ -3488,7 +3284,7 @@ const FfiConverterTypeWalletNotification = (() => {
  * Each call to `Wallet.notifications()` creates an independent stream backed
  * by a new broadcast receiver. Only one consumer loop per holder is assumed.
  */
-export interface NotificationHolderInterface {
+export interface NotificationHolderLike {
   /**
    * Cancel the currently pending `next_notification()` wait.
    *
@@ -3514,6 +3310,10 @@ export interface NotificationHolderInterface {
     signal: AbortSignal;
   }): /*throws*/ Promise<WalletNotification | undefined>;
 }
+/**
+ * @deprecated Use `NotificationHolderLike` instead.
+ */
+export type NotificationHolderInterface = NotificationHolderLike;
 
 /**
  * Pull-based handle for consuming wallet notifications.
@@ -3527,7 +3327,7 @@ export interface NotificationHolderInterface {
  */
 export class NotificationHolder
   extends UniffiAbstractObject
-  implements NotificationHolderInterface
+  implements NotificationHolderLike
 {
   readonly [uniffiTypeNameSymbol] = "NotificationHolder";
   readonly [destructorGuardSymbol]: UniffiGcObject;
@@ -3627,10 +3427,10 @@ export class NotificationHolder
   }
 }
 
-const uniffiTypeNotificationHolderObjectFactory: UniffiObjectFactory<NotificationHolderInterface> =
+const uniffiTypeNotificationHolderObjectFactory: UniffiObjectFactory<NotificationHolderLike> =
   (() => {
     return {
-      create(pointer: UniffiHandle): NotificationHolderInterface {
+      create(pointer: UniffiHandle): NotificationHolderLike {
         const instance = Object.create(NotificationHolder.prototype);
         instance[pointerLiteralSymbol] = pointer;
         instance[destructorGuardSymbol] = this.bless(pointer);
@@ -3653,14 +3453,14 @@ const uniffiTypeNotificationHolderObjectFactory: UniffiObjectFactory<Notificatio
         ptr.markDestroyed();
       },
 
-      pointer(obj: NotificationHolderInterface): UniffiHandle {
+      pointer(obj: NotificationHolderLike): UniffiHandle {
         if ((obj as any)[destructorGuardSymbol] === undefined) {
           throw new UniffiInternalError.UnexpectedNullPointer();
         }
         return (obj as any)[pointerLiteralSymbol];
       },
 
-      clonePointer(obj: NotificationHolderInterface): UniffiHandle {
+      clonePointer(obj: NotificationHolderLike): UniffiHandle {
         const pointer = this.pointer(obj);
         return uniffiCaller.rustCall(
           /*caller:*/ (callStatus) =>
@@ -3683,7 +3483,7 @@ const uniffiTypeNotificationHolderObjectFactory: UniffiObjectFactory<Notificatio
         );
       },
 
-      isConcreteType(obj: any): obj is NotificationHolderInterface {
+      isConcreteType(obj: any): obj is NotificationHolderLike {
         return (
           obj[destructorGuardSymbol] &&
           obj[uniffiTypeNameSymbol] === "NotificationHolder"
@@ -3691,7 +3491,7 @@ const uniffiTypeNotificationHolderObjectFactory: UniffiObjectFactory<Notificatio
       },
     };
   })();
-// FfiConverter for NotificationHolderInterface
+// FfiConverter for NotificationHolderLike
 const FfiConverterTypeNotificationHolder = new FfiConverterObject(
   uniffiTypeNotificationHolderObjectFactory
 );
@@ -3703,7 +3503,7 @@ const FfiConverterTypeNotificationHolder = new FfiConverterObject(
  * - Default: BDK-based wallet (built-in)
  * - Custom: Your own wallet implementation via callbacks
  */
-export interface OnchainWalletInterface {
+export interface OnchainWalletLike {
   /**
    * Get the onchain wallet balance
    */
@@ -3732,6 +3532,10 @@ export interface OnchainWalletInterface {
     signal: AbortSignal;
   }): /*throws*/ Promise</*u64*/ bigint>;
 }
+/**
+ * @deprecated Use `OnchainWalletLike` instead.
+ */
+export type OnchainWalletInterface = OnchainWalletLike;
 
 /**
  * Onchain Bitcoin wallet for boarding and exits
@@ -3742,7 +3546,7 @@ export interface OnchainWalletInterface {
  */
 export class OnchainWallet
   extends UniffiAbstractObject
-  implements OnchainWalletInterface
+  implements OnchainWalletLike
 {
   readonly [uniffiTypeNameSymbol] = "OnchainWallet";
   readonly [destructorGuardSymbol]: UniffiGcObject;
@@ -3764,7 +3568,7 @@ export class OnchainWallet
    */
   static custom(
     callbacks: CustomOnchainWalletCallbacks
-  ): OnchainWalletInterface /*throws*/ {
+  ): OnchainWalletLike /*throws*/ {
     return FfiConverterTypeOnchainWallet.lift(
       uniffiCaller.rustCallWithError(
         /*liftError:*/ FfiConverterTypeBarkError.lift.bind(
@@ -3792,7 +3596,7 @@ export class OnchainWallet
     config: Config,
     datadir: string,
     asyncOpts_?: { signal: AbortSignal }
-  ): Promise<OnchainWalletInterface> /*throws*/ {
+  ): Promise<OnchainWalletLike> /*throws*/ {
     const __stack = uniffiIsDebug ? new Error().stack : undefined;
     try {
       return await uniffiRustCallAsync(
@@ -4003,10 +3807,10 @@ export class OnchainWallet
   }
 }
 
-const uniffiTypeOnchainWalletObjectFactory: UniffiObjectFactory<OnchainWalletInterface> =
+const uniffiTypeOnchainWalletObjectFactory: UniffiObjectFactory<OnchainWalletLike> =
   (() => {
     return {
-      create(pointer: UniffiHandle): OnchainWalletInterface {
+      create(pointer: UniffiHandle): OnchainWalletLike {
         const instance = Object.create(OnchainWallet.prototype);
         instance[pointerLiteralSymbol] = pointer;
         instance[destructorGuardSymbol] = this.bless(pointer);
@@ -4029,14 +3833,14 @@ const uniffiTypeOnchainWalletObjectFactory: UniffiObjectFactory<OnchainWalletInt
         ptr.markDestroyed();
       },
 
-      pointer(obj: OnchainWalletInterface): UniffiHandle {
+      pointer(obj: OnchainWalletLike): UniffiHandle {
         if ((obj as any)[destructorGuardSymbol] === undefined) {
           throw new UniffiInternalError.UnexpectedNullPointer();
         }
         return (obj as any)[pointerLiteralSymbol];
       },
 
-      clonePointer(obj: OnchainWalletInterface): UniffiHandle {
+      clonePointer(obj: OnchainWalletLike): UniffiHandle {
         const pointer = this.pointer(obj);
         return uniffiCaller.rustCall(
           /*caller:*/ (callStatus) =>
@@ -4059,7 +3863,7 @@ const uniffiTypeOnchainWalletObjectFactory: UniffiObjectFactory<OnchainWalletInt
         );
       },
 
-      isConcreteType(obj: any): obj is OnchainWalletInterface {
+      isConcreteType(obj: any): obj is OnchainWalletLike {
         return (
           obj[destructorGuardSymbol] &&
           obj[uniffiTypeNameSymbol] === "OnchainWallet"
@@ -4067,7 +3871,7 @@ const uniffiTypeOnchainWalletObjectFactory: UniffiObjectFactory<OnchainWalletInt
       },
     };
   })();
-// FfiConverter for OnchainWalletInterface
+// FfiConverter for OnchainWalletLike
 const FfiConverterTypeOnchainWallet = new FfiConverterObject(
   uniffiTypeOnchainWalletObjectFactory
 );
@@ -4075,7 +3879,7 @@ const FfiConverterTypeOnchainWallet = new FfiConverterObject(
 /**
  * The main Bark wallet interface for Ark operations
  */
-export interface WalletInterface {
+export interface WalletLike {
   /**
    * Get earliest block height when all exits will be claimable
    *
@@ -4099,14 +3903,14 @@ export interface WalletInterface {
    * Board all funds from onchain wallet into Ark
    */
   boardAll(
-    onchainWallet: OnchainWalletInterface,
+    onchainWallet: OnchainWalletLike,
     asyncOpts_?: { signal: AbortSignal }
   ): /*throws*/ Promise<PendingBoard>;
   /**
    * Board a specific amount from onchain wallet into Ark
    */
   boardAmount(
-    onchainWallet: OnchainWalletInterface,
+    onchainWallet: OnchainWalletLike,
     amountSats: /*u64*/ bigint,
     asyncOpts_?: { signal: AbortSignal }
   ): /*throws*/ Promise<PendingBoard>;
@@ -4136,6 +3940,20 @@ export interface WalletInterface {
   cancelAllPendingRounds(asyncOpts_?: {
     signal: AbortSignal;
   }): /*throws*/ Promise<void>;
+  /**
+   * Cancel a pending lightning receive by payment hash
+   *
+   * Server will refuse if HTLCs already granted, preimage already revealed,
+   * or receive already finished.
+   *
+   * # Arguments
+   *
+   * * `payment_hash` - Payment hash as hex string
+   */
+  cancelLightningReceive(
+    paymentHash: string,
+    asyncOpts_?: { signal: AbortSignal }
+  ): /*throws*/ Promise<void>;
   /**
    * Cancel a specific pending round
    */
@@ -4442,14 +4260,14 @@ export interface WalletInterface {
    * More thorough than maintenance() - also syncs onchain wallet and exits.
    */
   maintenanceWithOnchain(
-    onchainWallet: OnchainWalletInterface,
+    onchainWallet: OnchainWalletLike,
     asyncOpts_?: { signal: AbortSignal }
   ): /*throws*/ Promise<void>;
   /**
    * Perform maintenance with onchain wallet in delegated mode
    */
   maintenanceWithOnchainDelegated(
-    onchainWallet: OnchainWalletInterface,
+    onchainWallet: OnchainWalletLike,
     asyncOpts_?: { signal: AbortSignal }
   ): /*throws*/ Promise<void>;
   /**
@@ -4485,7 +4303,7 @@ export interface WalletInterface {
    * Call `cancel_next_notification_wait()` to unblock a pending wait without
    * destroying the stream.
    */
-  notifications(): NotificationHolderInterface;
+  notifications(): NotificationHolderLike;
   offboardAll(
     bitcoinAddress: string,
     asyncOpts_?: { signal: AbortSignal }
@@ -4596,7 +4414,7 @@ export interface WalletInterface {
    * * `fee_rate_sat_per_vb` - Optional fee rate override in sats/vB
    */
   progressExits(
-    onchainWallet: OnchainWalletInterface,
+    onchainWallet: OnchainWalletLike,
     feeRateSatPerVb: /*u64*/ bigint | undefined,
     asyncOpts_?: { signal: AbortSignal }
   ): /*throws*/ Promise<Array<ExitProgressStatus>>;
@@ -4693,7 +4511,7 @@ export interface WalletInterface {
    * Sync exit state (checks status but doesn't progress)
    */
   syncExits(
-    onchainWallet: OnchainWalletInterface,
+    onchainWallet: OnchainWalletLike,
     asyncOpts_?: { signal: AbortSignal }
   ): /*throws*/ Promise<void>;
   /**
@@ -4732,11 +4550,15 @@ export interface WalletInterface {
   ): /*throws*/ Promise<boolean>;
   vtxos(asyncOpts_?: { signal: AbortSignal }): /*throws*/ Promise<Array<Vtxo>>;
 }
+/**
+ * @deprecated Use `WalletLike` instead.
+ */
+export type WalletInterface = WalletLike;
 
 /**
  * The main Bark wallet interface for Ark operations
  */
-export class Wallet extends UniffiAbstractObject implements WalletInterface {
+export class Wallet extends UniffiAbstractObject implements WalletLike {
   readonly [uniffiTypeNameSymbol] = "Wallet";
   readonly [destructorGuardSymbol]: UniffiGcObject;
   readonly [pointerLiteralSymbol]: UniffiHandle;
@@ -4756,7 +4578,7 @@ export class Wallet extends UniffiAbstractObject implements WalletInterface {
     datadir: string,
     forceRescan: boolean,
     asyncOpts_?: { signal: AbortSignal }
-  ): Promise<WalletInterface> /*throws*/ {
+  ): Promise<WalletLike> /*throws*/ {
     const __stack = uniffiIsDebug ? new Error().stack : undefined;
     try {
       return await uniffiRustCallAsync(
@@ -4796,10 +4618,10 @@ export class Wallet extends UniffiAbstractObject implements WalletInterface {
     mnemonic: string,
     config: Config,
     datadir: string,
-    onchainWallet: OnchainWalletInterface,
+    onchainWallet: OnchainWalletLike,
     forceRescan: boolean,
     asyncOpts_?: { signal: AbortSignal }
-  ): Promise<WalletInterface> /*throws*/ {
+  ): Promise<WalletLike> /*throws*/ {
     const __stack = uniffiIsDebug ? new Error().stack : undefined;
     try {
       return await uniffiRustCallAsync(
@@ -4841,7 +4663,7 @@ export class Wallet extends UniffiAbstractObject implements WalletInterface {
     config: Config,
     datadir: string,
     asyncOpts_?: { signal: AbortSignal }
-  ): Promise<WalletInterface> /*throws*/ {
+  ): Promise<WalletLike> /*throws*/ {
     const __stack = uniffiIsDebug ? new Error().stack : undefined;
     try {
       return await uniffiRustCallAsync(
@@ -4880,9 +4702,9 @@ export class Wallet extends UniffiAbstractObject implements WalletInterface {
     mnemonic: string,
     config: Config,
     datadir: string,
-    onchainWallet: OnchainWalletInterface,
+    onchainWallet: OnchainWalletLike,
     asyncOpts_?: { signal: AbortSignal }
-  ): Promise<WalletInterface> /*throws*/ {
+  ): Promise<WalletLike> /*throws*/ {
     const __stack = uniffiIsDebug ? new Error().stack : undefined;
     try {
       return await uniffiRustCallAsync(
@@ -5075,7 +4897,7 @@ export class Wallet extends UniffiAbstractObject implements WalletInterface {
    * Board all funds from onchain wallet into Ark
    */
   async boardAll(
-    onchainWallet: OnchainWalletInterface,
+    onchainWallet: OnchainWalletLike,
     asyncOpts_?: { signal: AbortSignal }
   ): Promise<PendingBoard> /*throws*/ {
     const __stack = uniffiIsDebug ? new Error().stack : undefined;
@@ -5117,7 +4939,7 @@ export class Wallet extends UniffiAbstractObject implements WalletInterface {
    * Board a specific amount from onchain wallet into Ark
    */
   async boardAmount(
-    onchainWallet: OnchainWalletInterface,
+    onchainWallet: OnchainWalletLike,
     amountSats: /*u64*/ bigint,
     asyncOpts_?: { signal: AbortSignal }
   ): Promise<PendingBoard> /*throws*/ {
@@ -5281,6 +5103,51 @@ export class Wallet extends UniffiAbstractObject implements WalletInterface {
     }
   }
 
+  /**
+   * Cancel a pending lightning receive by payment hash
+   *
+   * Server will refuse if HTLCs already granted, preimage already revealed,
+   * or receive already finished.
+   *
+   * # Arguments
+   *
+   * * `payment_hash` - Payment hash as hex string
+   */
+  async cancelLightningReceive(
+    paymentHash: string,
+    asyncOpts_?: { signal: AbortSignal }
+  ): Promise<void> /*throws*/ {
+    const __stack = uniffiIsDebug ? new Error().stack : undefined;
+    try {
+      return await uniffiRustCallAsync(
+        /*rustCaller:*/ uniffiCaller,
+        /*rustFutureFunc:*/ () => {
+          return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_cancel_lightning_receive(
+            uniffiTypeWalletObjectFactory.clonePointer(this),
+            FfiConverterString.lower(paymentHash)
+          );
+        },
+        /*pollFunc:*/ nativeModule().ubrn_ffi_bark_ffi_rust_future_poll_void,
+        /*cancelFunc:*/ nativeModule()
+          .ubrn_ffi_bark_ffi_rust_future_cancel_void,
+        /*completeFunc:*/ nativeModule()
+          .ubrn_ffi_bark_ffi_rust_future_complete_void,
+        /*freeFunc:*/ nativeModule().ubrn_ffi_bark_ffi_rust_future_free_void,
+        /*liftFunc:*/ (_v) => {},
+        /*liftString:*/ FfiConverterString.lift,
+        /*asyncOpts:*/ asyncOpts_,
+        /*errorHandler:*/ FfiConverterTypeBarkError.lift.bind(
+          FfiConverterTypeBarkError
+        )
+      );
+    } catch (__error: any) {
+      if (uniffiIsDebug && __error instanceof Error) {
+        __error.stack = __stack;
+      }
+      throw __error;
+    }
+  }
+
   /**
    * Cancel a specific pending round
    */
@@ -6612,7 +6479,7 @@ export class Wallet extends UniffiAbstractObject implements WalletInterface {
    * More thorough than maintenance() - also syncs onchain wallet and exits.
    */
   async maintenanceWithOnchain(
-    onchainWallet: OnchainWalletInterface,
+    onchainWallet: OnchainWalletLike,
     asyncOpts_?: { signal: AbortSignal }
   ): Promise<void> /*throws*/ {
     const __stack = uniffiIsDebug ? new Error().stack : undefined;
@@ -6650,7 +6517,7 @@ export class Wallet extends UniffiAbstractObject implements WalletInterface {
    * Perform maintenance with onchain wallet in delegated mode
    */
   async maintenanceWithOnchainDelegated(
-    onchainWallet: OnchainWalletInterface,
+    onchainWallet: OnchainWalletLike,
     asyncOpts_?: { signal: AbortSignal }
   ): Promise<void> /*throws*/ {
     const __stack = uniffiIsDebug ? new Error().stack : undefined;
@@ -6884,7 +6751,7 @@ export class Wallet extends UniffiAbstractObject implements WalletInterface {
    * Call `cancel_next_notification_wait()` to unblock a pending wait without
    * destroying the stream.
    */
-  notifications(): NotificationHolderInterface {
+  notifications(): NotificationHolderLike {
     return FfiConverterTypeNotificationHolder.lift(
       uniffiCaller.rustCall(
         /*caller:*/ (callStatus) => {
@@ -7519,7 +7386,7 @@ export class Wallet extends UniffiAbstractObject implements WalletInterface {
    * * `fee_rate_sat_per_vb` - Optional fee rate override in sats/vB
    */
   async progressExits(
-    onchainWallet: OnchainWalletInterface,
+    onchainWallet: OnchainWalletLike,
     feeRateSatPerVb: /*u64*/ bigint | undefined,
     asyncOpts_?: { signal: AbortSignal }
   ): Promise<Array<ExitProgressStatus>> /*throws*/ {
@@ -8044,7 +7911,7 @@ export class Wallet extends UniffiAbstractObject implements WalletInterface {
    * Sync exit state (checks status but doesn't progress)
    */
   async syncExits(
-    onchainWallet: OnchainWalletInterface,
+    onchainWallet: OnchainWalletLike,
     asyncOpts_?: { signal: AbortSignal }
   ): Promise<void> /*throws*/ {
     const __stack = uniffiIsDebug ? new Error().stack : undefined;
@@ -8294,70 +8161,69 @@ export class Wallet extends UniffiAbstractObject implements WalletInterface {
   }
 }
 
-const uniffiTypeWalletObjectFactory: UniffiObjectFactory<WalletInterface> =
-  (() => {
-    return {
-      create(pointer: UniffiHandle): WalletInterface {
-        const instance = Object.create(Wallet.prototype);
-        instance[pointerLiteralSymbol] = pointer;
-        instance[destructorGuardSymbol] = this.bless(pointer);
-        instance[uniffiTypeNameSymbol] = "Wallet";
-        return instance;
-      },
+const uniffiTypeWalletObjectFactory: UniffiObjectFactory<WalletLike> = (() => {
+  return {
+    create(pointer: UniffiHandle): WalletLike {
+      const instance = Object.create(Wallet.prototype);
+      instance[pointerLiteralSymbol] = pointer;
+      instance[destructorGuardSymbol] = this.bless(pointer);
+      instance[uniffiTypeNameSymbol] = "Wallet";
+      return instance;
+    },
 
-      bless(p: UniffiHandle): UniffiGcObject {
-        return uniffiCaller.rustCall(
-          /*caller:*/ (status) =>
-            nativeModule().ubrn_uniffi_internal_fn_method_wallet_ffi__bless_pointer(
-              p,
-              status
-            ),
-          /*liftString:*/ FfiConverterString.lift
-        );
-      },
+    bless(p: UniffiHandle): UniffiGcObject {
+      return uniffiCaller.rustCall(
+        /*caller:*/ (status) =>
+          nativeModule().ubrn_uniffi_internal_fn_method_wallet_ffi__bless_pointer(
+            p,
+            status
+          ),
+        /*liftString:*/ FfiConverterString.lift
+      );
+    },
 
-      unbless(ptr: UniffiGcObject) {
-        ptr.markDestroyed();
-      },
+    unbless(ptr: UniffiGcObject) {
+      ptr.markDestroyed();
+    },
 
-      pointer(obj: WalletInterface): UniffiHandle {
-        if ((obj as any)[destructorGuardSymbol] === undefined) {
-          throw new UniffiInternalError.UnexpectedNullPointer();
-        }
-        return (obj as any)[pointerLiteralSymbol];
-      },
+    pointer(obj: WalletLike): UniffiHandle {
+      if ((obj as any)[destructorGuardSymbol] === undefined) {
+        throw new UniffiInternalError.UnexpectedNullPointer();
+      }
+      return (obj as any)[pointerLiteralSymbol];
+    },
 
-      clonePointer(obj: WalletInterface): UniffiHandle {
-        const pointer = this.pointer(obj);
-        return uniffiCaller.rustCall(
-          /*caller:*/ (callStatus) =>
-            nativeModule().ubrn_uniffi_bark_ffi_fn_clone_wallet(
-              pointer,
-              callStatus
-            ),
-          /*liftString:*/ FfiConverterString.lift
-        );
-      },
+    clonePointer(obj: WalletLike): UniffiHandle {
+      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: UniffiHandle): void {
-        uniffiCaller.rustCall(
-          /*caller:*/ (callStatus) =>
-            nativeModule().ubrn_uniffi_bark_ffi_fn_free_wallet(
-              pointer,
-              callStatus
-            ),
-          /*liftString:*/ FfiConverterString.lift
-        );
-      },
+    freePointer(pointer: UniffiHandle): void {
+      uniffiCaller.rustCall(
+        /*caller:*/ (callStatus) =>
+          nativeModule().ubrn_uniffi_bark_ffi_fn_free_wallet(
+            pointer,
+            callStatus
+          ),
+        /*liftString:*/ FfiConverterString.lift
+      );
+    },
 
-      isConcreteType(obj: any): obj is WalletInterface {
-        return (
-          obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === "Wallet"
-        );
-      },
-    };
-  })();
-// FfiConverter for WalletInterface
+    isConcreteType(obj: any): obj is WalletLike {
+      return (
+        obj[destructorGuardSymbol] && obj[uniffiTypeNameSymbol] === "Wallet"
+      );
+    },
+  };
+})();
+// FfiConverter for WalletLike
 const FfiConverterTypeWallet = new FfiConverterObject(
   uniffiTypeWalletObjectFactory
 );
@@ -8511,7 +8377,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_notificationholder_cancel_next_notification_wait() !==
-    48074
+    6047
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_notificationholder_cancel_next_notification_wait"
@@ -8519,7 +8385,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_notificationholder_next_notification() !==
-    10262
+    33597
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_notificationholder_next_notification"
@@ -8527,7 +8393,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_onchainwallet_balance() !==
-    24090
+    56626
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_onchainwallet_balance"
@@ -8535,7 +8401,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_onchainwallet_new_address() !==
-    19984
+    54598
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_onchainwallet_new_address"
@@ -8543,7 +8409,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_onchainwallet_send() !==
-    11542
+    27783
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_onchainwallet_send"
@@ -8551,7 +8417,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_onchainwallet_sync() !==
-    16676
+    9607
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_onchainwallet_sync"
@@ -8559,7 +8425,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_all_exits_claimable_at_height() !==
-    13253
+    41888
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_all_exits_claimable_at_height"
@@ -8567,7 +8433,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_all_vtxos() !==
-    31
+    41609
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_all_vtxos"
@@ -8575,7 +8441,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_ark_info() !==
-    15972
+    47096
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_ark_info"
@@ -8583,7 +8449,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_balance() !==
-    5493
+    53107
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_balance"
@@ -8591,7 +8457,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_board_all() !==
-    20836
+    6211
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_board_all"
@@ -8599,7 +8465,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_board_amount() !==
-    42039
+    57213
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_board_amount"
@@ -8607,7 +8473,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_bolt11_invoice() !==
-    24463
+    8901
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_bolt11_invoice"
@@ -8615,7 +8481,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_broadcast_tx() !==
-    31354
+    10756
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_broadcast_tx"
@@ -8623,15 +8489,23 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_cancel_all_pending_rounds() !==
-    44373
+    48474
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_cancel_all_pending_rounds"
     );
   }
+  if (
+    nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_cancel_lightning_receive() !==
+    45189
+  ) {
+    throw new UniffiInternalError.ApiChecksumMismatch(
+      "uniffi_bark_ffi_checksum_method_wallet_cancel_lightning_receive"
+    );
+  }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_cancel_pending_round() !==
-    11047
+    63049
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_cancel_pending_round"
@@ -8639,7 +8513,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_check_lightning_payment() !==
-    24026
+    22806
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_check_lightning_payment"
@@ -8647,7 +8521,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_claimable_lightning_receive_balance_sats() !==
-    22912
+    13170
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_claimable_lightning_receive_balance_sats"
@@ -8655,7 +8529,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_config() !==
-    55585
+    52641
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_config"
@@ -8663,7 +8537,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_drain_exits() !==
-    50942
+    24496
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_drain_exits"
@@ -8671,7 +8545,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_estimate_arkoor_payment_fee() !==
-    26310
+    5843
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_estimate_arkoor_payment_fee"
@@ -8679,7 +8553,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_estimate_board_fee() !==
-    21849
+    17847
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_estimate_board_fee"
@@ -8687,7 +8561,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_estimate_lightning_receive_fee() !==
-    45832
+    45860
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_estimate_lightning_receive_fee"
@@ -8695,7 +8569,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_estimate_lightning_send_fee() !==
-    44983
+    18556
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_estimate_lightning_send_fee"
@@ -8703,7 +8577,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_estimate_offboard_all_fee() !==
-    30297
+    26906
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_estimate_offboard_all_fee"
@@ -8711,7 +8585,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_estimate_offboard_fee() !==
-    59237
+    3254
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_estimate_offboard_fee"
@@ -8719,7 +8593,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_estimate_refresh_fee() !==
-    15211
+    47327
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_estimate_refresh_fee"
@@ -8727,7 +8601,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_estimate_send_onchain_fee() !==
-    53679
+    61285
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_estimate_send_onchain_fee"
@@ -8735,7 +8609,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_fingerprint() !==
-    60041
+    59618
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_fingerprint"
@@ -8743,7 +8617,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_get_exit_status() !==
-    18529
+    45568
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_get_exit_status"
@@ -8751,7 +8625,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_get_exit_vtxos() !==
-    54522
+    49255
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_get_exit_vtxos"
@@ -8759,7 +8633,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_get_expiring_vtxos() !==
-    55353
+    30365
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_get_expiring_vtxos"
@@ -8767,7 +8641,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_get_first_expiring_vtxo_blockheight() !==
-    24067
+    17196
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_get_first_expiring_vtxo_blockheight"
@@ -8775,7 +8649,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_get_next_required_refresh_blockheight() !==
-    57380
+    37879
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_get_next_required_refresh_blockheight"
@@ -8783,7 +8657,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_get_vtxo_by_id() !==
-    10372
+    35493
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_get_vtxo_by_id"
@@ -8791,7 +8665,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_get_vtxos_to_refresh() !==
-    22136
+    42602
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_get_vtxos_to_refresh"
@@ -8799,7 +8673,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_has_pending_exits() !==
-    57567
+    46353
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_has_pending_exits"
@@ -8807,7 +8681,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_history() !==
-    15574
+    39257
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_history"
@@ -8815,7 +8689,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_history_by_payment_method() !==
-    61615
+    53117
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_history_by_payment_method"
@@ -8823,7 +8697,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_import_vtxo() !==
-    3547
+    49309
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_import_vtxo"
@@ -8831,7 +8705,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_lightning_receive_status() !==
-    7557
+    8110
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_lightning_receive_status"
@@ -8839,7 +8713,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_list_claimable_exits() !==
-    11227
+    28301
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_list_claimable_exits"
@@ -8847,7 +8721,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_mailbox_authorization() !==
-    8915
+    29750
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_mailbox_authorization"
@@ -8855,7 +8729,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_mailbox_identifier() !==
-    32893
+    36484
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_mailbox_identifier"
@@ -8863,7 +8737,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_maintenance() !==
-    53276
+    7229
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_maintenance"
@@ -8871,7 +8745,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_maintenance_delegated() !==
-    43852
+    33231
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_maintenance_delegated"
@@ -8879,7 +8753,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_maintenance_refresh() !==
-    10551
+    41843
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_maintenance_refresh"
@@ -8887,7 +8761,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_maintenance_with_onchain() !==
-    38002
+    64685
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_maintenance_with_onchain"
@@ -8895,7 +8769,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_maintenance_with_onchain_delegated() !==
-    17750
+    4380
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_maintenance_with_onchain_delegated"
@@ -8903,7 +8777,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_maybe_schedule_maintenance_refresh() !==
-    11223
+    26561
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_maybe_schedule_maintenance_refresh"
@@ -8911,7 +8785,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_network() !==
-    9541
+    62844
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_network"
@@ -8919,7 +8793,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_new_address() !==
-    49689
+    52843
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_new_address"
@@ -8927,7 +8801,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_new_address_with_index() !==
-    51943
+    42716
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_new_address_with_index"
@@ -8935,7 +8809,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_next_round_start_time() !==
-    51623
+    59834
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_next_round_start_time"
@@ -8943,7 +8817,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_notifications() !==
-    32641
+    2291
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_notifications"
@@ -8951,7 +8825,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_offboard_all() !==
-    32138
+    16535
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_offboard_all"
@@ -8959,7 +8833,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_offboard_vtxos() !==
-    3097
+    13685
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_offboard_vtxos"
@@ -8967,7 +8841,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_pay_lightning_address() !==
-    42228
+    61803
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_pay_lightning_address"
@@ -8975,7 +8849,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_pay_lightning_invoice() !==
-    27095
+    52071
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_pay_lightning_invoice"
@@ -8983,7 +8857,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_pay_lightning_offer() !==
-    28769
+    53647
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_pay_lightning_offer"
@@ -8991,7 +8865,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_peak_address() !==
-    58941
+    7833
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_peak_address"
@@ -8999,7 +8873,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_peek_address() !==
-    43710
+    6861
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_peek_address"
@@ -9007,7 +8881,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_pending_board_vtxos() !==
-    13395
+    7372
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_pending_board_vtxos"
@@ -9015,7 +8889,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_pending_boards() !==
-    62067
+    2627
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_pending_boards"
@@ -9023,7 +8897,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_pending_exits_total_sats() !==
-    46977
+    11288
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_pending_exits_total_sats"
@@ -9031,7 +8905,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_pending_lightning_receives() !==
-    35932
+    36627
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_pending_lightning_receives"
@@ -9039,7 +8913,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_pending_lightning_send_vtxos() !==
-    55533
+    2936
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_pending_lightning_send_vtxos"
@@ -9047,7 +8921,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_pending_lightning_sends() !==
-    26660
+    29185
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_pending_lightning_sends"
@@ -9055,7 +8929,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_pending_round_input_vtxos() !==
-    21866
+    47726
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_pending_round_input_vtxos"
@@ -9063,7 +8937,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_pending_round_states() !==
-    35008
+    40607
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_pending_round_states"
@@ -9071,7 +8945,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_progress_exits() !==
-    35774
+    56322
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_progress_exits"
@@ -9079,7 +8953,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_progress_pending_rounds() !==
-    1264
+    32996
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_progress_pending_rounds"
@@ -9087,7 +8961,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_properties() !==
-    19786
+    34379
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_properties"
@@ -9095,7 +8969,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_refresh_server() !==
-    32632
+    8899
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_refresh_server"
@@ -9103,7 +8977,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_refresh_vtxos() !==
-    16414
+    34165
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_refresh_vtxos"
@@ -9111,7 +8985,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_refresh_vtxos_delegated() !==
-    28232
+    16216
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_refresh_vtxos_delegated"
@@ -9119,7 +8993,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_send_arkoor_payment() !==
-    22412
+    30372
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_send_arkoor_payment"
@@ -9127,7 +9001,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_send_onchain() !==
-    11074
+    41628
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_send_onchain"
@@ -9135,7 +9009,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_sign_exit_claim_inputs() !==
-    60570
+    57734
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_sign_exit_claim_inputs"
@@ -9143,7 +9017,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_spendable_vtxos() !==
-    59499
+    50283
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_spendable_vtxos"
@@ -9151,7 +9025,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_start_exit_for_entire_wallet() !==
-    5830
+    64743
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_start_exit_for_entire_wallet"
@@ -9159,14 +9033,14 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_start_exit_for_vtxos() !==
-    60703
+    26632
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_start_exit_for_vtxos"
     );
   }
   if (
-    nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_sync() !== 40752
+    nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_sync() !== 22105
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_sync"
@@ -9174,7 +9048,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_sync_exits() !==
-    64538
+    48880
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_sync_exits"
@@ -9182,7 +9056,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_sync_pending_boards() !==
-    35491
+    54161
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_sync_pending_boards"
@@ -9190,7 +9064,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_try_claim_all_lightning_receives() !==
-    33011
+    8024
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_try_claim_all_lightning_receives"
@@ -9198,7 +9072,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_try_claim_lightning_receive() !==
-    51478
+    15026
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_try_claim_lightning_receive"
@@ -9206,14 +9080,14 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_validate_arkoor_address() !==
-    52352
+    40498
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_validate_arkoor_address"
     );
   }
   if (
-    nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_vtxos() !== 24992
+    nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_vtxos() !== 25706
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_wallet_vtxos"
@@ -9269,7 +9143,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_get_balance() !==
-    17287
+    16407
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_get_balance"
@@ -9277,7 +9151,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_prepare_tx() !==
-    44054
+    7671
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_prepare_tx"
@@ -9285,7 +9159,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_prepare_drain_tx() !==
-    7162
+    15428
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_prepare_drain_tx"
@@ -9293,7 +9167,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_finish_tx() !==
-    60386
+    2070
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_finish_tx"
@@ -9301,7 +9175,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_get_wallet_tx() !==
-    24800
+    35041
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_get_wallet_tx"
@@ -9309,7 +9183,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_get_wallet_tx_confirmed_block() !==
-    908
+    2541
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_get_wallet_tx_confirmed_block"
@@ -9317,7 +9191,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_get_spending_tx() !==
-    62027
+    27495
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_get_spending_tx"
@@ -9325,7 +9199,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_make_signed_p2a_cpfp() !==
-    51567
+    34889
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_make_signed_p2a_cpfp"
@@ -9333,7 +9207,7 @@ function uniffiEnsureInitialized() {
   }
   if (
     nativeModule().ubrn_uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_store_signed_p2a_cpfp() !==
-    35734
+    41685
   ) {
     throw new UniffiInternalError.ApiChecksumMismatch(
       "uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_store_signed_p2a_cpfp"