@secondts/bark-react-native 0.22.0 → 0.23.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -616,7 +616,7 @@ export type Config = {
616
616
  bitcoindCookiefile?: string;
617
617
  bitcoindUser?: string;
618
618
  bitcoindPass?: string;
619
- vtxoRefreshExpiryThreshold?: /*u32*/ number;
619
+ vtxoRefreshExpiryThreshold?: /*u16*/ number;
620
620
  vtxoExitMargin?: /*u16*/ number;
621
621
  htlcRecvClaimDelta?: /*u16*/ number;
622
622
  fallbackFeeRate?: /*u64*/ bigint;
@@ -655,7 +655,7 @@ const FfiConverterTypeConfig = (() => {
655
655
  bitcoindCookiefile: FfiConverterOptionalString.read(from),
656
656
  bitcoindUser: FfiConverterOptionalString.read(from),
657
657
  bitcoindPass: FfiConverterOptionalString.read(from),
658
- vtxoRefreshExpiryThreshold: FfiConverterOptionalUInt32.read(from),
658
+ vtxoRefreshExpiryThreshold: FfiConverterOptionalUInt16.read(from),
659
659
  vtxoExitMargin: FfiConverterOptionalUInt16.read(from),
660
660
  htlcRecvClaimDelta: FfiConverterOptionalUInt16.read(from),
661
661
  fallbackFeeRate: FfiConverterOptionalUInt64.read(from),
@@ -675,7 +675,7 @@ const FfiConverterTypeConfig = (() => {
675
675
  FfiConverterOptionalString.write(value.bitcoindCookiefile, into);
676
676
  FfiConverterOptionalString.write(value.bitcoindUser, into);
677
677
  FfiConverterOptionalString.write(value.bitcoindPass, into);
678
- FfiConverterOptionalUInt32.write(value.vtxoRefreshExpiryThreshold, into);
678
+ FfiConverterOptionalUInt16.write(value.vtxoRefreshExpiryThreshold, into);
679
679
  FfiConverterOptionalUInt16.write(value.vtxoExitMargin, into);
680
680
  FfiConverterOptionalUInt16.write(value.htlcRecvClaimDelta, into);
681
681
  FfiConverterOptionalUInt64.write(value.fallbackFeeRate, into);
@@ -701,7 +701,7 @@ const FfiConverterTypeConfig = (() => {
701
701
  FfiConverterOptionalString.allocationSize(value.bitcoindCookiefile) +
702
702
  FfiConverterOptionalString.allocationSize(value.bitcoindUser) +
703
703
  FfiConverterOptionalString.allocationSize(value.bitcoindPass) +
704
- FfiConverterOptionalUInt32.allocationSize(
704
+ FfiConverterOptionalUInt16.allocationSize(
705
705
  value.vtxoRefreshExpiryThreshold
706
706
  ) +
707
707
  FfiConverterOptionalUInt16.allocationSize(value.vtxoExitMargin) +
@@ -2326,9 +2326,19 @@ const FfiConverterTypeRefreshFees = (() => {
2326
2326
  export type RoundState = {
2327
2327
  id: /*u32*/ number;
2328
2328
  /**
2329
- * Whether the round is ongoing
2329
+ * Whether the interactive part of the round is ongoing. Equivalent to
2330
+ * `state` being `Pending` or `Ongoing`; kept for compatibility.
2330
2331
  */
2331
2332
  ongoing: boolean;
2333
+ /**
2334
+ * Lifecycle phase of the participation.
2335
+ */
2336
+ state: RoundFlowKind;
2337
+ /**
2338
+ * Block height a delegated participation waits for, if it asked the
2339
+ * server to schedule one. Only set while `state` is `DelegatedPending`.
2340
+ */
2341
+ scheduledHeight?: /*u32*/ number;
2332
2342
  };
2333
2343
 
2334
2344
  /**
@@ -2355,16 +2365,22 @@ const FfiConverterTypeRoundState = (() => {
2355
2365
  return {
2356
2366
  id: FfiConverterUInt32.read(from),
2357
2367
  ongoing: FfiConverterBool.read(from),
2368
+ state: FfiConverterTypeRoundFlowKind.read(from),
2369
+ scheduledHeight: FfiConverterOptionalUInt32.read(from),
2358
2370
  };
2359
2371
  }
2360
2372
  write(value: TypeName, into: RustBuffer): void {
2361
2373
  FfiConverterUInt32.write(value.id, into);
2362
2374
  FfiConverterBool.write(value.ongoing, into);
2375
+ FfiConverterTypeRoundFlowKind.write(value.state, into);
2376
+ FfiConverterOptionalUInt32.write(value.scheduledHeight, into);
2363
2377
  }
2364
2378
  allocationSize(value: TypeName): number {
2365
2379
  return (
2366
2380
  FfiConverterUInt32.allocationSize(value.id) +
2367
- FfiConverterBool.allocationSize(value.ongoing)
2381
+ FfiConverterBool.allocationSize(value.ongoing) +
2382
+ FfiConverterTypeRoundFlowKind.allocationSize(value.state) +
2383
+ FfiConverterOptionalUInt32.allocationSize(value.scheduledHeight)
2368
2384
  );
2369
2385
  }
2370
2386
  }
@@ -2492,7 +2508,7 @@ export type WalletOpenArgs = {
2492
2508
  * Whether to skip the seed-recovery mailbox scan
2493
2509
  *
2494
2510
  * The scan runs on the open that creates the wallet locally and makes
2495
- * network calls; its result is available from `Wallet::recovery_report`.
2511
+ * network calls; its outcome is available from `Wallet::recovery_status`.
2496
2512
  * Set this to open without it.
2497
2513
  *
2498
2514
  * Default: false
@@ -4627,6 +4643,291 @@ const FfiConverterTypeOnchainUtxo = (() => {
4627
4643
  return new FFIConverter();
4628
4644
  })();
4629
4645
 
4646
+ // Enum: RecoveryStatus
4647
+ export enum RecoveryStatus_Tags {
4648
+ NotRun = "NotRun",
4649
+ Failed = "Failed",
4650
+ Completed = "Completed",
4651
+ }
4652
+ /**
4653
+ * Outcome of the seed-recovery scan `Wallet::open` runs, mirroring
4654
+ * `bark::RecoveryStatus`.
4655
+ *
4656
+ * The three variants are distinguishable on purpose: `NotRun` means nothing
4657
+ * was attempted (wallet already existed locally, or `skip_recovery` was set),
4658
+ * `Failed` means the scan errored before producing a report so funds may be
4659
+ * missing until a retry succeeds, and `Completed` carries the report — whose
4660
+ * `is_complete` can still be `false` for individual VTXOs.
4661
+ *
4662
+ * Serde/TS tags: `"not-run"` | `"failed"` | `"completed"`.
4663
+ */
4664
+ export const RecoveryStatus = (() => {
4665
+ type NotRun__interface = {
4666
+ tag: RecoveryStatus_Tags.NotRun;
4667
+ };
4668
+
4669
+ /**
4670
+ * No scan was attempted.
4671
+ */
4672
+ class NotRun_ extends UniffiEnum implements NotRun__interface {
4673
+ /**
4674
+ * @private
4675
+ * This field is private and should not be used, use `tag` instead.
4676
+ */
4677
+ readonly [uniffiTypeNameSymbol] = "RecoveryStatus";
4678
+ readonly tag = RecoveryStatus_Tags.NotRun;
4679
+ constructor() {
4680
+ super("RecoveryStatus", "NotRun");
4681
+ }
4682
+
4683
+ static new(): NotRun_ {
4684
+ return new NotRun_();
4685
+ }
4686
+
4687
+ static instanceOf(obj: any): obj is NotRun_ {
4688
+ return obj.tag === RecoveryStatus_Tags.NotRun;
4689
+ }
4690
+ }
4691
+
4692
+ type Failed__interface = {
4693
+ tag: RecoveryStatus_Tags.Failed;
4694
+ inner: Readonly<{ message: string }>;
4695
+ };
4696
+
4697
+ /**
4698
+ * The scan errored before it could produce a report.
4699
+ */
4700
+ class Failed_ extends UniffiEnum implements Failed__interface {
4701
+ /**
4702
+ * @private
4703
+ * This field is private and should not be used, use `tag` instead.
4704
+ */
4705
+ readonly [uniffiTypeNameSymbol] = "RecoveryStatus";
4706
+ readonly tag = RecoveryStatus_Tags.Failed;
4707
+ readonly inner: Readonly<{ message: string }>;
4708
+ constructor(inner: { message: string }) {
4709
+ super("RecoveryStatus", "Failed");
4710
+ this.inner = Object.freeze(inner);
4711
+ }
4712
+
4713
+ static new(inner: { message: string }): Failed_ {
4714
+ return new Failed_(inner);
4715
+ }
4716
+
4717
+ static instanceOf(obj: any): obj is Failed_ {
4718
+ return obj.tag === RecoveryStatus_Tags.Failed;
4719
+ }
4720
+ }
4721
+
4722
+ type Completed__interface = {
4723
+ tag: RecoveryStatus_Tags.Completed;
4724
+ inner: Readonly<{ report: RecoveryReport }>;
4725
+ };
4726
+
4727
+ /**
4728
+ * The scan ran to the end.
4729
+ */
4730
+ class Completed_ extends UniffiEnum implements Completed__interface {
4731
+ /**
4732
+ * @private
4733
+ * This field is private and should not be used, use `tag` instead.
4734
+ */
4735
+ readonly [uniffiTypeNameSymbol] = "RecoveryStatus";
4736
+ readonly tag = RecoveryStatus_Tags.Completed;
4737
+ readonly inner: Readonly<{ report: RecoveryReport }>;
4738
+ constructor(inner: { report: RecoveryReport }) {
4739
+ super("RecoveryStatus", "Completed");
4740
+ this.inner = Object.freeze(inner);
4741
+ }
4742
+
4743
+ static new(inner: { report: RecoveryReport }): Completed_ {
4744
+ return new Completed_(inner);
4745
+ }
4746
+
4747
+ static instanceOf(obj: any): obj is Completed_ {
4748
+ return obj.tag === RecoveryStatus_Tags.Completed;
4749
+ }
4750
+ }
4751
+
4752
+ function instanceOf(obj: any): obj is RecoveryStatus {
4753
+ return obj[uniffiTypeNameSymbol] === "RecoveryStatus";
4754
+ }
4755
+
4756
+ return Object.freeze({
4757
+ instanceOf,
4758
+ NotRun: NotRun_,
4759
+ Failed: Failed_,
4760
+ Completed: Completed_,
4761
+ });
4762
+ })();
4763
+
4764
+ /**
4765
+ * Outcome of the seed-recovery scan `Wallet::open` runs, mirroring
4766
+ * `bark::RecoveryStatus`.
4767
+ *
4768
+ * The three variants are distinguishable on purpose: `NotRun` means nothing
4769
+ * was attempted (wallet already existed locally, or `skip_recovery` was set),
4770
+ * `Failed` means the scan errored before producing a report so funds may be
4771
+ * missing until a retry succeeds, and `Completed` carries the report — whose
4772
+ * `is_complete` can still be `false` for individual VTXOs.
4773
+ *
4774
+ * Serde/TS tags: `"not-run"` | `"failed"` | `"completed"`.
4775
+ */
4776
+
4777
+ export type RecoveryStatus = InstanceType<
4778
+ (typeof RecoveryStatus)[keyof Omit<typeof RecoveryStatus, "instanceOf">]
4779
+ >;
4780
+
4781
+ // FfiConverter for enum RecoveryStatus
4782
+ const FfiConverterTypeRecoveryStatus = (() => {
4783
+ const ordinalConverter = FfiConverterInt32;
4784
+ type TypeName = RecoveryStatus;
4785
+ class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
4786
+ read(from: RustBuffer): TypeName {
4787
+ switch (ordinalConverter.read(from)) {
4788
+ case 1:
4789
+ return new RecoveryStatus.NotRun();
4790
+ case 2:
4791
+ return new RecoveryStatus.Failed({
4792
+ message: FfiConverterString.read(from),
4793
+ });
4794
+ case 3:
4795
+ return new RecoveryStatus.Completed({
4796
+ report: FfiConverterTypeRecoveryReport.read(from),
4797
+ });
4798
+ default:
4799
+ throw new UniffiInternalError.UnexpectedEnumCase();
4800
+ }
4801
+ }
4802
+ write(value: TypeName, into: RustBuffer): void {
4803
+ switch (value.tag) {
4804
+ case RecoveryStatus_Tags.NotRun: {
4805
+ ordinalConverter.write(1, into);
4806
+ return;
4807
+ }
4808
+ case RecoveryStatus_Tags.Failed: {
4809
+ ordinalConverter.write(2, into);
4810
+ const inner = value.inner;
4811
+ FfiConverterString.write(inner.message, into);
4812
+ return;
4813
+ }
4814
+ case RecoveryStatus_Tags.Completed: {
4815
+ ordinalConverter.write(3, into);
4816
+ const inner = value.inner;
4817
+ FfiConverterTypeRecoveryReport.write(inner.report, into);
4818
+ return;
4819
+ }
4820
+ default:
4821
+ // Throwing from here means that RecoveryStatus_Tags hasn't matched an ordinal.
4822
+ throw new UniffiInternalError.UnexpectedEnumCase();
4823
+ }
4824
+ }
4825
+ allocationSize(value: TypeName): number {
4826
+ switch (value.tag) {
4827
+ case RecoveryStatus_Tags.NotRun: {
4828
+ return ordinalConverter.allocationSize(1);
4829
+ }
4830
+ case RecoveryStatus_Tags.Failed: {
4831
+ const inner = value.inner;
4832
+ let size = ordinalConverter.allocationSize(2);
4833
+ size += FfiConverterString.allocationSize(inner.message);
4834
+ return size;
4835
+ }
4836
+ case RecoveryStatus_Tags.Completed: {
4837
+ const inner = value.inner;
4838
+ let size = ordinalConverter.allocationSize(3);
4839
+ size += FfiConverterTypeRecoveryReport.allocationSize(inner.report);
4840
+ return size;
4841
+ }
4842
+ default:
4843
+ throw new UniffiInternalError.UnexpectedEnumCase();
4844
+ }
4845
+ }
4846
+ }
4847
+ return new FFIConverter();
4848
+ })();
4849
+
4850
+ /**
4851
+ * Lifecycle phase of a round participation, mirroring
4852
+ * `bark::round::RoundFlowKind`.
4853
+ *
4854
+ * Serde/TS tags match upstream's `Display` form: `"delegated-pending"` |
4855
+ * `"pending"` | `"ongoing"` | `"awaiting-confirmations"` | `"failed"` |
4856
+ * `"canceled"`.
4857
+ */
4858
+ export enum RoundFlowKind {
4859
+ /**
4860
+ * Delegated participation waiting for its scheduled round. See
4861
+ * [`RoundState::scheduled_height`].
4862
+ */
4863
+ DelegatedPending,
4864
+ /**
4865
+ * Interactive participation waiting for its round.
4866
+ */
4867
+ Pending,
4868
+ /**
4869
+ * The interactive part is being played out with the server.
4870
+ */
4871
+ Ongoing,
4872
+ /**
4873
+ * The round finished; waiting for its funding tx to confirm.
4874
+ */
4875
+ AwaitingConfirmations,
4876
+ /**
4877
+ * The participation failed.
4878
+ */
4879
+ Failed,
4880
+ /**
4881
+ * The user canceled the participation.
4882
+ */
4883
+ Canceled,
4884
+ }
4885
+
4886
+ const FfiConverterTypeRoundFlowKind = (() => {
4887
+ const ordinalConverter = FfiConverterInt32;
4888
+ type TypeName = RoundFlowKind;
4889
+ class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
4890
+ read(from: RustBuffer): TypeName {
4891
+ switch (ordinalConverter.read(from)) {
4892
+ case 1:
4893
+ return RoundFlowKind.DelegatedPending;
4894
+ case 2:
4895
+ return RoundFlowKind.Pending;
4896
+ case 3:
4897
+ return RoundFlowKind.Ongoing;
4898
+ case 4:
4899
+ return RoundFlowKind.AwaitingConfirmations;
4900
+ case 5:
4901
+ return RoundFlowKind.Failed;
4902
+ case 6:
4903
+ return RoundFlowKind.Canceled;
4904
+ default:
4905
+ throw new UniffiInternalError.UnexpectedEnumCase();
4906
+ }
4907
+ }
4908
+ write(value: TypeName, into: RustBuffer): void {
4909
+ switch (value) {
4910
+ case RoundFlowKind.DelegatedPending:
4911
+ return ordinalConverter.write(1, into);
4912
+ case RoundFlowKind.Pending:
4913
+ return ordinalConverter.write(2, into);
4914
+ case RoundFlowKind.Ongoing:
4915
+ return ordinalConverter.write(3, into);
4916
+ case RoundFlowKind.AwaitingConfirmations:
4917
+ return ordinalConverter.write(4, into);
4918
+ case RoundFlowKind.Failed:
4919
+ return ordinalConverter.write(5, into);
4920
+ case RoundFlowKind.Canceled:
4921
+ return ordinalConverter.write(6, into);
4922
+ }
4923
+ }
4924
+ allocationSize(value: TypeName): number {
4925
+ return ordinalConverter.allocationSize(0);
4926
+ }
4927
+ }
4928
+ return new FFIConverter();
4929
+ })();
4930
+
4630
4931
  // Enum: VtxoLockHolder
4631
4932
  export enum VtxoLockHolder_Tags {
4632
4933
  Action = "Action",
@@ -5459,6 +5760,18 @@ export interface CustomOnchainWalletCallbacks {
5459
5760
  * * `tx_hex` - Hex-encoded transaction
5460
5761
  */
5461
5762
  registerTx(txHex: string): /*throws*/ void;
5763
+ /**
5764
+ * Mark a wallet-known transaction as evicted from the mempool
5765
+ *
5766
+ * Bark calls this when a CPFP it broadcast was RBF-replaced by a competing
5767
+ * party, so the tx's inputs should return to coin selection immediately
5768
+ * instead of waiting for the sync eviction grace period. Only ever called
5769
+ * for a tx that has definitively been superseded on-chain.
5770
+ *
5771
+ * # Arguments
5772
+ * * `txid` - Hex-encoded transaction id
5773
+ */
5774
+ evictTx(txid: string): /*throws*/ void;
5462
5775
  /**
5463
5776
  * Create a signed P2A CPFP transaction
5464
5777
  *
@@ -5664,6 +5977,33 @@ export class CustomOnchainWalletCallbacksImpl
5664
5977
  );
5665
5978
  }
5666
5979
 
5980
+ /**
5981
+ * Mark a wallet-known transaction as evicted from the mempool
5982
+ *
5983
+ * Bark calls this when a CPFP it broadcast was RBF-replaced by a competing
5984
+ * party, so the tx's inputs should return to coin selection immediately
5985
+ * instead of waiting for the sync eviction grace period. Only ever called
5986
+ * for a tx that has definitively been superseded on-chain.
5987
+ *
5988
+ * # Arguments
5989
+ * * `txid` - Hex-encoded transaction id
5990
+ */
5991
+ evictTx(txid: string): void /*throws*/ {
5992
+ uniffiCaller.rustCallWithError(
5993
+ /*liftError:*/ FfiConverterTypeError.lift.bind(FfiConverterTypeError),
5994
+ /*caller:*/ (callStatus) => {
5995
+ nativeModule().ubrn_uniffi_bark_ffi_fn_method_customonchainwalletcallbacks_evict_tx(
5996
+ uniffiTypeCustomOnchainWalletCallbacksImplObjectFactory.clonePointer(
5997
+ this
5998
+ ),
5999
+ FfiConverterString.lower(txid),
6000
+ callStatus
6001
+ );
6002
+ },
6003
+ /*liftString:*/ FfiConverterString.lift
6004
+ );
6005
+ }
6006
+
5667
6007
  /**
5668
6008
  * Create a signed P2A CPFP transaction
5669
6009
  *
@@ -5991,6 +6331,27 @@ const uniffiCallbackInterfaceCustomOnchainWalletCallbacks: {
5991
6331
  );
5992
6332
  return uniffiResult;
5993
6333
  },
6334
+ evictTx: (uniffiHandle: bigint, txid: Uint8Array) => {
6335
+ const uniffiMakeCall = (): void => {
6336
+ const jsCallback =
6337
+ FfiConverterTypeCustomOnchainWalletCallbacks.lift(uniffiHandle);
6338
+ return jsCallback.evictTx(FfiConverterString.lift(txid));
6339
+ };
6340
+ const uniffiResult = UniffiResult.ready<void>();
6341
+ const uniffiHandleSuccess = (obj: any) => {};
6342
+ const uniffiHandleError = (code: number, errBuf: UniffiByteArray) => {
6343
+ UniffiResult.writeError(uniffiResult, code, errBuf);
6344
+ };
6345
+ uniffiTraitInterfaceCallWithError(
6346
+ /*makeCall:*/ uniffiMakeCall,
6347
+ /*handleSuccess:*/ uniffiHandleSuccess,
6348
+ /*handleError:*/ uniffiHandleError,
6349
+ /*isErrorType:*/ Exception.instanceOf,
6350
+ /*lowerError:*/ FfiConverterTypeError.lower.bind(FfiConverterTypeError),
6351
+ /*lowerString:*/ FfiConverterString.lower
6352
+ );
6353
+ return uniffiResult;
6354
+ },
5994
6355
  makeSignedP2aCpfp: (uniffiHandle: bigint, params: Uint8Array) => {
5995
6356
  const uniffiMakeCall = (): string => {
5996
6357
  const jsCallback =
@@ -6316,6 +6677,16 @@ export interface OnchainWalletLike {
6316
6677
  balance(asyncOpts_?: {
6317
6678
  signal: AbortSignal;
6318
6679
  }): /*throws*/ Promise<OnchainBalance>;
6680
+ /**
6681
+ * Mark a wallet-known transaction as evicted from the mempool, so its
6682
+ * inputs return to coin selection immediately. Only for a tx that has
6683
+ * definitively been superseded on-chain (e.g. an RBF-replaced exit CPFP);
6684
+ * evicting a still-in-flight tx invites a self-inflicted double-spend.
6685
+ */
6686
+ evictTx(
6687
+ txid: string,
6688
+ asyncOpts_?: { signal: AbortSignal }
6689
+ ): /*throws*/ Promise<void>;
6319
6690
  /**
6320
6691
  * Cached network fee-rate estimates from the wallet's chain source.
6321
6692
  */
@@ -6484,6 +6855,45 @@ export class OnchainWallet
6484
6855
  }
6485
6856
  }
6486
6857
 
6858
+ /**
6859
+ * Mark a wallet-known transaction as evicted from the mempool, so its
6860
+ * inputs return to coin selection immediately. Only for a tx that has
6861
+ * definitively been superseded on-chain (e.g. an RBF-replaced exit CPFP);
6862
+ * evicting a still-in-flight tx invites a self-inflicted double-spend.
6863
+ */
6864
+ async evictTx(
6865
+ txid: string,
6866
+ asyncOpts_?: { signal: AbortSignal }
6867
+ ): Promise<void> /*throws*/ {
6868
+ const __stack = uniffiIsDebug ? new Error().stack : undefined;
6869
+ try {
6870
+ return await uniffiRustCallAsync(
6871
+ /*rustCaller:*/ uniffiCaller,
6872
+ /*rustFutureFunc:*/ () => {
6873
+ return nativeModule().ubrn_uniffi_bark_ffi_fn_method_onchainwallet_evict_tx(
6874
+ uniffiTypeOnchainWalletObjectFactory.clonePointer(this),
6875
+ FfiConverterString.lower(txid)
6876
+ );
6877
+ },
6878
+ /*pollFunc:*/ nativeModule().ubrn_ffi_bark_ffi_rust_future_poll_void,
6879
+ /*cancelFunc:*/ nativeModule()
6880
+ .ubrn_ffi_bark_ffi_rust_future_cancel_void,
6881
+ /*completeFunc:*/ nativeModule()
6882
+ .ubrn_ffi_bark_ffi_rust_future_complete_void,
6883
+ /*freeFunc:*/ nativeModule().ubrn_ffi_bark_ffi_rust_future_free_void,
6884
+ /*liftFunc:*/ (_v) => {},
6885
+ /*liftString:*/ FfiConverterString.lift,
6886
+ /*asyncOpts:*/ asyncOpts_,
6887
+ /*errorHandler:*/ FfiConverterTypeError.lift.bind(FfiConverterTypeError)
6888
+ );
6889
+ } catch (__error: any) {
6890
+ if (uniffiIsDebug && __error instanceof Error) {
6891
+ __error.stack = __stack;
6892
+ }
6893
+ throw __error;
6894
+ }
6895
+ }
6896
+
6487
6897
  /**
6488
6898
  * Cached network fee-rate estimates from the wallet's chain source.
6489
6899
  */
@@ -7205,17 +7615,23 @@ export interface WalletLike {
7205
7615
  asyncOpts_?: { signal: AbortSignal }
7206
7616
  ): /*throws*/ Promise<RecoveryReport>;
7207
7617
  /**
7208
- * Result of the seed-recovery scan that ran during `Wallet::open`, or none
7209
- * if no report was produced.
7210
- *
7211
- * Recovery only runs on the open that creates the wallet locally, and not
7212
- * at all when `WalletOpenArgs.skip_recovery` is set, so this is empty on
7213
- * every subsequent open. It is also empty when the scan itself failed
7214
- * outright — bark logs that and lets open succeed, so an empty result does
7215
- * not prove no funds are missing. `isComplete == false` means funds may
7216
- * still be missing; retry the report's `failed` ids with `recoverVtxos`.
7618
+ * The report of the seed-recovery scan that ran during `Wallet::open`, or
7619
+ * none if the scan did not complete. Use `recovery_status` to tell a scan
7620
+ * that failed apart from one that never ran.
7217
7621
  */
7218
7622
  recoveryReport(): RecoveryReport | undefined;
7623
+ /**
7624
+ * Outcome of the seed-recovery scan that ran during `Wallet::open`.
7625
+ *
7626
+ * Recovery only runs on the open that creates the wallet locally, and not
7627
+ * at all when `WalletOpenArgs.skip_recovery` is set, so this is `NotRun`
7628
+ * on every subsequent open. `Failed` means the scan errored before
7629
+ * producing a report — bark logs that and lets open succeed — so funds
7630
+ * may be missing until a retry; `Completed` carries the report, and
7631
+ * `isComplete == false` there means funds may still be missing. Retry the
7632
+ * report's `failed` ids with `recoverVtxos`.
7633
+ */
7634
+ recoveryStatus(): RecoveryStatus;
7219
7635
  refreshServer(asyncOpts_?: { signal: AbortSignal }): /*throws*/ Promise<void>;
7220
7636
  refreshVtxos(
7221
7637
  vtxoIds: Array<string>,
@@ -7270,6 +7686,14 @@ export interface WalletLike {
7270
7686
  asyncOpts_?: { signal: AbortSignal }
7271
7687
  ): /*throws*/ Promise<void>;
7272
7688
  stopDaemon(asyncOpts_?: { signal: AbortSignal }): /*throws*/ Promise<void>;
7689
+ /**
7690
+ * Stop the background daemon and wait until its tasks have finished, so
7691
+ * nothing runs in the background afterwards (e.g. before deleting the
7692
+ * wallet's datadir). No-op when no daemon is running.
7693
+ */
7694
+ stopDaemonWait(asyncOpts_?: {
7695
+ signal: AbortSignal;
7696
+ }): /*throws*/ Promise<void>;
7273
7697
  stuckFailedLightningSends(asyncOpts_?: {
7274
7698
  signal: AbortSignal;
7275
7699
  }): /*throws*/ Promise<Array<LightningSend>>;
@@ -7302,6 +7726,12 @@ export interface WalletLike {
7302
7726
  expectedHolder: VtxoLockHolder | undefined,
7303
7727
  asyncOpts_?: { signal: AbortSignal }
7304
7728
  ): /*throws*/ Promise<void>;
7729
+ /**
7730
+ * Whether this wallet can pay `address` out-of-round: same network and
7731
+ * server, a supported VTXO policy, and only delivery mechanisms this bark
7732
+ * supports. An address listing no delivery mechanism is valid. Errors only
7733
+ * when the address does not parse.
7734
+ */
7305
7735
  validateArkoorAddress(
7306
7736
  address: string,
7307
7737
  asyncOpts_?: { signal: AbortSignal }
@@ -10081,15 +10511,9 @@ export class Wallet extends UniffiAbstractObject implements WalletLike {
10081
10511
  }
10082
10512
 
10083
10513
  /**
10084
- * Result of the seed-recovery scan that ran during `Wallet::open`, or none
10085
- * if no report was produced.
10086
- *
10087
- * Recovery only runs on the open that creates the wallet locally, and not
10088
- * at all when `WalletOpenArgs.skip_recovery` is set, so this is empty on
10089
- * every subsequent open. It is also empty when the scan itself failed
10090
- * outright — bark logs that and lets open succeed, so an empty result does
10091
- * not prove no funds are missing. `isComplete == false` means funds may
10092
- * still be missing; retry the report's `failed` ids with `recoverVtxos`.
10514
+ * The report of the seed-recovery scan that ran during `Wallet::open`, or
10515
+ * none if the scan did not complete. Use `recovery_status` to tell a scan
10516
+ * that failed apart from one that never ran.
10093
10517
  */
10094
10518
  recoveryReport(): RecoveryReport | undefined {
10095
10519
  return FfiConverterOptionalTypeRecoveryReport.lift(
@@ -10105,6 +10529,31 @@ export class Wallet extends UniffiAbstractObject implements WalletLike {
10105
10529
  );
10106
10530
  }
10107
10531
 
10532
+ /**
10533
+ * Outcome of the seed-recovery scan that ran during `Wallet::open`.
10534
+ *
10535
+ * Recovery only runs on the open that creates the wallet locally, and not
10536
+ * at all when `WalletOpenArgs.skip_recovery` is set, so this is `NotRun`
10537
+ * on every subsequent open. `Failed` means the scan errored before
10538
+ * producing a report — bark logs that and lets open succeed — so funds
10539
+ * may be missing until a retry; `Completed` carries the report, and
10540
+ * `isComplete == false` there means funds may still be missing. Retry the
10541
+ * report's `failed` ids with `recoverVtxos`.
10542
+ */
10543
+ recoveryStatus(): RecoveryStatus {
10544
+ return FfiConverterTypeRecoveryStatus.lift(
10545
+ uniffiCaller.rustCall(
10546
+ /*caller:*/ (callStatus) => {
10547
+ return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_recovery_status(
10548
+ uniffiTypeWalletObjectFactory.clonePointer(this),
10549
+ callStatus
10550
+ );
10551
+ },
10552
+ /*liftString:*/ FfiConverterString.lift
10553
+ )
10554
+ );
10555
+ }
10556
+
10108
10557
  async refreshServer(asyncOpts_?: {
10109
10558
  signal: AbortSignal;
10110
10559
  }): Promise<void> /*throws*/ {
@@ -10560,6 +11009,42 @@ export class Wallet extends UniffiAbstractObject implements WalletLike {
10560
11009
  }
10561
11010
  }
10562
11011
 
11012
+ /**
11013
+ * Stop the background daemon and wait until its tasks have finished, so
11014
+ * nothing runs in the background afterwards (e.g. before deleting the
11015
+ * wallet's datadir). No-op when no daemon is running.
11016
+ */
11017
+ async stopDaemonWait(asyncOpts_?: {
11018
+ signal: AbortSignal;
11019
+ }): Promise<void> /*throws*/ {
11020
+ const __stack = uniffiIsDebug ? new Error().stack : undefined;
11021
+ try {
11022
+ return await uniffiRustCallAsync(
11023
+ /*rustCaller:*/ uniffiCaller,
11024
+ /*rustFutureFunc:*/ () => {
11025
+ return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_stop_daemon_wait(
11026
+ uniffiTypeWalletObjectFactory.clonePointer(this)
11027
+ );
11028
+ },
11029
+ /*pollFunc:*/ nativeModule().ubrn_ffi_bark_ffi_rust_future_poll_void,
11030
+ /*cancelFunc:*/ nativeModule()
11031
+ .ubrn_ffi_bark_ffi_rust_future_cancel_void,
11032
+ /*completeFunc:*/ nativeModule()
11033
+ .ubrn_ffi_bark_ffi_rust_future_complete_void,
11034
+ /*freeFunc:*/ nativeModule().ubrn_ffi_bark_ffi_rust_future_free_void,
11035
+ /*liftFunc:*/ (_v) => {},
11036
+ /*liftString:*/ FfiConverterString.lift,
11037
+ /*asyncOpts:*/ asyncOpts_,
11038
+ /*errorHandler:*/ FfiConverterTypeError.lift.bind(FfiConverterTypeError)
11039
+ );
11040
+ } catch (__error: any) {
11041
+ if (uniffiIsDebug && __error instanceof Error) {
11042
+ __error.stack = __stack;
11043
+ }
11044
+ throw __error;
11045
+ }
11046
+ }
11047
+
10563
11048
  async stuckFailedLightningSends(asyncOpts_?: {
10564
11049
  signal: AbortSignal;
10565
11050
  }): Promise<Array<LightningSend>> /*throws*/ {
@@ -10835,6 +11320,12 @@ export class Wallet extends UniffiAbstractObject implements WalletLike {
10835
11320
  }
10836
11321
  }
10837
11322
 
11323
+ /**
11324
+ * Whether this wallet can pay `address` out-of-round: same network and
11325
+ * server, a supported VTXO policy, and only delivery mechanisms this bark
11326
+ * supports. An address listing no delivery mechanism is valid. Errors only
11327
+ * when the address does not parse.
11328
+ */
10838
11329
  async validateArkoorAddress(
10839
11330
  address: string,
10840
11331
  asyncOpts_?: { signal: AbortSignal }
@@ -11301,9 +11792,17 @@ function uniffiEnsureInitialized() {
11301
11792
  "uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_register_tx"
11302
11793
  );
11303
11794
  }
11795
+ if (
11796
+ nativeModule().ubrn_uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_evict_tx() !==
11797
+ 36298
11798
+ ) {
11799
+ throw new UniffiInternalError.ApiChecksumMismatch(
11800
+ "uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_evict_tx"
11801
+ );
11802
+ }
11304
11803
  if (
11305
11804
  nativeModule().ubrn_uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_make_signed_p2a_cpfp() !==
11306
- 62938
11805
+ 58200
11307
11806
  ) {
11308
11807
  throw new UniffiInternalError.ApiChecksumMismatch(
11309
11808
  "uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_make_signed_p2a_cpfp"
@@ -11311,7 +11810,7 @@ function uniffiEnsureInitialized() {
11311
11810
  }
11312
11811
  if (
11313
11812
  nativeModule().ubrn_uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_store_signed_p2a_cpfp() !==
11314
- 47426
11813
+ 64815
11315
11814
  ) {
11316
11815
  throw new UniffiInternalError.ApiChecksumMismatch(
11317
11816
  "uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_store_signed_p2a_cpfp"
@@ -11319,7 +11818,7 @@ function uniffiEnsureInitialized() {
11319
11818
  }
11320
11819
  if (
11321
11820
  nativeModule().ubrn_uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_sync() !==
11322
- 12900
11821
+ 29018
11323
11822
  ) {
11324
11823
  throw new UniffiInternalError.ApiChecksumMismatch(
11325
11824
  "uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_sync"
@@ -11341,6 +11840,14 @@ function uniffiEnsureInitialized() {
11341
11840
  "uniffi_bark_ffi_checksum_method_onchainwallet_balance"
11342
11841
  );
11343
11842
  }
11843
+ if (
11844
+ nativeModule().ubrn_uniffi_bark_ffi_checksum_method_onchainwallet_evict_tx() !==
11845
+ 26786
11846
+ ) {
11847
+ throw new UniffiInternalError.ApiChecksumMismatch(
11848
+ "uniffi_bark_ffi_checksum_method_onchainwallet_evict_tx"
11849
+ );
11850
+ }
11344
11851
  if (
11345
11852
  nativeModule().ubrn_uniffi_bark_ffi_checksum_method_onchainwallet_fee_rates() !==
11346
11853
  30741
@@ -12015,12 +12522,20 @@ function uniffiEnsureInitialized() {
12015
12522
  }
12016
12523
  if (
12017
12524
  nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_recovery_report() !==
12018
- 54899
12525
+ 10331
12019
12526
  ) {
12020
12527
  throw new UniffiInternalError.ApiChecksumMismatch(
12021
12528
  "uniffi_bark_ffi_checksum_method_wallet_recovery_report"
12022
12529
  );
12023
12530
  }
12531
+ if (
12532
+ nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_recovery_status() !==
12533
+ 14132
12534
+ ) {
12535
+ throw new UniffiInternalError.ApiChecksumMismatch(
12536
+ "uniffi_bark_ffi_checksum_method_wallet_recovery_status"
12537
+ );
12538
+ }
12024
12539
  if (
12025
12540
  nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_refresh_server() !==
12026
12541
  41162
@@ -12125,6 +12640,14 @@ function uniffiEnsureInitialized() {
12125
12640
  "uniffi_bark_ffi_checksum_method_wallet_stop_daemon"
12126
12641
  );
12127
12642
  }
12643
+ if (
12644
+ nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_stop_daemon_wait() !==
12645
+ 1734
12646
+ ) {
12647
+ throw new UniffiInternalError.ApiChecksumMismatch(
12648
+ "uniffi_bark_ffi_checksum_method_wallet_stop_daemon_wait"
12649
+ );
12650
+ }
12128
12651
  if (
12129
12652
  nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_stuck_failed_lightning_sends() !==
12130
12653
  31451
@@ -12190,7 +12713,7 @@ function uniffiEnsureInitialized() {
12190
12713
  }
12191
12714
  if (
12192
12715
  nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_validate_arkoor_address() !==
12193
- 10861
12716
+ 30498
12194
12717
  ) {
12195
12718
  throw new UniffiInternalError.ApiChecksumMismatch(
12196
12719
  "uniffi_bark_ffi_checksum_method_wallet_validate_arkoor_address"
@@ -12290,7 +12813,9 @@ export default Object.freeze({
12290
12813
  FfiConverterTypePpmExpiryFeeEntry,
12291
12814
  FfiConverterTypeRecoveryBucket,
12292
12815
  FfiConverterTypeRecoveryReport,
12816
+ FfiConverterTypeRecoveryStatus,
12293
12817
  FfiConverterTypeRefreshFees,
12818
+ FfiConverterTypeRoundFlowKind,
12294
12819
  FfiConverterTypeRoundState,
12295
12820
  FfiConverterTypeVtxo,
12296
12821
  FfiConverterTypeVtxoLockHolder,