@secondts/bark-react-native 0.15.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.
- package/README.md +1 -1
- package/cpp/generated/bark.cpp +140 -0
- package/cpp/generated/bark.hpp +8 -0
- package/lib/commonjs/generated/bark-ffi.js.map +1 -1
- package/lib/commonjs/generated/bark.js +2023 -202
- package/lib/commonjs/generated/bark.js.map +1 -1
- package/lib/module/generated/bark-ffi.js.map +1 -1
- package/lib/module/generated/bark.js +2022 -201
- package/lib/module/generated/bark.js.map +1 -1
- package/lib/typescript/commonjs/src/generated/bark-ffi.d.ts +8 -0
- package/lib/typescript/commonjs/src/generated/bark-ffi.d.ts.map +1 -1
- package/lib/typescript/commonjs/src/generated/bark.d.ts +1561 -127
- package/lib/typescript/commonjs/src/generated/bark.d.ts.map +1 -1
- package/lib/typescript/module/src/generated/bark-ffi.d.ts +8 -0
- package/lib/typescript/module/src/generated/bark-ffi.d.ts.map +1 -1
- package/lib/typescript/module/src/generated/bark.d.ts +1561 -127
- package/lib/typescript/module/src/generated/bark.d.ts.map +1 -1
- package/package.json +4 -4
- package/src/generated/bark-ffi.ts +10 -0
- package/src/generated/bark.ts +2678 -212
|
@@ -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
|
-
|
|
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
|
-
|
|
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) +
|
|
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:
|
|
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
|
-
|
|
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) +
|
|
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:
|
|
507
|
-
history:
|
|
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
|
-
|
|
514
|
-
|
|
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) +
|
|
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:
|
|
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
|
-
|
|
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) +
|
|
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
|
-
*
|
|
1327
|
+
* Fees for refreshing VTXOs in a round.
|
|
1011
1328
|
*/
|
|
1012
1329
|
|
|
1013
1330
|
/**
|
|
1014
|
-
* Generated factory for {@link
|
|
1331
|
+
* Generated factory for {@link RefreshFees} record objects.
|
|
1015
1332
|
*/
|
|
1016
|
-
export const
|
|
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
|
|
1344
|
+
const FfiConverterTypeRefreshFees = (() => {
|
|
1028
1345
|
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
1029
1346
|
read(from) {
|
|
1030
1347
|
return {
|
|
1031
|
-
|
|
1032
|
-
|
|
1348
|
+
baseFeeSats: FfiConverterUInt64.read(from),
|
|
1349
|
+
ppmExpiryTable: FfiConverterArrayTypePpmExpiryFeeEntry.read(from)
|
|
1033
1350
|
};
|
|
1034
1351
|
}
|
|
1035
1352
|
write(value, into) {
|
|
1036
|
-
|
|
1037
|
-
|
|
1353
|
+
FfiConverterUInt64.write(value.baseFeeSats, into);
|
|
1354
|
+
FfiConverterArrayTypePpmExpiryFeeEntry.write(value.ppmExpiryTable, into);
|
|
1038
1355
|
}
|
|
1039
1356
|
allocationSize(value) {
|
|
1040
|
-
return
|
|
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
|
-
*
|
|
1364
|
+
* A pending round state
|
|
1047
1365
|
*/
|
|
1048
|
-
|
|
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
|
|
1381
|
+
const FfiConverterTypeRoundState = (() => {
|
|
1060
1382
|
class FFIConverter extends AbstractFfiConverterByteArray {
|
|
1061
1383
|
read(from) {
|
|
1062
1384
|
return {
|
|
1063
|
-
id:
|
|
1064
|
-
|
|
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:
|
|
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
|
-
|
|
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) +
|
|
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:
|
|
1262
|
-
export let
|
|
1263
|
-
|
|
1264
|
-
|
|
1265
|
-
|
|
1266
|
-
|
|
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
|
-
*
|
|
3043
|
+
* Rich VTXO state, mirroring `bark::vtxo::VtxoState`.
|
|
1270
3044
|
*
|
|
1271
|
-
*
|
|
1272
|
-
* `
|
|
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
|
|
3048
|
+
export const VtxoState = (() => {
|
|
1276
3049
|
/**
|
|
1277
|
-
*
|
|
3050
|
+
* Available; can be spent in a future round.
|
|
1278
3051
|
*/
|
|
1279
|
-
class
|
|
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] = "
|
|
1285
|
-
tag =
|
|
3057
|
+
[uniffiTypeNameSymbol] = "VtxoState";
|
|
3058
|
+
tag = VtxoState_Tags.Spendable;
|
|
1286
3059
|
constructor() {
|
|
1287
|
-
super("
|
|
3060
|
+
super("VtxoState", "Spendable");
|
|
1288
3061
|
}
|
|
1289
3062
|
static new() {
|
|
1290
|
-
return new
|
|
3063
|
+
return new Spendable_();
|
|
1291
3064
|
}
|
|
1292
3065
|
static instanceOf(obj) {
|
|
1293
|
-
return obj.tag ===
|
|
3066
|
+
return obj.tag === VtxoState_Tags.Spendable;
|
|
1294
3067
|
}
|
|
1295
3068
|
}
|
|
1296
3069
|
/**
|
|
1297
|
-
*
|
|
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
|
|
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] = "
|
|
1305
|
-
tag =
|
|
3080
|
+
[uniffiTypeNameSymbol] = "VtxoState";
|
|
3081
|
+
tag = VtxoState_Tags.Locked;
|
|
1306
3082
|
constructor(inner) {
|
|
1307
|
-
super("
|
|
3083
|
+
super("VtxoState", "Locked");
|
|
1308
3084
|
this.inner = Object.freeze(inner);
|
|
1309
3085
|
}
|
|
1310
3086
|
static new(inner) {
|
|
1311
|
-
return new
|
|
3087
|
+
return new Locked_(inner);
|
|
1312
3088
|
}
|
|
1313
3089
|
static instanceOf(obj) {
|
|
1314
|
-
return obj.tag ===
|
|
3090
|
+
return obj.tag === VtxoState_Tags.Locked;
|
|
1315
3091
|
}
|
|
1316
3092
|
}
|
|
1317
3093
|
/**
|
|
1318
|
-
*
|
|
3094
|
+
* Consumed.
|
|
1319
3095
|
*/
|
|
1320
|
-
class
|
|
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] = "
|
|
1326
|
-
tag =
|
|
1327
|
-
constructor(
|
|
1328
|
-
super("
|
|
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(
|
|
1332
|
-
return new
|
|
3106
|
+
static new() {
|
|
3107
|
+
return new Spent_();
|
|
1333
3108
|
}
|
|
1334
3109
|
static instanceOf(obj) {
|
|
1335
|
-
return obj.tag ===
|
|
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] === "
|
|
3134
|
+
return obj[uniffiTypeNameSymbol] === "VtxoState";
|
|
1340
3135
|
}
|
|
1341
3136
|
return Object.freeze({
|
|
1342
3137
|
instanceOf,
|
|
1343
|
-
|
|
1344
|
-
|
|
1345
|
-
|
|
3138
|
+
Spendable: Spendable_,
|
|
3139
|
+
Locked: Locked_,
|
|
3140
|
+
Spent: Spent_,
|
|
3141
|
+
Exited: Exited_
|
|
1346
3142
|
});
|
|
1347
3143
|
})();
|
|
1348
3144
|
|
|
1349
3145
|
/**
|
|
1350
|
-
*
|
|
3146
|
+
* Rich VTXO state, mirroring `bark::vtxo::VtxoState`.
|
|
1351
3147
|
*
|
|
1352
|
-
*
|
|
1353
|
-
* `
|
|
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
|
|
1358
|
-
const
|
|
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
|
|
3159
|
+
return new VtxoState.Spendable();
|
|
1365
3160
|
case 2:
|
|
1366
|
-
return new
|
|
1367
|
-
|
|
3161
|
+
return new VtxoState.Locked({
|
|
3162
|
+
holder: FfiConverterOptionalTypeVtxoLockHolder.read(from)
|
|
1368
3163
|
});
|
|
1369
3164
|
case 3:
|
|
1370
|
-
return new
|
|
1371
|
-
|
|
1372
|
-
|
|
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
|
|
3174
|
+
case VtxoState_Tags.Spendable:
|
|
1381
3175
|
{
|
|
1382
3176
|
ordinalConverter.write(1, into);
|
|
1383
3177
|
return;
|
|
1384
3178
|
}
|
|
1385
|
-
case
|
|
3179
|
+
case VtxoState_Tags.Locked:
|
|
1386
3180
|
{
|
|
1387
3181
|
ordinalConverter.write(2, into);
|
|
1388
3182
|
const inner = value.inner;
|
|
1389
|
-
|
|
3183
|
+
FfiConverterOptionalTypeVtxoLockHolder.write(inner.holder, into);
|
|
1390
3184
|
return;
|
|
1391
3185
|
}
|
|
1392
|
-
case
|
|
3186
|
+
case VtxoState_Tags.Spent:
|
|
1393
3187
|
{
|
|
1394
3188
|
ordinalConverter.write(3, into);
|
|
1395
|
-
|
|
1396
|
-
|
|
1397
|
-
|
|
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
|
|
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
|
|
3203
|
+
case VtxoState_Tags.Spendable:
|
|
1408
3204
|
{
|
|
1409
3205
|
return ordinalConverter.allocationSize(1);
|
|
1410
3206
|
}
|
|
1411
|
-
case
|
|
3207
|
+
case VtxoState_Tags.Locked:
|
|
1412
3208
|
{
|
|
1413
3209
|
const inner = value.inner;
|
|
1414
3210
|
let size = ordinalConverter.allocationSize(2);
|
|
1415
|
-
size +=
|
|
3211
|
+
size += FfiConverterOptionalTypeVtxoLockHolder.allocationSize(inner.holder);
|
|
1416
3212
|
return size;
|
|
1417
3213
|
}
|
|
1418
|
-
case
|
|
3214
|
+
case VtxoState_Tags.Spent:
|
|
1419
3215
|
{
|
|
1420
|
-
|
|
1421
|
-
|
|
1422
|
-
|
|
1423
|
-
|
|
1424
|
-
return
|
|
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 (
|
|
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…`).
|
|
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<
|
|
3884
|
-
const
|
|
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() !==
|
|
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() !==
|
|
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
|