@breeztech/breez-sdk-spark 0.18.0 → 0.19.2

package/deno/breez_sdk_spark_wasm.d.ts

@@ -39,16 +39,24 @@ type ReserveResult =
 | { type: 'insufficientFunds' }
 | { type: 'waitForPending'; needed: number; available: number; pending: number };
 
+type LeafSelection =
+| { type: 'exact'; leaves: TreeNode[] }
+| { type: 'swapNeeded'; leaves: TreeNode[] }
+| { type: 'insufficientFunds' };
+
 export interface TreeStore {
     addLeaves: (leaves: TreeNode[]) => Promise<void>;
     getLeaves: () => Promise<Leaves>;
     getAvailableBalance: () => Promise<bigint>;
+    getVerifiedLeafKeys: () => Promise<[string, string, string][]>;
     setLeaves: (leaves: TreeNode[], missingLeaves: TreeNode[], refreshStartedAtMs: number) => Promise<void>;
     cancelReservation: (id: string, leavesToKeep: TreeNode[]) => Promise<void>;
     finalizeReservation: (id: string, newLeaves: TreeNode[] | null) => Promise<void>;
     tryReserveLeaves: (targetAmounts: TargetAmounts | null, exactOnly: boolean, purpose: string) => Promise<ReserveResult>;
     now: () => Promise<number>;
     updateReservation: (reservationId: string, reservedLeaves: TreeNode[], changeLeaves: TreeNode[]) => Promise<LeavesReservation>;
+    tryReserveLeavesByIds: (leafIds: string[], purpose: string) => Promise<LeavesReservation>;
+    trySelectLeaves: (targetAmounts: TargetAmounts | null) => Promise<LeafSelection>;
 }
 
 
@@ -123,6 +131,17 @@ export interface TokenStore {
     preferredOutputs: WasmTokenOutputWithPrevOut[] | null,
     selectionStrategy: string | null
     ) => Promise<WasmTokenOutputsReservation>;
+    selectTokenOutputs: (
+    tokenIdentifier: string,
+    target: WasmReservationTarget,
+    preferredOutputs: WasmTokenOutputWithPrevOut[] | null,
+    selectionStrategy: string | null
+    ) => Promise<WasmTokenOutputs>;
+    reserveTokenOutputsByOutpoints: (
+    tokenIdentifier: string,
+    outpoints: { prevTxHash: string; prevTxVout: number }[],
+    purpose: string
+    ) => Promise<WasmTokenOutputsReservation>;
     cancelReservation: (id: string) => Promise<void>;
     finalizeReservation: (id: string) => Promise<void>;
     now: () => Promise<number>;
@@ -288,6 +307,14 @@ export interface PrfProvider {
      * device. Hosts gate UX on the result.
      */
     isSupported(): Promise<boolean>;
+
+    /**
+     * Optional. Whether the silent single-CTA flow works here (a
+     * no-credential sign-in fast-fails with no UI). Omit to be treated as
+     * unsupported (`false`); the built-in browser provider returns the
+     * WebAuthn immediate-mediation capability.
+     */
+    supportsImmediateMediation?(): Promise<boolean>;
 }
 
 /**
@@ -303,7 +330,9 @@ export interface DeriveSeedOptions {
     allowCredentials?: Uint8Array[];
     /**
      * Fast-fail when no local credential is available. On the web this maps
-     * to WebAuthn `mediation: 'immediate'`: `true` opts in where the browser
+     * to WebAuthn `uiMode: 'immediate'`, used only on the unpinned probe (a
+     * non-empty allowCredentials keeps the standard picker, since a pin means
+     * a credential is already known): `true` opts in where the browser
      * advertises support, `false` uses the standard picker. Unset uses the
      * provider default.
      */
@@ -353,6 +382,15 @@ export interface PasskeyProviderOptions {
     userDisplayName?: string;
 }
 
+/**
+ * Request shape for `PasskeyClient.connectWithPasskey`.
+ */
+export interface ConnectWithPasskeyRequest {
+    label?: string;
+    allowCredentials?: Uint8Array[];
+    excludeCredentials?: Uint8Array[];
+}
+
 /**
  * Request shape for `PasskeyClient.register`.
  */
@@ -370,6 +408,15 @@ export interface SignInRequest {
     preferImmediatelyAvailableCredentials?: boolean;
 }
 
+/**
+ * Response shape for `PasskeyClient.connectWithPasskey`.
+ */
+export interface ConnectWithPasskeyResponse {
+    wallet: Wallet;
+    credential?: PasskeyCredential;
+    labels: string[];
+}
+
 /**
  * Response shape for `PasskeyClient.register`.
  */
@@ -536,6 +583,15 @@ export interface Bolt12OfferDetails {
     signingPubkey?: string;
 }
 
+export interface BuildUnsignedLnurlPayPackageRequest {
+    prepareResponse: PrepareLnurlPayResponse;
+}
+
+export interface BuildUnsignedTransferPackageRequest {
+    prepareResponse: PrepareSendPaymentResponse;
+    options?: BuildTransferPackageOptions;
+}
+
 export interface BurnIssuerTokenRequest {
     amount: bigint;
 }
@@ -1078,6 +1134,12 @@ export interface LnurlInfo {
     bech32: string;
 }
 
+export interface LnurlPayContext {
+    payRequest: LnurlPayRequestDetails;
+    comment?: string;
+    successAction?: SuccessAction;
+}
+
 export interface LnurlPayInfo {
     lnAddress?: string;
     comment?: string;
@@ -1267,6 +1329,14 @@ export interface PublicKeyBytes {
     bytes: number[];
 }
 
+export interface PublishSignedLnurlPayPackageRequest {
+    signedPackage: SignedTransferPackage;
+}
+
+export interface PublishSignedTransferPackageRequest {
+    signedPackage: SignedTransferPackage;
+}
+
 export interface Rate {
     coin: string;
     value: number;
@@ -1408,6 +1478,11 @@ export interface SignMessageResponse {
     signature: string;
 }
 
+export interface SignedTransferPackage {
+    unsigned: UnsignedTransferPackage;
+    signature: TransferSignature;
+}
+
 export interface SilentPaymentAddressDetails {
     address: string;
     network: BitcoinNetwork;
@@ -1428,6 +1503,7 @@ export interface SparkConfig {
     sspConfig: SparkSspConfig;
     expectedWithdrawBondSats: number;
     expectedWithdrawRelativeBlockLocktime: number;
+    maxTokenTransactionInputs?: number;
 }
 
 export interface SparkHtlcDetails {
@@ -1597,7 +1673,9 @@ export interface TurnkeyConfig {
     walletId: string;
     network: Network;
     accountNumber?: number;
+    identityPublicKey?: string;
     retry?: TurnkeyRetryConfig;
+    maxRps?: number;
 }
 
 export interface TurnkeyRetryConfig {
@@ -1680,6 +1758,8 @@ export type AutoOptimizationEvent = { type: "started"; totalRounds: number } | {
 
 export type BitcoinNetwork = "bitcoin" | "testnet3" | "testnet4" | "signet" | "regtest";
 
+export type BuildTransferPackageOptions = { type: "bitcoinAddress"; confirmationSpeed: OnchainConfirmationSpeed } | { type: "bolt11Invoice"; preferSpark: boolean; completionTimeoutSecs?: number };
+
 export type BuyBitcoinRequest = { type: "moonpay"; lockedAmountSat?: number; redirectUrl?: string } | { type: "cashApp"; amountSats: number };
 
 export type ChainApiType = "esplora" | "mempoolSpace";
@@ -1748,6 +1828,10 @@ export type PaymentType = "send" | "receive";
 
 export type ProvisionalPaymentDetails = { type: "bitcoin"; withdrawalAddress: string } | { type: "lightning"; invoice: string } | { type: "spark"; payRequest: string } | { type: "token"; tokenId: string; payRequest: string };
 
+export type PublishSignedLnurlPayResponse = { type: "swapCompleted" } | { type: "paymentSent"; response: LnurlPayResponse };
+
+export type PublishSignedTransferPackageResponse = { type: "swapCompleted" } | { type: "paymentSent"; payment: Payment };
+
 export type ReceivePaymentMethod = { type: "sparkAddress" } | { type: "sparkInvoice"; amount?: string; tokenIdentifier?: string; expiryTime?: number; description?: string; senderPublicKey?: string } | { type: "bitcoinAddress"; newAddress?: boolean } | { type: "bolt11Invoice"; description: string; amountSats?: number; expirySecs?: number; paymentHash?: string };
 
 export type SdkEvent = { type: "synced" } | { type: "unclaimedDeposits"; unclaimedDeposits: DepositInfo[] } | { type: "claimedDeposits"; claimedDeposits: DepositInfo[] } | { type: "paymentSucceeded"; payment: Payment } | { type: "paymentPending"; payment: Payment } | { type: "paymentFailed"; payment: Payment } | { type: "autoOptimization"; optimizationEvent: AutoOptimizationEvent } | { type: "lightningAddressChanged"; lightningAddress?: LightningAddressInfo } | { type: "newDeposits"; newDeposits: DepositInfo[] };
@@ -1776,6 +1860,12 @@ export type SuccessActionProcessed = { type: "aes"; result: AesSuccessActionData
 
 export type TokenTransactionType = "transfer" | "mint" | "burn";
 
+export type TransferSignature = { type: "transfer"; signed: ExternalPreparedTransfer } | { type: "token"; signed: ExternalPreparedTokenTransaction };
+
+export type TransferTarget = { type: "spark"; address: string; sparkInvoice?: string } | { type: "lightning"; bolt11: string; lnurlPay?: LnurlPayContext; feePolicy: FeePolicy; completionTimeoutSecs?: number } | { type: "coopExit"; address: string; feeQuote: SendOnchainFeeQuote; confirmationSpeed: OnchainConfirmationSpeed };
+
+export type UnsignedTransferPackage = { type: "swap"; prepareTransfer: ExternalPrepareTransferRequest; targetAmounts: number[]; amountSat: number; feeSat: number } | { type: "transfer"; prepareTransfer: ExternalPrepareTransferRequest; amountSat: number; feeSat: number; target: TransferTarget } | { type: "token"; prepareTokenTransaction: ExternalPrepareTokenTransactionRequest; tokenContext: number[]; tokenIdentifier: string; amount: string; fee: string; isSwap: boolean };
+
 export type UpdateDepositPayload = { type: "claimError"; error: DepositClaimError } | { type: "refund"; refundTxid: string; refundTx: string };
 
 export type WebhookEventType = { type: "lightningReceiveFinished" } | { type: "lightningSendFinished" } | { type: "coopExitFinished" } | { type: "staticDepositFinished" } | ({ type: "unknown" } & string);
@@ -1807,6 +1897,8 @@ export class BreezSdk {
     addContact(request: AddContactRequest): Promise<Contact>;
     addEventListener(listener: EventListener): Promise<string>;
     authorizeLightningAddressTransfer(request: AuthorizeTransferRequest): Promise<TransferAuthorization>;
+    buildUnsignedLnurlPayPackage(request: BuildUnsignedLnurlPayPackageRequest): Promise<UnsignedTransferPackage>;
+    buildUnsignedTransferPackage(request: BuildUnsignedTransferPackageRequest): Promise<UnsignedTransferPackage>;
     buyBitcoin(request: BuyBitcoinRequest): Promise<BuyBitcoinResponse>;
     checkLightningAddressAvailable(request: CheckLightningAddressRequest): Promise<boolean>;
     checkMessage(request: CheckMessageRequest): Promise<CheckMessageResponse>;
@@ -1837,6 +1929,8 @@ export class BreezSdk {
     parse(input: string): Promise<InputType>;
     prepareLnurlPay(request: PrepareLnurlPayRequest): Promise<PrepareLnurlPayResponse>;
     prepareSendPayment(request: PrepareSendPaymentRequest): Promise<PrepareSendPaymentResponse>;
+    publishSignedLnurlPayPackage(request: PublishSignedLnurlPayPackageRequest): Promise<PublishSignedLnurlPayResponse>;
+    publishSignedTransferPackage(request: PublishSignedTransferPackageRequest): Promise<PublishSignedTransferPackageResponse>;
     receivePayment(request: ReceivePaymentRequest): Promise<ReceivePaymentResponse>;
     recommendedFees(): Promise<RecommendedFees>;
     refundDeposit(request: RefundDepositRequest): Promise<RefundDepositResponse>;
@@ -1852,6 +1946,21 @@ export class BreezSdk {
     updateUserSettings(request: UpdateUserSettingsRequest): Promise<void>;
 }
 
+/**
+ * A JS handle to a backend's own session store (from `defaultSessionStore`),
+ * exposing the same `getSession` / `setSession` interface. Wrap it in a JS
+ * `SessionStore` decorator and pass that to `SdkBuilder.withSessionStore` to
+ * transform tokens while keeping the backend's persistence: for example
+ * at-rest encryption, which the SDK does not apply itself.
+ */
+export class DefaultSessionStore {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    getSession(service_identity_key: string): Promise<Session>;
+    setSession(service_identity_key: string, session: Session): Promise<void>;
+}
+
 /**
  * A Rust-backed [`ExternalBreezSigner`] surfaced to JS as a signer object that
  * can be passed to `connectWithSigner` or `SdkBuilder.newWithSigner`. Produced
@@ -1979,6 +2088,18 @@ export class PasskeyClient {
      * hosts can gate UX on.
      */
     checkAvailability(): Promise<PasskeyAvailability>;
+    /**
+     * Single-CTA onboarding: silent sign-in that falls through to
+     * registration when no credential exists on the device. Pins
+     * immediate mediation, so on web only use it where the browser
+     * advertises it (`supportsImmediateMediation`); otherwise the silent
+     * probe degrades to the standard picker and a dismiss does not fall
+     * through to register, so
+     * present an explicit create / sign-in choice instead. Called without
+     * a `label`, the response `labels` lists a returning user's wallets
+     * for a picker.
+     */
+    connectWithPasskey(request: ConnectWithPasskeyRequest): Promise<ConnectWithPasskeyResponse>;
     /**
      * Label sub-object. List / publish labels for this passkey's identity.
      */
@@ -2003,6 +2124,14 @@ export class PasskeyClient {
      * label set in the same ceremony.
      */
     signIn(request: SignInRequest): Promise<SignInResponse>;
+    /**
+     * Whether this browser advertises WebAuthn immediate mediation: the
+     * silent single-CTA probe (a no-credential sign-in fast-fails with no
+     * UI) works here, so a web host can pick single- vs two-button
+     * onboarding. Web-only and WASM-only: native does the silent probe
+     * inherently, so there is nothing to query off-web.
+     */
+    supportsImmediateMediation(): Promise<boolean>;
 }
 
 /**
@@ -2051,6 +2180,13 @@ export class SdkBuilder {
      */
     withPostgresBackend(config: PostgresStorageConfig): SdkBuilder;
     withRestChainService(url: string, api_type: ChainApiType, credentials?: Credentials | null): SdkBuilder;
+    /**
+     * Overrides the session store used to cache auth tokens, replacing the one
+     * the backend provides. Pass any `SessionStore`: for example one that wraps
+     * the backend's own store from `defaultSessionStore` to add at-rest
+     * encryption, which the SDK does not apply itself.
+     */
+    withSessionStore(session_store: SessionStore): SdkBuilder;
     /**
      * Threads a shared [`WasmSdkContext`] into the builder.
      *
@@ -2185,6 +2321,14 @@ export function defaultPostgresStorageConfig(connection_string: string): Postgre
 
 export function defaultServerConfig(network: Network): Config;
 
+/**
+ * The session store the `config`'s backend provides for `identity` (the wallet
+ * identity public key, hex), as a handle to wrap in a `SessionStore` decorator
+ * and pass to `SdkBuilder.withSessionStore`, keeping the backend's persistence.
+ * A typical use is at-rest encryption, which the SDK does not apply itself.
+ */
+export function defaultSessionStore(config: WasmStorageConfig, network: Network, identity: string): Promise<DefaultSessionStore>;
+
 /**
  * File-based storage rooted at `storageDir` — IndexedDB in the browser,
  * SQLite under Node.js.