@secondts/bark-react-native 0.22.0 → 0.24.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.
@@ -20,6 +20,16 @@ typeof process !== "object" ||
20
20
  process?.env?.NODE_ENV !== "production" || false;
21
21
  // Public interface members begin here.
22
22
 
23
+ /**
24
+ * Default for `Config.vtxo_key_gap_limit`: the run of consecutive unused
25
+ * seed-derived VTXO key indices a scan crosses before concluding a VTXO
26
+ * isn't ours.
27
+ */
28
+ export function defaultVtxoKeyGapLimit() {
29
+ return FfiConverterUInt32.lift(uniffiCaller.rustCall(/*caller:*/callStatus => {
30
+ return nativeModule().ubrn_uniffi_bark_ffi_fn_func_default_vtxo_key_gap_limit(callStatus);
31
+ }, /*liftString:*/FfiConverterString.lift));
32
+ }
23
33
  /**
24
34
  * Extract a signed transaction from a PSBT
25
35
  *
@@ -47,6 +57,16 @@ export function generateMnemonic() /*throws*/{
47
57
  return nativeModule().ubrn_uniffi_bark_ffi_fn_func_generate_mnemonic(callStatus);
48
58
  }, /*liftString:*/FfiConverterString.lift));
49
59
  }
60
+ /**
61
+ * Largest value `Config.vtxo_key_gap_limit` (or an import/recovery
62
+ * `gap_limit` override) accepts. A scan that matches nothing runs the limit
63
+ * to its end, so an unbounded limit is unbounded work.
64
+ */
65
+ export function maxVtxoKeyGapLimit() {
66
+ return FfiConverterUInt32.lift(uniffiCaller.rustCall(/*caller:*/callStatus => {
67
+ return nativeModule().ubrn_uniffi_bark_ffi_fn_func_max_vtxo_key_gap_limit(callStatus);
68
+ }, /*liftString:*/FfiConverterString.lift));
69
+ }
50
70
  /**
51
71
  * Validate an Ark address (basic format check only)
52
72
  *
@@ -373,7 +393,7 @@ const FfiConverterTypeConfig = (() => {
373
393
  bitcoindCookiefile: FfiConverterOptionalString.read(from),
374
394
  bitcoindUser: FfiConverterOptionalString.read(from),
375
395
  bitcoindPass: FfiConverterOptionalString.read(from),
376
- vtxoRefreshExpiryThreshold: FfiConverterOptionalUInt32.read(from),
396
+ vtxoRefreshExpiryThreshold: FfiConverterOptionalUInt16.read(from),
377
397
  vtxoExitMargin: FfiConverterOptionalUInt16.read(from),
378
398
  htlcRecvClaimDelta: FfiConverterOptionalUInt16.read(from),
379
399
  fallbackFeeRate: FfiConverterOptionalUInt64.read(from),
@@ -382,7 +402,8 @@ const FfiConverterTypeConfig = (() => {
382
402
  offboardRequiredConfirmations: FfiConverterOptionalUInt32.read(from),
383
403
  daemonManualSync: FfiConverterOptionalBool.read(from),
384
404
  lightningReceiveClaimRetries: FfiConverterOptionalUInt8.read(from),
385
- userAgent: FfiConverterOptionalString.read(from)
405
+ userAgent: FfiConverterOptionalString.read(from),
406
+ vtxoKeyGapLimit: FfiConverterOptionalUInt32.read(from)
386
407
  };
387
408
  }
388
409
  write(value, into) {
@@ -393,7 +414,7 @@ const FfiConverterTypeConfig = (() => {
393
414
  FfiConverterOptionalString.write(value.bitcoindCookiefile, into);
394
415
  FfiConverterOptionalString.write(value.bitcoindUser, into);
395
416
  FfiConverterOptionalString.write(value.bitcoindPass, into);
396
- FfiConverterOptionalUInt32.write(value.vtxoRefreshExpiryThreshold, into);
417
+ FfiConverterOptionalUInt16.write(value.vtxoRefreshExpiryThreshold, into);
397
418
  FfiConverterOptionalUInt16.write(value.vtxoExitMargin, into);
398
419
  FfiConverterOptionalUInt16.write(value.htlcRecvClaimDelta, into);
399
420
  FfiConverterOptionalUInt64.write(value.fallbackFeeRate, into);
@@ -403,9 +424,10 @@ const FfiConverterTypeConfig = (() => {
403
424
  FfiConverterOptionalBool.write(value.daemonManualSync, into);
404
425
  FfiConverterOptionalUInt8.write(value.lightningReceiveClaimRetries, into);
405
426
  FfiConverterOptionalString.write(value.userAgent, into);
427
+ FfiConverterOptionalUInt32.write(value.vtxoKeyGapLimit, into);
406
428
  }
407
429
  allocationSize(value) {
408
- return FfiConverterString.allocationSize(value.serverAddress) + FfiConverterOptionalString.allocationSize(value.serverAccessToken) + FfiConverterOptionalString.allocationSize(value.esploraAddress) + FfiConverterOptionalString.allocationSize(value.bitcoindAddress) + FfiConverterOptionalString.allocationSize(value.bitcoindCookiefile) + FfiConverterOptionalString.allocationSize(value.bitcoindUser) + FfiConverterOptionalString.allocationSize(value.bitcoindPass) + FfiConverterOptionalUInt32.allocationSize(value.vtxoRefreshExpiryThreshold) + FfiConverterOptionalUInt16.allocationSize(value.vtxoExitMargin) + FfiConverterOptionalUInt16.allocationSize(value.htlcRecvClaimDelta) + FfiConverterOptionalUInt64.allocationSize(value.fallbackFeeRate) + FfiConverterOptionalUInt32.allocationSize(value.roundTxRequiredConfirmations) + FfiConverterOptionalUInt64.allocationSize(value.daemonSyncIntervalSecs) + FfiConverterOptionalUInt32.allocationSize(value.offboardRequiredConfirmations) + FfiConverterOptionalBool.allocationSize(value.daemonManualSync) + FfiConverterOptionalUInt8.allocationSize(value.lightningReceiveClaimRetries) + FfiConverterOptionalString.allocationSize(value.userAgent);
430
+ return FfiConverterString.allocationSize(value.serverAddress) + FfiConverterOptionalString.allocationSize(value.serverAccessToken) + FfiConverterOptionalString.allocationSize(value.esploraAddress) + FfiConverterOptionalString.allocationSize(value.bitcoindAddress) + FfiConverterOptionalString.allocationSize(value.bitcoindCookiefile) + FfiConverterOptionalString.allocationSize(value.bitcoindUser) + FfiConverterOptionalString.allocationSize(value.bitcoindPass) + FfiConverterOptionalUInt16.allocationSize(value.vtxoRefreshExpiryThreshold) + FfiConverterOptionalUInt16.allocationSize(value.vtxoExitMargin) + FfiConverterOptionalUInt16.allocationSize(value.htlcRecvClaimDelta) + FfiConverterOptionalUInt64.allocationSize(value.fallbackFeeRate) + FfiConverterOptionalUInt32.allocationSize(value.roundTxRequiredConfirmations) + FfiConverterOptionalUInt64.allocationSize(value.daemonSyncIntervalSecs) + FfiConverterOptionalUInt32.allocationSize(value.offboardRequiredConfirmations) + FfiConverterOptionalBool.allocationSize(value.daemonManualSync) + FfiConverterOptionalUInt8.allocationSize(value.lightningReceiveClaimRetries) + FfiConverterOptionalString.allocationSize(value.userAgent) + FfiConverterOptionalUInt32.allocationSize(value.vtxoKeyGapLimit);
409
431
  }
410
432
  }
411
433
  return new FFIConverter();
@@ -896,6 +918,52 @@ const FfiConverterTypeFeeSchedule = (() => {
896
918
  }
897
919
  return new FFIConverter();
898
920
  })();
921
+
922
+ /**
923
+ * Arguments for `Wallet::import_vtxo` / `Wallet::import_vtxos`, mirroring
924
+ * `bark::ImportVtxoArgs`.
925
+ *
926
+ * Every field has a default, so callers only set what they need.
927
+ */
928
+
929
+ /**
930
+ * Generated factory for {@link ImportVtxoArgs} record objects.
931
+ */
932
+ export const ImportVtxoArgs = (() => {
933
+ const defaults = () => ({
934
+ gapLimit: undefined,
935
+ skipStatusCheck: false,
936
+ allowPartial: false
937
+ });
938
+ const create = (() => {
939
+ return uniffiCreateRecord(defaults);
940
+ })();
941
+ return Object.freeze({
942
+ create,
943
+ new: create,
944
+ defaults: () => Object.freeze(defaults())
945
+ });
946
+ })();
947
+ const FfiConverterTypeImportVtxoArgs = (() => {
948
+ class FFIConverter extends AbstractFfiConverterByteArray {
949
+ read(from) {
950
+ return {
951
+ gapLimit: FfiConverterOptionalUInt32.read(from),
952
+ skipStatusCheck: FfiConverterBool.read(from),
953
+ allowPartial: FfiConverterBool.read(from)
954
+ };
955
+ }
956
+ write(value, into) {
957
+ FfiConverterOptionalUInt32.write(value.gapLimit, into);
958
+ FfiConverterBool.write(value.skipStatusCheck, into);
959
+ FfiConverterBool.write(value.allowPartial, into);
960
+ }
961
+ allocationSize(value) {
962
+ return FfiConverterOptionalUInt32.allocationSize(value.gapLimit) + FfiConverterBool.allocationSize(value.skipStatusCheck) + FfiConverterBool.allocationSize(value.allowPartial);
963
+ }
964
+ }
965
+ return new FFIConverter();
966
+ })();
899
967
  /**
900
968
  * Generated factory for {@link LightningInvoice} record objects.
901
969
  */
@@ -1521,15 +1589,19 @@ const FfiConverterTypeRoundState = (() => {
1521
1589
  read(from) {
1522
1590
  return {
1523
1591
  id: FfiConverterUInt32.read(from),
1524
- ongoing: FfiConverterBool.read(from)
1592
+ ongoing: FfiConverterBool.read(from),
1593
+ state: FfiConverterTypeRoundFlowKind.read(from),
1594
+ scheduledHeight: FfiConverterOptionalUInt32.read(from)
1525
1595
  };
1526
1596
  }
1527
1597
  write(value, into) {
1528
1598
  FfiConverterUInt32.write(value.id, into);
1529
1599
  FfiConverterBool.write(value.ongoing, into);
1600
+ FfiConverterTypeRoundFlowKind.write(value.state, into);
1601
+ FfiConverterOptionalUInt32.write(value.scheduledHeight, into);
1530
1602
  }
1531
1603
  allocationSize(value) {
1532
- return FfiConverterUInt32.allocationSize(value.id) + FfiConverterBool.allocationSize(value.ongoing);
1604
+ return FfiConverterUInt32.allocationSize(value.id) + FfiConverterBool.allocationSize(value.ongoing) + FfiConverterTypeRoundFlowKind.allocationSize(value.state) + FfiConverterOptionalUInt32.allocationSize(value.scheduledHeight);
1533
1605
  }
1534
1606
  }
1535
1607
  return new FFIConverter();
@@ -1591,7 +1663,6 @@ const FfiConverterTypeVtxo = (() => {
1591
1663
  export const WalletOpenArgs = (() => {
1592
1664
  const defaults = () => ({
1593
1665
  runDaemon: true,
1594
- onchain: undefined,
1595
1666
  createIfNotExists: true,
1596
1667
  createWithoutServer: false,
1597
1668
  skipRecovery: false
@@ -3270,6 +3341,266 @@ const FfiConverterTypeOnchainUtxo = (() => {
3270
3341
  return new FFIConverter();
3271
3342
  })();
3272
3343
 
3344
+ // Enum: RecoveryStatus
3345
+ export let RecoveryStatus_Tags = /*#__PURE__*/function (RecoveryStatus_Tags) {
3346
+ RecoveryStatus_Tags["NotRun"] = "NotRun";
3347
+ RecoveryStatus_Tags["Failed"] = "Failed";
3348
+ RecoveryStatus_Tags["Completed"] = "Completed";
3349
+ return RecoveryStatus_Tags;
3350
+ }({});
3351
+ /**
3352
+ * Outcome of the seed-recovery scan `Wallet::open` runs, mirroring
3353
+ * `bark::RecoveryStatus`.
3354
+ *
3355
+ * The three variants are distinguishable on purpose: `NotRun` means nothing
3356
+ * was attempted (wallet already existed locally, or `skip_recovery` was set),
3357
+ * `Failed` means the scan errored before producing a report so funds may be
3358
+ * missing until a retry succeeds, and `Completed` carries the report — whose
3359
+ * `is_complete` can still be `false` for individual VTXOs.
3360
+ *
3361
+ * Serde/TS tags: `"not-run"` | `"failed"` | `"completed"`.
3362
+ */
3363
+ export const RecoveryStatus = (() => {
3364
+ /**
3365
+ * No scan was attempted.
3366
+ */
3367
+ class NotRun_ extends UniffiEnum {
3368
+ /**
3369
+ * @private
3370
+ * This field is private and should not be used, use `tag` instead.
3371
+ */
3372
+ [uniffiTypeNameSymbol] = "RecoveryStatus";
3373
+ tag = RecoveryStatus_Tags.NotRun;
3374
+ constructor() {
3375
+ super("RecoveryStatus", "NotRun");
3376
+ }
3377
+ static new() {
3378
+ return new NotRun_();
3379
+ }
3380
+ static instanceOf(obj) {
3381
+ return obj.tag === RecoveryStatus_Tags.NotRun;
3382
+ }
3383
+ }
3384
+ /**
3385
+ * The scan errored before it could produce a report.
3386
+ */
3387
+ class Failed_ extends UniffiEnum {
3388
+ /**
3389
+ * @private
3390
+ * This field is private and should not be used, use `tag` instead.
3391
+ */
3392
+ [uniffiTypeNameSymbol] = "RecoveryStatus";
3393
+ tag = RecoveryStatus_Tags.Failed;
3394
+ constructor(inner) {
3395
+ super("RecoveryStatus", "Failed");
3396
+ this.inner = Object.freeze(inner);
3397
+ }
3398
+ static new(inner) {
3399
+ return new Failed_(inner);
3400
+ }
3401
+ static instanceOf(obj) {
3402
+ return obj.tag === RecoveryStatus_Tags.Failed;
3403
+ }
3404
+ }
3405
+ /**
3406
+ * The scan ran to the end.
3407
+ */
3408
+ class Completed_ extends UniffiEnum {
3409
+ /**
3410
+ * @private
3411
+ * This field is private and should not be used, use `tag` instead.
3412
+ */
3413
+ [uniffiTypeNameSymbol] = "RecoveryStatus";
3414
+ tag = RecoveryStatus_Tags.Completed;
3415
+ constructor(inner) {
3416
+ super("RecoveryStatus", "Completed");
3417
+ this.inner = Object.freeze(inner);
3418
+ }
3419
+ static new(inner) {
3420
+ return new Completed_(inner);
3421
+ }
3422
+ static instanceOf(obj) {
3423
+ return obj.tag === RecoveryStatus_Tags.Completed;
3424
+ }
3425
+ }
3426
+ function instanceOf(obj) {
3427
+ return obj[uniffiTypeNameSymbol] === "RecoveryStatus";
3428
+ }
3429
+ return Object.freeze({
3430
+ instanceOf,
3431
+ NotRun: NotRun_,
3432
+ Failed: Failed_,
3433
+ Completed: Completed_
3434
+ });
3435
+ })();
3436
+
3437
+ /**
3438
+ * Outcome of the seed-recovery scan `Wallet::open` runs, mirroring
3439
+ * `bark::RecoveryStatus`.
3440
+ *
3441
+ * The three variants are distinguishable on purpose: `NotRun` means nothing
3442
+ * was attempted (wallet already existed locally, or `skip_recovery` was set),
3443
+ * `Failed` means the scan errored before producing a report so funds may be
3444
+ * missing until a retry succeeds, and `Completed` carries the report — whose
3445
+ * `is_complete` can still be `false` for individual VTXOs.
3446
+ *
3447
+ * Serde/TS tags: `"not-run"` | `"failed"` | `"completed"`.
3448
+ */
3449
+
3450
+ // FfiConverter for enum RecoveryStatus
3451
+ const FfiConverterTypeRecoveryStatus = (() => {
3452
+ const ordinalConverter = FfiConverterInt32;
3453
+ class FFIConverter extends AbstractFfiConverterByteArray {
3454
+ read(from) {
3455
+ switch (ordinalConverter.read(from)) {
3456
+ case 1:
3457
+ return new RecoveryStatus.NotRun();
3458
+ case 2:
3459
+ return new RecoveryStatus.Failed({
3460
+ message: FfiConverterString.read(from)
3461
+ });
3462
+ case 3:
3463
+ return new RecoveryStatus.Completed({
3464
+ report: FfiConverterTypeRecoveryReport.read(from)
3465
+ });
3466
+ default:
3467
+ throw new UniffiInternalError.UnexpectedEnumCase();
3468
+ }
3469
+ }
3470
+ write(value, into) {
3471
+ switch (value.tag) {
3472
+ case RecoveryStatus_Tags.NotRun:
3473
+ {
3474
+ ordinalConverter.write(1, into);
3475
+ return;
3476
+ }
3477
+ case RecoveryStatus_Tags.Failed:
3478
+ {
3479
+ ordinalConverter.write(2, into);
3480
+ const inner = value.inner;
3481
+ FfiConverterString.write(inner.message, into);
3482
+ return;
3483
+ }
3484
+ case RecoveryStatus_Tags.Completed:
3485
+ {
3486
+ ordinalConverter.write(3, into);
3487
+ const inner = value.inner;
3488
+ FfiConverterTypeRecoveryReport.write(inner.report, into);
3489
+ return;
3490
+ }
3491
+ default:
3492
+ // Throwing from here means that RecoveryStatus_Tags hasn't matched an ordinal.
3493
+ throw new UniffiInternalError.UnexpectedEnumCase();
3494
+ }
3495
+ }
3496
+ allocationSize(value) {
3497
+ switch (value.tag) {
3498
+ case RecoveryStatus_Tags.NotRun:
3499
+ {
3500
+ return ordinalConverter.allocationSize(1);
3501
+ }
3502
+ case RecoveryStatus_Tags.Failed:
3503
+ {
3504
+ const inner = value.inner;
3505
+ let size = ordinalConverter.allocationSize(2);
3506
+ size += FfiConverterString.allocationSize(inner.message);
3507
+ return size;
3508
+ }
3509
+ case RecoveryStatus_Tags.Completed:
3510
+ {
3511
+ const inner = value.inner;
3512
+ let size = ordinalConverter.allocationSize(3);
3513
+ size += FfiConverterTypeRecoveryReport.allocationSize(inner.report);
3514
+ return size;
3515
+ }
3516
+ default:
3517
+ throw new UniffiInternalError.UnexpectedEnumCase();
3518
+ }
3519
+ }
3520
+ }
3521
+ return new FFIConverter();
3522
+ })();
3523
+
3524
+ /**
3525
+ * Lifecycle phase of a round participation, mirroring
3526
+ * `bark::round::RoundFlowKind`.
3527
+ *
3528
+ * Serde/TS tags match upstream's `Display` form: `"delegated-pending"` |
3529
+ * `"pending"` | `"ongoing"` | `"awaiting-confirmations"` | `"failed"` |
3530
+ * `"canceled"`.
3531
+ */
3532
+ export let RoundFlowKind = /*#__PURE__*/function (RoundFlowKind) {
3533
+ /**
3534
+ * Delegated participation waiting for its scheduled round. See
3535
+ * [`RoundState::scheduled_height`].
3536
+ */
3537
+ RoundFlowKind[RoundFlowKind["DelegatedPending"] = 0] = "DelegatedPending";
3538
+ /**
3539
+ * Interactive participation waiting for its round.
3540
+ */
3541
+ RoundFlowKind[RoundFlowKind["Pending"] = 1] = "Pending";
3542
+ /**
3543
+ * The interactive part is being played out with the server.
3544
+ */
3545
+ RoundFlowKind[RoundFlowKind["Ongoing"] = 2] = "Ongoing";
3546
+ /**
3547
+ * The round finished; waiting for its funding tx to confirm.
3548
+ */
3549
+ RoundFlowKind[RoundFlowKind["AwaitingConfirmations"] = 3] = "AwaitingConfirmations";
3550
+ /**
3551
+ * The participation failed.
3552
+ */
3553
+ RoundFlowKind[RoundFlowKind["Failed"] = 4] = "Failed";
3554
+ /**
3555
+ * The user canceled the participation.
3556
+ */
3557
+ RoundFlowKind[RoundFlowKind["Canceled"] = 5] = "Canceled";
3558
+ return RoundFlowKind;
3559
+ }({});
3560
+ const FfiConverterTypeRoundFlowKind = (() => {
3561
+ const ordinalConverter = FfiConverterInt32;
3562
+ class FFIConverter extends AbstractFfiConverterByteArray {
3563
+ read(from) {
3564
+ switch (ordinalConverter.read(from)) {
3565
+ case 1:
3566
+ return RoundFlowKind.DelegatedPending;
3567
+ case 2:
3568
+ return RoundFlowKind.Pending;
3569
+ case 3:
3570
+ return RoundFlowKind.Ongoing;
3571
+ case 4:
3572
+ return RoundFlowKind.AwaitingConfirmations;
3573
+ case 5:
3574
+ return RoundFlowKind.Failed;
3575
+ case 6:
3576
+ return RoundFlowKind.Canceled;
3577
+ default:
3578
+ throw new UniffiInternalError.UnexpectedEnumCase();
3579
+ }
3580
+ }
3581
+ write(value, into) {
3582
+ switch (value) {
3583
+ case RoundFlowKind.DelegatedPending:
3584
+ return ordinalConverter.write(1, into);
3585
+ case RoundFlowKind.Pending:
3586
+ return ordinalConverter.write(2, into);
3587
+ case RoundFlowKind.Ongoing:
3588
+ return ordinalConverter.write(3, into);
3589
+ case RoundFlowKind.AwaitingConfirmations:
3590
+ return ordinalConverter.write(4, into);
3591
+ case RoundFlowKind.Failed:
3592
+ return ordinalConverter.write(5, into);
3593
+ case RoundFlowKind.Canceled:
3594
+ return ordinalConverter.write(6, into);
3595
+ }
3596
+ }
3597
+ allocationSize(value) {
3598
+ return ordinalConverter.allocationSize(0);
3599
+ }
3600
+ }
3601
+ return new FFIConverter();
3602
+ })();
3603
+
3273
3604
  // Enum: VtxoLockHolder
3274
3605
  export let VtxoLockHolder_Tags = /*#__PURE__*/function (VtxoLockHolder_Tags) {
3275
3606
  VtxoLockHolder_Tags["Action"] = "Action";
@@ -3986,6 +4317,23 @@ export class CustomOnchainWalletCallbacksImpl extends UniffiAbstractObject {
3986
4317
  }, /*liftString:*/FfiConverterString.lift);
3987
4318
  }
3988
4319
 
4320
+ /**
4321
+ * Mark a wallet-known transaction as evicted from the mempool
4322
+ *
4323
+ * Bark calls this when a CPFP it broadcast was RBF-replaced by a competing
4324
+ * party, so the tx's inputs should return to coin selection immediately
4325
+ * instead of waiting for the sync eviction grace period. Only ever called
4326
+ * for a tx that has definitively been superseded on-chain.
4327
+ *
4328
+ * # Arguments
4329
+ * * `txid` - Hex-encoded transaction id
4330
+ */
4331
+ evictTx(txid) /*throws*/{
4332
+ uniffiCaller.rustCallWithError(/*liftError:*/FfiConverterTypeError.lift.bind(FfiConverterTypeError), /*caller:*/callStatus => {
4333
+ nativeModule().ubrn_uniffi_bark_ffi_fn_method_customonchainwalletcallbacks_evict_tx(uniffiTypeCustomOnchainWalletCallbacksImplObjectFactory.clonePointer(this), FfiConverterString.lower(txid), callStatus);
4334
+ }, /*liftString:*/FfiConverterString.lift);
4335
+ }
4336
+
3989
4337
  /**
3990
4338
  * Create a signed P2A CPFP transaction
3991
4339
  *
@@ -4174,6 +4522,19 @@ const uniffiCallbackInterfaceCustomOnchainWalletCallbacks = {
4174
4522
  uniffiTraitInterfaceCallWithError(/*makeCall:*/uniffiMakeCall, /*handleSuccess:*/uniffiHandleSuccess, /*handleError:*/uniffiHandleError, /*isErrorType:*/Exception.instanceOf, /*lowerError:*/FfiConverterTypeError.lower.bind(FfiConverterTypeError), /*lowerString:*/FfiConverterString.lower);
4175
4523
  return uniffiResult;
4176
4524
  },
4525
+ evictTx: (uniffiHandle, txid) => {
4526
+ const uniffiMakeCall = () => {
4527
+ const jsCallback = FfiConverterTypeCustomOnchainWalletCallbacks.lift(uniffiHandle);
4528
+ return jsCallback.evictTx(FfiConverterString.lift(txid));
4529
+ };
4530
+ const uniffiResult = UniffiResult.ready();
4531
+ const uniffiHandleSuccess = obj => {};
4532
+ const uniffiHandleError = (code, errBuf) => {
4533
+ UniffiResult.writeError(uniffiResult, code, errBuf);
4534
+ };
4535
+ uniffiTraitInterfaceCallWithError(/*makeCall:*/uniffiMakeCall, /*handleSuccess:*/uniffiHandleSuccess, /*handleError:*/uniffiHandleError, /*isErrorType:*/Exception.instanceOf, /*lowerError:*/FfiConverterTypeError.lower.bind(FfiConverterTypeError), /*lowerString:*/FfiConverterString.lower);
4536
+ return uniffiResult;
4537
+ },
4177
4538
  makeSignedP2aCpfp: (uniffiHandle, params) => {
4178
4539
  const uniffiMakeCall = () => {
4179
4540
  const jsCallback = FfiConverterTypeCustomOnchainWalletCallbacks.lift(uniffiHandle);
@@ -4428,6 +4789,26 @@ export class OnchainWallet extends UniffiAbstractObject {
4428
4789
  }
4429
4790
  }
4430
4791
 
4792
+ /**
4793
+ * Mark a wallet-known transaction as evicted from the mempool, so its
4794
+ * inputs return to coin selection immediately. Only for a tx that has
4795
+ * definitively been superseded on-chain (e.g. an RBF-replaced exit CPFP);
4796
+ * evicting a still-in-flight tx invites a self-inflicted double-spend.
4797
+ */
4798
+ async evictTx(txid, asyncOpts_) /*throws*/{
4799
+ const __stack = uniffiIsDebug ? new Error().stack : undefined;
4800
+ try {
4801
+ return await uniffiRustCallAsync(/*rustCaller:*/uniffiCaller, /*rustFutureFunc:*/() => {
4802
+ return nativeModule().ubrn_uniffi_bark_ffi_fn_method_onchainwallet_evict_tx(uniffiTypeOnchainWalletObjectFactory.clonePointer(this), FfiConverterString.lower(txid));
4803
+ }, /*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:*/FfiConverterTypeError.lift.bind(FfiConverterTypeError));
4804
+ } catch (__error) {
4805
+ if (uniffiIsDebug && __error instanceof Error) {
4806
+ __error.stack = __stack;
4807
+ }
4808
+ throw __error;
4809
+ }
4810
+ }
4811
+
4431
4812
  /**
4432
4813
  * Cached network fee-rate estimates from the wallet's chain source.
4433
4814
  */
@@ -5229,15 +5610,20 @@ export class Wallet extends UniffiAbstractObject {
5229
5610
  /**
5230
5611
  * Import a VTXO from its serialized form (hex or base64).
5231
5612
  *
5232
- * The parameter keeps its historical `vtxo_base64` name for foreign
5613
+ * The VTXO is stored in the state the server reports for it, so one that
5614
+ * was already spent is recorded as spent rather than refused. Pass `args`
5615
+ * to widen the key-scan gap limit, skip the server status check, or allow
5616
+ * partial success; omit it for the defaults.
5617
+ *
5618
+ * The first parameter keeps its historical `vtxo_base64` name for foreign
5233
5619
  * binding compatibility (uniffi exposes parameter names), but hex as
5234
5620
  * returned by [`Wallet::vtxo_encoded`] is accepted too.
5235
5621
  */
5236
- async importVtxo(vtxoBase64, asyncOpts_) /*throws*/{
5622
+ async importVtxo(vtxoBase64, args = undefined, asyncOpts_) /*throws*/{
5237
5623
  const __stack = uniffiIsDebug ? new Error().stack : undefined;
5238
5624
  try {
5239
5625
  return await uniffiRustCallAsync(/*rustCaller:*/uniffiCaller, /*rustFutureFunc:*/() => {
5240
- return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_import_vtxo(uniffiTypeWalletObjectFactory.clonePointer(this), FfiConverterString.lower(vtxoBase64));
5626
+ return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_import_vtxo(uniffiTypeWalletObjectFactory.clonePointer(this), FfiConverterString.lower(vtxoBase64), FfiConverterOptionalTypeImportVtxoArgs.lower(args));
5241
5627
  }, /*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:*/FfiConverterTypeError.lift.bind(FfiConverterTypeError));
5242
5628
  } catch (__error) {
5243
5629
  if (uniffiIsDebug && __error instanceof Error) {
@@ -5246,6 +5632,29 @@ export class Wallet extends UniffiAbstractObject {
5246
5632
  throw __error;
5247
5633
  }
5248
5634
  }
5635
+
5636
+ /**
5637
+ * Import several VTXOs (hex or base64) under a single key scan and a
5638
+ * single write, which is why this is not just a loop over `import_vtxo`.
5639
+ *
5640
+ * Returns the ids now held — whether this call stored them or found them
5641
+ * already present — so a failed batch can be retried. One VTXO that cannot
5642
+ * be imported discards the whole batch unless `args.allow_partial` is set,
5643
+ * in which case the ones that did import are kept.
5644
+ */
5645
+ async importVtxos(encodedVtxos, args = undefined, asyncOpts_) /*throws*/{
5646
+ const __stack = uniffiIsDebug ? new Error().stack : undefined;
5647
+ try {
5648
+ return await uniffiRustCallAsync(/*rustCaller:*/uniffiCaller, /*rustFutureFunc:*/() => {
5649
+ return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_import_vtxos(uniffiTypeWalletObjectFactory.clonePointer(this), FfiConverterArrayString.lower(encodedVtxos), FfiConverterOptionalTypeImportVtxoArgs.lower(args));
5650
+ }, /*pollFunc:*/nativeModule().ubrn_ffi_bark_ffi_rust_future_poll_rust_buffer, /*cancelFunc:*/nativeModule().ubrn_ffi_bark_ffi_rust_future_cancel_rust_buffer, /*completeFunc:*/nativeModule().ubrn_ffi_bark_ffi_rust_future_complete_rust_buffer, /*freeFunc:*/nativeModule().ubrn_ffi_bark_ffi_rust_future_free_rust_buffer, /*liftFunc:*/FfiConverterArrayString.lift.bind(FfiConverterArrayString), /*liftString:*/FfiConverterString.lift, /*asyncOpts:*/asyncOpts_, /*errorHandler:*/FfiConverterTypeError.lift.bind(FfiConverterTypeError));
5651
+ } catch (__error) {
5652
+ if (uniffiIsDebug && __error instanceof Error) {
5653
+ __error.stack = __stack;
5654
+ }
5655
+ throw __error;
5656
+ }
5657
+ }
5249
5658
  async isInvoicePaid(paymentHash, asyncOpts_) /*throws*/{
5250
5659
  const __stack = uniffiIsDebug ? new Error().stack : undefined;
5251
5660
  try {
@@ -5672,12 +6081,16 @@ export class Wallet extends UniffiAbstractObject {
5672
6081
  * Recover the given VTXO ids from the server, importing the ones this
5673
6082
  * wallet owns that are still spendable. Use it to retry ids a previous
5674
6083
  * scan reported as `failed`.
6084
+ *
6085
+ * `gap_limit` overrides `Config.vtxo_key_gap_limit` for the key scan that
6086
+ * decides which of `vtxo_ids` this wallet owns. Widen it to reach ids a
6087
+ * previous scan bucketed as `foreign`.
5675
6088
  */
5676
- async recoverVtxos(vtxoIds, asyncOpts_) /*throws*/{
6089
+ async recoverVtxos(vtxoIds, gapLimit = undefined, asyncOpts_) /*throws*/{
5677
6090
  const __stack = uniffiIsDebug ? new Error().stack : undefined;
5678
6091
  try {
5679
6092
  return await uniffiRustCallAsync(/*rustCaller:*/uniffiCaller, /*rustFutureFunc:*/() => {
5680
- return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_recover_vtxos(uniffiTypeWalletObjectFactory.clonePointer(this), FfiConverterArrayString.lower(vtxoIds));
6093
+ return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_recover_vtxos(uniffiTypeWalletObjectFactory.clonePointer(this), FfiConverterArrayString.lower(vtxoIds), FfiConverterOptionalUInt32.lower(gapLimit));
5681
6094
  }, /*pollFunc:*/nativeModule().ubrn_ffi_bark_ffi_rust_future_poll_rust_buffer, /*cancelFunc:*/nativeModule().ubrn_ffi_bark_ffi_rust_future_cancel_rust_buffer, /*completeFunc:*/nativeModule().ubrn_ffi_bark_ffi_rust_future_complete_rust_buffer, /*freeFunc:*/nativeModule().ubrn_ffi_bark_ffi_rust_future_free_rust_buffer, /*liftFunc:*/FfiConverterTypeRecoveryReport.lift.bind(FfiConverterTypeRecoveryReport), /*liftString:*/FfiConverterString.lift, /*asyncOpts:*/asyncOpts_, /*errorHandler:*/FfiConverterTypeError.lift.bind(FfiConverterTypeError));
5682
6095
  } catch (__error) {
5683
6096
  if (uniffiIsDebug && __error instanceof Error) {
@@ -5688,21 +6101,32 @@ export class Wallet extends UniffiAbstractObject {
5688
6101
  }
5689
6102
 
5690
6103
  /**
5691
- * Result of the seed-recovery scan that ran during `Wallet::open`, or none
5692
- * if no report was produced.
5693
- *
5694
- * Recovery only runs on the open that creates the wallet locally, and not
5695
- * at all when `WalletOpenArgs.skip_recovery` is set, so this is empty on
5696
- * every subsequent open. It is also empty when the scan itself failed
5697
- * outright — bark logs that and lets open succeed, so an empty result does
5698
- * not prove no funds are missing. `isComplete == false` means funds may
5699
- * still be missing; retry the report's `failed` ids with `recoverVtxos`.
6104
+ * The report of the seed-recovery scan that ran during `Wallet::open`, or
6105
+ * none if the scan did not complete. Use `recovery_status` to tell a scan
6106
+ * that failed apart from one that never ran.
5700
6107
  */
5701
6108
  recoveryReport() {
5702
6109
  return FfiConverterOptionalTypeRecoveryReport.lift(uniffiCaller.rustCall(/*caller:*/callStatus => {
5703
6110
  return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_recovery_report(uniffiTypeWalletObjectFactory.clonePointer(this), callStatus);
5704
6111
  }, /*liftString:*/FfiConverterString.lift));
5705
6112
  }
6113
+
6114
+ /**
6115
+ * Outcome of the seed-recovery scan that ran during `Wallet::open`.
6116
+ *
6117
+ * Recovery only runs on the open that creates the wallet locally, and not
6118
+ * at all when `WalletOpenArgs.skip_recovery` is set, so this is `NotRun`
6119
+ * on every subsequent open. `Failed` means the scan errored before
6120
+ * producing a report — bark logs that and lets open succeed — so funds
6121
+ * may be missing until a retry; `Completed` carries the report, and
6122
+ * `isComplete == false` there means funds may still be missing. Retry the
6123
+ * report's `failed` ids with `recoverVtxos`.
6124
+ */
6125
+ recoveryStatus() {
6126
+ return FfiConverterTypeRecoveryStatus.lift(uniffiCaller.rustCall(/*caller:*/callStatus => {
6127
+ return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_recovery_status(uniffiTypeWalletObjectFactory.clonePointer(this), callStatus);
6128
+ }, /*liftString:*/FfiConverterString.lift));
6129
+ }
5706
6130
  async refreshServer(asyncOpts_) /*throws*/{
5707
6131
  const __stack = uniffiIsDebug ? new Error().stack : undefined;
5708
6132
  try {
@@ -5884,6 +6308,25 @@ export class Wallet extends UniffiAbstractObject {
5884
6308
  throw __error;
5885
6309
  }
5886
6310
  }
6311
+
6312
+ /**
6313
+ * Stop the background daemon and wait until its tasks have finished, so
6314
+ * nothing runs in the background afterwards (e.g. before deleting the
6315
+ * wallet's datadir). No-op when no daemon is running.
6316
+ */
6317
+ async stopDaemonWait(asyncOpts_) /*throws*/{
6318
+ const __stack = uniffiIsDebug ? new Error().stack : undefined;
6319
+ try {
6320
+ return await uniffiRustCallAsync(/*rustCaller:*/uniffiCaller, /*rustFutureFunc:*/() => {
6321
+ return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_stop_daemon_wait(uniffiTypeWalletObjectFactory.clonePointer(this));
6322
+ }, /*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:*/FfiConverterTypeError.lift.bind(FfiConverterTypeError));
6323
+ } catch (__error) {
6324
+ if (uniffiIsDebug && __error instanceof Error) {
6325
+ __error.stack = __stack;
6326
+ }
6327
+ throw __error;
6328
+ }
6329
+ }
5887
6330
  async stuckFailedLightningSends(asyncOpts_) /*throws*/{
5888
6331
  const __stack = uniffiIsDebug ? new Error().stack : undefined;
5889
6332
  try {
@@ -5996,6 +6439,13 @@ export class Wallet extends UniffiAbstractObject {
5996
6439
  throw __error;
5997
6440
  }
5998
6441
  }
6442
+
6443
+ /**
6444
+ * Whether this wallet can pay `address` out-of-round: same network and
6445
+ * server, a supported VTXO policy, and only delivery mechanisms this bark
6446
+ * supports. An address listing no delivery mechanism is valid. Errors only
6447
+ * when the address does not parse.
6448
+ */
5999
6449
  async validateArkoorAddress(address, asyncOpts_) /*throws*/{
6000
6450
  const __stack = uniffiIsDebug ? new Error().stack : undefined;
6001
6451
  try {
@@ -6109,6 +6559,9 @@ const FfiConverterOptionalTypeBlockRef = new FfiConverterOptional(FfiConverterTy
6109
6559
  // FfiConverter for ExitTransactionStatus | undefined
6110
6560
  const FfiConverterOptionalTypeExitTransactionStatus = new FfiConverterOptional(FfiConverterTypeExitTransactionStatus);
6111
6561
 
6562
+ // FfiConverter for ImportVtxoArgs | undefined
6563
+ const FfiConverterOptionalTypeImportVtxoArgs = new FfiConverterOptional(FfiConverterTypeImportVtxoArgs);
6564
+
6112
6565
  // FfiConverter for RecoveryReport | undefined
6113
6566
  const FfiConverterOptionalTypeRecoveryReport = new FfiConverterOptional(FfiConverterTypeRecoveryReport);
6114
6567
 
@@ -6208,12 +6661,18 @@ function uniffiEnsureInitialized() {
6208
6661
  if (bindingsContractVersion !== scaffoldingContractVersion) {
6209
6662
  throw new UniffiInternalError.ContractVersionMismatch(scaffoldingContractVersion, bindingsContractVersion);
6210
6663
  }
6664
+ if (nativeModule().ubrn_uniffi_bark_ffi_checksum_func_default_vtxo_key_gap_limit() !== 3344) {
6665
+ throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_func_default_vtxo_key_gap_limit");
6666
+ }
6211
6667
  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_func_extract_tx_from_psbt() !== 8893) {
6212
6668
  throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_func_extract_tx_from_psbt");
6213
6669
  }
6214
6670
  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_func_generate_mnemonic() !== 65033) {
6215
6671
  throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_func_generate_mnemonic");
6216
6672
  }
6673
+ if (nativeModule().ubrn_uniffi_bark_ffi_checksum_func_max_vtxo_key_gap_limit() !== 15808) {
6674
+ throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_func_max_vtxo_key_gap_limit");
6675
+ }
6217
6676
  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_func_validate_ark_address() !== 43084) {
6218
6677
  throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_func_validate_ark_address");
6219
6678
  }
@@ -6250,13 +6709,16 @@ function uniffiEnsureInitialized() {
6250
6709
  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_register_tx() !== 17970) {
6251
6710
  throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_register_tx");
6252
6711
  }
6253
- if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_make_signed_p2a_cpfp() !== 62938) {
6712
+ if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_evict_tx() !== 36298) {
6713
+ throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_evict_tx");
6714
+ }
6715
+ if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_make_signed_p2a_cpfp() !== 58200) {
6254
6716
  throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_make_signed_p2a_cpfp");
6255
6717
  }
6256
- if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_store_signed_p2a_cpfp() !== 47426) {
6718
+ if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_store_signed_p2a_cpfp() !== 64815) {
6257
6719
  throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_store_signed_p2a_cpfp");
6258
6720
  }
6259
- if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_sync() !== 12900) {
6721
+ if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_sync() !== 29018) {
6260
6722
  throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_customonchainwalletcallbacks_sync");
6261
6723
  }
6262
6724
  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_barklogger_log() !== 30279) {
@@ -6265,6 +6727,9 @@ function uniffiEnsureInitialized() {
6265
6727
  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_onchainwallet_balance() !== 39213) {
6266
6728
  throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_onchainwallet_balance");
6267
6729
  }
6730
+ if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_onchainwallet_evict_tx() !== 26786) {
6731
+ throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_onchainwallet_evict_tx");
6732
+ }
6268
6733
  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_onchainwallet_fee_rates() !== 30741) {
6269
6734
  throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_onchainwallet_fee_rates");
6270
6735
  }
@@ -6412,9 +6877,12 @@ function uniffiEnsureInitialized() {
6412
6877
  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_history_by_payment_method() !== 11845) {
6413
6878
  throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_history_by_payment_method");
6414
6879
  }
6415
- if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_import_vtxo() !== 48135) {
6880
+ if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_import_vtxo() !== 26027) {
6416
6881
  throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_import_vtxo");
6417
6882
  }
6883
+ if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_import_vtxos() !== 13727) {
6884
+ throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_import_vtxos");
6885
+ }
6418
6886
  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_is_invoice_paid() !== 31079) {
6419
6887
  throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_is_invoice_paid");
6420
6888
  }
@@ -6514,12 +6982,15 @@ function uniffiEnsureInitialized() {
6514
6982
  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_properties() !== 9773) {
6515
6983
  throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_properties");
6516
6984
  }
6517
- if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_recover_vtxos() !== 640) {
6985
+ if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_recover_vtxos() !== 56476) {
6518
6986
  throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_recover_vtxos");
6519
6987
  }
6520
- if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_recovery_report() !== 54899) {
6988
+ if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_recovery_report() !== 10331) {
6521
6989
  throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_recovery_report");
6522
6990
  }
6991
+ if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_recovery_status() !== 14132) {
6992
+ throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_recovery_status");
6993
+ }
6523
6994
  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_refresh_server() !== 41162) {
6524
6995
  throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_refresh_server");
6525
6996
  }
@@ -6559,6 +7030,9 @@ function uniffiEnsureInitialized() {
6559
7030
  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_stop_daemon() !== 7109) {
6560
7031
  throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_stop_daemon");
6561
7032
  }
7033
+ if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_stop_daemon_wait() !== 1734) {
7034
+ throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_stop_daemon_wait");
7035
+ }
6562
7036
  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_stuck_failed_lightning_sends() !== 31451) {
6563
7037
  throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_stuck_failed_lightning_sends");
6564
7038
  }
@@ -6583,7 +7057,7 @@ function uniffiEnsureInitialized() {
6583
7057
  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_unlock_vtxos() !== 42168) {
6584
7058
  throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_unlock_vtxos");
6585
7059
  }
6586
- if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_validate_arkoor_address() !== 10861) {
7060
+ if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_validate_arkoor_address() !== 30498) {
6587
7061
  throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_validate_arkoor_address");
6588
7062
  }
6589
7063
  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_vtxo_encoded() !== 25637) {
@@ -6634,6 +7108,7 @@ export default Object.freeze({
6634
7108
  FfiConverterTypeFeeEstimate,
6635
7109
  FfiConverterTypeFeeRates,
6636
7110
  FfiConverterTypeFeeSchedule,
7111
+ FfiConverterTypeImportVtxoArgs,
6637
7112
  FfiConverterTypeLightningInvoice,
6638
7113
  FfiConverterTypeLightningReceive,
6639
7114
  FfiConverterTypeLightningReceiveFees,
@@ -6654,7 +7129,9 @@ export default Object.freeze({
6654
7129
  FfiConverterTypePpmExpiryFeeEntry,
6655
7130
  FfiConverterTypeRecoveryBucket,
6656
7131
  FfiConverterTypeRecoveryReport,
7132
+ FfiConverterTypeRecoveryStatus,
6657
7133
  FfiConverterTypeRefreshFees,
7134
+ FfiConverterTypeRoundFlowKind,
6658
7135
  FfiConverterTypeRoundState,
6659
7136
  FfiConverterTypeVtxo,
6660
7137
  FfiConverterTypeVtxoLockHolder,