@secondts/bark-react-native 0.13.0 → 0.15.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.
@@ -1 +1 @@
1
- {"version":3,"names":["getter","globalThis","NativeBark","isRustFutureContinuationCallbackTypeCompatible","isUniffiForeignFutureTypeCompatible"],"sourceRoot":"../../../src","sources":["generated/bark-ffi.ts"],"mappings":";;AAAA;AACA;;AAEA;AACA;AACA;;AAgvBA;AACA;AACA;AACA;AACA;AACA,MAAMA,MAAmC,GAAGA,CAAA,KACzCC,UAAU,CAASC,UAAU;AAChC,eAAeF,MAAM;;AAErB;;AAwKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMG,8CAGL,GAAG,IAAI;AACR,MAAMC,mCAGL,GAAG,IAAI","ignoreList":[]}
1
+ {"version":3,"names":["getter","globalThis","NativeBark","isRustFutureContinuationCallbackTypeCompatible","isUniffiForeignFutureTypeCompatible"],"sourceRoot":"../../../src","sources":["generated/bark-ffi.ts"],"mappings":";;AAAA;AACA;;AAEA;AACA;AACA;;AAwwBA;AACA;AACA;AACA;AACA;AACA,MAAMA,MAAmC,GAAGA,CAAA,KACzCC,UAAU,CAASC,UAAU;AAChC,eAAeF,MAAM;;AAErB;;AAwKA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,MAAMG,8CAGL,GAAG,IAAI;AACR,MAAMC,mCAGL,GAAG,IAAI","ignoreList":[]}
@@ -654,7 +654,8 @@ const FfiConverterTypeLightningReceive = (() => {
654
654
  amountSats: FfiConverterUInt64.read(from),
655
655
  state: FfiConverterString.read(from),
656
656
  paymentPreimage: FfiConverterOptionalString.read(from),
657
- settledAt: FfiConverterOptionalInt64.read(from)
657
+ settledAt: FfiConverterOptionalInt64.read(from),
658
+ claimDestination: FfiConverterOptionalString.read(from)
658
659
  };
659
660
  }
660
661
  write(value, into) {
@@ -664,9 +665,10 @@ const FfiConverterTypeLightningReceive = (() => {
664
665
  FfiConverterString.write(value.state, into);
665
666
  FfiConverterOptionalString.write(value.paymentPreimage, into);
666
667
  FfiConverterOptionalInt64.write(value.settledAt, into);
668
+ FfiConverterOptionalString.write(value.claimDestination, into);
667
669
  }
668
670
  allocationSize(value) {
669
- return FfiConverterString.allocationSize(value.paymentHash) + FfiConverterString.allocationSize(value.invoice) + FfiConverterUInt64.allocationSize(value.amountSats) + FfiConverterString.allocationSize(value.state) + FfiConverterOptionalString.allocationSize(value.paymentPreimage) + FfiConverterOptionalInt64.allocationSize(value.settledAt);
671
+ return FfiConverterString.allocationSize(value.paymentHash) + FfiConverterString.allocationSize(value.invoice) + FfiConverterUInt64.allocationSize(value.amountSats) + FfiConverterString.allocationSize(value.state) + FfiConverterOptionalString.allocationSize(value.paymentPreimage) + FfiConverterOptionalInt64.allocationSize(value.settledAt) + FfiConverterOptionalString.allocationSize(value.claimDestination);
670
672
  }
671
673
  }
672
674
  return new FFIConverter();
@@ -911,6 +913,99 @@ const FfiConverterTypePendingBoard = (() => {
911
913
  return new FFIConverter();
912
914
  })();
913
915
 
916
+ /**
917
+ * One bucket of a [`RecoveryReport`].
918
+ *
919
+ * `total_sats` only sums the VTXOs whose amount is known, so it can
920
+ * under-count `failed`, where a VTXO may have failed before being fetched.
921
+ * `vtxo_ids` is sorted, since upstream buckets them unordered.
922
+ */
923
+
924
+ /**
925
+ * Generated factory for {@link RecoveryBucket} record objects.
926
+ */
927
+ export const RecoveryBucket = (() => {
928
+ const defaults = () => ({});
929
+ const create = (() => {
930
+ return uniffiCreateRecord(defaults);
931
+ })();
932
+ return Object.freeze({
933
+ create,
934
+ new: create,
935
+ defaults: () => Object.freeze(defaults())
936
+ });
937
+ })();
938
+ const FfiConverterTypeRecoveryBucket = (() => {
939
+ class FFIConverter extends AbstractFfiConverterByteArray {
940
+ read(from) {
941
+ return {
942
+ vtxoIds: FfiConverterArrayString.read(from),
943
+ totalSats: FfiConverterUInt64.read(from)
944
+ };
945
+ }
946
+ write(value, into) {
947
+ FfiConverterArrayString.write(value.vtxoIds, into);
948
+ FfiConverterUInt64.write(value.totalSats, into);
949
+ }
950
+ allocationSize(value) {
951
+ return FfiConverterArrayString.allocationSize(value.vtxoIds) + FfiConverterUInt64.allocationSize(value.totalSats);
952
+ }
953
+ }
954
+ return new FFIConverter();
955
+ })();
956
+
957
+ /**
958
+ * Outcome of a recovery scan: every VTXO id the scan looked at, bucketed by
959
+ * what was decided about it.
960
+ *
961
+ * `skipped` vs `failed` is the load-bearing distinction: a `skipped` VTXO was
962
+ * decided not to be spendable (spent, exited, or reported non-spendable),
963
+ * while a `failed` one could not be decided because of an error, so its funds
964
+ * may still be missing. `failed` is retryable via `recover_vtxos`; a `foreign`
965
+ * id instead sits beyond the key-derivation gap limit and needs a wider scan.
966
+ */
967
+
968
+ /**
969
+ * Generated factory for {@link RecoveryReport} record objects.
970
+ */
971
+ export const RecoveryReport = (() => {
972
+ const defaults = () => ({});
973
+ const create = (() => {
974
+ return uniffiCreateRecord(defaults);
975
+ })();
976
+ return Object.freeze({
977
+ create,
978
+ new: create,
979
+ defaults: () => Object.freeze(defaults())
980
+ });
981
+ })();
982
+ const FfiConverterTypeRecoveryReport = (() => {
983
+ class FFIConverter extends AbstractFfiConverterByteArray {
984
+ read(from) {
985
+ return {
986
+ recovered: FfiConverterTypeRecoveryBucket.read(from),
987
+ skipped: FfiConverterTypeRecoveryBucket.read(from),
988
+ foreign: FfiConverterTypeRecoveryBucket.read(from),
989
+ failed: FfiConverterTypeRecoveryBucket.read(from),
990
+ exited: FfiConverterTypeRecoveryBucket.read(from),
991
+ isComplete: FfiConverterBool.read(from)
992
+ };
993
+ }
994
+ write(value, into) {
995
+ FfiConverterTypeRecoveryBucket.write(value.recovered, into);
996
+ FfiConverterTypeRecoveryBucket.write(value.skipped, into);
997
+ FfiConverterTypeRecoveryBucket.write(value.foreign, into);
998
+ FfiConverterTypeRecoveryBucket.write(value.failed, into);
999
+ FfiConverterTypeRecoveryBucket.write(value.exited, into);
1000
+ FfiConverterBool.write(value.isComplete, into);
1001
+ }
1002
+ allocationSize(value) {
1003
+ return FfiConverterTypeRecoveryBucket.allocationSize(value.recovered) + FfiConverterTypeRecoveryBucket.allocationSize(value.skipped) + FfiConverterTypeRecoveryBucket.allocationSize(value.foreign) + FfiConverterTypeRecoveryBucket.allocationSize(value.failed) + FfiConverterTypeRecoveryBucket.allocationSize(value.exited) + FfiConverterBool.allocationSize(value.isComplete);
1004
+ }
1005
+ }
1006
+ return new FFIConverter();
1007
+ })();
1008
+
914
1009
  /**
915
1010
  * A pending round state
916
1011
  */
@@ -971,7 +1066,8 @@ const FfiConverterTypeVtxo = (() => {
971
1066
  kind: FfiConverterString.read(from),
972
1067
  state: FfiConverterString.read(from),
973
1068
  exitDepth: FfiConverterUInt32.read(from),
974
- exitTxWeightWu: FfiConverterUInt64.read(from)
1069
+ exitTxWeightWu: FfiConverterUInt64.read(from),
1070
+ registered: FfiConverterBool.read(from)
975
1071
  };
976
1072
  }
977
1073
  write(value, into) {
@@ -982,9 +1078,10 @@ const FfiConverterTypeVtxo = (() => {
982
1078
  FfiConverterString.write(value.state, into);
983
1079
  FfiConverterUInt32.write(value.exitDepth, into);
984
1080
  FfiConverterUInt64.write(value.exitTxWeightWu, into);
1081
+ FfiConverterBool.write(value.registered, into);
985
1082
  }
986
1083
  allocationSize(value) {
987
- return FfiConverterString.allocationSize(value.id) + FfiConverterUInt64.allocationSize(value.amountSats) + FfiConverterUInt32.allocationSize(value.expiryHeight) + FfiConverterString.allocationSize(value.kind) + FfiConverterString.allocationSize(value.state) + FfiConverterUInt32.allocationSize(value.exitDepth) + FfiConverterUInt64.allocationSize(value.exitTxWeightWu);
1084
+ return FfiConverterString.allocationSize(value.id) + FfiConverterUInt64.allocationSize(value.amountSats) + FfiConverterUInt32.allocationSize(value.expiryHeight) + FfiConverterString.allocationSize(value.kind) + FfiConverterString.allocationSize(value.state) + FfiConverterUInt32.allocationSize(value.exitDepth) + FfiConverterUInt64.allocationSize(value.exitTxWeightWu) + FfiConverterBool.allocationSize(value.registered);
988
1085
  }
989
1086
  }
990
1087
  return new FFIConverter();
@@ -1004,7 +1101,8 @@ export const WalletOpenArgs = (() => {
1004
1101
  runDaemon: true,
1005
1102
  onchain: undefined,
1006
1103
  createIfNotExists: true,
1007
- createWithoutServer: false
1104
+ createWithoutServer: false,
1105
+ skipRecovery: false
1008
1106
  });
1009
1107
  const create = (() => {
1010
1108
  return uniffiCreateRecord(defaults);
@@ -1023,7 +1121,8 @@ const FfiConverterTypeWalletOpenArgs = (() => {
1023
1121
  datadir: FfiConverterString.read(from),
1024
1122
  onchain: FfiConverterOptionalTypeOnchainWallet.read(from),
1025
1123
  createIfNotExists: FfiConverterBool.read(from),
1026
- createWithoutServer: FfiConverterBool.read(from)
1124
+ createWithoutServer: FfiConverterBool.read(from),
1125
+ skipRecovery: FfiConverterBool.read(from)
1027
1126
  };
1028
1127
  }
1029
1128
  write(value, into) {
@@ -1032,9 +1131,10 @@ const FfiConverterTypeWalletOpenArgs = (() => {
1032
1131
  FfiConverterOptionalTypeOnchainWallet.write(value.onchain, into);
1033
1132
  FfiConverterBool.write(value.createIfNotExists, into);
1034
1133
  FfiConverterBool.write(value.createWithoutServer, into);
1134
+ FfiConverterBool.write(value.skipRecovery, into);
1035
1135
  }
1036
1136
  allocationSize(value) {
1037
- return FfiConverterBool.allocationSize(value.runDaemon) + FfiConverterString.allocationSize(value.datadir) + FfiConverterOptionalTypeOnchainWallet.allocationSize(value.onchain) + FfiConverterBool.allocationSize(value.createIfNotExists) + FfiConverterBool.allocationSize(value.createWithoutServer);
1137
+ return FfiConverterBool.allocationSize(value.runDaemon) + FfiConverterString.allocationSize(value.datadir) + FfiConverterOptionalTypeOnchainWallet.allocationSize(value.onchain) + FfiConverterBool.allocationSize(value.createIfNotExists) + FfiConverterBool.allocationSize(value.createWithoutServer) + FfiConverterBool.allocationSize(value.skipRecovery);
1038
1138
  }
1039
1139
  }
1040
1140
  return new FFIConverter();
@@ -2508,6 +2608,36 @@ export class Wallet extends UniffiAbstractObject {
2508
2608
  throw __error;
2509
2609
  }
2510
2610
  }
2611
+
2612
+ /**
2613
+ * Create an invoice whose claimed VTXO is delivered to `claim_destination`
2614
+ * (an Ark address), letting that wallet receive while offline.
2615
+ *
2616
+ * The claim is signed directly to that address's own policy, so this wallet
2617
+ * has no custodial control and cannot redirect the payment. It can still
2618
+ * strand it: delivering the signed output to the destination's mailbox is a
2619
+ * separate step only this wallet can perform, and the recipient has no
2620
+ * independent way to recover the funds until it happens. Delivery resumes
2621
+ * automatically on restart, so a crash recovers on its own — but running
2622
+ * this for someone else means they trust you to stay online and eventually
2623
+ * deliver, not that they trust you with custody.
2624
+ *
2625
+ * A `claim_destination` owned by this wallet is claimed locally instead of
2626
+ * going through its mailbox.
2627
+ */
2628
+ async bolt11InvoiceForAddress(amountSats, claimDestination, description = undefined, token = undefined, asyncOpts_) /*throws*/{
2629
+ const __stack = uniffiIsDebug ? new Error().stack : undefined;
2630
+ try {
2631
+ return await uniffiRustCallAsync(/*rustCaller:*/uniffiCaller, /*rustFutureFunc:*/() => {
2632
+ return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_bolt11_invoice_for_address(uniffiTypeWalletObjectFactory.clonePointer(this), FfiConverterUInt64.lower(amountSats), FfiConverterString.lower(claimDestination), FfiConverterOptionalString.lower(description), FfiConverterOptionalString.lower(token));
2633
+ }, /*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:*/FfiConverterTypeLightningInvoice.lift.bind(FfiConverterTypeLightningInvoice), /*liftString:*/FfiConverterString.lift, /*asyncOpts:*/asyncOpts_, /*errorHandler:*/FfiConverterTypeError.lift.bind(FfiConverterTypeError));
2634
+ } catch (__error) {
2635
+ if (uniffiIsDebug && __error instanceof Error) {
2636
+ __error.stack = __stack;
2637
+ }
2638
+ throw __error;
2639
+ }
2640
+ }
2511
2641
  async broadcastTx(txHex, asyncOpts_) /*throws*/{
2512
2642
  const __stack = uniffiIsDebug ? new Error().stack : undefined;
2513
2643
  try {
@@ -3280,6 +3410,42 @@ export class Wallet extends UniffiAbstractObject {
3280
3410
  throw __error;
3281
3411
  }
3282
3412
  }
3413
+
3414
+ /**
3415
+ * Recover the given VTXO ids from the server, importing the ones this
3416
+ * wallet owns that are still spendable. Use it to retry ids a previous
3417
+ * scan reported as `failed`.
3418
+ */
3419
+ async recoverVtxos(vtxoIds, asyncOpts_) /*throws*/{
3420
+ const __stack = uniffiIsDebug ? new Error().stack : undefined;
3421
+ try {
3422
+ return await uniffiRustCallAsync(/*rustCaller:*/uniffiCaller, /*rustFutureFunc:*/() => {
3423
+ return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_recover_vtxos(uniffiTypeWalletObjectFactory.clonePointer(this), FfiConverterArrayString.lower(vtxoIds));
3424
+ }, /*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));
3425
+ } catch (__error) {
3426
+ if (uniffiIsDebug && __error instanceof Error) {
3427
+ __error.stack = __stack;
3428
+ }
3429
+ throw __error;
3430
+ }
3431
+ }
3432
+
3433
+ /**
3434
+ * Result of the seed-recovery scan that ran during `Wallet::open`, or none
3435
+ * if no report was produced.
3436
+ *
3437
+ * Recovery only runs on the open that creates the wallet locally, and not
3438
+ * at all when `WalletOpenArgs.skip_recovery` is set, so this is empty on
3439
+ * every subsequent open. It is also empty when the scan itself failed
3440
+ * outright — bark logs that and lets open succeed, so an empty result does
3441
+ * not prove no funds are missing. `isComplete == false` means funds may
3442
+ * still be missing; retry the report's `failed` ids with `recoverVtxos`.
3443
+ */
3444
+ recoveryReport() {
3445
+ return FfiConverterOptionalTypeRecoveryReport.lift(uniffiCaller.rustCall(/*caller:*/callStatus => {
3446
+ return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_recovery_report(uniffiTypeWalletObjectFactory.clonePointer(this), callStatus);
3447
+ }, /*liftString:*/FfiConverterString.lift));
3448
+ }
3283
3449
  async refreshServer(asyncOpts_) /*throws*/{
3284
3450
  const __stack = uniffiIsDebug ? new Error().stack : undefined;
3285
3451
  try {
@@ -3320,6 +3486,26 @@ export class Wallet extends UniffiAbstractObject {
3320
3486
  }
3321
3487
  }
3322
3488
 
3489
+ /**
3490
+ * Schedule a delegated refresh for `scheduled_height` instead of the next
3491
+ * round. The refresh fee is priced against the VTXO's remaining lifetime at
3492
+ * that height, and the server charges less the closer a VTXO is to expiry,
3493
+ * so scheduling further out never costs more than refreshing now.
3494
+ */
3495
+ async refreshVtxosScheduled(vtxoIds, scheduledHeight, asyncOpts_) /*throws*/{
3496
+ const __stack = uniffiIsDebug ? new Error().stack : undefined;
3497
+ try {
3498
+ return await uniffiRustCallAsync(/*rustCaller:*/uniffiCaller, /*rustFutureFunc:*/() => {
3499
+ return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_refresh_vtxos_scheduled(uniffiTypeWalletObjectFactory.clonePointer(this), FfiConverterArrayString.lower(vtxoIds), FfiConverterUInt32.lower(scheduledHeight));
3500
+ }, /*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:*/FfiConverterOptionalTypeRoundState.lift.bind(FfiConverterOptionalTypeRoundState), /*liftString:*/FfiConverterString.lift, /*asyncOpts:*/asyncOpts_, /*errorHandler:*/FfiConverterTypeError.lift.bind(FfiConverterTypeError));
3501
+ } catch (__error) {
3502
+ if (uniffiIsDebug && __error instanceof Error) {
3503
+ __error.stack = __stack;
3504
+ }
3505
+ throw __error;
3506
+ }
3507
+ }
3508
+
3323
3509
  /**
3324
3510
  * Start the background daemon. The onchain wallet used by the daemon is
3325
3511
  * the one supplied to `Wallet::open` (see `WalletOpenArgs.onchain`).
@@ -3637,6 +3823,9 @@ const FfiConverterOptionalTypeArkInfo = new FfiConverterOptional(FfiConverterTyp
3637
3823
  // FfiConverter for ExitTransactionStatus | undefined
3638
3824
  const FfiConverterOptionalTypeExitTransactionStatus = new FfiConverterOptional(FfiConverterTypeExitTransactionStatus);
3639
3825
 
3826
+ // FfiConverter for RecoveryReport | undefined
3827
+ const FfiConverterOptionalTypeRecoveryReport = new FfiConverterOptional(FfiConverterTypeRecoveryReport);
3828
+
3640
3829
  // FfiConverter for RoundState | undefined
3641
3830
  const FfiConverterOptionalTypeRoundState = new FfiConverterOptional(FfiConverterTypeRoundState);
3642
3831
 
@@ -3805,6 +3994,9 @@ function uniffiEnsureInitialized() {
3805
3994
  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_bolt11_invoice() !== 54959) {
3806
3995
  throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_bolt11_invoice");
3807
3996
  }
3997
+ if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_bolt11_invoice_for_address() !== 56368) {
3998
+ throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_bolt11_invoice_for_address");
3999
+ }
3808
4000
  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_broadcast_tx() !== 46367) {
3809
4001
  throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_broadcast_tx");
3810
4002
  }
@@ -3985,6 +4177,12 @@ function uniffiEnsureInitialized() {
3985
4177
  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_properties() !== 9773) {
3986
4178
  throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_properties");
3987
4179
  }
4180
+ if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_recover_vtxos() !== 640) {
4181
+ throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_recover_vtxos");
4182
+ }
4183
+ if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_recovery_report() !== 54899) {
4184
+ throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_recovery_report");
4185
+ }
3988
4186
  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_refresh_server() !== 41162) {
3989
4187
  throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_refresh_server");
3990
4188
  }
@@ -3994,6 +4192,9 @@ function uniffiEnsureInitialized() {
3994
4192
  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_refresh_vtxos_delegated() !== 61476) {
3995
4193
  throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_refresh_vtxos_delegated");
3996
4194
  }
4195
+ if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_refresh_vtxos_scheduled() !== 50488) {
4196
+ throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_refresh_vtxos_scheduled");
4197
+ }
3997
4198
  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_run_daemon() !== 9520) {
3998
4199
  throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_run_daemon");
3999
4200
  }
@@ -4091,6 +4292,8 @@ export default Object.freeze({
4091
4292
  FfiConverterTypeOnchainWallet,
4092
4293
  FfiConverterTypeOutPoint,
4093
4294
  FfiConverterTypePendingBoard,
4295
+ FfiConverterTypeRecoveryBucket,
4296
+ FfiConverterTypeRecoveryReport,
4094
4297
  FfiConverterTypeRoundState,
4095
4298
  FfiConverterTypeVtxo,
4096
4299
  FfiConverterTypeWallet,