@secondts/bark-react-native 0.16.1 → 0.18.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 +146 -0
- package/cpp/generated/bark.hpp +8 -0
- package/lib/commonjs/generated/bark-ffi.js.map +1 -1
- package/lib/commonjs/generated/bark.js +362 -6
- 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 +361 -5
- 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 +217 -3
- 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 +217 -3
- package/lib/typescript/module/src/generated/bark.d.ts.map +1 -1
- package/package.json +4 -4
- package/src/generated/bark-ffi.ts +22 -0
- package/src/generated/bark.ts +536 -8
package/src/generated/bark.ts
CHANGED
|
@@ -760,6 +760,61 @@ const FfiConverterTypeDestination = (() => {
|
|
|
760
760
|
return new FFIConverter();
|
|
761
761
|
})();
|
|
762
762
|
|
|
763
|
+
/**
|
|
764
|
+
* Outcome of a cancellation request.
|
|
765
|
+
*
|
|
766
|
+
* `canceled` is `true` when the exit is now canceled — including when it was
|
|
767
|
+
* already canceled by an earlier call, since cancellation is idempotent.
|
|
768
|
+
* When `false`, `reason` says why.
|
|
769
|
+
*/
|
|
770
|
+
export type ExitCancelResult = {
|
|
771
|
+
canceled: boolean;
|
|
772
|
+
/**
|
|
773
|
+
* Present exactly when `canceled` is `false`.
|
|
774
|
+
*/
|
|
775
|
+
reason?: ExitCancelFailure;
|
|
776
|
+
};
|
|
777
|
+
|
|
778
|
+
/**
|
|
779
|
+
* Generated factory for {@link ExitCancelResult} record objects.
|
|
780
|
+
*/
|
|
781
|
+
export const ExitCancelResult = (() => {
|
|
782
|
+
const defaults = () => ({});
|
|
783
|
+
const create = (() => {
|
|
784
|
+
return uniffiCreateRecord<ExitCancelResult, ReturnType<typeof defaults>>(
|
|
785
|
+
defaults
|
|
786
|
+
);
|
|
787
|
+
})();
|
|
788
|
+
return Object.freeze({
|
|
789
|
+
create,
|
|
790
|
+
new: create,
|
|
791
|
+
defaults: () => Object.freeze(defaults()) as Partial<ExitCancelResult>,
|
|
792
|
+
});
|
|
793
|
+
})();
|
|
794
|
+
|
|
795
|
+
const FfiConverterTypeExitCancelResult = (() => {
|
|
796
|
+
type TypeName = ExitCancelResult;
|
|
797
|
+
class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
|
|
798
|
+
read(from: RustBuffer): TypeName {
|
|
799
|
+
return {
|
|
800
|
+
canceled: FfiConverterBool.read(from),
|
|
801
|
+
reason: FfiConverterOptionalTypeExitCancelFailure.read(from),
|
|
802
|
+
};
|
|
803
|
+
}
|
|
804
|
+
write(value: TypeName, into: RustBuffer): void {
|
|
805
|
+
FfiConverterBool.write(value.canceled, into);
|
|
806
|
+
FfiConverterOptionalTypeExitCancelFailure.write(value.reason, into);
|
|
807
|
+
}
|
|
808
|
+
allocationSize(value: TypeName): number {
|
|
809
|
+
return (
|
|
810
|
+
FfiConverterBool.allocationSize(value.canceled) +
|
|
811
|
+
FfiConverterOptionalTypeExitCancelFailure.allocationSize(value.reason)
|
|
812
|
+
);
|
|
813
|
+
}
|
|
814
|
+
}
|
|
815
|
+
return new FFIConverter();
|
|
816
|
+
})();
|
|
817
|
+
|
|
763
818
|
/**
|
|
764
819
|
* Claim transaction for exited funds
|
|
765
820
|
*/
|
|
@@ -1661,7 +1716,7 @@ const FfiConverterTypeOffboardFees = (() => {
|
|
|
1661
1716
|
})();
|
|
1662
1717
|
|
|
1663
1718
|
export type OffboardResult = {
|
|
1664
|
-
|
|
1719
|
+
txid: string;
|
|
1665
1720
|
};
|
|
1666
1721
|
|
|
1667
1722
|
/**
|
|
@@ -1686,14 +1741,14 @@ const FfiConverterTypeOffboardResult = (() => {
|
|
|
1686
1741
|
class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
|
|
1687
1742
|
read(from: RustBuffer): TypeName {
|
|
1688
1743
|
return {
|
|
1689
|
-
|
|
1744
|
+
txid: FfiConverterString.read(from),
|
|
1690
1745
|
};
|
|
1691
1746
|
}
|
|
1692
1747
|
write(value: TypeName, into: RustBuffer): void {
|
|
1693
|
-
FfiConverterString.write(value.
|
|
1748
|
+
FfiConverterString.write(value.txid, into);
|
|
1694
1749
|
}
|
|
1695
1750
|
allocationSize(value: TypeName): number {
|
|
1696
|
-
return FfiConverterString.allocationSize(value.
|
|
1751
|
+
return FfiConverterString.allocationSize(value.txid);
|
|
1697
1752
|
}
|
|
1698
1753
|
}
|
|
1699
1754
|
return new FFIConverter();
|
|
@@ -2575,6 +2630,207 @@ const FfiConverterTypeError = (() => {
|
|
|
2575
2630
|
return new FfiConverter();
|
|
2576
2631
|
})();
|
|
2577
2632
|
|
|
2633
|
+
// Enum: ExitCancelFailure
|
|
2634
|
+
export enum ExitCancelFailure_Tags {
|
|
2635
|
+
NotExiting = "NotExiting",
|
|
2636
|
+
TooLate = "TooLate",
|
|
2637
|
+
AlreadyBroadcast = "AlreadyBroadcast",
|
|
2638
|
+
}
|
|
2639
|
+
/**
|
|
2640
|
+
* Why a [`Wallet::cancel_exit`](crate::core::Wallet::cancel_exit) did not
|
|
2641
|
+
* cancel the exit.
|
|
2642
|
+
*
|
|
2643
|
+
* These are the *expected* negative outcomes of asking to cancel, not faults:
|
|
2644
|
+
* each is a normal state the exit can legitimately be in. Genuine failures
|
|
2645
|
+
* (database, chain source unreachable) still surface as `Err`.
|
|
2646
|
+
*/
|
|
2647
|
+
export const ExitCancelFailure = (() => {
|
|
2648
|
+
type NotExiting__interface = {
|
|
2649
|
+
tag: ExitCancelFailure_Tags.NotExiting;
|
|
2650
|
+
};
|
|
2651
|
+
|
|
2652
|
+
/**
|
|
2653
|
+
* No exit was ever started for this VTXO.
|
|
2654
|
+
*/
|
|
2655
|
+
class NotExiting_ extends UniffiEnum implements NotExiting__interface {
|
|
2656
|
+
/**
|
|
2657
|
+
* @private
|
|
2658
|
+
* This field is private and should not be used, use `tag` instead.
|
|
2659
|
+
*/
|
|
2660
|
+
readonly [uniffiTypeNameSymbol] = "ExitCancelFailure";
|
|
2661
|
+
readonly tag = ExitCancelFailure_Tags.NotExiting;
|
|
2662
|
+
constructor() {
|
|
2663
|
+
super("ExitCancelFailure", "NotExiting");
|
|
2664
|
+
}
|
|
2665
|
+
|
|
2666
|
+
static new(): NotExiting_ {
|
|
2667
|
+
return new NotExiting_();
|
|
2668
|
+
}
|
|
2669
|
+
|
|
2670
|
+
static instanceOf(obj: any): obj is NotExiting_ {
|
|
2671
|
+
return obj.tag === ExitCancelFailure_Tags.NotExiting;
|
|
2672
|
+
}
|
|
2673
|
+
}
|
|
2674
|
+
|
|
2675
|
+
type TooLate__interface = {
|
|
2676
|
+
tag: ExitCancelFailure_Tags.TooLate;
|
|
2677
|
+
inner: Readonly<{ state: ExitStateKind }>;
|
|
2678
|
+
};
|
|
2679
|
+
|
|
2680
|
+
/**
|
|
2681
|
+
* The exit has progressed past its abortable window. `state` is the
|
|
2682
|
+
* state that blocked the cancellation.
|
|
2683
|
+
*/
|
|
2684
|
+
class TooLate_ extends UniffiEnum implements TooLate__interface {
|
|
2685
|
+
/**
|
|
2686
|
+
* @private
|
|
2687
|
+
* This field is private and should not be used, use `tag` instead.
|
|
2688
|
+
*/
|
|
2689
|
+
readonly [uniffiTypeNameSymbol] = "ExitCancelFailure";
|
|
2690
|
+
readonly tag = ExitCancelFailure_Tags.TooLate;
|
|
2691
|
+
readonly inner: Readonly<{ state: ExitStateKind }>;
|
|
2692
|
+
constructor(inner: { state: ExitStateKind }) {
|
|
2693
|
+
super("ExitCancelFailure", "TooLate");
|
|
2694
|
+
this.inner = Object.freeze(inner);
|
|
2695
|
+
}
|
|
2696
|
+
|
|
2697
|
+
static new(inner: { state: ExitStateKind }): TooLate_ {
|
|
2698
|
+
return new TooLate_(inner);
|
|
2699
|
+
}
|
|
2700
|
+
|
|
2701
|
+
static instanceOf(obj: any): obj is TooLate_ {
|
|
2702
|
+
return obj.tag === ExitCancelFailure_Tags.TooLate;
|
|
2703
|
+
}
|
|
2704
|
+
}
|
|
2705
|
+
|
|
2706
|
+
type AlreadyBroadcast__interface = {
|
|
2707
|
+
tag: ExitCancelFailure_Tags.AlreadyBroadcast;
|
|
2708
|
+
inner: Readonly<{ txid: string }>;
|
|
2709
|
+
};
|
|
2710
|
+
|
|
2711
|
+
/**
|
|
2712
|
+
* The final exit transaction is already in the mempool or a block, so
|
|
2713
|
+
* the exit can no longer be called off.
|
|
2714
|
+
*/
|
|
2715
|
+
class AlreadyBroadcast_
|
|
2716
|
+
extends UniffiEnum
|
|
2717
|
+
implements AlreadyBroadcast__interface
|
|
2718
|
+
{
|
|
2719
|
+
/**
|
|
2720
|
+
* @private
|
|
2721
|
+
* This field is private and should not be used, use `tag` instead.
|
|
2722
|
+
*/
|
|
2723
|
+
readonly [uniffiTypeNameSymbol] = "ExitCancelFailure";
|
|
2724
|
+
readonly tag = ExitCancelFailure_Tags.AlreadyBroadcast;
|
|
2725
|
+
readonly inner: Readonly<{ txid: string }>;
|
|
2726
|
+
constructor(inner: { txid: string }) {
|
|
2727
|
+
super("ExitCancelFailure", "AlreadyBroadcast");
|
|
2728
|
+
this.inner = Object.freeze(inner);
|
|
2729
|
+
}
|
|
2730
|
+
|
|
2731
|
+
static new(inner: { txid: string }): AlreadyBroadcast_ {
|
|
2732
|
+
return new AlreadyBroadcast_(inner);
|
|
2733
|
+
}
|
|
2734
|
+
|
|
2735
|
+
static instanceOf(obj: any): obj is AlreadyBroadcast_ {
|
|
2736
|
+
return obj.tag === ExitCancelFailure_Tags.AlreadyBroadcast;
|
|
2737
|
+
}
|
|
2738
|
+
}
|
|
2739
|
+
|
|
2740
|
+
function instanceOf(obj: any): obj is ExitCancelFailure {
|
|
2741
|
+
return obj[uniffiTypeNameSymbol] === "ExitCancelFailure";
|
|
2742
|
+
}
|
|
2743
|
+
|
|
2744
|
+
return Object.freeze({
|
|
2745
|
+
instanceOf,
|
|
2746
|
+
NotExiting: NotExiting_,
|
|
2747
|
+
TooLate: TooLate_,
|
|
2748
|
+
AlreadyBroadcast: AlreadyBroadcast_,
|
|
2749
|
+
});
|
|
2750
|
+
})();
|
|
2751
|
+
|
|
2752
|
+
/**
|
|
2753
|
+
* Why a [`Wallet::cancel_exit`](crate::core::Wallet::cancel_exit) did not
|
|
2754
|
+
* cancel the exit.
|
|
2755
|
+
*
|
|
2756
|
+
* These are the *expected* negative outcomes of asking to cancel, not faults:
|
|
2757
|
+
* each is a normal state the exit can legitimately be in. Genuine failures
|
|
2758
|
+
* (database, chain source unreachable) still surface as `Err`.
|
|
2759
|
+
*/
|
|
2760
|
+
|
|
2761
|
+
export type ExitCancelFailure = InstanceType<
|
|
2762
|
+
(typeof ExitCancelFailure)[keyof Omit<typeof ExitCancelFailure, "instanceOf">]
|
|
2763
|
+
>;
|
|
2764
|
+
|
|
2765
|
+
// FfiConverter for enum ExitCancelFailure
|
|
2766
|
+
const FfiConverterTypeExitCancelFailure = (() => {
|
|
2767
|
+
const ordinalConverter = FfiConverterInt32;
|
|
2768
|
+
type TypeName = ExitCancelFailure;
|
|
2769
|
+
class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
|
|
2770
|
+
read(from: RustBuffer): TypeName {
|
|
2771
|
+
switch (ordinalConverter.read(from)) {
|
|
2772
|
+
case 1:
|
|
2773
|
+
return new ExitCancelFailure.NotExiting();
|
|
2774
|
+
case 2:
|
|
2775
|
+
return new ExitCancelFailure.TooLate({
|
|
2776
|
+
state: FfiConverterTypeExitStateKind.read(from),
|
|
2777
|
+
});
|
|
2778
|
+
case 3:
|
|
2779
|
+
return new ExitCancelFailure.AlreadyBroadcast({
|
|
2780
|
+
txid: FfiConverterString.read(from),
|
|
2781
|
+
});
|
|
2782
|
+
default:
|
|
2783
|
+
throw new UniffiInternalError.UnexpectedEnumCase();
|
|
2784
|
+
}
|
|
2785
|
+
}
|
|
2786
|
+
write(value: TypeName, into: RustBuffer): void {
|
|
2787
|
+
switch (value.tag) {
|
|
2788
|
+
case ExitCancelFailure_Tags.NotExiting: {
|
|
2789
|
+
ordinalConverter.write(1, into);
|
|
2790
|
+
return;
|
|
2791
|
+
}
|
|
2792
|
+
case ExitCancelFailure_Tags.TooLate: {
|
|
2793
|
+
ordinalConverter.write(2, into);
|
|
2794
|
+
const inner = value.inner;
|
|
2795
|
+
FfiConverterTypeExitStateKind.write(inner.state, into);
|
|
2796
|
+
return;
|
|
2797
|
+
}
|
|
2798
|
+
case ExitCancelFailure_Tags.AlreadyBroadcast: {
|
|
2799
|
+
ordinalConverter.write(3, into);
|
|
2800
|
+
const inner = value.inner;
|
|
2801
|
+
FfiConverterString.write(inner.txid, into);
|
|
2802
|
+
return;
|
|
2803
|
+
}
|
|
2804
|
+
default:
|
|
2805
|
+
// Throwing from here means that ExitCancelFailure_Tags hasn't matched an ordinal.
|
|
2806
|
+
throw new UniffiInternalError.UnexpectedEnumCase();
|
|
2807
|
+
}
|
|
2808
|
+
}
|
|
2809
|
+
allocationSize(value: TypeName): number {
|
|
2810
|
+
switch (value.tag) {
|
|
2811
|
+
case ExitCancelFailure_Tags.NotExiting: {
|
|
2812
|
+
return ordinalConverter.allocationSize(1);
|
|
2813
|
+
}
|
|
2814
|
+
case ExitCancelFailure_Tags.TooLate: {
|
|
2815
|
+
const inner = value.inner;
|
|
2816
|
+
let size = ordinalConverter.allocationSize(2);
|
|
2817
|
+
size += FfiConverterTypeExitStateKind.allocationSize(inner.state);
|
|
2818
|
+
return size;
|
|
2819
|
+
}
|
|
2820
|
+
case ExitCancelFailure_Tags.AlreadyBroadcast: {
|
|
2821
|
+
const inner = value.inner;
|
|
2822
|
+
let size = ordinalConverter.allocationSize(3);
|
|
2823
|
+
size += FfiConverterString.allocationSize(inner.txid);
|
|
2824
|
+
return size;
|
|
2825
|
+
}
|
|
2826
|
+
default:
|
|
2827
|
+
throw new UniffiInternalError.UnexpectedEnumCase();
|
|
2828
|
+
}
|
|
2829
|
+
}
|
|
2830
|
+
}
|
|
2831
|
+
return new FFIConverter();
|
|
2832
|
+
})();
|
|
2833
|
+
|
|
2578
2834
|
// Enum: ExitState
|
|
2579
2835
|
export enum ExitState_Tags {
|
|
2580
2836
|
Start = "Start",
|
|
@@ -3131,6 +3387,78 @@ const FfiConverterTypeExitState = (() => {
|
|
|
3131
3387
|
return new FFIConverter();
|
|
3132
3388
|
})();
|
|
3133
3389
|
|
|
3390
|
+
/**
|
|
3391
|
+
* Lightweight discriminator for [`ExitState`], mirroring
|
|
3392
|
+
* `bark::exit::ExitStateKind`.
|
|
3393
|
+
*
|
|
3394
|
+
* Carries no payload — use it where only the variant matters (e.g. reporting
|
|
3395
|
+
* which state blocked a cancellation). Serde/TS tags match upstream's
|
|
3396
|
+
* kebab-case serialization.
|
|
3397
|
+
*/
|
|
3398
|
+
export enum ExitStateKind {
|
|
3399
|
+
Start,
|
|
3400
|
+
Processing,
|
|
3401
|
+
AwaitingDelta,
|
|
3402
|
+
Claimable,
|
|
3403
|
+
ClaimInProgress,
|
|
3404
|
+
Claimed,
|
|
3405
|
+
VtxoAlreadySpent,
|
|
3406
|
+
Canceled,
|
|
3407
|
+
}
|
|
3408
|
+
|
|
3409
|
+
const FfiConverterTypeExitStateKind = (() => {
|
|
3410
|
+
const ordinalConverter = FfiConverterInt32;
|
|
3411
|
+
type TypeName = ExitStateKind;
|
|
3412
|
+
class FFIConverter extends AbstractFfiConverterByteArray<TypeName> {
|
|
3413
|
+
read(from: RustBuffer): TypeName {
|
|
3414
|
+
switch (ordinalConverter.read(from)) {
|
|
3415
|
+
case 1:
|
|
3416
|
+
return ExitStateKind.Start;
|
|
3417
|
+
case 2:
|
|
3418
|
+
return ExitStateKind.Processing;
|
|
3419
|
+
case 3:
|
|
3420
|
+
return ExitStateKind.AwaitingDelta;
|
|
3421
|
+
case 4:
|
|
3422
|
+
return ExitStateKind.Claimable;
|
|
3423
|
+
case 5:
|
|
3424
|
+
return ExitStateKind.ClaimInProgress;
|
|
3425
|
+
case 6:
|
|
3426
|
+
return ExitStateKind.Claimed;
|
|
3427
|
+
case 7:
|
|
3428
|
+
return ExitStateKind.VtxoAlreadySpent;
|
|
3429
|
+
case 8:
|
|
3430
|
+
return ExitStateKind.Canceled;
|
|
3431
|
+
default:
|
|
3432
|
+
throw new UniffiInternalError.UnexpectedEnumCase();
|
|
3433
|
+
}
|
|
3434
|
+
}
|
|
3435
|
+
write(value: TypeName, into: RustBuffer): void {
|
|
3436
|
+
switch (value) {
|
|
3437
|
+
case ExitStateKind.Start:
|
|
3438
|
+
return ordinalConverter.write(1, into);
|
|
3439
|
+
case ExitStateKind.Processing:
|
|
3440
|
+
return ordinalConverter.write(2, into);
|
|
3441
|
+
case ExitStateKind.AwaitingDelta:
|
|
3442
|
+
return ordinalConverter.write(3, into);
|
|
3443
|
+
case ExitStateKind.Claimable:
|
|
3444
|
+
return ordinalConverter.write(4, into);
|
|
3445
|
+
case ExitStateKind.ClaimInProgress:
|
|
3446
|
+
return ordinalConverter.write(5, into);
|
|
3447
|
+
case ExitStateKind.Claimed:
|
|
3448
|
+
return ordinalConverter.write(6, into);
|
|
3449
|
+
case ExitStateKind.VtxoAlreadySpent:
|
|
3450
|
+
return ordinalConverter.write(7, into);
|
|
3451
|
+
case ExitStateKind.Canceled:
|
|
3452
|
+
return ordinalConverter.write(8, into);
|
|
3453
|
+
}
|
|
3454
|
+
}
|
|
3455
|
+
allocationSize(value: TypeName): number {
|
|
3456
|
+
return ordinalConverter.allocationSize(0);
|
|
3457
|
+
}
|
|
3458
|
+
}
|
|
3459
|
+
return new FFIConverter();
|
|
3460
|
+
})();
|
|
3461
|
+
|
|
3134
3462
|
// Enum: ExitTxOrigin
|
|
3135
3463
|
export enum ExitTxOrigin_Tags {
|
|
3136
3464
|
Wallet = "Wallet",
|
|
@@ -6382,6 +6710,10 @@ export interface WalletLike {
|
|
|
6382
6710
|
cancelAllPendingRounds(asyncOpts_?: {
|
|
6383
6711
|
signal: AbortSignal;
|
|
6384
6712
|
}): /*throws*/ Promise<void>;
|
|
6713
|
+
cancelExit(
|
|
6714
|
+
vtxoId: string,
|
|
6715
|
+
asyncOpts_?: { signal: AbortSignal }
|
|
6716
|
+
): /*throws*/ Promise<ExitCancelResult>;
|
|
6385
6717
|
cancelLightningReceive(
|
|
6386
6718
|
paymentHash: string,
|
|
6387
6719
|
asyncOpts_?: { signal: AbortSignal }
|
|
@@ -6507,6 +6839,11 @@ export interface WalletLike {
|
|
|
6507
6839
|
listClaimableExits(asyncOpts_?: {
|
|
6508
6840
|
signal: AbortSignal;
|
|
6509
6841
|
}): /*throws*/ Promise<Array<ExitVtxo>>;
|
|
6842
|
+
lockVtxos(
|
|
6843
|
+
vtxoIds: Array<string>,
|
|
6844
|
+
holder: VtxoLockHolder | undefined,
|
|
6845
|
+
asyncOpts_?: { signal: AbortSignal }
|
|
6846
|
+
): /*throws*/ Promise<void>;
|
|
6510
6847
|
mailboxAuthorization(): /*throws*/ string;
|
|
6511
6848
|
mailboxIdentifier(): /*throws*/ string;
|
|
6512
6849
|
maintenance(asyncOpts_?: { signal: AbortSignal }): /*throws*/ Promise<void>;
|
|
@@ -6533,7 +6870,7 @@ export interface WalletLike {
|
|
|
6533
6870
|
vtxoIds: Array<string>,
|
|
6534
6871
|
bitcoinAddress: string,
|
|
6535
6872
|
asyncOpts_?: { signal: AbortSignal }
|
|
6536
|
-
): /*throws*/ Promise<
|
|
6873
|
+
): /*throws*/ Promise<OffboardResult>;
|
|
6537
6874
|
/**
|
|
6538
6875
|
* Pay to a Lightning Address (`user@domain`), resolved via LNURL-pay.
|
|
6539
6876
|
*/
|
|
@@ -6677,6 +7014,10 @@ export interface WalletLike {
|
|
|
6677
7014
|
vtxoIds: Array<string>,
|
|
6678
7015
|
asyncOpts_?: { signal: AbortSignal }
|
|
6679
7016
|
): /*throws*/ Promise<void>;
|
|
7017
|
+
startExitForVtxosIncludingNonStandard(
|
|
7018
|
+
vtxoIds: Array<string>,
|
|
7019
|
+
asyncOpts_?: { signal: AbortSignal }
|
|
7020
|
+
): /*throws*/ Promise<void>;
|
|
6680
7021
|
stopDaemon(asyncOpts_?: { signal: AbortSignal }): /*throws*/ Promise<void>;
|
|
6681
7022
|
stuckFailedLightningSends(asyncOpts_?: {
|
|
6682
7023
|
signal: AbortSignal;
|
|
@@ -6705,6 +7046,11 @@ export interface WalletLike {
|
|
|
6705
7046
|
wait: boolean,
|
|
6706
7047
|
asyncOpts_?: { signal: AbortSignal }
|
|
6707
7048
|
): /*throws*/ Promise<LightningReceive>;
|
|
7049
|
+
unlockVtxos(
|
|
7050
|
+
vtxoIds: Array<string>,
|
|
7051
|
+
expectedHolder: VtxoLockHolder | undefined,
|
|
7052
|
+
asyncOpts_?: { signal: AbortSignal }
|
|
7053
|
+
): /*throws*/ Promise<void>;
|
|
6708
7054
|
validateArkoorAddress(
|
|
6709
7055
|
address: string,
|
|
6710
7056
|
asyncOpts_?: { signal: AbortSignal }
|
|
@@ -7236,6 +7582,43 @@ export class Wallet extends UniffiAbstractObject implements WalletLike {
|
|
|
7236
7582
|
}
|
|
7237
7583
|
}
|
|
7238
7584
|
|
|
7585
|
+
async cancelExit(
|
|
7586
|
+
vtxoId: string,
|
|
7587
|
+
asyncOpts_?: { signal: AbortSignal }
|
|
7588
|
+
): Promise<ExitCancelResult> /*throws*/ {
|
|
7589
|
+
const __stack = uniffiIsDebug ? new Error().stack : undefined;
|
|
7590
|
+
try {
|
|
7591
|
+
return await uniffiRustCallAsync(
|
|
7592
|
+
/*rustCaller:*/ uniffiCaller,
|
|
7593
|
+
/*rustFutureFunc:*/ () => {
|
|
7594
|
+
return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_cancel_exit(
|
|
7595
|
+
uniffiTypeWalletObjectFactory.clonePointer(this),
|
|
7596
|
+
FfiConverterString.lower(vtxoId)
|
|
7597
|
+
);
|
|
7598
|
+
},
|
|
7599
|
+
/*pollFunc:*/ nativeModule()
|
|
7600
|
+
.ubrn_ffi_bark_ffi_rust_future_poll_rust_buffer,
|
|
7601
|
+
/*cancelFunc:*/ nativeModule()
|
|
7602
|
+
.ubrn_ffi_bark_ffi_rust_future_cancel_rust_buffer,
|
|
7603
|
+
/*completeFunc:*/ nativeModule()
|
|
7604
|
+
.ubrn_ffi_bark_ffi_rust_future_complete_rust_buffer,
|
|
7605
|
+
/*freeFunc:*/ nativeModule()
|
|
7606
|
+
.ubrn_ffi_bark_ffi_rust_future_free_rust_buffer,
|
|
7607
|
+
/*liftFunc:*/ FfiConverterTypeExitCancelResult.lift.bind(
|
|
7608
|
+
FfiConverterTypeExitCancelResult
|
|
7609
|
+
),
|
|
7610
|
+
/*liftString:*/ FfiConverterString.lift,
|
|
7611
|
+
/*asyncOpts:*/ asyncOpts_,
|
|
7612
|
+
/*errorHandler:*/ FfiConverterTypeError.lift.bind(FfiConverterTypeError)
|
|
7613
|
+
);
|
|
7614
|
+
} catch (__error: any) {
|
|
7615
|
+
if (uniffiIsDebug && __error instanceof Error) {
|
|
7616
|
+
__error.stack = __stack;
|
|
7617
|
+
}
|
|
7618
|
+
throw __error;
|
|
7619
|
+
}
|
|
7620
|
+
}
|
|
7621
|
+
|
|
7239
7622
|
async cancelLightningReceive(
|
|
7240
7623
|
paymentHash: string,
|
|
7241
7624
|
asyncOpts_?: { signal: AbortSignal }
|
|
@@ -8298,6 +8681,41 @@ export class Wallet extends UniffiAbstractObject implements WalletLike {
|
|
|
8298
8681
|
}
|
|
8299
8682
|
}
|
|
8300
8683
|
|
|
8684
|
+
async lockVtxos(
|
|
8685
|
+
vtxoIds: Array<string>,
|
|
8686
|
+
holder: VtxoLockHolder | undefined,
|
|
8687
|
+
asyncOpts_?: { signal: AbortSignal }
|
|
8688
|
+
): Promise<void> /*throws*/ {
|
|
8689
|
+
const __stack = uniffiIsDebug ? new Error().stack : undefined;
|
|
8690
|
+
try {
|
|
8691
|
+
return await uniffiRustCallAsync(
|
|
8692
|
+
/*rustCaller:*/ uniffiCaller,
|
|
8693
|
+
/*rustFutureFunc:*/ () => {
|
|
8694
|
+
return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_lock_vtxos(
|
|
8695
|
+
uniffiTypeWalletObjectFactory.clonePointer(this),
|
|
8696
|
+
FfiConverterArrayString.lower(vtxoIds),
|
|
8697
|
+
FfiConverterOptionalTypeVtxoLockHolder.lower(holder)
|
|
8698
|
+
);
|
|
8699
|
+
},
|
|
8700
|
+
/*pollFunc:*/ nativeModule().ubrn_ffi_bark_ffi_rust_future_poll_void,
|
|
8701
|
+
/*cancelFunc:*/ nativeModule()
|
|
8702
|
+
.ubrn_ffi_bark_ffi_rust_future_cancel_void,
|
|
8703
|
+
/*completeFunc:*/ nativeModule()
|
|
8704
|
+
.ubrn_ffi_bark_ffi_rust_future_complete_void,
|
|
8705
|
+
/*freeFunc:*/ nativeModule().ubrn_ffi_bark_ffi_rust_future_free_void,
|
|
8706
|
+
/*liftFunc:*/ (_v) => {},
|
|
8707
|
+
/*liftString:*/ FfiConverterString.lift,
|
|
8708
|
+
/*asyncOpts:*/ asyncOpts_,
|
|
8709
|
+
/*errorHandler:*/ FfiConverterTypeError.lift.bind(FfiConverterTypeError)
|
|
8710
|
+
);
|
|
8711
|
+
} catch (__error: any) {
|
|
8712
|
+
if (uniffiIsDebug && __error instanceof Error) {
|
|
8713
|
+
__error.stack = __stack;
|
|
8714
|
+
}
|
|
8715
|
+
throw __error;
|
|
8716
|
+
}
|
|
8717
|
+
}
|
|
8718
|
+
|
|
8301
8719
|
mailboxAuthorization(): string /*throws*/ {
|
|
8302
8720
|
return FfiConverterString.lift(
|
|
8303
8721
|
uniffiCaller.rustCallWithError(
|
|
@@ -8613,7 +9031,7 @@ export class Wallet extends UniffiAbstractObject implements WalletLike {
|
|
|
8613
9031
|
vtxoIds: Array<string>,
|
|
8614
9032
|
bitcoinAddress: string,
|
|
8615
9033
|
asyncOpts_?: { signal: AbortSignal }
|
|
8616
|
-
): Promise<
|
|
9034
|
+
): Promise<OffboardResult> /*throws*/ {
|
|
8617
9035
|
const __stack = uniffiIsDebug ? new Error().stack : undefined;
|
|
8618
9036
|
try {
|
|
8619
9037
|
return await uniffiRustCallAsync(
|
|
@@ -8633,7 +9051,9 @@ export class Wallet extends UniffiAbstractObject implements WalletLike {
|
|
|
8633
9051
|
.ubrn_ffi_bark_ffi_rust_future_complete_rust_buffer,
|
|
8634
9052
|
/*freeFunc:*/ nativeModule()
|
|
8635
9053
|
.ubrn_ffi_bark_ffi_rust_future_free_rust_buffer,
|
|
8636
|
-
/*liftFunc:*/
|
|
9054
|
+
/*liftFunc:*/ FfiConverterTypeOffboardResult.lift.bind(
|
|
9055
|
+
FfiConverterTypeOffboardResult
|
|
9056
|
+
),
|
|
8637
9057
|
/*liftString:*/ FfiConverterString.lift,
|
|
8638
9058
|
/*asyncOpts:*/ asyncOpts_,
|
|
8639
9059
|
/*errorHandler:*/ FfiConverterTypeError.lift.bind(FfiConverterTypeError)
|
|
@@ -9694,6 +10114,39 @@ export class Wallet extends UniffiAbstractObject implements WalletLike {
|
|
|
9694
10114
|
}
|
|
9695
10115
|
}
|
|
9696
10116
|
|
|
10117
|
+
async startExitForVtxosIncludingNonStandard(
|
|
10118
|
+
vtxoIds: Array<string>,
|
|
10119
|
+
asyncOpts_?: { signal: AbortSignal }
|
|
10120
|
+
): Promise<void> /*throws*/ {
|
|
10121
|
+
const __stack = uniffiIsDebug ? new Error().stack : undefined;
|
|
10122
|
+
try {
|
|
10123
|
+
return await uniffiRustCallAsync(
|
|
10124
|
+
/*rustCaller:*/ uniffiCaller,
|
|
10125
|
+
/*rustFutureFunc:*/ () => {
|
|
10126
|
+
return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_start_exit_for_vtxos_including_non_standard(
|
|
10127
|
+
uniffiTypeWalletObjectFactory.clonePointer(this),
|
|
10128
|
+
FfiConverterArrayString.lower(vtxoIds)
|
|
10129
|
+
);
|
|
10130
|
+
},
|
|
10131
|
+
/*pollFunc:*/ nativeModule().ubrn_ffi_bark_ffi_rust_future_poll_void,
|
|
10132
|
+
/*cancelFunc:*/ nativeModule()
|
|
10133
|
+
.ubrn_ffi_bark_ffi_rust_future_cancel_void,
|
|
10134
|
+
/*completeFunc:*/ nativeModule()
|
|
10135
|
+
.ubrn_ffi_bark_ffi_rust_future_complete_void,
|
|
10136
|
+
/*freeFunc:*/ nativeModule().ubrn_ffi_bark_ffi_rust_future_free_void,
|
|
10137
|
+
/*liftFunc:*/ (_v) => {},
|
|
10138
|
+
/*liftString:*/ FfiConverterString.lift,
|
|
10139
|
+
/*asyncOpts:*/ asyncOpts_,
|
|
10140
|
+
/*errorHandler:*/ FfiConverterTypeError.lift.bind(FfiConverterTypeError)
|
|
10141
|
+
);
|
|
10142
|
+
} catch (__error: any) {
|
|
10143
|
+
if (uniffiIsDebug && __error instanceof Error) {
|
|
10144
|
+
__error.stack = __stack;
|
|
10145
|
+
}
|
|
10146
|
+
throw __error;
|
|
10147
|
+
}
|
|
10148
|
+
}
|
|
10149
|
+
|
|
9697
10150
|
async stopDaemon(asyncOpts_?: {
|
|
9698
10151
|
signal: AbortSignal;
|
|
9699
10152
|
}): Promise<void> /*throws*/ {
|
|
@@ -9965,6 +10418,41 @@ export class Wallet extends UniffiAbstractObject implements WalletLike {
|
|
|
9965
10418
|
}
|
|
9966
10419
|
}
|
|
9967
10420
|
|
|
10421
|
+
async unlockVtxos(
|
|
10422
|
+
vtxoIds: Array<string>,
|
|
10423
|
+
expectedHolder: VtxoLockHolder | undefined,
|
|
10424
|
+
asyncOpts_?: { signal: AbortSignal }
|
|
10425
|
+
): Promise<void> /*throws*/ {
|
|
10426
|
+
const __stack = uniffiIsDebug ? new Error().stack : undefined;
|
|
10427
|
+
try {
|
|
10428
|
+
return await uniffiRustCallAsync(
|
|
10429
|
+
/*rustCaller:*/ uniffiCaller,
|
|
10430
|
+
/*rustFutureFunc:*/ () => {
|
|
10431
|
+
return nativeModule().ubrn_uniffi_bark_ffi_fn_method_wallet_unlock_vtxos(
|
|
10432
|
+
uniffiTypeWalletObjectFactory.clonePointer(this),
|
|
10433
|
+
FfiConverterArrayString.lower(vtxoIds),
|
|
10434
|
+
FfiConverterOptionalTypeVtxoLockHolder.lower(expectedHolder)
|
|
10435
|
+
);
|
|
10436
|
+
},
|
|
10437
|
+
/*pollFunc:*/ nativeModule().ubrn_ffi_bark_ffi_rust_future_poll_void,
|
|
10438
|
+
/*cancelFunc:*/ nativeModule()
|
|
10439
|
+
.ubrn_ffi_bark_ffi_rust_future_cancel_void,
|
|
10440
|
+
/*completeFunc:*/ nativeModule()
|
|
10441
|
+
.ubrn_ffi_bark_ffi_rust_future_complete_void,
|
|
10442
|
+
/*freeFunc:*/ nativeModule().ubrn_ffi_bark_ffi_rust_future_free_void,
|
|
10443
|
+
/*liftFunc:*/ (_v) => {},
|
|
10444
|
+
/*liftString:*/ FfiConverterString.lift,
|
|
10445
|
+
/*asyncOpts:*/ asyncOpts_,
|
|
10446
|
+
/*errorHandler:*/ FfiConverterTypeError.lift.bind(FfiConverterTypeError)
|
|
10447
|
+
);
|
|
10448
|
+
} catch (__error: any) {
|
|
10449
|
+
if (uniffiIsDebug && __error instanceof Error) {
|
|
10450
|
+
__error.stack = __stack;
|
|
10451
|
+
}
|
|
10452
|
+
throw __error;
|
|
10453
|
+
}
|
|
10454
|
+
}
|
|
10455
|
+
|
|
9968
10456
|
async validateArkoorAddress(
|
|
9969
10457
|
address: string,
|
|
9970
10458
|
asyncOpts_?: { signal: AbortSignal }
|
|
@@ -10264,6 +10752,11 @@ const FfiConverterArrayTypeWalletTransaction = new FfiConverterArray(
|
|
|
10264
10752
|
// FfiConverter for Array<string>
|
|
10265
10753
|
const FfiConverterArrayString = new FfiConverterArray(FfiConverterString);
|
|
10266
10754
|
|
|
10755
|
+
// FfiConverter for ExitCancelFailure | undefined
|
|
10756
|
+
const FfiConverterOptionalTypeExitCancelFailure = new FfiConverterOptional(
|
|
10757
|
+
FfiConverterTypeExitCancelFailure
|
|
10758
|
+
);
|
|
10759
|
+
|
|
10267
10760
|
// FfiConverter for VtxoLockHolder | undefined
|
|
10268
10761
|
const FfiConverterOptionalTypeVtxoLockHolder = new FfiConverterOptional(
|
|
10269
10762
|
FfiConverterTypeVtxoLockHolder
|
|
@@ -10618,6 +11111,14 @@ function uniffiEnsureInitialized() {
|
|
|
10618
11111
|
"uniffi_bark_ffi_checksum_method_wallet_cancel_all_pending_rounds"
|
|
10619
11112
|
);
|
|
10620
11113
|
}
|
|
11114
|
+
if (
|
|
11115
|
+
nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_cancel_exit() !==
|
|
11116
|
+
1772
|
|
11117
|
+
) {
|
|
11118
|
+
throw new UniffiInternalError.ApiChecksumMismatch(
|
|
11119
|
+
"uniffi_bark_ffi_checksum_method_wallet_cancel_exit"
|
|
11120
|
+
);
|
|
11121
|
+
}
|
|
10621
11122
|
if (
|
|
10622
11123
|
nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_cancel_lightning_receive() !==
|
|
10623
11124
|
49444
|
|
@@ -10858,6 +11359,14 @@ function uniffiEnsureInitialized() {
|
|
|
10858
11359
|
"uniffi_bark_ffi_checksum_method_wallet_list_claimable_exits"
|
|
10859
11360
|
);
|
|
10860
11361
|
}
|
|
11362
|
+
if (
|
|
11363
|
+
nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_lock_vtxos() !==
|
|
11364
|
+
25205
|
|
11365
|
+
) {
|
|
11366
|
+
throw new UniffiInternalError.ApiChecksumMismatch(
|
|
11367
|
+
"uniffi_bark_ffi_checksum_method_wallet_lock_vtxos"
|
|
11368
|
+
);
|
|
11369
|
+
}
|
|
10861
11370
|
if (
|
|
10862
11371
|
nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_mailbox_authorization() !==
|
|
10863
11372
|
52372
|
|
@@ -10948,7 +11457,7 @@ function uniffiEnsureInitialized() {
|
|
|
10948
11457
|
}
|
|
10949
11458
|
if (
|
|
10950
11459
|
nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_offboard_vtxos() !==
|
|
10951
|
-
|
|
11460
|
+
64605
|
|
10952
11461
|
) {
|
|
10953
11462
|
throw new UniffiInternalError.ApiChecksumMismatch(
|
|
10954
11463
|
"uniffi_bark_ffi_checksum_method_wallet_offboard_vtxos"
|
|
@@ -11186,6 +11695,14 @@ function uniffiEnsureInitialized() {
|
|
|
11186
11695
|
"uniffi_bark_ffi_checksum_method_wallet_start_exit_for_vtxos"
|
|
11187
11696
|
);
|
|
11188
11697
|
}
|
|
11698
|
+
if (
|
|
11699
|
+
nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_start_exit_for_vtxos_including_non_standard() !==
|
|
11700
|
+
29239
|
|
11701
|
+
) {
|
|
11702
|
+
throw new UniffiInternalError.ApiChecksumMismatch(
|
|
11703
|
+
"uniffi_bark_ffi_checksum_method_wallet_start_exit_for_vtxos_including_non_standard"
|
|
11704
|
+
);
|
|
11705
|
+
}
|
|
11189
11706
|
if (
|
|
11190
11707
|
nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_stop_daemon() !==
|
|
11191
11708
|
7109
|
|
@@ -11249,6 +11766,14 @@ function uniffiEnsureInitialized() {
|
|
|
11249
11766
|
"uniffi_bark_ffi_checksum_method_wallet_try_claim_lightning_receive"
|
|
11250
11767
|
);
|
|
11251
11768
|
}
|
|
11769
|
+
if (
|
|
11770
|
+
nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_unlock_vtxos() !==
|
|
11771
|
+
42168
|
|
11772
|
+
) {
|
|
11773
|
+
throw new UniffiInternalError.ApiChecksumMismatch(
|
|
11774
|
+
"uniffi_bark_ffi_checksum_method_wallet_unlock_vtxos"
|
|
11775
|
+
);
|
|
11776
|
+
}
|
|
11252
11777
|
if (
|
|
11253
11778
|
nativeModule().ubrn_uniffi_bark_ffi_checksum_method_wallet_validate_arkoor_address() !==
|
|
11254
11779
|
10861
|
|
@@ -11315,9 +11840,12 @@ export default Object.freeze({
|
|
|
11315
11840
|
FfiConverterTypeCustomOnchainWalletCallbacks,
|
|
11316
11841
|
FfiConverterTypeDestination,
|
|
11317
11842
|
FfiConverterTypeError,
|
|
11843
|
+
FfiConverterTypeExitCancelFailure,
|
|
11844
|
+
FfiConverterTypeExitCancelResult,
|
|
11318
11845
|
FfiConverterTypeExitClaimTransaction,
|
|
11319
11846
|
FfiConverterTypeExitProgressStatus,
|
|
11320
11847
|
FfiConverterTypeExitState,
|
|
11848
|
+
FfiConverterTypeExitStateKind,
|
|
11321
11849
|
FfiConverterTypeExitTransactionStatus,
|
|
11322
11850
|
FfiConverterTypeExitTx,
|
|
11323
11851
|
FfiConverterTypeExitTxOrigin,
|