@secondts/bark-react-native 0.14.0 → 0.16.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.
@@ -159,7 +159,7 @@ const FfiConverterTypeArkInfo = (() => {
159
159
  maxUserInvoiceCltvDelta: FfiConverterUInt16.read(from),
160
160
  minBoardAmountSats: FfiConverterUInt64.read(from),
161
161
  lnReceiveAntiDosRequired: FfiConverterBool.read(from),
162
- feeScheduleJson: FfiConverterString.read(from),
162
+ feeSchedule: FfiConverterTypeFeeSchedule.read(from),
163
163
  maxVtxoExitDepth: FfiConverterUInt16.read(from)
164
164
  };
165
165
  }
@@ -177,11 +177,11 @@ const FfiConverterTypeArkInfo = (() => {
177
177
  FfiConverterUInt16.write(value.maxUserInvoiceCltvDelta, into);
178
178
  FfiConverterUInt64.write(value.minBoardAmountSats, into);
179
179
  FfiConverterBool.write(value.lnReceiveAntiDosRequired, into);
180
- FfiConverterString.write(value.feeScheduleJson, into);
180
+ FfiConverterTypeFeeSchedule.write(value.feeSchedule, into);
181
181
  FfiConverterUInt16.write(value.maxVtxoExitDepth, into);
182
182
  }
183
183
  allocationSize(value) {
184
- return FfiConverterTypeNetwork.allocationSize(value.network) + FfiConverterString.allocationSize(value.serverPubkey) + FfiConverterUInt64.allocationSize(value.roundIntervalSecs) + FfiConverterUInt32.allocationSize(value.nbRoundNonces) + FfiConverterUInt32.allocationSize(value.vtxoExitDelta) + FfiConverterUInt32.allocationSize(value.vtxoExpiryDelta) + FfiConverterUInt32.allocationSize(value.htlcSendExpiryDelta) + FfiConverterUInt32.allocationSize(value.htlcExpiryDelta) + FfiConverterOptionalUInt64.allocationSize(value.maxVtxoAmountSats) + FfiConverterUInt32.allocationSize(value.requiredBoardConfirmations) + FfiConverterUInt16.allocationSize(value.maxUserInvoiceCltvDelta) + FfiConverterUInt64.allocationSize(value.minBoardAmountSats) + FfiConverterBool.allocationSize(value.lnReceiveAntiDosRequired) + FfiConverterString.allocationSize(value.feeScheduleJson) + FfiConverterUInt16.allocationSize(value.maxVtxoExitDepth);
184
+ return FfiConverterTypeNetwork.allocationSize(value.network) + FfiConverterString.allocationSize(value.serverPubkey) + FfiConverterUInt64.allocationSize(value.roundIntervalSecs) + FfiConverterUInt32.allocationSize(value.nbRoundNonces) + FfiConverterUInt32.allocationSize(value.vtxoExitDelta) + FfiConverterUInt32.allocationSize(value.vtxoExpiryDelta) + FfiConverterUInt32.allocationSize(value.htlcSendExpiryDelta) + FfiConverterUInt32.allocationSize(value.htlcExpiryDelta) + FfiConverterOptionalUInt64.allocationSize(value.maxVtxoAmountSats) + FfiConverterUInt32.allocationSize(value.requiredBoardConfirmations) + FfiConverterUInt16.allocationSize(value.maxUserInvoiceCltvDelta) + FfiConverterUInt64.allocationSize(value.minBoardAmountSats) + FfiConverterBool.allocationSize(value.lnReceiveAntiDosRequired) + FfiConverterTypeFeeSchedule.allocationSize(value.feeSchedule) + FfiConverterUInt16.allocationSize(value.maxVtxoExitDepth);
185
185
  }
186
186
  }
187
187
  return new FFIConverter();
@@ -263,6 +263,45 @@ const FfiConverterTypeBlockRef = (() => {
263
263
  }
264
264
  return new FFIConverter();
265
265
  })();
266
+
267
+ /**
268
+ * Fees for boarding onchain funds into the Ark.
269
+ */
270
+
271
+ /**
272
+ * Generated factory for {@link BoardFees} record objects.
273
+ */
274
+ export const BoardFees = (() => {
275
+ const defaults = () => ({});
276
+ const create = (() => {
277
+ return uniffiCreateRecord(defaults);
278
+ })();
279
+ return Object.freeze({
280
+ create,
281
+ new: create,
282
+ defaults: () => Object.freeze(defaults())
283
+ });
284
+ })();
285
+ const FfiConverterTypeBoardFees = (() => {
286
+ class FFIConverter extends AbstractFfiConverterByteArray {
287
+ read(from) {
288
+ return {
289
+ minFeeSats: FfiConverterUInt64.read(from),
290
+ baseFeeSats: FfiConverterUInt64.read(from),
291
+ ppm: FfiConverterUInt64.read(from)
292
+ };
293
+ }
294
+ write(value, into) {
295
+ FfiConverterUInt64.write(value.minFeeSats, into);
296
+ FfiConverterUInt64.write(value.baseFeeSats, into);
297
+ FfiConverterUInt64.write(value.ppm, into);
298
+ }
299
+ allocationSize(value) {
300
+ return FfiConverterUInt64.allocationSize(value.minFeeSats) + FfiConverterUInt64.allocationSize(value.baseFeeSats) + FfiConverterUInt64.allocationSize(value.ppm);
301
+ }
302
+ }
303
+ return new FFIConverter();
304
+ })();
266
305
  /**
267
306
  * Generated factory for {@link Config} record objects.
268
307
  */
@@ -464,17 +503,17 @@ const FfiConverterTypeExitProgressStatus = (() => {
464
503
  read(from) {
465
504
  return {
466
505
  vtxoId: FfiConverterString.read(from),
467
- state: FfiConverterString.read(from),
506
+ state: FfiConverterTypeExitState.read(from),
468
507
  error: FfiConverterOptionalString.read(from)
469
508
  };
470
509
  }
471
510
  write(value, into) {
472
511
  FfiConverterString.write(value.vtxoId, into);
473
- FfiConverterString.write(value.state, into);
512
+ FfiConverterTypeExitState.write(value.state, into);
474
513
  FfiConverterOptionalString.write(value.error, into);
475
514
  }
476
515
  allocationSize(value) {
477
- return FfiConverterString.allocationSize(value.vtxoId) + FfiConverterString.allocationSize(value.state) + FfiConverterOptionalString.allocationSize(value.error);
516
+ return FfiConverterString.allocationSize(value.vtxoId) + FfiConverterTypeExitState.allocationSize(value.state) + FfiConverterOptionalString.allocationSize(value.error);
478
517
  }
479
518
  }
480
519
  return new FFIConverter();
@@ -503,19 +542,56 @@ const FfiConverterTypeExitTransactionStatus = (() => {
503
542
  read(from) {
504
543
  return {
505
544
  vtxoId: FfiConverterString.read(from),
506
- state: FfiConverterString.read(from),
507
- history: FfiConverterOptionalArrayString.read(from),
545
+ state: FfiConverterTypeExitState.read(from),
546
+ history: FfiConverterOptionalArrayTypeExitState.read(from),
508
547
  transactionCount: FfiConverterUInt32.read(from)
509
548
  };
510
549
  }
511
550
  write(value, into) {
512
551
  FfiConverterString.write(value.vtxoId, into);
513
- FfiConverterString.write(value.state, into);
514
- FfiConverterOptionalArrayString.write(value.history, into);
552
+ FfiConverterTypeExitState.write(value.state, into);
553
+ FfiConverterOptionalArrayTypeExitState.write(value.history, into);
515
554
  FfiConverterUInt32.write(value.transactionCount, into);
516
555
  }
517
556
  allocationSize(value) {
518
- return FfiConverterString.allocationSize(value.vtxoId) + FfiConverterString.allocationSize(value.state) + FfiConverterOptionalArrayString.allocationSize(value.history) + FfiConverterUInt32.allocationSize(value.transactionCount);
557
+ return FfiConverterString.allocationSize(value.vtxoId) + FfiConverterTypeExitState.allocationSize(value.state) + FfiConverterOptionalArrayTypeExitState.allocationSize(value.history) + FfiConverterUInt32.allocationSize(value.transactionCount);
558
+ }
559
+ }
560
+ return new FFIConverter();
561
+ })();
562
+
563
+ /**
564
+ * One transaction in an exit's unilateral broadcast chain.
565
+ */
566
+
567
+ /**
568
+ * Generated factory for {@link ExitTx} record objects.
569
+ */
570
+ export const ExitTx = (() => {
571
+ const defaults = () => ({});
572
+ const create = (() => {
573
+ return uniffiCreateRecord(defaults);
574
+ })();
575
+ return Object.freeze({
576
+ create,
577
+ new: create,
578
+ defaults: () => Object.freeze(defaults())
579
+ });
580
+ })();
581
+ const FfiConverterTypeExitTx = (() => {
582
+ class FFIConverter extends AbstractFfiConverterByteArray {
583
+ read(from) {
584
+ return {
585
+ txid: FfiConverterString.read(from),
586
+ status: FfiConverterTypeExitTxStatus.read(from)
587
+ };
588
+ }
589
+ write(value, into) {
590
+ FfiConverterString.write(value.txid, into);
591
+ FfiConverterTypeExitTxStatus.write(value.status, into);
592
+ }
593
+ allocationSize(value) {
594
+ return FfiConverterString.allocationSize(value.txid) + FfiConverterTypeExitTxStatus.allocationSize(value.status);
519
595
  }
520
596
  }
521
597
  return new FFIConverter();
@@ -545,18 +621,18 @@ const FfiConverterTypeExitVtxo = (() => {
545
621
  return {
546
622
  vtxoId: FfiConverterString.read(from),
547
623
  amountSats: FfiConverterUInt64.read(from),
548
- state: FfiConverterString.read(from),
624
+ state: FfiConverterTypeExitState.read(from),
549
625
  isClaimable: FfiConverterBool.read(from)
550
626
  };
551
627
  }
552
628
  write(value, into) {
553
629
  FfiConverterString.write(value.vtxoId, into);
554
630
  FfiConverterUInt64.write(value.amountSats, into);
555
- FfiConverterString.write(value.state, into);
631
+ FfiConverterTypeExitState.write(value.state, into);
556
632
  FfiConverterBool.write(value.isClaimable, into);
557
633
  }
558
634
  allocationSize(value) {
559
- return FfiConverterString.allocationSize(value.vtxoId) + FfiConverterUInt64.allocationSize(value.amountSats) + FfiConverterString.allocationSize(value.state) + FfiConverterBool.allocationSize(value.isClaimable);
635
+ return FfiConverterString.allocationSize(value.vtxoId) + FfiConverterUInt64.allocationSize(value.amountSats) + FfiConverterTypeExitState.allocationSize(value.state) + FfiConverterBool.allocationSize(value.isClaimable);
560
636
  }
561
637
  }
562
638
  return new FFIConverter();
@@ -597,6 +673,91 @@ const FfiConverterTypeFeeEstimate = (() => {
597
673
  }
598
674
  return new FFIConverter();
599
675
  })();
676
+
677
+ /**
678
+ * Network fee rates by urgency, mirroring `bark::chain::FeeRates`.
679
+ *
680
+ * Rates are in sat/kwu (satoshis per 1000 weight units) — divide by 250 for
681
+ * sat/vB.
682
+ */
683
+
684
+ /**
685
+ * Generated factory for {@link FeeRates} record objects.
686
+ */
687
+ export const FeeRates = (() => {
688
+ const defaults = () => ({});
689
+ const create = (() => {
690
+ return uniffiCreateRecord(defaults);
691
+ })();
692
+ return Object.freeze({
693
+ create,
694
+ new: create,
695
+ defaults: () => Object.freeze(defaults())
696
+ });
697
+ })();
698
+ const FfiConverterTypeFeeRates = (() => {
699
+ class FFIConverter extends AbstractFfiConverterByteArray {
700
+ read(from) {
701
+ return {
702
+ fastSatPerKwu: FfiConverterUInt64.read(from),
703
+ regularSatPerKwu: FfiConverterUInt64.read(from),
704
+ slowSatPerKwu: FfiConverterUInt64.read(from)
705
+ };
706
+ }
707
+ write(value, into) {
708
+ FfiConverterUInt64.write(value.fastSatPerKwu, into);
709
+ FfiConverterUInt64.write(value.regularSatPerKwu, into);
710
+ FfiConverterUInt64.write(value.slowSatPerKwu, into);
711
+ }
712
+ allocationSize(value) {
713
+ return FfiConverterUInt64.allocationSize(value.fastSatPerKwu) + FfiConverterUInt64.allocationSize(value.regularSatPerKwu) + FfiConverterUInt64.allocationSize(value.slowSatPerKwu);
714
+ }
715
+ }
716
+ return new FFIConverter();
717
+ })();
718
+
719
+ /**
720
+ * The Ark server's complete fee schedule, mirroring `ark::fees::FeeSchedule`.
721
+ */
722
+
723
+ /**
724
+ * Generated factory for {@link FeeSchedule} record objects.
725
+ */
726
+ export const FeeSchedule = (() => {
727
+ const defaults = () => ({});
728
+ const create = (() => {
729
+ return uniffiCreateRecord(defaults);
730
+ })();
731
+ return Object.freeze({
732
+ create,
733
+ new: create,
734
+ defaults: () => Object.freeze(defaults())
735
+ });
736
+ })();
737
+ const FfiConverterTypeFeeSchedule = (() => {
738
+ class FFIConverter extends AbstractFfiConverterByteArray {
739
+ read(from) {
740
+ return {
741
+ board: FfiConverterTypeBoardFees.read(from),
742
+ offboard: FfiConverterTypeOffboardFees.read(from),
743
+ refresh: FfiConverterTypeRefreshFees.read(from),
744
+ lightningReceive: FfiConverterTypeLightningReceiveFees.read(from),
745
+ lightningSend: FfiConverterTypeLightningSendFees.read(from)
746
+ };
747
+ }
748
+ write(value, into) {
749
+ FfiConverterTypeBoardFees.write(value.board, into);
750
+ FfiConverterTypeOffboardFees.write(value.offboard, into);
751
+ FfiConverterTypeRefreshFees.write(value.refresh, into);
752
+ FfiConverterTypeLightningReceiveFees.write(value.lightningReceive, into);
753
+ FfiConverterTypeLightningSendFees.write(value.lightningSend, into);
754
+ }
755
+ allocationSize(value) {
756
+ return FfiConverterTypeBoardFees.allocationSize(value.board) + FfiConverterTypeOffboardFees.allocationSize(value.offboard) + FfiConverterTypeRefreshFees.allocationSize(value.refresh) + FfiConverterTypeLightningReceiveFees.allocationSize(value.lightningReceive) + FfiConverterTypeLightningSendFees.allocationSize(value.lightningSend);
757
+ }
758
+ }
759
+ return new FFIConverter();
760
+ })();
600
761
  /**
601
762
  * Generated factory for {@link LightningInvoice} record objects.
602
763
  */
@@ -673,6 +834,43 @@ const FfiConverterTypeLightningReceive = (() => {
673
834
  }
674
835
  return new FFIConverter();
675
836
  })();
837
+
838
+ /**
839
+ * Fees for receiving over lightning.
840
+ */
841
+
842
+ /**
843
+ * Generated factory for {@link LightningReceiveFees} record objects.
844
+ */
845
+ export const LightningReceiveFees = (() => {
846
+ const defaults = () => ({});
847
+ const create = (() => {
848
+ return uniffiCreateRecord(defaults);
849
+ })();
850
+ return Object.freeze({
851
+ create,
852
+ new: create,
853
+ defaults: () => Object.freeze(defaults())
854
+ });
855
+ })();
856
+ const FfiConverterTypeLightningReceiveFees = (() => {
857
+ class FFIConverter extends AbstractFfiConverterByteArray {
858
+ read(from) {
859
+ return {
860
+ baseFeeSats: FfiConverterUInt64.read(from),
861
+ ppm: FfiConverterUInt64.read(from)
862
+ };
863
+ }
864
+ write(value, into) {
865
+ FfiConverterUInt64.write(value.baseFeeSats, into);
866
+ FfiConverterUInt64.write(value.ppm, into);
867
+ }
868
+ allocationSize(value) {
869
+ return FfiConverterUInt64.allocationSize(value.baseFeeSats) + FfiConverterUInt64.allocationSize(value.ppm);
870
+ }
871
+ }
872
+ return new FFIConverter();
873
+ })();
676
874
  /**
677
875
  * Generated factory for {@link LightningSend} record objects.
678
876
  */
@@ -711,6 +909,45 @@ const FfiConverterTypeLightningSend = (() => {
711
909
  }
712
910
  return new FFIConverter();
713
911
  })();
912
+
913
+ /**
914
+ * Fees for sending over lightning.
915
+ */
916
+
917
+ /**
918
+ * Generated factory for {@link LightningSendFees} record objects.
919
+ */
920
+ export const LightningSendFees = (() => {
921
+ const defaults = () => ({});
922
+ const create = (() => {
923
+ return uniffiCreateRecord(defaults);
924
+ })();
925
+ return Object.freeze({
926
+ create,
927
+ new: create,
928
+ defaults: () => Object.freeze(defaults())
929
+ });
930
+ })();
931
+ const FfiConverterTypeLightningSendFees = (() => {
932
+ class FFIConverter extends AbstractFfiConverterByteArray {
933
+ read(from) {
934
+ return {
935
+ minFeeSats: FfiConverterUInt64.read(from),
936
+ baseFeeSats: FfiConverterUInt64.read(from),
937
+ ppmExpiryTable: FfiConverterArrayTypePpmExpiryFeeEntry.read(from)
938
+ };
939
+ }
940
+ write(value, into) {
941
+ FfiConverterUInt64.write(value.minFeeSats, into);
942
+ FfiConverterUInt64.write(value.baseFeeSats, into);
943
+ FfiConverterArrayTypePpmExpiryFeeEntry.write(value.ppmExpiryTable, into);
944
+ }
945
+ allocationSize(value) {
946
+ return FfiConverterUInt64.allocationSize(value.minFeeSats) + FfiConverterUInt64.allocationSize(value.baseFeeSats) + FfiConverterArrayTypePpmExpiryFeeEntry.allocationSize(value.ppmExpiryTable);
947
+ }
948
+ }
949
+ return new FFIConverter();
950
+ })();
714
951
  /**
715
952
  * Generated factory for {@link Movement} record objects.
716
953
  */
@@ -777,6 +1014,45 @@ const FfiConverterTypeMovement = (() => {
777
1014
  }
778
1015
  return new FFIConverter();
779
1016
  })();
1017
+
1018
+ /**
1019
+ * Fees for offboarding VTXOs to an onchain address.
1020
+ */
1021
+
1022
+ /**
1023
+ * Generated factory for {@link OffboardFees} record objects.
1024
+ */
1025
+ export const OffboardFees = (() => {
1026
+ const defaults = () => ({});
1027
+ const create = (() => {
1028
+ return uniffiCreateRecord(defaults);
1029
+ })();
1030
+ return Object.freeze({
1031
+ create,
1032
+ new: create,
1033
+ defaults: () => Object.freeze(defaults())
1034
+ });
1035
+ })();
1036
+ const FfiConverterTypeOffboardFees = (() => {
1037
+ class FFIConverter extends AbstractFfiConverterByteArray {
1038
+ read(from) {
1039
+ return {
1040
+ baseFeeSats: FfiConverterUInt64.read(from),
1041
+ fixedAdditionalVb: FfiConverterUInt64.read(from),
1042
+ ppmExpiryTable: FfiConverterArrayTypePpmExpiryFeeEntry.read(from)
1043
+ };
1044
+ }
1045
+ write(value, into) {
1046
+ FfiConverterUInt64.write(value.baseFeeSats, into);
1047
+ FfiConverterUInt64.write(value.fixedAdditionalVb, into);
1048
+ FfiConverterArrayTypePpmExpiryFeeEntry.write(value.ppmExpiryTable, into);
1049
+ }
1050
+ allocationSize(value) {
1051
+ return FfiConverterUInt64.allocationSize(value.baseFeeSats) + FfiConverterUInt64.allocationSize(value.fixedAdditionalVb) + FfiConverterArrayTypePpmExpiryFeeEntry.allocationSize(value.ppmExpiryTable);
1052
+ }
1053
+ }
1054
+ return new FFIConverter();
1055
+ })();
780
1056
  /**
781
1057
  * Generated factory for {@link OffboardResult} record objects.
782
1058
  */
@@ -913,6 +1189,47 @@ const FfiConverterTypePendingBoard = (() => {
913
1189
  return new FFIConverter();
914
1190
  })();
915
1191
 
1192
+ /**
1193
+ * One tier of a PPM-by-expiry fee table.
1194
+ *
1195
+ * The entry applies when a VTXO expires in at most `expiry_blocks_threshold`
1196
+ * blocks and no other entry has a threshold between this one and the VTXO's
1197
+ * actual expiry distance. Tables are sorted ascending by threshold.
1198
+ */
1199
+
1200
+ /**
1201
+ * Generated factory for {@link PpmExpiryFeeEntry} record objects.
1202
+ */
1203
+ export const PpmExpiryFeeEntry = (() => {
1204
+ const defaults = () => ({});
1205
+ const create = (() => {
1206
+ return uniffiCreateRecord(defaults);
1207
+ })();
1208
+ return Object.freeze({
1209
+ create,
1210
+ new: create,
1211
+ defaults: () => Object.freeze(defaults())
1212
+ });
1213
+ })();
1214
+ const FfiConverterTypePpmExpiryFeeEntry = (() => {
1215
+ class FFIConverter extends AbstractFfiConverterByteArray {
1216
+ read(from) {
1217
+ return {
1218
+ expiryBlocksThreshold: FfiConverterUInt32.read(from),
1219
+ ppm: FfiConverterUInt64.read(from)
1220
+ };
1221
+ }
1222
+ write(value, into) {
1223
+ FfiConverterUInt32.write(value.expiryBlocksThreshold, into);
1224
+ FfiConverterUInt64.write(value.ppm, into);
1225
+ }
1226
+ allocationSize(value) {
1227
+ return FfiConverterUInt32.allocationSize(value.expiryBlocksThreshold) + FfiConverterUInt64.allocationSize(value.ppm);
1228
+ }
1229
+ }
1230
+ return new FFIConverter();
1231
+ })();
1232
+
916
1233
  /**
917
1234
  * One bucket of a [`RecoveryReport`].
918
1235
  *
@@ -1007,13 +1324,13 @@ const FfiConverterTypeRecoveryReport = (() => {
1007
1324
  })();
1008
1325
 
1009
1326
  /**
1010
- * A pending round state
1327
+ * Fees for refreshing VTXOs in a round.
1011
1328
  */
1012
1329
 
1013
1330
  /**
1014
- * Generated factory for {@link RoundState} record objects.
1331
+ * Generated factory for {@link RefreshFees} record objects.
1015
1332
  */
1016
- export const RoundState = (() => {
1333
+ export const RefreshFees = (() => {
1017
1334
  const defaults = () => ({});
1018
1335
  const create = (() => {
1019
1336
  return uniffiCreateRecord(defaults);
@@ -1024,28 +1341,33 @@ export const RoundState = (() => {
1024
1341
  defaults: () => Object.freeze(defaults())
1025
1342
  });
1026
1343
  })();
1027
- const FfiConverterTypeRoundState = (() => {
1344
+ const FfiConverterTypeRefreshFees = (() => {
1028
1345
  class FFIConverter extends AbstractFfiConverterByteArray {
1029
1346
  read(from) {
1030
1347
  return {
1031
- id: FfiConverterUInt32.read(from),
1032
- ongoing: FfiConverterBool.read(from)
1348
+ baseFeeSats: FfiConverterUInt64.read(from),
1349
+ ppmExpiryTable: FfiConverterArrayTypePpmExpiryFeeEntry.read(from)
1033
1350
  };
1034
1351
  }
1035
1352
  write(value, into) {
1036
- FfiConverterUInt32.write(value.id, into);
1037
- FfiConverterBool.write(value.ongoing, into);
1353
+ FfiConverterUInt64.write(value.baseFeeSats, into);
1354
+ FfiConverterArrayTypePpmExpiryFeeEntry.write(value.ppmExpiryTable, into);
1038
1355
  }
1039
1356
  allocationSize(value) {
1040
- return FfiConverterUInt32.allocationSize(value.id) + FfiConverterBool.allocationSize(value.ongoing);
1357
+ return FfiConverterUInt64.allocationSize(value.baseFeeSats) + FfiConverterArrayTypePpmExpiryFeeEntry.allocationSize(value.ppmExpiryTable);
1041
1358
  }
1042
1359
  }
1043
1360
  return new FFIConverter();
1044
1361
  })();
1362
+
1045
1363
  /**
1046
- * Generated factory for {@link Vtxo} record objects.
1364
+ * A pending round state
1047
1365
  */
1048
- export const Vtxo = (() => {
1366
+
1367
+ /**
1368
+ * Generated factory for {@link RoundState} record objects.
1369
+ */
1370
+ export const RoundState = (() => {
1049
1371
  const defaults = () => ({});
1050
1372
  const create = (() => {
1051
1373
  return uniffiCreateRecord(defaults);
@@ -1056,15 +1378,47 @@ export const Vtxo = (() => {
1056
1378
  defaults: () => Object.freeze(defaults())
1057
1379
  });
1058
1380
  })();
1059
- const FfiConverterTypeVtxo = (() => {
1381
+ const FfiConverterTypeRoundState = (() => {
1060
1382
  class FFIConverter extends AbstractFfiConverterByteArray {
1061
1383
  read(from) {
1062
1384
  return {
1063
- id: FfiConverterString.read(from),
1064
- amountSats: FfiConverterUInt64.read(from),
1385
+ id: FfiConverterUInt32.read(from),
1386
+ ongoing: FfiConverterBool.read(from)
1387
+ };
1388
+ }
1389
+ write(value, into) {
1390
+ FfiConverterUInt32.write(value.id, into);
1391
+ FfiConverterBool.write(value.ongoing, into);
1392
+ }
1393
+ allocationSize(value) {
1394
+ return FfiConverterUInt32.allocationSize(value.id) + FfiConverterBool.allocationSize(value.ongoing);
1395
+ }
1396
+ }
1397
+ return new FFIConverter();
1398
+ })();
1399
+ /**
1400
+ * Generated factory for {@link Vtxo} record objects.
1401
+ */
1402
+ export const Vtxo = (() => {
1403
+ const defaults = () => ({});
1404
+ const create = (() => {
1405
+ return uniffiCreateRecord(defaults);
1406
+ })();
1407
+ return Object.freeze({
1408
+ create,
1409
+ new: create,
1410
+ defaults: () => Object.freeze(defaults())
1411
+ });
1412
+ })();
1413
+ const FfiConverterTypeVtxo = (() => {
1414
+ class FFIConverter extends AbstractFfiConverterByteArray {
1415
+ read(from) {
1416
+ return {
1417
+ id: FfiConverterString.read(from),
1418
+ amountSats: FfiConverterUInt64.read(from),
1065
1419
  expiryHeight: FfiConverterUInt32.read(from),
1066
1420
  kind: FfiConverterString.read(from),
1067
- state: FfiConverterString.read(from),
1421
+ state: FfiConverterTypeVtxoState.read(from),
1068
1422
  exitDepth: FfiConverterUInt32.read(from),
1069
1423
  exitTxWeightWu: FfiConverterUInt64.read(from),
1070
1424
  registered: FfiConverterBool.read(from)
@@ -1075,13 +1429,13 @@ const FfiConverterTypeVtxo = (() => {
1075
1429
  FfiConverterUInt64.write(value.amountSats, into);
1076
1430
  FfiConverterUInt32.write(value.expiryHeight, into);
1077
1431
  FfiConverterString.write(value.kind, into);
1078
- FfiConverterString.write(value.state, into);
1432
+ FfiConverterTypeVtxoState.write(value.state, into);
1079
1433
  FfiConverterUInt32.write(value.exitDepth, into);
1080
1434
  FfiConverterUInt64.write(value.exitTxWeightWu, into);
1081
1435
  FfiConverterBool.write(value.registered, into);
1082
1436
  }
1083
1437
  allocationSize(value) {
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);
1438
+ return FfiConverterString.allocationSize(value.id) + FfiConverterUInt64.allocationSize(value.amountSats) + FfiConverterUInt32.allocationSize(value.expiryHeight) + FfiConverterString.allocationSize(value.kind) + FfiConverterTypeVtxoState.allocationSize(value.state) + FfiConverterUInt32.allocationSize(value.exitDepth) + FfiConverterUInt64.allocationSize(value.exitTxWeightWu) + FfiConverterBool.allocationSize(value.registered);
1085
1439
  }
1086
1440
  }
1087
1441
  return new FFIConverter();
@@ -1171,6 +1525,52 @@ const FfiConverterTypeWalletProperties = (() => {
1171
1525
  }
1172
1526
  return new FFIConverter();
1173
1527
  })();
1528
+
1529
+ /**
1530
+ * Summary of one onchain wallet transaction, mirroring
1531
+ * `bark::onchain::WalletTxInfo`.
1532
+ */
1533
+
1534
+ /**
1535
+ * Generated factory for {@link WalletTransaction} record objects.
1536
+ */
1537
+ export const WalletTransaction = (() => {
1538
+ const defaults = () => ({});
1539
+ const create = (() => {
1540
+ return uniffiCreateRecord(defaults);
1541
+ })();
1542
+ return Object.freeze({
1543
+ create,
1544
+ new: create,
1545
+ defaults: () => Object.freeze(defaults())
1546
+ });
1547
+ })();
1548
+ const FfiConverterTypeWalletTransaction = (() => {
1549
+ class FFIConverter extends AbstractFfiConverterByteArray {
1550
+ read(from) {
1551
+ return {
1552
+ txid: FfiConverterString.read(from),
1553
+ txHex: FfiConverterString.read(from),
1554
+ onchainFeeSats: FfiConverterOptionalUInt64.read(from),
1555
+ balanceChangeSats: FfiConverterInt64.read(from),
1556
+ confirmation: FfiConverterOptionalTypeBlockRef.read(from),
1557
+ isCpfp: FfiConverterBool.read(from)
1558
+ };
1559
+ }
1560
+ write(value, into) {
1561
+ FfiConverterString.write(value.txid, into);
1562
+ FfiConverterString.write(value.txHex, into);
1563
+ FfiConverterOptionalUInt64.write(value.onchainFeeSats, into);
1564
+ FfiConverterInt64.write(value.balanceChangeSats, into);
1565
+ FfiConverterOptionalTypeBlockRef.write(value.confirmation, into);
1566
+ FfiConverterBool.write(value.isCpfp, into);
1567
+ }
1568
+ allocationSize(value) {
1569
+ return FfiConverterString.allocationSize(value.txid) + FfiConverterString.allocationSize(value.txHex) + FfiConverterOptionalUInt64.allocationSize(value.onchainFeeSats) + FfiConverterInt64.allocationSize(value.balanceChangeSats) + FfiConverterOptionalTypeBlockRef.allocationSize(value.confirmation) + FfiConverterBool.allocationSize(value.isCpfp);
1570
+ }
1571
+ }
1572
+ return new FFIConverter();
1573
+ })();
1174
1574
  const stringConverter = {
1175
1575
  stringToBytes: s => uniffiCaller.rustCall(status => nativeModule().ubrn_uniffi_internal_fn_func_ffi__string_to_arraybuffer(s, status)),
1176
1576
  bytesToString: ab => uniffiCaller.rustCall(status => nativeModule().ubrn_uniffi_internal_fn_func_ffi__arraybuffer_to_string(ab, status)),
@@ -1255,173 +1655,1569 @@ const FfiConverterTypeError = (() => {
1255
1655
  return intConverter.allocationSize(0);
1256
1656
  }
1257
1657
  }
1258
- return new FfiConverter();
1658
+ return new FfiConverter();
1659
+ })();
1660
+
1661
+ // Enum: ExitState
1662
+ export let ExitState_Tags = /*#__PURE__*/function (ExitState_Tags) {
1663
+ ExitState_Tags["Start"] = "Start";
1664
+ ExitState_Tags["Processing"] = "Processing";
1665
+ ExitState_Tags["AwaitingDelta"] = "AwaitingDelta";
1666
+ ExitState_Tags["Claimable"] = "Claimable";
1667
+ ExitState_Tags["ClaimInProgress"] = "ClaimInProgress";
1668
+ ExitState_Tags["Claimed"] = "Claimed";
1669
+ ExitState_Tags["VtxoAlreadySpent"] = "VtxoAlreadySpent";
1670
+ ExitState_Tags["Canceled"] = "Canceled";
1671
+ return ExitState_Tags;
1672
+ }({});
1673
+ /**
1674
+ * State of a unilateral exit, mirroring `bark::exit::ExitState`.
1675
+ *
1676
+ * Serde/TS tags match upstream's kebab-case serialization (`"start"`,
1677
+ * `"processing"`, `"awaiting-delta"`, `"claimable"`, `"claim-in-progress"`,
1678
+ * `"claimed"`, `"vtxo-already-spent"`, `"canceled"`), with camelCase fields.
1679
+ */
1680
+ export const ExitState = (() => {
1681
+ /**
1682
+ * The exit was requested at the given tip.
1683
+ */
1684
+ class Start_ extends UniffiEnum {
1685
+ /**
1686
+ * @private
1687
+ * This field is private and should not be used, use `tag` instead.
1688
+ */
1689
+ [uniffiTypeNameSymbol] = "ExitState";
1690
+ tag = ExitState_Tags.Start;
1691
+ constructor(inner) {
1692
+ super("ExitState", "Start");
1693
+ this.inner = Object.freeze(inner);
1694
+ }
1695
+ static new(inner) {
1696
+ return new Start_(inner);
1697
+ }
1698
+ static instanceOf(obj) {
1699
+ return obj.tag === ExitState_Tags.Start;
1700
+ }
1701
+ }
1702
+ /**
1703
+ * The exit transaction chain is being broadcast and confirmed.
1704
+ */
1705
+ class Processing_ extends UniffiEnum {
1706
+ /**
1707
+ * @private
1708
+ * This field is private and should not be used, use `tag` instead.
1709
+ */
1710
+ [uniffiTypeNameSymbol] = "ExitState";
1711
+ tag = ExitState_Tags.Processing;
1712
+ constructor(inner) {
1713
+ super("ExitState", "Processing");
1714
+ this.inner = Object.freeze(inner);
1715
+ }
1716
+ static new(inner) {
1717
+ return new Processing_(inner);
1718
+ }
1719
+ static instanceOf(obj) {
1720
+ return obj.tag === ExitState_Tags.Processing;
1721
+ }
1722
+ }
1723
+ /**
1724
+ * Fully confirmed; waiting out the exit delta until claimable.
1725
+ */
1726
+ class AwaitingDelta_ extends UniffiEnum {
1727
+ /**
1728
+ * @private
1729
+ * This field is private and should not be used, use `tag` instead.
1730
+ */
1731
+ [uniffiTypeNameSymbol] = "ExitState";
1732
+ tag = ExitState_Tags.AwaitingDelta;
1733
+ constructor(inner) {
1734
+ super("ExitState", "AwaitingDelta");
1735
+ this.inner = Object.freeze(inner);
1736
+ }
1737
+ static new(inner) {
1738
+ return new AwaitingDelta_(inner);
1739
+ }
1740
+ static instanceOf(obj) {
1741
+ return obj.tag === ExitState_Tags.AwaitingDelta;
1742
+ }
1743
+ }
1744
+ /**
1745
+ * The exit output can be claimed.
1746
+ */
1747
+ class Claimable_ extends UniffiEnum {
1748
+ /**
1749
+ * @private
1750
+ * This field is private and should not be used, use `tag` instead.
1751
+ */
1752
+ [uniffiTypeNameSymbol] = "ExitState";
1753
+ tag = ExitState_Tags.Claimable;
1754
+ constructor(inner) {
1755
+ super("ExitState", "Claimable");
1756
+ this.inner = Object.freeze(inner);
1757
+ }
1758
+ static new(inner) {
1759
+ return new Claimable_(inner);
1760
+ }
1761
+ static instanceOf(obj) {
1762
+ return obj.tag === ExitState_Tags.Claimable;
1763
+ }
1764
+ }
1765
+ /**
1766
+ * A claim transaction has been broadcast.
1767
+ */
1768
+ class ClaimInProgress_ extends UniffiEnum {
1769
+ /**
1770
+ * @private
1771
+ * This field is private and should not be used, use `tag` instead.
1772
+ */
1773
+ [uniffiTypeNameSymbol] = "ExitState";
1774
+ tag = ExitState_Tags.ClaimInProgress;
1775
+ constructor(inner) {
1776
+ super("ExitState", "ClaimInProgress");
1777
+ this.inner = Object.freeze(inner);
1778
+ }
1779
+ static new(inner) {
1780
+ return new ClaimInProgress_(inner);
1781
+ }
1782
+ static instanceOf(obj) {
1783
+ return obj.tag === ExitState_Tags.ClaimInProgress;
1784
+ }
1785
+ }
1786
+ /**
1787
+ * Terminal: the exit output was claimed (or spent deeper in the tree).
1788
+ */
1789
+ class Claimed_ extends UniffiEnum {
1790
+ /**
1791
+ * @private
1792
+ * This field is private and should not be used, use `tag` instead.
1793
+ */
1794
+ [uniffiTypeNameSymbol] = "ExitState";
1795
+ tag = ExitState_Tags.Claimed;
1796
+ constructor(inner) {
1797
+ super("ExitState", "Claimed");
1798
+ this.inner = Object.freeze(inner);
1799
+ }
1800
+ static new(inner) {
1801
+ return new Claimed_(inner);
1802
+ }
1803
+ static instanceOf(obj) {
1804
+ return obj.tag === ExitState_Tags.Claimed;
1805
+ }
1806
+ }
1807
+ /**
1808
+ * Terminal: the VTXO was already spent offchain, so the exit cannot
1809
+ * proceed.
1810
+ */
1811
+ class VtxoAlreadySpent_ extends UniffiEnum {
1812
+ /**
1813
+ * @private
1814
+ * This field is private and should not be used, use `tag` instead.
1815
+ */
1816
+ [uniffiTypeNameSymbol] = "ExitState";
1817
+ tag = ExitState_Tags.VtxoAlreadySpent;
1818
+ constructor(inner) {
1819
+ super("ExitState", "VtxoAlreadySpent");
1820
+ this.inner = Object.freeze(inner);
1821
+ }
1822
+ static new(inner) {
1823
+ return new VtxoAlreadySpent_(inner);
1824
+ }
1825
+ static instanceOf(obj) {
1826
+ return obj.tag === ExitState_Tags.VtxoAlreadySpent;
1827
+ }
1828
+ }
1829
+ /**
1830
+ * Resumable: the user canceled the exit before its final transaction
1831
+ * was broadcast. The VTXO stays spendable.
1832
+ */
1833
+ class Canceled_ extends UniffiEnum {
1834
+ /**
1835
+ * @private
1836
+ * This field is private and should not be used, use `tag` instead.
1837
+ */
1838
+ [uniffiTypeNameSymbol] = "ExitState";
1839
+ tag = ExitState_Tags.Canceled;
1840
+ constructor(inner) {
1841
+ super("ExitState", "Canceled");
1842
+ this.inner = Object.freeze(inner);
1843
+ }
1844
+ static new(inner) {
1845
+ return new Canceled_(inner);
1846
+ }
1847
+ static instanceOf(obj) {
1848
+ return obj.tag === ExitState_Tags.Canceled;
1849
+ }
1850
+ }
1851
+ function instanceOf(obj) {
1852
+ return obj[uniffiTypeNameSymbol] === "ExitState";
1853
+ }
1854
+ return Object.freeze({
1855
+ instanceOf,
1856
+ Start: Start_,
1857
+ Processing: Processing_,
1858
+ AwaitingDelta: AwaitingDelta_,
1859
+ Claimable: Claimable_,
1860
+ ClaimInProgress: ClaimInProgress_,
1861
+ Claimed: Claimed_,
1862
+ VtxoAlreadySpent: VtxoAlreadySpent_,
1863
+ Canceled: Canceled_
1864
+ });
1865
+ })();
1866
+
1867
+ /**
1868
+ * State of a unilateral exit, mirroring `bark::exit::ExitState`.
1869
+ *
1870
+ * Serde/TS tags match upstream's kebab-case serialization (`"start"`,
1871
+ * `"processing"`, `"awaiting-delta"`, `"claimable"`, `"claim-in-progress"`,
1872
+ * `"claimed"`, `"vtxo-already-spent"`, `"canceled"`), with camelCase fields.
1873
+ */
1874
+
1875
+ // FfiConverter for enum ExitState
1876
+ const FfiConverterTypeExitState = (() => {
1877
+ const ordinalConverter = FfiConverterInt32;
1878
+ class FFIConverter extends AbstractFfiConverterByteArray {
1879
+ read(from) {
1880
+ switch (ordinalConverter.read(from)) {
1881
+ case 1:
1882
+ return new ExitState.Start({
1883
+ tipHeight: FfiConverterUInt32.read(from)
1884
+ });
1885
+ case 2:
1886
+ return new ExitState.Processing({
1887
+ tipHeight: FfiConverterUInt32.read(from),
1888
+ transactions: FfiConverterArrayTypeExitTx.read(from)
1889
+ });
1890
+ case 3:
1891
+ return new ExitState.AwaitingDelta({
1892
+ tipHeight: FfiConverterUInt32.read(from),
1893
+ confirmedBlock: FfiConverterTypeBlockRef.read(from),
1894
+ claimableHeight: FfiConverterUInt32.read(from)
1895
+ });
1896
+ case 4:
1897
+ return new ExitState.Claimable({
1898
+ tipHeight: FfiConverterUInt32.read(from),
1899
+ claimableSince: FfiConverterTypeBlockRef.read(from),
1900
+ lastScannedBlock: FfiConverterOptionalTypeBlockRef.read(from)
1901
+ });
1902
+ case 5:
1903
+ return new ExitState.ClaimInProgress({
1904
+ tipHeight: FfiConverterUInt32.read(from),
1905
+ claimableSince: FfiConverterTypeBlockRef.read(from),
1906
+ claimTxid: FfiConverterString.read(from)
1907
+ });
1908
+ case 6:
1909
+ return new ExitState.Claimed({
1910
+ tipHeight: FfiConverterUInt32.read(from),
1911
+ txid: FfiConverterString.read(from),
1912
+ block: FfiConverterTypeBlockRef.read(from)
1913
+ });
1914
+ case 7:
1915
+ return new ExitState.VtxoAlreadySpent({
1916
+ tipHeight: FfiConverterUInt32.read(from)
1917
+ });
1918
+ case 8:
1919
+ return new ExitState.Canceled({
1920
+ tipHeight: FfiConverterUInt32.read(from)
1921
+ });
1922
+ default:
1923
+ throw new UniffiInternalError.UnexpectedEnumCase();
1924
+ }
1925
+ }
1926
+ write(value, into) {
1927
+ switch (value.tag) {
1928
+ case ExitState_Tags.Start:
1929
+ {
1930
+ ordinalConverter.write(1, into);
1931
+ const inner = value.inner;
1932
+ FfiConverterUInt32.write(inner.tipHeight, into);
1933
+ return;
1934
+ }
1935
+ case ExitState_Tags.Processing:
1936
+ {
1937
+ ordinalConverter.write(2, into);
1938
+ const inner = value.inner;
1939
+ FfiConverterUInt32.write(inner.tipHeight, into);
1940
+ FfiConverterArrayTypeExitTx.write(inner.transactions, into);
1941
+ return;
1942
+ }
1943
+ case ExitState_Tags.AwaitingDelta:
1944
+ {
1945
+ ordinalConverter.write(3, into);
1946
+ const inner = value.inner;
1947
+ FfiConverterUInt32.write(inner.tipHeight, into);
1948
+ FfiConverterTypeBlockRef.write(inner.confirmedBlock, into);
1949
+ FfiConverterUInt32.write(inner.claimableHeight, into);
1950
+ return;
1951
+ }
1952
+ case ExitState_Tags.Claimable:
1953
+ {
1954
+ ordinalConverter.write(4, into);
1955
+ const inner = value.inner;
1956
+ FfiConverterUInt32.write(inner.tipHeight, into);
1957
+ FfiConverterTypeBlockRef.write(inner.claimableSince, into);
1958
+ FfiConverterOptionalTypeBlockRef.write(inner.lastScannedBlock, into);
1959
+ return;
1960
+ }
1961
+ case ExitState_Tags.ClaimInProgress:
1962
+ {
1963
+ ordinalConverter.write(5, into);
1964
+ const inner = value.inner;
1965
+ FfiConverterUInt32.write(inner.tipHeight, into);
1966
+ FfiConverterTypeBlockRef.write(inner.claimableSince, into);
1967
+ FfiConverterString.write(inner.claimTxid, into);
1968
+ return;
1969
+ }
1970
+ case ExitState_Tags.Claimed:
1971
+ {
1972
+ ordinalConverter.write(6, into);
1973
+ const inner = value.inner;
1974
+ FfiConverterUInt32.write(inner.tipHeight, into);
1975
+ FfiConverterString.write(inner.txid, into);
1976
+ FfiConverterTypeBlockRef.write(inner.block, into);
1977
+ return;
1978
+ }
1979
+ case ExitState_Tags.VtxoAlreadySpent:
1980
+ {
1981
+ ordinalConverter.write(7, into);
1982
+ const inner = value.inner;
1983
+ FfiConverterUInt32.write(inner.tipHeight, into);
1984
+ return;
1985
+ }
1986
+ case ExitState_Tags.Canceled:
1987
+ {
1988
+ ordinalConverter.write(8, into);
1989
+ const inner = value.inner;
1990
+ FfiConverterUInt32.write(inner.tipHeight, into);
1991
+ return;
1992
+ }
1993
+ default:
1994
+ // Throwing from here means that ExitState_Tags hasn't matched an ordinal.
1995
+ throw new UniffiInternalError.UnexpectedEnumCase();
1996
+ }
1997
+ }
1998
+ allocationSize(value) {
1999
+ switch (value.tag) {
2000
+ case ExitState_Tags.Start:
2001
+ {
2002
+ const inner = value.inner;
2003
+ let size = ordinalConverter.allocationSize(1);
2004
+ size += FfiConverterUInt32.allocationSize(inner.tipHeight);
2005
+ return size;
2006
+ }
2007
+ case ExitState_Tags.Processing:
2008
+ {
2009
+ const inner = value.inner;
2010
+ let size = ordinalConverter.allocationSize(2);
2011
+ size += FfiConverterUInt32.allocationSize(inner.tipHeight);
2012
+ size += FfiConverterArrayTypeExitTx.allocationSize(inner.transactions);
2013
+ return size;
2014
+ }
2015
+ case ExitState_Tags.AwaitingDelta:
2016
+ {
2017
+ const inner = value.inner;
2018
+ let size = ordinalConverter.allocationSize(3);
2019
+ size += FfiConverterUInt32.allocationSize(inner.tipHeight);
2020
+ size += FfiConverterTypeBlockRef.allocationSize(inner.confirmedBlock);
2021
+ size += FfiConverterUInt32.allocationSize(inner.claimableHeight);
2022
+ return size;
2023
+ }
2024
+ case ExitState_Tags.Claimable:
2025
+ {
2026
+ const inner = value.inner;
2027
+ let size = ordinalConverter.allocationSize(4);
2028
+ size += FfiConverterUInt32.allocationSize(inner.tipHeight);
2029
+ size += FfiConverterTypeBlockRef.allocationSize(inner.claimableSince);
2030
+ size += FfiConverterOptionalTypeBlockRef.allocationSize(inner.lastScannedBlock);
2031
+ return size;
2032
+ }
2033
+ case ExitState_Tags.ClaimInProgress:
2034
+ {
2035
+ const inner = value.inner;
2036
+ let size = ordinalConverter.allocationSize(5);
2037
+ size += FfiConverterUInt32.allocationSize(inner.tipHeight);
2038
+ size += FfiConverterTypeBlockRef.allocationSize(inner.claimableSince);
2039
+ size += FfiConverterString.allocationSize(inner.claimTxid);
2040
+ return size;
2041
+ }
2042
+ case ExitState_Tags.Claimed:
2043
+ {
2044
+ const inner = value.inner;
2045
+ let size = ordinalConverter.allocationSize(6);
2046
+ size += FfiConverterUInt32.allocationSize(inner.tipHeight);
2047
+ size += FfiConverterString.allocationSize(inner.txid);
2048
+ size += FfiConverterTypeBlockRef.allocationSize(inner.block);
2049
+ return size;
2050
+ }
2051
+ case ExitState_Tags.VtxoAlreadySpent:
2052
+ {
2053
+ const inner = value.inner;
2054
+ let size = ordinalConverter.allocationSize(7);
2055
+ size += FfiConverterUInt32.allocationSize(inner.tipHeight);
2056
+ return size;
2057
+ }
2058
+ case ExitState_Tags.Canceled:
2059
+ {
2060
+ const inner = value.inner;
2061
+ let size = ordinalConverter.allocationSize(8);
2062
+ size += FfiConverterUInt32.allocationSize(inner.tipHeight);
2063
+ return size;
2064
+ }
2065
+ default:
2066
+ throw new UniffiInternalError.UnexpectedEnumCase();
2067
+ }
2068
+ }
2069
+ }
2070
+ return new FFIConverter();
2071
+ })();
2072
+
2073
+ // Enum: ExitTxOrigin
2074
+ export let ExitTxOrigin_Tags = /*#__PURE__*/function (ExitTxOrigin_Tags) {
2075
+ ExitTxOrigin_Tags["Wallet"] = "Wallet";
2076
+ ExitTxOrigin_Tags["Mempool"] = "Mempool";
2077
+ ExitTxOrigin_Tags["Block"] = "Block";
2078
+ return ExitTxOrigin_Tags;
2079
+ }({});
2080
+ /**
2081
+ * Where an exit transaction was first seen, mirroring `bark::exit::ExitTxOrigin`.
2082
+ */
2083
+ export const ExitTxOrigin = (() => {
2084
+ /**
2085
+ * Broadcast by this wallet.
2086
+ */
2087
+ class Wallet_ extends UniffiEnum {
2088
+ /**
2089
+ * @private
2090
+ * This field is private and should not be used, use `tag` instead.
2091
+ */
2092
+ [uniffiTypeNameSymbol] = "ExitTxOrigin";
2093
+ tag = ExitTxOrigin_Tags.Wallet;
2094
+ constructor(inner) {
2095
+ super("ExitTxOrigin", "Wallet");
2096
+ this.inner = Object.freeze(inner);
2097
+ }
2098
+ static new(inner) {
2099
+ return new Wallet_(inner);
2100
+ }
2101
+ static instanceOf(obj) {
2102
+ return obj.tag === ExitTxOrigin_Tags.Wallet;
2103
+ }
2104
+ }
2105
+ /**
2106
+ * Seen in the mempool.
2107
+ */
2108
+ class Mempool_ extends UniffiEnum {
2109
+ /**
2110
+ * @private
2111
+ * This field is private and should not be used, use `tag` instead.
2112
+ */
2113
+ [uniffiTypeNameSymbol] = "ExitTxOrigin";
2114
+ tag = ExitTxOrigin_Tags.Mempool;
2115
+ constructor() {
2116
+ super("ExitTxOrigin", "Mempool");
2117
+ }
2118
+ static new() {
2119
+ return new Mempool_();
2120
+ }
2121
+ static instanceOf(obj) {
2122
+ return obj.tag === ExitTxOrigin_Tags.Mempool;
2123
+ }
2124
+ }
2125
+ /**
2126
+ * Seen confirmed in a block.
2127
+ */
2128
+ class Block_ extends UniffiEnum {
2129
+ /**
2130
+ * @private
2131
+ * This field is private and should not be used, use `tag` instead.
2132
+ */
2133
+ [uniffiTypeNameSymbol] = "ExitTxOrigin";
2134
+ tag = ExitTxOrigin_Tags.Block;
2135
+ constructor(inner) {
2136
+ super("ExitTxOrigin", "Block");
2137
+ this.inner = Object.freeze(inner);
2138
+ }
2139
+ static new(inner) {
2140
+ return new Block_(inner);
2141
+ }
2142
+ static instanceOf(obj) {
2143
+ return obj.tag === ExitTxOrigin_Tags.Block;
2144
+ }
2145
+ }
2146
+ function instanceOf(obj) {
2147
+ return obj[uniffiTypeNameSymbol] === "ExitTxOrigin";
2148
+ }
2149
+ return Object.freeze({
2150
+ instanceOf,
2151
+ Wallet: Wallet_,
2152
+ Mempool: Mempool_,
2153
+ Block: Block_
2154
+ });
2155
+ })();
2156
+
2157
+ /**
2158
+ * Where an exit transaction was first seen, mirroring `bark::exit::ExitTxOrigin`.
2159
+ */
2160
+
2161
+ // FfiConverter for enum ExitTxOrigin
2162
+ const FfiConverterTypeExitTxOrigin = (() => {
2163
+ const ordinalConverter = FfiConverterInt32;
2164
+ class FFIConverter extends AbstractFfiConverterByteArray {
2165
+ read(from) {
2166
+ switch (ordinalConverter.read(from)) {
2167
+ case 1:
2168
+ return new ExitTxOrigin.Wallet({
2169
+ confirmedIn: FfiConverterOptionalTypeBlockRef.read(from)
2170
+ });
2171
+ case 2:
2172
+ return new ExitTxOrigin.Mempool();
2173
+ case 3:
2174
+ return new ExitTxOrigin.Block({
2175
+ confirmedIn: FfiConverterTypeBlockRef.read(from)
2176
+ });
2177
+ default:
2178
+ throw new UniffiInternalError.UnexpectedEnumCase();
2179
+ }
2180
+ }
2181
+ write(value, into) {
2182
+ switch (value.tag) {
2183
+ case ExitTxOrigin_Tags.Wallet:
2184
+ {
2185
+ ordinalConverter.write(1, into);
2186
+ const inner = value.inner;
2187
+ FfiConverterOptionalTypeBlockRef.write(inner.confirmedIn, into);
2188
+ return;
2189
+ }
2190
+ case ExitTxOrigin_Tags.Mempool:
2191
+ {
2192
+ ordinalConverter.write(2, into);
2193
+ return;
2194
+ }
2195
+ case ExitTxOrigin_Tags.Block:
2196
+ {
2197
+ ordinalConverter.write(3, into);
2198
+ const inner = value.inner;
2199
+ FfiConverterTypeBlockRef.write(inner.confirmedIn, into);
2200
+ return;
2201
+ }
2202
+ default:
2203
+ // Throwing from here means that ExitTxOrigin_Tags hasn't matched an ordinal.
2204
+ throw new UniffiInternalError.UnexpectedEnumCase();
2205
+ }
2206
+ }
2207
+ allocationSize(value) {
2208
+ switch (value.tag) {
2209
+ case ExitTxOrigin_Tags.Wallet:
2210
+ {
2211
+ const inner = value.inner;
2212
+ let size = ordinalConverter.allocationSize(1);
2213
+ size += FfiConverterOptionalTypeBlockRef.allocationSize(inner.confirmedIn);
2214
+ return size;
2215
+ }
2216
+ case ExitTxOrigin_Tags.Mempool:
2217
+ {
2218
+ return ordinalConverter.allocationSize(2);
2219
+ }
2220
+ case ExitTxOrigin_Tags.Block:
2221
+ {
2222
+ const inner = value.inner;
2223
+ let size = ordinalConverter.allocationSize(3);
2224
+ size += FfiConverterTypeBlockRef.allocationSize(inner.confirmedIn);
2225
+ return size;
2226
+ }
2227
+ default:
2228
+ throw new UniffiInternalError.UnexpectedEnumCase();
2229
+ }
2230
+ }
2231
+ }
2232
+ return new FFIConverter();
2233
+ })();
2234
+
2235
+ // Enum: ExitTxStatus
2236
+ export let ExitTxStatus_Tags = /*#__PURE__*/function (ExitTxStatus_Tags) {
2237
+ ExitTxStatus_Tags["VerifyInputs"] = "VerifyInputs";
2238
+ ExitTxStatus_Tags["AwaitingInputConfirmation"] = "AwaitingInputConfirmation";
2239
+ ExitTxStatus_Tags["AwaitingCpfpBroadcast"] = "AwaitingCpfpBroadcast";
2240
+ ExitTxStatus_Tags["AwaitingConfirmation"] = "AwaitingConfirmation";
2241
+ ExitTxStatus_Tags["Confirmed"] = "Confirmed";
2242
+ return ExitTxStatus_Tags;
2243
+ }({});
2244
+ /**
2245
+ * Broadcast/confirmation status of one transaction in an exit chain,
2246
+ * mirroring `bark::exit::ExitTxStatus`.
2247
+ */
2248
+ export const ExitTxStatus = (() => {
2249
+ /**
2250
+ * Inputs are still being verified.
2251
+ */
2252
+ class VerifyInputs_ extends UniffiEnum {
2253
+ /**
2254
+ * @private
2255
+ * This field is private and should not be used, use `tag` instead.
2256
+ */
2257
+ [uniffiTypeNameSymbol] = "ExitTxStatus";
2258
+ tag = ExitTxStatus_Tags.VerifyInputs;
2259
+ constructor() {
2260
+ super("ExitTxStatus", "VerifyInputs");
2261
+ }
2262
+ static new() {
2263
+ return new VerifyInputs_();
2264
+ }
2265
+ static instanceOf(obj) {
2266
+ return obj.tag === ExitTxStatus_Tags.VerifyInputs;
2267
+ }
2268
+ }
2269
+ /**
2270
+ * Waiting for the given input txids to confirm. Sorted for a stable
2271
+ * order (upstream keeps them in a set).
2272
+ */
2273
+ class AwaitingInputConfirmation_ extends UniffiEnum {
2274
+ /**
2275
+ * @private
2276
+ * This field is private and should not be used, use `tag` instead.
2277
+ */
2278
+ [uniffiTypeNameSymbol] = "ExitTxStatus";
2279
+ tag = ExitTxStatus_Tags.AwaitingInputConfirmation;
2280
+ constructor(inner) {
2281
+ super("ExitTxStatus", "AwaitingInputConfirmation");
2282
+ this.inner = Object.freeze(inner);
2283
+ }
2284
+ static new(inner) {
2285
+ return new AwaitingInputConfirmation_(inner);
2286
+ }
2287
+ static instanceOf(obj) {
2288
+ return obj.tag === ExitTxStatus_Tags.AwaitingInputConfirmation;
2289
+ }
2290
+ }
2291
+ /**
2292
+ * Ready for its CPFP child to be broadcast.
2293
+ */
2294
+ class AwaitingCpfpBroadcast_ extends UniffiEnum {
2295
+ /**
2296
+ * @private
2297
+ * This field is private and should not be used, use `tag` instead.
2298
+ */
2299
+ [uniffiTypeNameSymbol] = "ExitTxStatus";
2300
+ tag = ExitTxStatus_Tags.AwaitingCpfpBroadcast;
2301
+ constructor() {
2302
+ super("ExitTxStatus", "AwaitingCpfpBroadcast");
2303
+ }
2304
+ static new() {
2305
+ return new AwaitingCpfpBroadcast_();
2306
+ }
2307
+ static instanceOf(obj) {
2308
+ return obj.tag === ExitTxStatus_Tags.AwaitingCpfpBroadcast;
2309
+ }
2310
+ }
2311
+ /**
2312
+ * CPFP child broadcast; waiting for confirmation.
2313
+ */
2314
+ class AwaitingConfirmation_ extends UniffiEnum {
2315
+ /**
2316
+ * @private
2317
+ * This field is private and should not be used, use `tag` instead.
2318
+ */
2319
+ [uniffiTypeNameSymbol] = "ExitTxStatus";
2320
+ tag = ExitTxStatus_Tags.AwaitingConfirmation;
2321
+ constructor(inner) {
2322
+ super("ExitTxStatus", "AwaitingConfirmation");
2323
+ this.inner = Object.freeze(inner);
2324
+ }
2325
+ static new(inner) {
2326
+ return new AwaitingConfirmation_(inner);
2327
+ }
2328
+ static instanceOf(obj) {
2329
+ return obj.tag === ExitTxStatus_Tags.AwaitingConfirmation;
2330
+ }
2331
+ }
2332
+ /**
2333
+ * Confirmed in a block.
2334
+ */
2335
+ class Confirmed_ extends UniffiEnum {
2336
+ /**
2337
+ * @private
2338
+ * This field is private and should not be used, use `tag` instead.
2339
+ */
2340
+ [uniffiTypeNameSymbol] = "ExitTxStatus";
2341
+ tag = ExitTxStatus_Tags.Confirmed;
2342
+ constructor(inner) {
2343
+ super("ExitTxStatus", "Confirmed");
2344
+ this.inner = Object.freeze(inner);
2345
+ }
2346
+ static new(inner) {
2347
+ return new Confirmed_(inner);
2348
+ }
2349
+ static instanceOf(obj) {
2350
+ return obj.tag === ExitTxStatus_Tags.Confirmed;
2351
+ }
2352
+ }
2353
+ function instanceOf(obj) {
2354
+ return obj[uniffiTypeNameSymbol] === "ExitTxStatus";
2355
+ }
2356
+ return Object.freeze({
2357
+ instanceOf,
2358
+ VerifyInputs: VerifyInputs_,
2359
+ AwaitingInputConfirmation: AwaitingInputConfirmation_,
2360
+ AwaitingCpfpBroadcast: AwaitingCpfpBroadcast_,
2361
+ AwaitingConfirmation: AwaitingConfirmation_,
2362
+ Confirmed: Confirmed_
2363
+ });
2364
+ })();
2365
+
2366
+ /**
2367
+ * Broadcast/confirmation status of one transaction in an exit chain,
2368
+ * mirroring `bark::exit::ExitTxStatus`.
2369
+ */
2370
+
2371
+ // FfiConverter for enum ExitTxStatus
2372
+ const FfiConverterTypeExitTxStatus = (() => {
2373
+ const ordinalConverter = FfiConverterInt32;
2374
+ class FFIConverter extends AbstractFfiConverterByteArray {
2375
+ read(from) {
2376
+ switch (ordinalConverter.read(from)) {
2377
+ case 1:
2378
+ return new ExitTxStatus.VerifyInputs();
2379
+ case 2:
2380
+ return new ExitTxStatus.AwaitingInputConfirmation({
2381
+ txids: FfiConverterArrayString.read(from)
2382
+ });
2383
+ case 3:
2384
+ return new ExitTxStatus.AwaitingCpfpBroadcast();
2385
+ case 4:
2386
+ return new ExitTxStatus.AwaitingConfirmation({
2387
+ childTxid: FfiConverterString.read(from),
2388
+ origin: FfiConverterTypeExitTxOrigin.read(from)
2389
+ });
2390
+ case 5:
2391
+ return new ExitTxStatus.Confirmed({
2392
+ childTxid: FfiConverterString.read(from),
2393
+ block: FfiConverterTypeBlockRef.read(from),
2394
+ origin: FfiConverterTypeExitTxOrigin.read(from)
2395
+ });
2396
+ default:
2397
+ throw new UniffiInternalError.UnexpectedEnumCase();
2398
+ }
2399
+ }
2400
+ write(value, into) {
2401
+ switch (value.tag) {
2402
+ case ExitTxStatus_Tags.VerifyInputs:
2403
+ {
2404
+ ordinalConverter.write(1, into);
2405
+ return;
2406
+ }
2407
+ case ExitTxStatus_Tags.AwaitingInputConfirmation:
2408
+ {
2409
+ ordinalConverter.write(2, into);
2410
+ const inner = value.inner;
2411
+ FfiConverterArrayString.write(inner.txids, into);
2412
+ return;
2413
+ }
2414
+ case ExitTxStatus_Tags.AwaitingCpfpBroadcast:
2415
+ {
2416
+ ordinalConverter.write(3, into);
2417
+ return;
2418
+ }
2419
+ case ExitTxStatus_Tags.AwaitingConfirmation:
2420
+ {
2421
+ ordinalConverter.write(4, into);
2422
+ const inner = value.inner;
2423
+ FfiConverterString.write(inner.childTxid, into);
2424
+ FfiConverterTypeExitTxOrigin.write(inner.origin, into);
2425
+ return;
2426
+ }
2427
+ case ExitTxStatus_Tags.Confirmed:
2428
+ {
2429
+ ordinalConverter.write(5, into);
2430
+ const inner = value.inner;
2431
+ FfiConverterString.write(inner.childTxid, into);
2432
+ FfiConverterTypeBlockRef.write(inner.block, into);
2433
+ FfiConverterTypeExitTxOrigin.write(inner.origin, into);
2434
+ return;
2435
+ }
2436
+ default:
2437
+ // Throwing from here means that ExitTxStatus_Tags hasn't matched an ordinal.
2438
+ throw new UniffiInternalError.UnexpectedEnumCase();
2439
+ }
2440
+ }
2441
+ allocationSize(value) {
2442
+ switch (value.tag) {
2443
+ case ExitTxStatus_Tags.VerifyInputs:
2444
+ {
2445
+ return ordinalConverter.allocationSize(1);
2446
+ }
2447
+ case ExitTxStatus_Tags.AwaitingInputConfirmation:
2448
+ {
2449
+ const inner = value.inner;
2450
+ let size = ordinalConverter.allocationSize(2);
2451
+ size += FfiConverterArrayString.allocationSize(inner.txids);
2452
+ return size;
2453
+ }
2454
+ case ExitTxStatus_Tags.AwaitingCpfpBroadcast:
2455
+ {
2456
+ return ordinalConverter.allocationSize(3);
2457
+ }
2458
+ case ExitTxStatus_Tags.AwaitingConfirmation:
2459
+ {
2460
+ const inner = value.inner;
2461
+ let size = ordinalConverter.allocationSize(4);
2462
+ size += FfiConverterString.allocationSize(inner.childTxid);
2463
+ size += FfiConverterTypeExitTxOrigin.allocationSize(inner.origin);
2464
+ return size;
2465
+ }
2466
+ case ExitTxStatus_Tags.Confirmed:
2467
+ {
2468
+ const inner = value.inner;
2469
+ let size = ordinalConverter.allocationSize(5);
2470
+ size += FfiConverterString.allocationSize(inner.childTxid);
2471
+ size += FfiConverterTypeBlockRef.allocationSize(inner.block);
2472
+ size += FfiConverterTypeExitTxOrigin.allocationSize(inner.origin);
2473
+ return size;
2474
+ }
2475
+ default:
2476
+ throw new UniffiInternalError.UnexpectedEnumCase();
2477
+ }
2478
+ }
2479
+ }
2480
+ return new FFIConverter();
2481
+ })();
2482
+
2483
+ // Enum: LightningSendStatus
2484
+ export let LightningSendStatus_Tags = /*#__PURE__*/function (LightningSendStatus_Tags) {
2485
+ LightningSendStatus_Tags["Unknown"] = "Unknown";
2486
+ LightningSendStatus_Tags["InProgress"] = "InProgress";
2487
+ LightningSendStatus_Tags["Paid"] = "Paid";
2488
+ return LightningSendStatus_Tags;
2489
+ }({});
2490
+ /**
2491
+ * Terminal/in-flight state of an outgoing lightning send.
2492
+ *
2493
+ * Mirrors `bark`'s `LightningSendState`. `pay_lightning_*` and
2494
+ * `check_lightning_payment` now return this so callers can drive the
2495
+ * crash-safe send flow themselves (initiate with `wait = false`, then poll).
2496
+ */
2497
+ export const LightningSendStatus = (() => {
2498
+ /**
2499
+ * No record of this payment (never started, or already pruned).
2500
+ */
2501
+ class Unknown_ extends UniffiEnum {
2502
+ /**
2503
+ * @private
2504
+ * This field is private and should not be used, use `tag` instead.
2505
+ */
2506
+ [uniffiTypeNameSymbol] = "LightningSendStatus";
2507
+ tag = LightningSendStatus_Tags.Unknown;
2508
+ constructor() {
2509
+ super("LightningSendStatus", "Unknown");
2510
+ }
2511
+ static new() {
2512
+ return new Unknown_();
2513
+ }
2514
+ static instanceOf(obj) {
2515
+ return obj.tag === LightningSendStatus_Tags.Unknown;
2516
+ }
2517
+ }
2518
+ /**
2519
+ * Send is in flight; HTLC VTXOs are locked.
2520
+ */
2521
+ class InProgress_ extends UniffiEnum {
2522
+ /**
2523
+ * @private
2524
+ * This field is private and should not be used, use `tag` instead.
2525
+ */
2526
+ [uniffiTypeNameSymbol] = "LightningSendStatus";
2527
+ tag = LightningSendStatus_Tags.InProgress;
2528
+ constructor(inner) {
2529
+ super("LightningSendStatus", "InProgress");
2530
+ this.inner = Object.freeze(inner);
2531
+ }
2532
+ static new(inner) {
2533
+ return new InProgress_(inner);
2534
+ }
2535
+ static instanceOf(obj) {
2536
+ return obj.tag === LightningSendStatus_Tags.InProgress;
2537
+ }
2538
+ }
2539
+ /**
2540
+ * Send has settled; the preimage proves payment.
2541
+ */
2542
+ class Paid_ extends UniffiEnum {
2543
+ /**
2544
+ * @private
2545
+ * This field is private and should not be used, use `tag` instead.
2546
+ */
2547
+ [uniffiTypeNameSymbol] = "LightningSendStatus";
2548
+ tag = LightningSendStatus_Tags.Paid;
2549
+ constructor(inner) {
2550
+ super("LightningSendStatus", "Paid");
2551
+ this.inner = Object.freeze(inner);
2552
+ }
2553
+ static new(inner) {
2554
+ return new Paid_(inner);
2555
+ }
2556
+ static instanceOf(obj) {
2557
+ return obj.tag === LightningSendStatus_Tags.Paid;
2558
+ }
2559
+ }
2560
+ function instanceOf(obj) {
2561
+ return obj[uniffiTypeNameSymbol] === "LightningSendStatus";
2562
+ }
2563
+ return Object.freeze({
2564
+ instanceOf,
2565
+ Unknown: Unknown_,
2566
+ InProgress: InProgress_,
2567
+ Paid: Paid_
2568
+ });
2569
+ })();
2570
+
2571
+ /**
2572
+ * Terminal/in-flight state of an outgoing lightning send.
2573
+ *
2574
+ * Mirrors `bark`'s `LightningSendState`. `pay_lightning_*` and
2575
+ * `check_lightning_payment` now return this so callers can drive the
2576
+ * crash-safe send flow themselves (initiate with `wait = false`, then poll).
2577
+ */
2578
+
2579
+ // FfiConverter for enum LightningSendStatus
2580
+ const FfiConverterTypeLightningSendStatus = (() => {
2581
+ const ordinalConverter = FfiConverterInt32;
2582
+ class FFIConverter extends AbstractFfiConverterByteArray {
2583
+ read(from) {
2584
+ switch (ordinalConverter.read(from)) {
2585
+ case 1:
2586
+ return new LightningSendStatus.Unknown();
2587
+ case 2:
2588
+ return new LightningSendStatus.InProgress({
2589
+ send: FfiConverterTypeLightningSend.read(from)
2590
+ });
2591
+ case 3:
2592
+ return new LightningSendStatus.Paid({
2593
+ paymentHash: FfiConverterString.read(from),
2594
+ preimage: FfiConverterString.read(from)
2595
+ });
2596
+ default:
2597
+ throw new UniffiInternalError.UnexpectedEnumCase();
2598
+ }
2599
+ }
2600
+ write(value, into) {
2601
+ switch (value.tag) {
2602
+ case LightningSendStatus_Tags.Unknown:
2603
+ {
2604
+ ordinalConverter.write(1, into);
2605
+ return;
2606
+ }
2607
+ case LightningSendStatus_Tags.InProgress:
2608
+ {
2609
+ ordinalConverter.write(2, into);
2610
+ const inner = value.inner;
2611
+ FfiConverterTypeLightningSend.write(inner.send, into);
2612
+ return;
2613
+ }
2614
+ case LightningSendStatus_Tags.Paid:
2615
+ {
2616
+ ordinalConverter.write(3, into);
2617
+ const inner = value.inner;
2618
+ FfiConverterString.write(inner.paymentHash, into);
2619
+ FfiConverterString.write(inner.preimage, into);
2620
+ return;
2621
+ }
2622
+ default:
2623
+ // Throwing from here means that LightningSendStatus_Tags hasn't matched an ordinal.
2624
+ throw new UniffiInternalError.UnexpectedEnumCase();
2625
+ }
2626
+ }
2627
+ allocationSize(value) {
2628
+ switch (value.tag) {
2629
+ case LightningSendStatus_Tags.Unknown:
2630
+ {
2631
+ return ordinalConverter.allocationSize(1);
2632
+ }
2633
+ case LightningSendStatus_Tags.InProgress:
2634
+ {
2635
+ const inner = value.inner;
2636
+ let size = ordinalConverter.allocationSize(2);
2637
+ size += FfiConverterTypeLightningSend.allocationSize(inner.send);
2638
+ return size;
2639
+ }
2640
+ case LightningSendStatus_Tags.Paid:
2641
+ {
2642
+ const inner = value.inner;
2643
+ let size = ordinalConverter.allocationSize(3);
2644
+ size += FfiConverterString.allocationSize(inner.paymentHash);
2645
+ size += FfiConverterString.allocationSize(inner.preimage);
2646
+ return size;
2647
+ }
2648
+ default:
2649
+ throw new UniffiInternalError.UnexpectedEnumCase();
2650
+ }
2651
+ }
2652
+ }
2653
+ return new FFIConverter();
2654
+ })();
2655
+
2656
+ /**
2657
+ * Severity of a log record.
2658
+ */
2659
+ export let LogLevel = /*#__PURE__*/function (LogLevel) {
2660
+ LogLevel[LogLevel["Error"] = 0] = "Error";
2661
+ LogLevel[LogLevel["Warn"] = 1] = "Warn";
2662
+ LogLevel[LogLevel["Info"] = 2] = "Info";
2663
+ LogLevel[LogLevel["Debug"] = 3] = "Debug";
2664
+ LogLevel[LogLevel["Trace"] = 4] = "Trace";
2665
+ return LogLevel;
2666
+ }({});
2667
+ const FfiConverterTypeLogLevel = (() => {
2668
+ const ordinalConverter = FfiConverterInt32;
2669
+ class FFIConverter extends AbstractFfiConverterByteArray {
2670
+ read(from) {
2671
+ switch (ordinalConverter.read(from)) {
2672
+ case 1:
2673
+ return LogLevel.Error;
2674
+ case 2:
2675
+ return LogLevel.Warn;
2676
+ case 3:
2677
+ return LogLevel.Info;
2678
+ case 4:
2679
+ return LogLevel.Debug;
2680
+ case 5:
2681
+ return LogLevel.Trace;
2682
+ default:
2683
+ throw new UniffiInternalError.UnexpectedEnumCase();
2684
+ }
2685
+ }
2686
+ write(value, into) {
2687
+ switch (value) {
2688
+ case LogLevel.Error:
2689
+ return ordinalConverter.write(1, into);
2690
+ case LogLevel.Warn:
2691
+ return ordinalConverter.write(2, into);
2692
+ case LogLevel.Info:
2693
+ return ordinalConverter.write(3, into);
2694
+ case LogLevel.Debug:
2695
+ return ordinalConverter.write(4, into);
2696
+ case LogLevel.Trace:
2697
+ return ordinalConverter.write(5, into);
2698
+ }
2699
+ }
2700
+ allocationSize(value) {
2701
+ return ordinalConverter.allocationSize(0);
2702
+ }
2703
+ }
2704
+ return new FFIConverter();
2705
+ })();
2706
+ export let Network = /*#__PURE__*/function (Network) {
2707
+ Network[Network["Bitcoin"] = 0] = "Bitcoin";
2708
+ Network[Network["Testnet"] = 1] = "Testnet";
2709
+ Network[Network["Signet"] = 2] = "Signet";
2710
+ Network[Network["Regtest"] = 3] = "Regtest";
2711
+ return Network;
2712
+ }({});
2713
+ const FfiConverterTypeNetwork = (() => {
2714
+ const ordinalConverter = FfiConverterInt32;
2715
+ class FFIConverter extends AbstractFfiConverterByteArray {
2716
+ read(from) {
2717
+ switch (ordinalConverter.read(from)) {
2718
+ case 1:
2719
+ return Network.Bitcoin;
2720
+ case 2:
2721
+ return Network.Testnet;
2722
+ case 3:
2723
+ return Network.Signet;
2724
+ case 4:
2725
+ return Network.Regtest;
2726
+ default:
2727
+ throw new UniffiInternalError.UnexpectedEnumCase();
2728
+ }
2729
+ }
2730
+ write(value, into) {
2731
+ switch (value) {
2732
+ case Network.Bitcoin:
2733
+ return ordinalConverter.write(1, into);
2734
+ case Network.Testnet:
2735
+ return ordinalConverter.write(2, into);
2736
+ case Network.Signet:
2737
+ return ordinalConverter.write(3, into);
2738
+ case Network.Regtest:
2739
+ return ordinalConverter.write(4, into);
2740
+ }
2741
+ }
2742
+ allocationSize(value) {
2743
+ return ordinalConverter.allocationSize(0);
2744
+ }
2745
+ }
2746
+ return new FFIConverter();
2747
+ })();
2748
+
2749
+ // Enum: OnchainUtxo
2750
+ export let OnchainUtxo_Tags = /*#__PURE__*/function (OnchainUtxo_Tags) {
2751
+ OnchainUtxo_Tags["Local"] = "Local";
2752
+ OnchainUtxo_Tags["Exit"] = "Exit";
2753
+ return OnchainUtxo_Tags;
2754
+ }({});
2755
+ /**
2756
+ * An onchain UTXO known to the wallet, mirroring `bark::onchain::Utxo`.
2757
+ */
2758
+ export const OnchainUtxo = (() => {
2759
+ /**
2760
+ * A standard wallet UTXO.
2761
+ */
2762
+ class Local_ extends UniffiEnum {
2763
+ /**
2764
+ * @private
2765
+ * This field is private and should not be used, use `tag` instead.
2766
+ */
2767
+ [uniffiTypeNameSymbol] = "OnchainUtxo";
2768
+ tag = OnchainUtxo_Tags.Local;
2769
+ constructor(inner) {
2770
+ super("OnchainUtxo", "Local");
2771
+ this.inner = Object.freeze(inner);
2772
+ }
2773
+ static new(inner) {
2774
+ return new Local_(inner);
2775
+ }
2776
+ static instanceOf(obj) {
2777
+ return obj.tag === OnchainUtxo_Tags.Local;
2778
+ }
2779
+ }
2780
+ /**
2781
+ * A spendable unilateral-exit output claimed from a VTXO.
2782
+ */
2783
+ class Exit_ extends UniffiEnum {
2784
+ /**
2785
+ * @private
2786
+ * This field is private and should not be used, use `tag` instead.
2787
+ */
2788
+ [uniffiTypeNameSymbol] = "OnchainUtxo";
2789
+ tag = OnchainUtxo_Tags.Exit;
2790
+ constructor(inner) {
2791
+ super("OnchainUtxo", "Exit");
2792
+ this.inner = Object.freeze(inner);
2793
+ }
2794
+ static new(inner) {
2795
+ return new Exit_(inner);
2796
+ }
2797
+ static instanceOf(obj) {
2798
+ return obj.tag === OnchainUtxo_Tags.Exit;
2799
+ }
2800
+ }
2801
+ function instanceOf(obj) {
2802
+ return obj[uniffiTypeNameSymbol] === "OnchainUtxo";
2803
+ }
2804
+ return Object.freeze({
2805
+ instanceOf,
2806
+ Local: Local_,
2807
+ Exit: Exit_
2808
+ });
2809
+ })();
2810
+
2811
+ /**
2812
+ * An onchain UTXO known to the wallet, mirroring `bark::onchain::Utxo`.
2813
+ */
2814
+
2815
+ // FfiConverter for enum OnchainUtxo
2816
+ const FfiConverterTypeOnchainUtxo = (() => {
2817
+ const ordinalConverter = FfiConverterInt32;
2818
+ class FFIConverter extends AbstractFfiConverterByteArray {
2819
+ read(from) {
2820
+ switch (ordinalConverter.read(from)) {
2821
+ case 1:
2822
+ return new OnchainUtxo.Local({
2823
+ outpoint: FfiConverterTypeOutPoint.read(from),
2824
+ amountSats: FfiConverterUInt64.read(from),
2825
+ confirmationHeight: FfiConverterOptionalUInt32.read(from)
2826
+ });
2827
+ case 2:
2828
+ return new OnchainUtxo.Exit({
2829
+ vtxoId: FfiConverterString.read(from),
2830
+ amountSats: FfiConverterUInt64.read(from),
2831
+ height: FfiConverterUInt32.read(from)
2832
+ });
2833
+ default:
2834
+ throw new UniffiInternalError.UnexpectedEnumCase();
2835
+ }
2836
+ }
2837
+ write(value, into) {
2838
+ switch (value.tag) {
2839
+ case OnchainUtxo_Tags.Local:
2840
+ {
2841
+ ordinalConverter.write(1, into);
2842
+ const inner = value.inner;
2843
+ FfiConverterTypeOutPoint.write(inner.outpoint, into);
2844
+ FfiConverterUInt64.write(inner.amountSats, into);
2845
+ FfiConverterOptionalUInt32.write(inner.confirmationHeight, into);
2846
+ return;
2847
+ }
2848
+ case OnchainUtxo_Tags.Exit:
2849
+ {
2850
+ ordinalConverter.write(2, into);
2851
+ const inner = value.inner;
2852
+ FfiConverterString.write(inner.vtxoId, into);
2853
+ FfiConverterUInt64.write(inner.amountSats, into);
2854
+ FfiConverterUInt32.write(inner.height, into);
2855
+ return;
2856
+ }
2857
+ default:
2858
+ // Throwing from here means that OnchainUtxo_Tags hasn't matched an ordinal.
2859
+ throw new UniffiInternalError.UnexpectedEnumCase();
2860
+ }
2861
+ }
2862
+ allocationSize(value) {
2863
+ switch (value.tag) {
2864
+ case OnchainUtxo_Tags.Local:
2865
+ {
2866
+ const inner = value.inner;
2867
+ let size = ordinalConverter.allocationSize(1);
2868
+ size += FfiConverterTypeOutPoint.allocationSize(inner.outpoint);
2869
+ size += FfiConverterUInt64.allocationSize(inner.amountSats);
2870
+ size += FfiConverterOptionalUInt32.allocationSize(inner.confirmationHeight);
2871
+ return size;
2872
+ }
2873
+ case OnchainUtxo_Tags.Exit:
2874
+ {
2875
+ const inner = value.inner;
2876
+ let size = ordinalConverter.allocationSize(2);
2877
+ size += FfiConverterString.allocationSize(inner.vtxoId);
2878
+ size += FfiConverterUInt64.allocationSize(inner.amountSats);
2879
+ size += FfiConverterUInt32.allocationSize(inner.height);
2880
+ return size;
2881
+ }
2882
+ default:
2883
+ throw new UniffiInternalError.UnexpectedEnumCase();
2884
+ }
2885
+ }
2886
+ }
2887
+ return new FFIConverter();
2888
+ })();
2889
+
2890
+ // Enum: VtxoLockHolder
2891
+ export let VtxoLockHolder_Tags = /*#__PURE__*/function (VtxoLockHolder_Tags) {
2892
+ VtxoLockHolder_Tags["Action"] = "Action";
2893
+ VtxoLockHolder_Tags["Movement"] = "Movement";
2894
+ return VtxoLockHolder_Tags;
2895
+ }({});
2896
+ /**
2897
+ * Who holds the lock on a [`VtxoState::Locked`] VTXO.
2898
+ *
2899
+ * Mirrors `bark::vtxo::VtxoLockHolder`. Action-based subsystems lock with
2900
+ * `Action`; pre-action subsystems (round, offboard, board, lightning
2901
+ * receive) lock with `Movement`. As upstream converts subsystems to
2902
+ * actions, new locks migrate from `Movement` to `Action` per-subsystem.
2903
+ *
2904
+ * Serde/TS tags match upstream's serialization: `"action"` / `"movement"`.
2905
+ */
2906
+ export const VtxoLockHolder = (() => {
2907
+ /**
2908
+ * A wallet action checkpoint. `id` is upstream's `WalletActionId`
2909
+ * (an opaque string).
2910
+ */
2911
+ class Action_ extends UniffiEnum {
2912
+ /**
2913
+ * @private
2914
+ * This field is private and should not be used, use `tag` instead.
2915
+ */
2916
+ [uniffiTypeNameSymbol] = "VtxoLockHolder";
2917
+ tag = VtxoLockHolder_Tags.Action;
2918
+ constructor(inner) {
2919
+ super("VtxoLockHolder", "Action");
2920
+ this.inner = Object.freeze(inner);
2921
+ }
2922
+ static new(inner) {
2923
+ return new Action_(inner);
2924
+ }
2925
+ static instanceOf(obj) {
2926
+ return obj.tag === VtxoLockHolder_Tags.Action;
2927
+ }
2928
+ }
2929
+ /**
2930
+ * A pre-action subsystem, keyed by its movement.
2931
+ */
2932
+ class Movement_ extends UniffiEnum {
2933
+ /**
2934
+ * @private
2935
+ * This field is private and should not be used, use `tag` instead.
2936
+ */
2937
+ [uniffiTypeNameSymbol] = "VtxoLockHolder";
2938
+ tag = VtxoLockHolder_Tags.Movement;
2939
+ constructor(inner) {
2940
+ super("VtxoLockHolder", "Movement");
2941
+ this.inner = Object.freeze(inner);
2942
+ }
2943
+ static new(inner) {
2944
+ return new Movement_(inner);
2945
+ }
2946
+ static instanceOf(obj) {
2947
+ return obj.tag === VtxoLockHolder_Tags.Movement;
2948
+ }
2949
+ }
2950
+ function instanceOf(obj) {
2951
+ return obj[uniffiTypeNameSymbol] === "VtxoLockHolder";
2952
+ }
2953
+ return Object.freeze({
2954
+ instanceOf,
2955
+ Action: Action_,
2956
+ Movement: Movement_
2957
+ });
2958
+ })();
2959
+
2960
+ /**
2961
+ * Who holds the lock on a [`VtxoState::Locked`] VTXO.
2962
+ *
2963
+ * Mirrors `bark::vtxo::VtxoLockHolder`. Action-based subsystems lock with
2964
+ * `Action`; pre-action subsystems (round, offboard, board, lightning
2965
+ * receive) lock with `Movement`. As upstream converts subsystems to
2966
+ * actions, new locks migrate from `Movement` to `Action` per-subsystem.
2967
+ *
2968
+ * Serde/TS tags match upstream's serialization: `"action"` / `"movement"`.
2969
+ */
2970
+
2971
+ // FfiConverter for enum VtxoLockHolder
2972
+ const FfiConverterTypeVtxoLockHolder = (() => {
2973
+ const ordinalConverter = FfiConverterInt32;
2974
+ class FFIConverter extends AbstractFfiConverterByteArray {
2975
+ read(from) {
2976
+ switch (ordinalConverter.read(from)) {
2977
+ case 1:
2978
+ return new VtxoLockHolder.Action({
2979
+ id: FfiConverterString.read(from)
2980
+ });
2981
+ case 2:
2982
+ return new VtxoLockHolder.Movement({
2983
+ id: FfiConverterUInt32.read(from)
2984
+ });
2985
+ default:
2986
+ throw new UniffiInternalError.UnexpectedEnumCase();
2987
+ }
2988
+ }
2989
+ write(value, into) {
2990
+ switch (value.tag) {
2991
+ case VtxoLockHolder_Tags.Action:
2992
+ {
2993
+ ordinalConverter.write(1, into);
2994
+ const inner = value.inner;
2995
+ FfiConverterString.write(inner.id, into);
2996
+ return;
2997
+ }
2998
+ case VtxoLockHolder_Tags.Movement:
2999
+ {
3000
+ ordinalConverter.write(2, into);
3001
+ const inner = value.inner;
3002
+ FfiConverterUInt32.write(inner.id, into);
3003
+ return;
3004
+ }
3005
+ default:
3006
+ // Throwing from here means that VtxoLockHolder_Tags hasn't matched an ordinal.
3007
+ throw new UniffiInternalError.UnexpectedEnumCase();
3008
+ }
3009
+ }
3010
+ allocationSize(value) {
3011
+ switch (value.tag) {
3012
+ case VtxoLockHolder_Tags.Action:
3013
+ {
3014
+ const inner = value.inner;
3015
+ let size = ordinalConverter.allocationSize(1);
3016
+ size += FfiConverterString.allocationSize(inner.id);
3017
+ return size;
3018
+ }
3019
+ case VtxoLockHolder_Tags.Movement:
3020
+ {
3021
+ const inner = value.inner;
3022
+ let size = ordinalConverter.allocationSize(2);
3023
+ size += FfiConverterUInt32.allocationSize(inner.id);
3024
+ return size;
3025
+ }
3026
+ default:
3027
+ throw new UniffiInternalError.UnexpectedEnumCase();
3028
+ }
3029
+ }
3030
+ }
3031
+ return new FFIConverter();
1259
3032
  })();
1260
3033
 
1261
- // Enum: LightningSendStatus
1262
- export let LightningSendStatus_Tags = /*#__PURE__*/function (LightningSendStatus_Tags) {
1263
- LightningSendStatus_Tags["Unknown"] = "Unknown";
1264
- LightningSendStatus_Tags["InProgress"] = "InProgress";
1265
- LightningSendStatus_Tags["Paid"] = "Paid";
1266
- return LightningSendStatus_Tags;
3034
+ // Enum: VtxoState
3035
+ export let VtxoState_Tags = /*#__PURE__*/function (VtxoState_Tags) {
3036
+ VtxoState_Tags["Spendable"] = "Spendable";
3037
+ VtxoState_Tags["Locked"] = "Locked";
3038
+ VtxoState_Tags["Spent"] = "Spent";
3039
+ VtxoState_Tags["Exited"] = "Exited";
3040
+ return VtxoState_Tags;
1267
3041
  }({});
1268
3042
  /**
1269
- * Terminal/in-flight state of an outgoing lightning send.
3043
+ * Rich VTXO state, mirroring `bark::vtxo::VtxoState`.
1270
3044
  *
1271
- * Mirrors `bark`'s `LightningSendState`. `pay_lightning_*` and
1272
- * `check_lightning_payment` now return this so callers can drive the
1273
- * crash-safe send flow themselves (initiate with `wait = false`, then poll).
3045
+ * Serde/TS tags match upstream's kebab-case serialization:
3046
+ * `"spendable"` | `"locked"` | `"spent"` | `"exited"`.
1274
3047
  */
1275
- export const LightningSendStatus = (() => {
3048
+ export const VtxoState = (() => {
1276
3049
  /**
1277
- * No record of this payment (never started, or already pruned).
3050
+ * Available; can be spent in a future round.
1278
3051
  */
1279
- class Unknown_ extends UniffiEnum {
3052
+ class Spendable_ extends UniffiEnum {
1280
3053
  /**
1281
3054
  * @private
1282
3055
  * This field is private and should not be used, use `tag` instead.
1283
3056
  */
1284
- [uniffiTypeNameSymbol] = "LightningSendStatus";
1285
- tag = LightningSendStatus_Tags.Unknown;
3057
+ [uniffiTypeNameSymbol] = "VtxoState";
3058
+ tag = VtxoState_Tags.Spendable;
1286
3059
  constructor() {
1287
- super("LightningSendStatus", "Unknown");
3060
+ super("VtxoState", "Spendable");
1288
3061
  }
1289
3062
  static new() {
1290
- return new Unknown_();
3063
+ return new Spendable_();
1291
3064
  }
1292
3065
  static instanceOf(obj) {
1293
- return obj.tag === LightningSendStatus_Tags.Unknown;
3066
+ return obj.tag === VtxoState_Tags.Spendable;
1294
3067
  }
1295
3068
  }
1296
3069
  /**
1297
- * Send is in flight; HTLC VTXOs are locked.
3070
+ * Locked by an operation. `holder` is `None` only for the narrow
3071
+ * window between creating a fresh locked VTXO and pinning it to a
3072
+ * specific operation, so a locked VTXO can legitimately carry no
3073
+ * lock reason yet.
1298
3074
  */
1299
- class InProgress_ extends UniffiEnum {
3075
+ class Locked_ extends UniffiEnum {
1300
3076
  /**
1301
3077
  * @private
1302
3078
  * This field is private and should not be used, use `tag` instead.
1303
3079
  */
1304
- [uniffiTypeNameSymbol] = "LightningSendStatus";
1305
- tag = LightningSendStatus_Tags.InProgress;
3080
+ [uniffiTypeNameSymbol] = "VtxoState";
3081
+ tag = VtxoState_Tags.Locked;
1306
3082
  constructor(inner) {
1307
- super("LightningSendStatus", "InProgress");
3083
+ super("VtxoState", "Locked");
1308
3084
  this.inner = Object.freeze(inner);
1309
3085
  }
1310
3086
  static new(inner) {
1311
- return new InProgress_(inner);
3087
+ return new Locked_(inner);
1312
3088
  }
1313
3089
  static instanceOf(obj) {
1314
- return obj.tag === LightningSendStatus_Tags.InProgress;
3090
+ return obj.tag === VtxoState_Tags.Locked;
1315
3091
  }
1316
3092
  }
1317
3093
  /**
1318
- * Send has settled; the preimage proves payment.
3094
+ * Consumed.
1319
3095
  */
1320
- class Paid_ extends UniffiEnum {
3096
+ class Spent_ extends UniffiEnum {
1321
3097
  /**
1322
3098
  * @private
1323
3099
  * This field is private and should not be used, use `tag` instead.
1324
3100
  */
1325
- [uniffiTypeNameSymbol] = "LightningSendStatus";
1326
- tag = LightningSendStatus_Tags.Paid;
1327
- constructor(inner) {
1328
- super("LightningSendStatus", "Paid");
1329
- this.inner = Object.freeze(inner);
3101
+ [uniffiTypeNameSymbol] = "VtxoState";
3102
+ tag = VtxoState_Tags.Spent;
3103
+ constructor() {
3104
+ super("VtxoState", "Spent");
1330
3105
  }
1331
- static new(inner) {
1332
- return new Paid_(inner);
3106
+ static new() {
3107
+ return new Spent_();
1333
3108
  }
1334
3109
  static instanceOf(obj) {
1335
- return obj.tag === LightningSendStatus_Tags.Paid;
3110
+ return obj.tag === VtxoState_Tags.Spent;
3111
+ }
3112
+ }
3113
+ /**
3114
+ * In (or completed) a unilateral exit.
3115
+ */
3116
+ class Exited_ extends UniffiEnum {
3117
+ /**
3118
+ * @private
3119
+ * This field is private and should not be used, use `tag` instead.
3120
+ */
3121
+ [uniffiTypeNameSymbol] = "VtxoState";
3122
+ tag = VtxoState_Tags.Exited;
3123
+ constructor() {
3124
+ super("VtxoState", "Exited");
3125
+ }
3126
+ static new() {
3127
+ return new Exited_();
3128
+ }
3129
+ static instanceOf(obj) {
3130
+ return obj.tag === VtxoState_Tags.Exited;
1336
3131
  }
1337
3132
  }
1338
3133
  function instanceOf(obj) {
1339
- return obj[uniffiTypeNameSymbol] === "LightningSendStatus";
3134
+ return obj[uniffiTypeNameSymbol] === "VtxoState";
1340
3135
  }
1341
3136
  return Object.freeze({
1342
3137
  instanceOf,
1343
- Unknown: Unknown_,
1344
- InProgress: InProgress_,
1345
- Paid: Paid_
3138
+ Spendable: Spendable_,
3139
+ Locked: Locked_,
3140
+ Spent: Spent_,
3141
+ Exited: Exited_
1346
3142
  });
1347
3143
  })();
1348
3144
 
1349
3145
  /**
1350
- * Terminal/in-flight state of an outgoing lightning send.
3146
+ * Rich VTXO state, mirroring `bark::vtxo::VtxoState`.
1351
3147
  *
1352
- * Mirrors `bark`'s `LightningSendState`. `pay_lightning_*` and
1353
- * `check_lightning_payment` now return this so callers can drive the
1354
- * crash-safe send flow themselves (initiate with `wait = false`, then poll).
3148
+ * Serde/TS tags match upstream's kebab-case serialization:
3149
+ * `"spendable"` | `"locked"` | `"spent"` | `"exited"`.
1355
3150
  */
1356
3151
 
1357
- // FfiConverter for enum LightningSendStatus
1358
- const FfiConverterTypeLightningSendStatus = (() => {
3152
+ // FfiConverter for enum VtxoState
3153
+ const FfiConverterTypeVtxoState = (() => {
1359
3154
  const ordinalConverter = FfiConverterInt32;
1360
3155
  class FFIConverter extends AbstractFfiConverterByteArray {
1361
3156
  read(from) {
1362
3157
  switch (ordinalConverter.read(from)) {
1363
3158
  case 1:
1364
- return new LightningSendStatus.Unknown();
3159
+ return new VtxoState.Spendable();
1365
3160
  case 2:
1366
- return new LightningSendStatus.InProgress({
1367
- send: FfiConverterTypeLightningSend.read(from)
3161
+ return new VtxoState.Locked({
3162
+ holder: FfiConverterOptionalTypeVtxoLockHolder.read(from)
1368
3163
  });
1369
3164
  case 3:
1370
- return new LightningSendStatus.Paid({
1371
- paymentHash: FfiConverterString.read(from),
1372
- preimage: FfiConverterString.read(from)
1373
- });
3165
+ return new VtxoState.Spent();
3166
+ case 4:
3167
+ return new VtxoState.Exited();
1374
3168
  default:
1375
3169
  throw new UniffiInternalError.UnexpectedEnumCase();
1376
3170
  }
1377
3171
  }
1378
3172
  write(value, into) {
1379
3173
  switch (value.tag) {
1380
- case LightningSendStatus_Tags.Unknown:
3174
+ case VtxoState_Tags.Spendable:
1381
3175
  {
1382
3176
  ordinalConverter.write(1, into);
1383
3177
  return;
1384
3178
  }
1385
- case LightningSendStatus_Tags.InProgress:
3179
+ case VtxoState_Tags.Locked:
1386
3180
  {
1387
3181
  ordinalConverter.write(2, into);
1388
3182
  const inner = value.inner;
1389
- FfiConverterTypeLightningSend.write(inner.send, into);
3183
+ FfiConverterOptionalTypeVtxoLockHolder.write(inner.holder, into);
1390
3184
  return;
1391
3185
  }
1392
- case LightningSendStatus_Tags.Paid:
3186
+ case VtxoState_Tags.Spent:
1393
3187
  {
1394
3188
  ordinalConverter.write(3, into);
1395
- const inner = value.inner;
1396
- FfiConverterString.write(inner.paymentHash, into);
1397
- FfiConverterString.write(inner.preimage, into);
3189
+ return;
3190
+ }
3191
+ case VtxoState_Tags.Exited:
3192
+ {
3193
+ ordinalConverter.write(4, into);
1398
3194
  return;
1399
3195
  }
1400
3196
  default:
1401
- // Throwing from here means that LightningSendStatus_Tags hasn't matched an ordinal.
3197
+ // Throwing from here means that VtxoState_Tags hasn't matched an ordinal.
1402
3198
  throw new UniffiInternalError.UnexpectedEnumCase();
1403
3199
  }
1404
3200
  }
1405
3201
  allocationSize(value) {
1406
3202
  switch (value.tag) {
1407
- case LightningSendStatus_Tags.Unknown:
3203
+ case VtxoState_Tags.Spendable:
1408
3204
  {
1409
3205
  return ordinalConverter.allocationSize(1);
1410
3206
  }
1411
- case LightningSendStatus_Tags.InProgress:
3207
+ case VtxoState_Tags.Locked:
1412
3208
  {
1413
3209
  const inner = value.inner;
1414
3210
  let size = ordinalConverter.allocationSize(2);
1415
- size += FfiConverterTypeLightningSend.allocationSize(inner.send);
3211
+ size += FfiConverterOptionalTypeVtxoLockHolder.allocationSize(inner.holder);
1416
3212
  return size;
1417
3213
  }
1418
- case LightningSendStatus_Tags.Paid:
3214
+ case VtxoState_Tags.Spent:
1419
3215
  {
1420
- const inner = value.inner;
1421
- let size = ordinalConverter.allocationSize(3);
1422
- size += FfiConverterString.allocationSize(inner.paymentHash);
1423
- size += FfiConverterString.allocationSize(inner.preimage);
1424
- return size;
3216
+ return ordinalConverter.allocationSize(3);
3217
+ }
3218
+ case VtxoState_Tags.Exited:
3219
+ {
3220
+ return ordinalConverter.allocationSize(4);
1425
3221
  }
1426
3222
  default:
1427
3223
  throw new UniffiInternalError.UnexpectedEnumCase();
@@ -1431,99 +3227,6 @@ const FfiConverterTypeLightningSendStatus = (() => {
1431
3227
  return new FFIConverter();
1432
3228
  })();
1433
3229
 
1434
- /**
1435
- * Severity of a log record.
1436
- */
1437
- export let LogLevel = /*#__PURE__*/function (LogLevel) {
1438
- LogLevel[LogLevel["Error"] = 0] = "Error";
1439
- LogLevel[LogLevel["Warn"] = 1] = "Warn";
1440
- LogLevel[LogLevel["Info"] = 2] = "Info";
1441
- LogLevel[LogLevel["Debug"] = 3] = "Debug";
1442
- LogLevel[LogLevel["Trace"] = 4] = "Trace";
1443
- return LogLevel;
1444
- }({});
1445
- const FfiConverterTypeLogLevel = (() => {
1446
- const ordinalConverter = FfiConverterInt32;
1447
- class FFIConverter extends AbstractFfiConverterByteArray {
1448
- read(from) {
1449
- switch (ordinalConverter.read(from)) {
1450
- case 1:
1451
- return LogLevel.Error;
1452
- case 2:
1453
- return LogLevel.Warn;
1454
- case 3:
1455
- return LogLevel.Info;
1456
- case 4:
1457
- return LogLevel.Debug;
1458
- case 5:
1459
- return LogLevel.Trace;
1460
- default:
1461
- throw new UniffiInternalError.UnexpectedEnumCase();
1462
- }
1463
- }
1464
- write(value, into) {
1465
- switch (value) {
1466
- case LogLevel.Error:
1467
- return ordinalConverter.write(1, into);
1468
- case LogLevel.Warn:
1469
- return ordinalConverter.write(2, into);
1470
- case LogLevel.Info:
1471
- return ordinalConverter.write(3, into);
1472
- case LogLevel.Debug:
1473
- return ordinalConverter.write(4, into);
1474
- case LogLevel.Trace:
1475
- return ordinalConverter.write(5, into);
1476
- }
1477
- }
1478
- allocationSize(value) {
1479
- return ordinalConverter.allocationSize(0);
1480
- }
1481
- }
1482
- return new FFIConverter();
1483
- })();
1484
- export let Network = /*#__PURE__*/function (Network) {
1485
- Network[Network["Bitcoin"] = 0] = "Bitcoin";
1486
- Network[Network["Testnet"] = 1] = "Testnet";
1487
- Network[Network["Signet"] = 2] = "Signet";
1488
- Network[Network["Regtest"] = 3] = "Regtest";
1489
- return Network;
1490
- }({});
1491
- const FfiConverterTypeNetwork = (() => {
1492
- const ordinalConverter = FfiConverterInt32;
1493
- class FFIConverter extends AbstractFfiConverterByteArray {
1494
- read(from) {
1495
- switch (ordinalConverter.read(from)) {
1496
- case 1:
1497
- return Network.Bitcoin;
1498
- case 2:
1499
- return Network.Testnet;
1500
- case 3:
1501
- return Network.Signet;
1502
- case 4:
1503
- return Network.Regtest;
1504
- default:
1505
- throw new UniffiInternalError.UnexpectedEnumCase();
1506
- }
1507
- }
1508
- write(value, into) {
1509
- switch (value) {
1510
- case Network.Bitcoin:
1511
- return ordinalConverter.write(1, into);
1512
- case Network.Testnet:
1513
- return ordinalConverter.write(2, into);
1514
- case Network.Signet:
1515
- return ordinalConverter.write(3, into);
1516
- case Network.Regtest:
1517
- return ordinalConverter.write(4, into);
1518
- }
1519
- }
1520
- allocationSize(value) {
1521
- return ordinalConverter.allocationSize(0);
1522
- }
1523
- }
1524
- return new FFIConverter();
1525
- })();
1526
-
1527
3230
  // Enum: WalletNotification
1528
3231
  export let WalletNotification_Tags = /*#__PURE__*/function (WalletNotification_Tags) {
1529
3232
  WalletNotification_Tags["MovementCreated"] = "MovementCreated";
@@ -2341,6 +4044,23 @@ export class OnchainWallet extends UniffiAbstractObject {
2341
4044
  throw __error;
2342
4045
  }
2343
4046
  }
4047
+
4048
+ /**
4049
+ * Cached network fee-rate estimates from the wallet's chain source.
4050
+ */
4051
+ async feeRates(asyncOpts_) /*throws*/{
4052
+ const __stack = uniffiIsDebug ? new Error().stack : undefined;
4053
+ try {
4054
+ return await uniffiRustCallAsync(/*rustCaller:*/uniffiCaller, /*rustFutureFunc:*/() => {
4055
+ return nativeModule().ubrn_uniffi_bark_ffi_fn_method_onchainwallet_fee_rates(uniffiTypeOnchainWalletObjectFactory.clonePointer(this));
4056
+ }, /*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:*/FfiConverterTypeFeeRates.lift.bind(FfiConverterTypeFeeRates), /*liftString:*/FfiConverterString.lift, /*asyncOpts:*/asyncOpts_, /*errorHandler:*/FfiConverterTypeError.lift.bind(FfiConverterTypeError));
4057
+ } catch (__error) {
4058
+ if (uniffiIsDebug && __error instanceof Error) {
4059
+ __error.stack = __stack;
4060
+ }
4061
+ throw __error;
4062
+ }
4063
+ }
2344
4064
  async newAddress(asyncOpts_) /*throws*/{
2345
4065
  const __stack = uniffiIsDebug ? new Error().stack : undefined;
2346
4066
  try {
@@ -2381,6 +4101,58 @@ export class OnchainWallet extends UniffiAbstractObject {
2381
4101
  }
2382
4102
  }
2383
4103
 
4104
+ /**
4105
+ * Current chain tip height from the wallet's chain source.
4106
+ */
4107
+ async tipHeight(asyncOpts_) /*throws*/{
4108
+ const __stack = uniffiIsDebug ? new Error().stack : undefined;
4109
+ try {
4110
+ return await uniffiRustCallAsync(/*rustCaller:*/uniffiCaller, /*rustFutureFunc:*/() => {
4111
+ return nativeModule().ubrn_uniffi_bark_ffi_fn_method_onchainwallet_tip_height(uniffiTypeOnchainWalletObjectFactory.clonePointer(this));
4112
+ }, /*pollFunc:*/nativeModule().ubrn_ffi_bark_ffi_rust_future_poll_u32, /*cancelFunc:*/nativeModule().ubrn_ffi_bark_ffi_rust_future_cancel_u32, /*completeFunc:*/nativeModule().ubrn_ffi_bark_ffi_rust_future_complete_u32, /*freeFunc:*/nativeModule().ubrn_ffi_bark_ffi_rust_future_free_u32, /*liftFunc:*/FfiConverterUInt32.lift.bind(FfiConverterUInt32), /*liftString:*/FfiConverterString.lift, /*asyncOpts:*/asyncOpts_, /*errorHandler:*/FfiConverterTypeError.lift.bind(FfiConverterTypeError));
4113
+ } catch (__error) {
4114
+ if (uniffiIsDebug && __error instanceof Error) {
4115
+ __error.stack = __stack;
4116
+ }
4117
+ throw __error;
4118
+ }
4119
+ }
4120
+
4121
+ /**
4122
+ * Every wallet transaction with fee, balance change, confirmation and
4123
+ * CPFP flag. Requires a prior `sync` to be meaningful.
4124
+ */
4125
+ async transactions(asyncOpts_) /*throws*/{
4126
+ const __stack = uniffiIsDebug ? new Error().stack : undefined;
4127
+ try {
4128
+ return await uniffiRustCallAsync(/*rustCaller:*/uniffiCaller, /*rustFutureFunc:*/() => {
4129
+ return nativeModule().ubrn_uniffi_bark_ffi_fn_method_onchainwallet_transactions(uniffiTypeOnchainWalletObjectFactory.clonePointer(this));
4130
+ }, /*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:*/FfiConverterArrayTypeWalletTransaction.lift.bind(FfiConverterArrayTypeWalletTransaction), /*liftString:*/FfiConverterString.lift, /*asyncOpts:*/asyncOpts_, /*errorHandler:*/FfiConverterTypeError.lift.bind(FfiConverterTypeError));
4131
+ } catch (__error) {
4132
+ if (uniffiIsDebug && __error instanceof Error) {
4133
+ __error.stack = __stack;
4134
+ }
4135
+ throw __error;
4136
+ }
4137
+ }
4138
+
4139
+ /**
4140
+ * The wallet's unspent outputs. Requires a prior `sync` to be meaningful.
4141
+ */
4142
+ async utxos(asyncOpts_) /*throws*/{
4143
+ const __stack = uniffiIsDebug ? new Error().stack : undefined;
4144
+ try {
4145
+ return await uniffiRustCallAsync(/*rustCaller:*/uniffiCaller, /*rustFutureFunc:*/() => {
4146
+ return nativeModule().ubrn_uniffi_bark_ffi_fn_method_onchainwallet_utxos(uniffiTypeOnchainWalletObjectFactory.clonePointer(this));
4147
+ }, /*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:*/FfiConverterArrayTypeOnchainUtxo.lift.bind(FfiConverterArrayTypeOnchainUtxo), /*liftString:*/FfiConverterString.lift, /*asyncOpts:*/asyncOpts_, /*errorHandler:*/FfiConverterTypeError.lift.bind(FfiConverterTypeError));
4148
+ } catch (__error) {
4149
+ if (uniffiIsDebug && __error instanceof Error) {
4150
+ __error.stack = __stack;
4151
+ }
4152
+ throw __error;
4153
+ }
4154
+ }
4155
+
2384
4156
  /**
2385
4157
  * {@inheritDoc uniffi-bindgen-react-native#UniffiAbstractObject.uniffiDestroy}
2386
4158
  */
@@ -3193,7 +4965,7 @@ export class Wallet extends UniffiAbstractObject {
3193
4965
  }
3194
4966
 
3195
4967
  /**
3196
- * Pay to a Lightning Address (LNURL). UniFFI-only — lnurl-rs is not wasm-compatible.
4968
+ * Pay to a Lightning Address (`user@domain`), resolved via LNURL-pay.
3197
4969
  */
3198
4970
  async payLightningAddress(lightningAddress, amountSats, comment, wait = false, asyncOpts_) /*throws*/{
3199
4971
  const __stack = uniffiIsDebug ? new Error().stack : undefined;
@@ -3236,7 +5008,7 @@ export class Wallet extends UniffiAbstractObject {
3236
5008
  }
3237
5009
 
3238
5010
  /**
3239
- * Pay a raw LNURL-pay link (`lnurl1…`). UniFFI-only — lnurl-rs is not wasm-compatible.
5011
+ * Pay a raw LNURL-pay link (`lnurl1…`).
3240
5012
  *
3241
5013
  * Resolves the LNURL-pay endpoint to a BOLT11 invoice and pays it. Errors
3242
5014
  * if the link decodes to a non-pay LNURL (auth, withdraw, channel).
@@ -3820,6 +5592,9 @@ const FfiConverterOptionalInt64 = new FfiConverterOptional(FfiConverterInt64);
3820
5592
  // FfiConverter for ArkInfo | undefined
3821
5593
  const FfiConverterOptionalTypeArkInfo = new FfiConverterOptional(FfiConverterTypeArkInfo);
3822
5594
 
5595
+ // FfiConverter for BlockRef | undefined
5596
+ const FfiConverterOptionalTypeBlockRef = new FfiConverterOptional(FfiConverterTypeBlockRef);
5597
+
3823
5598
  // FfiConverter for ExitTransactionStatus | undefined
3824
5599
  const FfiConverterOptionalTypeExitTransactionStatus = new FfiConverterOptional(FfiConverterTypeExitTransactionStatus);
3825
5600
 
@@ -3850,6 +5625,9 @@ const FfiConverterArrayTypeDestination = new FfiConverterArray(FfiConverterTypeD
3850
5625
  // FfiConverter for Array<ExitProgressStatus>
3851
5626
  const FfiConverterArrayTypeExitProgressStatus = new FfiConverterArray(FfiConverterTypeExitProgressStatus);
3852
5627
 
5628
+ // FfiConverter for Array<ExitTx>
5629
+ const FfiConverterArrayTypeExitTx = new FfiConverterArray(FfiConverterTypeExitTx);
5630
+
3853
5631
  // FfiConverter for Array<ExitVtxo>
3854
5632
  const FfiConverterArrayTypeExitVtxo = new FfiConverterArray(FfiConverterTypeExitVtxo);
3855
5633
 
@@ -3865,23 +5643,38 @@ const FfiConverterArrayTypeMovement = new FfiConverterArray(FfiConverterTypeMove
3865
5643
  // FfiConverter for Array<PendingBoard>
3866
5644
  const FfiConverterArrayTypePendingBoard = new FfiConverterArray(FfiConverterTypePendingBoard);
3867
5645
 
5646
+ // FfiConverter for Array<PpmExpiryFeeEntry>
5647
+ const FfiConverterArrayTypePpmExpiryFeeEntry = new FfiConverterArray(FfiConverterTypePpmExpiryFeeEntry);
5648
+
3868
5649
  // FfiConverter for Array<RoundState>
3869
5650
  const FfiConverterArrayTypeRoundState = new FfiConverterArray(FfiConverterTypeRoundState);
3870
5651
 
3871
5652
  // FfiConverter for Array<Vtxo>
3872
5653
  const FfiConverterArrayTypeVtxo = new FfiConverterArray(FfiConverterTypeVtxo);
3873
5654
 
5655
+ // FfiConverter for Array<WalletTransaction>
5656
+ const FfiConverterArrayTypeWalletTransaction = new FfiConverterArray(FfiConverterTypeWalletTransaction);
5657
+
3874
5658
  // FfiConverter for Array<string>
3875
5659
  const FfiConverterArrayString = new FfiConverterArray(FfiConverterString);
3876
5660
 
5661
+ // FfiConverter for VtxoLockHolder | undefined
5662
+ const FfiConverterOptionalTypeVtxoLockHolder = new FfiConverterOptional(FfiConverterTypeVtxoLockHolder);
5663
+
3877
5664
  // FfiConverter for WalletNotification | undefined
3878
5665
  const FfiConverterOptionalTypeWalletNotification = new FfiConverterOptional(FfiConverterTypeWalletNotification);
3879
5666
 
3880
5667
  // FfiConverter for OnchainWalletLike | undefined
3881
5668
  const FfiConverterOptionalTypeOnchainWallet = new FfiConverterOptional(FfiConverterTypeOnchainWallet);
3882
5669
 
3883
- // FfiConverter for Array<string> | undefined
3884
- const FfiConverterOptionalArrayString = new FfiConverterOptional(FfiConverterArrayString);
5670
+ // FfiConverter for Array<ExitState>
5671
+ const FfiConverterArrayTypeExitState = new FfiConverterArray(FfiConverterTypeExitState);
5672
+
5673
+ // FfiConverter for Array<OnchainUtxo>
5674
+ const FfiConverterArrayTypeOnchainUtxo = new FfiConverterArray(FfiConverterTypeOnchainUtxo);
5675
+
5676
+ // FfiConverter for Array<ExitState> | undefined
5677
+ const FfiConverterOptionalArrayTypeExitState = new FfiConverterOptional(FfiConverterArrayTypeExitState);
3885
5678
 
3886
5679
  /**
3887
5680
  * This should be called before anything else.
@@ -3958,6 +5751,9 @@ function uniffiEnsureInitialized() {
3958
5751
  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_onchainwallet_balance() !== 39213) {
3959
5752
  throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_onchainwallet_balance");
3960
5753
  }
5754
+ if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_onchainwallet_fee_rates() !== 30741) {
5755
+ throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_onchainwallet_fee_rates");
5756
+ }
3961
5757
  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_onchainwallet_new_address() !== 7405) {
3962
5758
  throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_onchainwallet_new_address");
3963
5759
  }
@@ -3967,6 +5763,15 @@ function uniffiEnsureInitialized() {
3967
5763
  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_onchainwallet_sync() !== 4373) {
3968
5764
  throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_onchainwallet_sync");
3969
5765
  }
5766
+ if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_onchainwallet_tip_height() !== 12254) {
5767
+ throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_onchainwallet_tip_height");
5768
+ }
5769
+ if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_onchainwallet_transactions() !== 566) {
5770
+ throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_onchainwallet_transactions");
5771
+ }
5772
+ if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_onchainwallet_utxos() !== 44926) {
5773
+ throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_onchainwallet_utxos");
5774
+ }
3970
5775
  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_all_exits_claimable_at_height() !== 59034) {
3971
5776
  throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_all_exits_claimable_at_height");
3972
5777
  }
@@ -4129,7 +5934,7 @@ function uniffiEnsureInitialized() {
4129
5934
  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_offboard_vtxos() !== 26775) {
4130
5935
  throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_offboard_vtxos");
4131
5936
  }
4132
- if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_pay_lightning_address() !== 19392) {
5937
+ if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_pay_lightning_address() !== 43061) {
4133
5938
  throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_pay_lightning_address");
4134
5939
  }
4135
5940
  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_pay_lightning_invoice() !== 26921) {
@@ -4138,7 +5943,7 @@ function uniffiEnsureInitialized() {
4138
5943
  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_pay_lightning_offer() !== 25462) {
4139
5944
  throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_pay_lightning_offer");
4140
5945
  }
4141
- if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_pay_lnurl() !== 25859) {
5946
+ if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_pay_lnurl() !== 1459) {
4142
5947
  throw new UniffiInternalError.ApiChecksumMismatch("uniffi_bark_ffi_checksum_method_wallet_pay_lnurl");
4143
5948
  }
4144
5949
  if (nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_peek_address() !== 31847) {
@@ -4269,6 +6074,7 @@ export default Object.freeze({
4269
6074
  FfiConverterTypeBalance,
4270
6075
  FfiConverterTypeBarkLogger,
4271
6076
  FfiConverterTypeBlockRef,
6077
+ FfiConverterTypeBoardFees,
4272
6078
  FfiConverterTypeConfig,
4273
6079
  FfiConverterTypeCpfpParams,
4274
6080
  FfiConverterTypeCustomOnchainWalletCallbacks,
@@ -4276,30 +6082,45 @@ export default Object.freeze({
4276
6082
  FfiConverterTypeError,
4277
6083
  FfiConverterTypeExitClaimTransaction,
4278
6084
  FfiConverterTypeExitProgressStatus,
6085
+ FfiConverterTypeExitState,
4279
6086
  FfiConverterTypeExitTransactionStatus,
6087
+ FfiConverterTypeExitTx,
6088
+ FfiConverterTypeExitTxOrigin,
6089
+ FfiConverterTypeExitTxStatus,
4280
6090
  FfiConverterTypeExitVtxo,
4281
6091
  FfiConverterTypeFeeEstimate,
6092
+ FfiConverterTypeFeeRates,
6093
+ FfiConverterTypeFeeSchedule,
4282
6094
  FfiConverterTypeLightningInvoice,
4283
6095
  FfiConverterTypeLightningReceive,
6096
+ FfiConverterTypeLightningReceiveFees,
4284
6097
  FfiConverterTypeLightningSend,
6098
+ FfiConverterTypeLightningSendFees,
4285
6099
  FfiConverterTypeLightningSendStatus,
4286
6100
  FfiConverterTypeLogLevel,
4287
6101
  FfiConverterTypeMovement,
4288
6102
  FfiConverterTypeNetwork,
4289
6103
  FfiConverterTypeNotificationHolder,
6104
+ FfiConverterTypeOffboardFees,
4290
6105
  FfiConverterTypeOffboardResult,
4291
6106
  FfiConverterTypeOnchainBalance,
6107
+ FfiConverterTypeOnchainUtxo,
4292
6108
  FfiConverterTypeOnchainWallet,
4293
6109
  FfiConverterTypeOutPoint,
4294
6110
  FfiConverterTypePendingBoard,
6111
+ FfiConverterTypePpmExpiryFeeEntry,
4295
6112
  FfiConverterTypeRecoveryBucket,
4296
6113
  FfiConverterTypeRecoveryReport,
6114
+ FfiConverterTypeRefreshFees,
4297
6115
  FfiConverterTypeRoundState,
4298
6116
  FfiConverterTypeVtxo,
6117
+ FfiConverterTypeVtxoLockHolder,
6118
+ FfiConverterTypeVtxoState,
4299
6119
  FfiConverterTypeWallet,
4300
6120
  FfiConverterTypeWalletNotification,
4301
6121
  FfiConverterTypeWalletOpenArgs,
4302
- FfiConverterTypeWalletProperties
6122
+ FfiConverterTypeWalletProperties,
6123
+ FfiConverterTypeWalletTransaction
4303
6124
  }
4304
6125
  });
4305
6126
  //# sourceMappingURL=bark.js.map