@breeztech/breez-sdk-spark 0.20.0-dev1 → 0.21.0

package/nodejs/postgres-tree-store/index.cjs

@@ -40,6 +40,16 @@ const RESERVATION_TIMEOUT_SECS = 300; // 5 minutes
  */
 const SPENT_MARKER_CLEANUP_THRESHOLD_MS = 5 * 60 * 1000; // 5 minutes
 
+/**
+ * Leaves per INSERT when upserting a refreshed leaf set.
+ *
+ * A wallet can hold six figures of leaves, each serializing to a JSON blob
+ * carrying up to five transactions. Building that as a single statement
+ * materializes the whole set at once, which is the largest allocation in a
+ * refresh and lands at its very end.
+ */
+const LEAF_UPSERT_CHUNK_SIZE = 1000;
+
 /**
  * Slim projection: only (id, value) for leaves the selection might use.
  * Includes all leaves with value <= $2 (covers exact-match + the small-leaf
@@ -1019,23 +1029,29 @@ class PostgresTreeStore {
 
     if (filtered.length === 0) return;
 
-    const ids = filtered.map((l) => l.id);
-    const statuses = filtered.map((l) => l.status);
-    const missingFlags = filtered.map(() => isMissingFromOperators);
-    const dataValues = filtered.map((l) => JSON.stringify(l));
-
-    await client.query(
-      `INSERT INTO brz_tree_leaves (user_id, id, status, is_missing_from_operators, data, added_at)
-       SELECT $5, id, status, missing, data::jsonb, NOW()
-       FROM UNNEST($1::text[], $2::text[], $3::bool[], $4::text[])
-           AS t(id, status, missing, data)
-       ON CONFLICT (user_id, id) DO UPDATE SET
-         status = EXCLUDED.status,
-         is_missing_from_operators = EXCLUDED.is_missing_from_operators,
-         data = EXCLUDED.data,
-         added_at = NOW()`,
-      [ids, statuses, missingFlags, dataValues, this.identity]
-    );
+    // All chunks run inside the caller's transaction, and NOW() is the
+    // transaction timestamp, so every row still lands atomically with one
+    // shared added_at.
+    for (let i = 0; i < filtered.length; i += LEAF_UPSERT_CHUNK_SIZE) {
+      const chunk = filtered.slice(i, i + LEAF_UPSERT_CHUNK_SIZE);
+      const ids = chunk.map((l) => l.id);
+      const statuses = chunk.map((l) => l.status);
+      const missingFlags = chunk.map(() => isMissingFromOperators);
+      const dataValues = chunk.map((l) => JSON.stringify(l));
+
+      await client.query(
+        `INSERT INTO brz_tree_leaves (user_id, id, status, is_missing_from_operators, data, added_at)
+         SELECT $5, id, status, missing, data::jsonb, NOW()
+         FROM UNNEST($1::text[], $2::text[], $3::bool[], $4::text[])
+             AS t(id, status, missing, data)
+         ON CONFLICT (user_id, id) DO UPDATE SET
+           status = EXCLUDED.status,
+           is_missing_from_operators = EXCLUDED.is_missing_from_operators,
+           data = EXCLUDED.data,
+           added_at = NOW()`,
+        [ids, statuses, missingFlags, dataValues, this.identity]
+      );
+    }
   }
 
   /**

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@breeztech/breez-sdk-spark",
-    "version": "0.20.0-dev1",
+    "version": "0.21.0",
     "description": "Breez Spark SDK",
     "repository": "https://github.com/breez/spark-sdk",
     "author": "Breez <contact@breez.technology> (https://github.com/breez)",

package/web/breez_sdk_spark_wasm.d.ts

@@ -89,7 +89,7 @@ interface WasmTokenOutputWithPrevOut {
 }
 
 interface WasmTokenOutputs {
-    metadata: WasmTokenMetadata;
+    metadata: WasmTokenMetadata[];
     outputs: WasmTokenOutputWithPrevOut[];
 }
 
@@ -119,26 +119,23 @@ type WasmReservationTarget =
 | { type: 'maxOutputCount'; value: number };
 
 export interface TokenStore {
-    setTokensOutputs: (tokenOutputs: WasmTokenOutputs[], refreshStartedAtMs: number) => Promise<void>;
+    setTokensOutputs: (tokenOutputs: WasmTokenOutputs, refreshStartedAtMs: number) => Promise<void>;
     listTokensOutputs: () => Promise<WasmTokenOutputsPerStatus[]>;
     getTokenBalances: () => Promise<WasmTokenBalance[]>;
     getTokenOutputs: (filter: WasmGetTokenOutputsFilter) => Promise<WasmTokenOutputsPerStatus>;
-    updateTokenOutputs: (outputsToRemove: [string, number][], outputsToAdd: WasmTokenOutputs | null) => Promise<void>;
+    updateTokenOutputs: (outputsToRemove: [string, number][], outputsToAdd: WasmTokenOutputs) => Promise<void>;
     reserveTokenOutputs: (
-    tokenIdentifier: string,
-    target: WasmReservationTarget,
+    targets: [string, WasmReservationTarget][],
     purpose: string,
     preferredOutputs: WasmTokenOutputWithPrevOut[] | null,
     selectionStrategy: string | null
     ) => Promise<WasmTokenOutputsReservation>;
     selectTokenOutputs: (
-    tokenIdentifier: string,
-    target: WasmReservationTarget,
+    targets: [string, WasmReservationTarget][],
     preferredOutputs: WasmTokenOutputWithPrevOut[] | null,
     selectionStrategy: string | null
     ) => Promise<WasmTokenOutputs>;
     reserveTokenOutputsByOutpoints: (
-    tokenIdentifier: string,
     outpoints: { prevTxHash: string; prevTxVout: number }[],
     purpose: string
     ) => Promise<WasmTokenOutputsReservation>;
@@ -147,6 +144,20 @@ export interface TokenStore {
     now: () => Promise<number>;
 }
 
+/**
+ * A created credential, plus the PRF outputs when the browser evaluated
+ * them during the create ceremony. `seeds` is null when it did not, so
+ * the caller derives through `deriveSeeds`.
+ *
+ * Seeds returned here must equal what `deriveSeeds` returns for the same
+ * salts: the wallet is derived from them either way, so a mismatch means
+ * register and sign-in land on different wallets.
+ */
+export interface CreatePasskeyOutput {
+    credential: PasskeyCredential;
+    seeds?: Uint8Array[] | null;
+}
+
 /**
  * A passkey credential from `register` or `signIn`. `credentialId` is
  * always set. The attestation fields (`userId`, `aaguid`,
@@ -297,10 +308,14 @@ export interface PrfProvider {
      * `excludeCredentials` lists already-registered IDs; a match raises
      * `PasskeyAlreadyExistsError`.
      *
+     * Evaluating PRF for `salts` in the same ceremony returns the seeds on
+     * `seeds`, and the caller then needs no assertion. Return `seeds: null`
+     * when the authenticator evaluated none, or fewer than one per salt.
+     *
      * @throws `PasskeyAlreadyExistsError` when an entry in
      *   `excludeCredentials` matches a credential already on the device.
      */
-    createPasskey?(excludeCredentials: Uint8Array[]): Promise<PasskeyCredential>;
+    createPasskey?(excludeCredentials: Uint8Array[], salts: string[]): Promise<CreatePasskeyOutput>;
 
     /**
      * Whether this provider can produce PRF outputs on the current
@@ -488,6 +503,17 @@ export interface AuthorizeTransferRequest {
     transfereePubkey: string;
 }
 
+export interface BatchRecipient {
+    paymentRequest: string;
+    amount?: bigint;
+    tokenIdentifier?: string;
+}
+
+export interface BatchTotal {
+    tokenIdentifier?: string;
+    amount: bigint;
+}
+
 export interface Bip21Details {
     amountSat?: number;
     assetId?: string;
@@ -585,6 +611,10 @@ export interface Bolt12OfferDetails {
     signingPubkey?: string;
 }
 
+export interface BuildUnsignedBatchPackageRequest {
+    prepareResponse: PrepareSendBatchResponse;
+}
+
 export interface BuildUnsignedLnurlPayPackageRequest {
     prepareResponse: PrepareLnurlPayResponse;
 }
@@ -1315,6 +1345,15 @@ export interface PrepareLnurlPayResponse {
     feePolicy: FeePolicy;
 }
 
+export interface PrepareSendBatchRequest {
+    recipients: BatchRecipient[];
+}
+
+export interface PrepareSendBatchResponse {
+    recipients: ResolvedBatchRecipient[];
+    totals: BatchTotal[];
+}
+
 export interface PrepareSendPaymentRequest {
     paymentRequest: PaymentRequest;
     amount?: bigint;
@@ -1445,6 +1484,12 @@ export interface RegisterWebhookResponse {
     webhookId: string;
 }
 
+export interface ResolvedBatchRecipient {
+    destination: BatchDestination;
+    amount: bigint;
+    tokenIdentifier?: string;
+}
+
 export interface RestClient {
     getRequest(url: string, headers?: Record<string, string>): Promise<RestResponse>;
     postRequest(url: string, headers?: Record<string, string>, body?: string): Promise<RestResponse>;
@@ -1464,6 +1509,14 @@ export interface SecretBytes {
     bytes: number[];
 }
 
+export interface SendBatchRequest {
+    prepareResponse: PrepareSendBatchResponse;
+}
+
+export interface SendBatchResponse {
+    payments: Payment[];
+}
+
 export interface SendOnchainFeeQuote {
     id: string;
     expiresAt: number;
@@ -1822,6 +1875,8 @@ export type AssetFilter = { type: "bitcoin" } | { type: "token"; tokenIdentifier
 
 export type AutoOptimizationEvent = { type: "started"; totalRounds: number } | { type: "roundCompleted"; currentRound: number; totalRounds: number } | { type: "completed" } | { type: "cancelled" } | { type: "failed"; error: string } | { type: "skipped" };
 
+export type BatchDestination = { type: "sparkAddress"; address: string } | { type: "sparkInvoice"; invoiceDetails: SparkInvoiceDetails };
+
 export type BitcoinNetwork = "bitcoin" | "testnet3" | "testnet4" | "signet" | "regtest";
 
 export type BuildTransferPackageOptions = { type: "bitcoinAddress"; confirmationSpeed: OnchainConfirmationSpeed } | { type: "bolt11Invoice"; preferSpark: boolean; completionTimeoutSecs?: number };
@@ -1906,7 +1961,7 @@ export type ProvisionalPaymentDetails = { type: "bitcoin"; withdrawalAddress: st
 
 export type PublishSignedLnurlPayResponse = { type: "swapCompleted" } | { type: "paymentSent"; response: LnurlPayResponse };
 
-export type PublishSignedTransferPackageResponse = { type: "swapCompleted" } | { type: "paymentSent"; payment: Payment };
+export type PublishSignedTransferPackageResponse = { type: "swapCompleted" } | { type: "paymentSent"; payment: Payment } | { type: "paymentsSent"; payments: 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 };
 
@@ -1944,7 +1999,7 @@ export type TransferTarget = { type: "spark"; address: string; sparkInvoice?: st
 
 export type UnilateralExitTxKind = "fanOut" | "node" | "refund" | "sweep";
 
-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 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 } | { type: "tokenBatch"; prepareTokenTransaction: ExternalPrepareTokenTransactionRequest; tokenContext: number[]; totals: BatchTotal[]; isSwap: boolean };
 
 export type UpdateDepositPayload = { type: "claimError"; error: DepositClaimError } | { type: "refund"; refundTxid: string; refundTx: string };
 
@@ -1979,6 +2034,7 @@ export class BreezSdk {
     addContact(request: AddContactRequest): Promise<Contact>;
     addEventListener(listener: EventListener): Promise<string>;
     authorizeLightningAddressTransfer(request: AuthorizeTransferRequest): Promise<TransferAuthorization>;
+    buildUnsignedBatchPackage(request: BuildUnsignedBatchPackageRequest): Promise<UnsignedTransferPackage>;
     buildUnsignedLnurlPayPackage(request: BuildUnsignedLnurlPayPackageRequest): Promise<UnsignedTransferPackage>;
     buildUnsignedTransferPackage(request: BuildUnsignedTransferPackageRequest): Promise<UnsignedTransferPackage>;
     buyBitcoin(request: BuyBitcoinRequest): Promise<BuyBitcoinResponse>;
@@ -2010,6 +2066,7 @@ export class BreezSdk {
     optimizeLeaves(request: OptimizeLeavesRequest): Promise<OptimizeLeavesResponse>;
     parse(input: string): Promise<InputType>;
     prepareLnurlPay(request: PrepareLnurlPayRequest): Promise<PrepareLnurlPayResponse>;
+    prepareSendBatch(request: PrepareSendBatchRequest): Promise<PrepareSendBatchResponse>;
     prepareSendPayment(request: PrepareSendPaymentRequest): Promise<PrepareSendPaymentResponse>;
     prepareUnilateralExit(request: PrepareUnilateralExitRequest): Promise<PrepareUnilateralExitResponse>;
     publishSignedLnurlPayPackage(request: PublishSignedLnurlPayPackageRequest): Promise<PublishSignedLnurlPayResponse>;
@@ -2021,6 +2078,7 @@ export class BreezSdk {
     registerLightningAddress(request: RegisterLightningAddressRequest): Promise<LightningAddressInfo>;
     registerWebhook(request: RegisterWebhookRequest): Promise<RegisterWebhookResponse>;
     removeEventListener(id: string): Promise<boolean>;
+    sendBatch(request: SendBatchRequest): Promise<SendBatchResponse>;
     sendPayment(request: SendPaymentRequest): Promise<SendPaymentResponse>;
     signMessage(request: SignMessageRequest): Promise<SignMessageResponse>;
     syncWallet(request: SyncWalletRequest): Promise<SyncWalletResponse>;
@@ -2502,6 +2560,7 @@ export interface InitOutput {
     readonly breezsdk_addContact: (a: number, b: any) => any;
     readonly breezsdk_addEventListener: (a: number, b: any) => any;
     readonly breezsdk_authorizeLightningAddressTransfer: (a: number, b: any) => any;
+    readonly breezsdk_buildUnsignedBatchPackage: (a: number, b: any) => any;
     readonly breezsdk_buildUnsignedLnurlPayPackage: (a: number, b: any) => any;
     readonly breezsdk_buildUnsignedTransferPackage: (a: number, b: any) => any;
     readonly breezsdk_buyBitcoin: (a: number, b: any) => any;
@@ -2533,6 +2592,7 @@ export interface InitOutput {
     readonly breezsdk_optimizeLeaves: (a: number, b: any) => any;
     readonly breezsdk_parse: (a: number, b: number, c: number) => any;
     readonly breezsdk_prepareLnurlPay: (a: number, b: any) => any;
+    readonly breezsdk_prepareSendBatch: (a: number, b: any) => any;
     readonly breezsdk_prepareSendPayment: (a: number, b: any) => any;
     readonly breezsdk_prepareUnilateralExit: (a: number, b: any) => any;
     readonly breezsdk_publishSignedLnurlPayPackage: (a: number, b: any) => any;
@@ -2544,6 +2604,7 @@ export interface InitOutput {
     readonly breezsdk_registerLightningAddress: (a: number, b: any) => any;
     readonly breezsdk_registerWebhook: (a: number, b: any) => any;
     readonly breezsdk_removeEventListener: (a: number, b: number, c: number) => any;
+    readonly breezsdk_sendBatch: (a: number, b: any) => any;
     readonly breezsdk_sendPayment: (a: number, b: any) => any;
     readonly breezsdk_signMessage: (a: number, b: any) => any;
     readonly breezsdk_syncWallet: (a: number, b: any) => any;

package/web/breez_sdk_spark_wasm.js

@@ -137,6 +137,14 @@ export class BreezSdk {
         const ret = wasm.breezsdk_authorizeLightningAddressTransfer(this.__wbg_ptr, request);
         return ret;
     }
+    /**
+     * @param {BuildUnsignedBatchPackageRequest} request
+     * @returns {Promise<UnsignedTransferPackage>}
+     */
+    buildUnsignedBatchPackage(request) {
+        const ret = wasm.breezsdk_buildUnsignedBatchPackage(this.__wbg_ptr, request);
+        return ret;
+    }
     /**
      * @param {BuildUnsignedLnurlPayPackageRequest} request
      * @returns {Promise<UnsignedTransferPackage>}
@@ -381,6 +389,14 @@ export class BreezSdk {
         const ret = wasm.breezsdk_prepareLnurlPay(this.__wbg_ptr, request);
         return ret;
     }
+    /**
+     * @param {PrepareSendBatchRequest} request
+     * @returns {Promise<PrepareSendBatchResponse>}
+     */
+    prepareSendBatch(request) {
+        const ret = wasm.breezsdk_prepareSendBatch(this.__wbg_ptr, request);
+        return ret;
+    }
     /**
      * @param {PrepareSendPaymentRequest} request
      * @returns {Promise<PrepareSendPaymentResponse>}
@@ -469,6 +485,14 @@ export class BreezSdk {
         const ret = wasm.breezsdk_removeEventListener(this.__wbg_ptr, ptr0, len0);
         return ret;
     }
+    /**
+     * @param {SendBatchRequest} request
+     * @returns {Promise<SendBatchResponse>}
+     */
+    sendBatch(request) {
+        const ret = wasm.breezsdk_sendBatch(this.__wbg_ptr, request);
+        return ret;
+    }
     /**
      * @param {SendPaymentRequest} request
      * @returns {Promise<SendPaymentResponse>}
@@ -2200,8 +2224,8 @@ function __wbg_get_imports() {
             const ret = createMysqlTreeStoreWithPool(arg0, getArrayU8FromWasm0(arg1, arg2), arg3, arg4, arg5 !== 0);
             return ret;
         }, arguments); },
-        __wbg_createPasskey_5ceae054474c582a: function() { return handleError(function (arg0, arg1) {
-            const ret = arg0.createPasskey(arg1);
+        __wbg_createPasskey_37eb4d30fdaf2a3f: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = arg0.createPasskey(arg1, arg2);
             return ret;
         }, arguments); },
         __wbg_createPostgresPool_3c396c7ab2f0eab2: function() { return handleError(function (arg0) {
@@ -3068,38 +3092,28 @@ function __wbg_get_imports() {
             const ret = module.require;
             return ret;
         }, arguments); },
-        __wbg_reserveTokenOutputsByOutpoints_a18be5f9fb4ab30a: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
+        __wbg_reserveTokenOutputsByOutpoints_2b3aa01becdba378: function() { return handleError(function (arg0, arg1, arg2, arg3) {
             let deferred0_0;
             let deferred0_1;
-            let deferred1_0;
-            let deferred1_1;
             try {
-                deferred0_0 = arg1;
-                deferred0_1 = arg2;
-                deferred1_0 = arg4;
-                deferred1_1 = arg5;
-                const ret = arg0.reserveTokenOutputsByOutpoints(getStringFromWasm0(arg1, arg2), arg3, getStringFromWasm0(arg4, arg5));
+                deferred0_0 = arg2;
+                deferred0_1 = arg3;
+                const ret = arg0.reserveTokenOutputsByOutpoints(arg1, getStringFromWasm0(arg2, arg3));
                 return ret;
             } finally {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
-                wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
             }
         }, arguments); },
-        __wbg_reserveTokenOutputs_233990fbd0ce963a: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
+        __wbg_reserveTokenOutputs_17ba3b5fcc91b000: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
             let deferred0_0;
             let deferred0_1;
-            let deferred1_0;
-            let deferred1_1;
             try {
-                deferred0_0 = arg1;
-                deferred0_1 = arg2;
-                deferred1_0 = arg4;
-                deferred1_1 = arg5;
-                const ret = arg0.reserveTokenOutputs(getStringFromWasm0(arg1, arg2), arg3, getStringFromWasm0(arg4, arg5), arg6, arg7);
+                deferred0_0 = arg2;
+                deferred0_1 = arg3;
+                const ret = arg0.reserveTokenOutputs(arg1, getStringFromWasm0(arg2, arg3), arg4, arg5);
                 return ret;
             } finally {
                 wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
-                wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
             }
         }, arguments); },
         __wbg_resolve_9feb5d906ca62419: function(arg0) {
@@ -3113,17 +3127,9 @@ function __wbg_get_imports() {
             const ret = SdkBuilder.__wrap(arg0);
             return ret;
         },
-        __wbg_selectTokenOutputs_450f20621013b14d: function() { return handleError(function (arg0, arg1, arg2, arg3, arg4, arg5) {
-            let deferred0_0;
-            let deferred0_1;
-            try {
-                deferred0_0 = arg1;
-                deferred0_1 = arg2;
-                const ret = arg0.selectTokenOutputs(getStringFromWasm0(arg1, arg2), arg3, arg4, arg5);
-                return ret;
-            } finally {
-                wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
-            }
+        __wbg_selectTokenOutputs_378aebd65f866d1b: function() { return handleError(function (arg0, arg1, arg2, arg3) {
+            const ret = arg0.selectTokenOutputs(arg1, arg2, arg3);
+            return ret;
         }, arguments); },
         __wbg_send_0edb796d05cd3239: function() { return handleError(function (arg0, arg1, arg2) {
             arg0.send(getStringFromWasm0(arg1, arg2));
@@ -3578,27 +3584,27 @@ function __wbg_get_imports() {
             return ret;
         },
         __wbindgen_cast_0000000000000002: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 389, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [Externref], shim_idx: 392, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h3120db8c4a8a92b2);
             return ret;
         },
         __wbindgen_cast_0000000000000003: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("CloseEvent")], shim_idx: 389, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("CloseEvent")], shim_idx: 392, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h3120db8c4a8a92b2_2);
             return ret;
         },
         __wbindgen_cast_0000000000000004: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("ErrorEvent")], shim_idx: 389, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("ErrorEvent")], shim_idx: 392, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h3120db8c4a8a92b2_3);
             return ret;
         },
         __wbindgen_cast_0000000000000005: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("Event")], shim_idx: 389, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("Event")], shim_idx: 392, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h3120db8c4a8a92b2_4);
             return ret;
         },
         __wbindgen_cast_0000000000000006: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 389, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [NamedExternref("MessageEvent")], shim_idx: 392, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h3120db8c4a8a92b2_5);
             return ret;
         },
@@ -3623,12 +3629,12 @@ function __wbg_get_imports() {
             return ret;
         },
         __wbindgen_cast_000000000000000b: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 394, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 397, ret: Unit, inner_ret: Some(Unit) }, mutable: true }) -> Externref`.
             const ret = makeMutClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h1d6669a7b693932a);
             return ret;
         },
         __wbindgen_cast_000000000000000c: function(arg0, arg1) {
-            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 425, ret: Unit, inner_ret: Some(Unit) }, mutable: false }) -> Externref`.
+            // Cast intrinsic for `Closure(Closure { owned: true, function: Function { arguments: [], shim_idx: 427, ret: Unit, inner_ret: Some(Unit) }, mutable: false }) -> Externref`.
             const ret = makeClosure(arg0, arg1, wasm_bindgen__convert__closures_____invoke__h0fa3f876e31d2a3e);
             return ret;
         },

package/web/breez_sdk_spark_wasm_bg.wasm.d.ts

@@ -21,6 +21,7 @@ export const bitcoinchainservicehandle_recommendedFees: (a: number) => any;
 export const breezsdk_addContact: (a: number, b: any) => any;
 export const breezsdk_addEventListener: (a: number, b: any) => any;
 export const breezsdk_authorizeLightningAddressTransfer: (a: number, b: any) => any;
+export const breezsdk_buildUnsignedBatchPackage: (a: number, b: any) => any;
 export const breezsdk_buildUnsignedLnurlPayPackage: (a: number, b: any) => any;
 export const breezsdk_buildUnsignedTransferPackage: (a: number, b: any) => any;
 export const breezsdk_buyBitcoin: (a: number, b: any) => any;
@@ -52,6 +53,7 @@ export const breezsdk_lnurlWithdraw: (a: number, b: any) => any;
 export const breezsdk_optimizeLeaves: (a: number, b: any) => any;
 export const breezsdk_parse: (a: number, b: number, c: number) => any;
 export const breezsdk_prepareLnurlPay: (a: number, b: any) => any;
+export const breezsdk_prepareSendBatch: (a: number, b: any) => any;
 export const breezsdk_prepareSendPayment: (a: number, b: any) => any;
 export const breezsdk_prepareUnilateralExit: (a: number, b: any) => any;
 export const breezsdk_publishSignedLnurlPayPackage: (a: number, b: any) => any;
@@ -63,6 +65,7 @@ export const breezsdk_refundPendingConversions: (a: number) => any;
 export const breezsdk_registerLightningAddress: (a: number, b: any) => any;
 export const breezsdk_registerWebhook: (a: number, b: any) => any;
 export const breezsdk_removeEventListener: (a: number, b: number, c: number) => any;
+export const breezsdk_sendBatch: (a: number, b: any) => any;
 export const breezsdk_sendPayment: (a: number, b: any) => any;
 export const breezsdk_signMessage: (a: number, b: any) => any;
 export const breezsdk_syncWallet: (a: number, b: any) => any;

package/web/passkey-prf-provider/index.d.ts

@@ -4,11 +4,18 @@ import type {
     PasskeyProviderOptions,
     PrfProvider,
     PasskeyCredential,
+    CreatePasskeyOutput,
     DeriveSeedsResult,
     DeriveSeedOptions
 } from '../breez_sdk_spark_wasm.js';
 
-export type { PasskeyCredential, DeriveSeedsResult, DeriveSeedOptions, PasskeyProviderOptions };
+export type {
+    PasskeyCredential,
+    CreatePasskeyOutput,
+    DeriveSeedsResult,
+    DeriveSeedOptions,
+    PasskeyProviderOptions
+};
 
 /**
  * Outcome of a domain-association check: whether `rpId` is a valid
@@ -135,7 +142,7 @@ export declare class PasskeyProvider {
      *   `excludeCredentials` already exists on the device.
      * @throws If the user cancels or PRF is not supported.
      */
-    createPasskey(excludeCredentials?: Uint8Array[]): Promise<PasskeyCredential>;
+    createPasskey(excludeCredentials?: Uint8Array[], salts?: string[]): Promise<CreatePasskeyOutput>;
 
     /**
      * Check if a PRF-capable passkey is available on this device.

package/web/passkey-prf-provider/index.js

@@ -259,12 +259,19 @@ export class PasskeyProvider {
      * `excludeCredentials` (already-registered IDs) to surface a repeat
      * registration as `PasskeyAlreadyExistsError`.
      *
+     * Asking the create ceremony to evaluate PRF for `salts` removes the
+     * assertion that would otherwise follow it, so registration costs one
+     * prompt instead of two. Browsers that acknowledge PRF without
+     * evaluating return `seeds: null` and the caller derives as before.
+     *
      * @param {Uint8Array[]} [excludeCredentials]
-     * @returns {Promise<PasskeyCredential>} `aaguid`/`backupEligible`
-     *   are null on browsers without `getAuthenticatorData()`.
+     * @param {string[]} [salts] Salts to evaluate during the ceremony.
+     * @returns {Promise<CreatePasskeyOutput>} `aaguid`/`backupEligible`
+     *   are null on browsers without `getAuthenticatorData()`. `seeds` is
+     *   null unless the browser returned one output per salt.
      */
-    async createPasskey(excludeCredentials = []) {
-        return await this._registerCredential(excludeCredentials);
+    async createPasskey(excludeCredentials = [], salts = []) {
+        return await this._registerCredential(excludeCredentials, salts);
     }
 
     /**
@@ -504,10 +511,12 @@ export class PasskeyProvider {
      * @param {Uint8Array[]} [excludeCredentials=[]] - Already-registered
      *   IDs; a match makes the authenticator refuse, preventing a
      *   duplicate registration on the same device.
-     * @returns {Promise<{ credentialId: Uint8Array, userId: Uint8Array, aaguid: Uint8Array | null, backupEligible: boolean | null }>}
+     * @param {string[]} [salts=[]] - Salts to evaluate during the create
+     *   ceremony; omit to register without deriving.
+     * @returns {Promise<{ credential: { credentialId: Uint8Array, userId: Uint8Array, aaguid: Uint8Array | null, backupEligible: boolean | null }, seeds: Uint8Array[] | null }>}
      * @private
      */
-    async _registerCredential(excludeCredentials = []) {
+    async _registerCredential(excludeCredentials = [], salts = []) {
         // Fresh per-call user.id: reusing one across creates on the same
         // rpId silently overwrites the prior credential on some
         // authenticators. (WebAuthn requires 1 to 64 bytes.)
@@ -540,7 +549,18 @@ export class PasskeyProvider {
             authenticatorSelection,
             // Explicit so future security review can't read it as ambient.
             attestation: 'none',
-            extensions: { prf: {} },
+            extensions: {
+                prf: salts.length > 0
+                    ? {
+                        eval: {
+                            first: new TextEncoder().encode(salts[0]),
+                            ...(salts.length > 1
+                                ? { second: new TextEncoder().encode(salts[1]) }
+                                : {}),
+                        },
+                    }
+                    : {},
+            },
         };
 
         if (Array.isArray(this.hints) && this.hints.length > 0) {
@@ -599,12 +619,30 @@ export class PasskeyProvider {
             );
         }
 
+        // Only usable as a complete set: a browser that drops the second
+        // output leaves a partial derive, which is no derive at all, so
+        // fall back to the assertion path rather than half-deriving.
+        let seeds = null;
+        const results = extensionResults.prf.results;
+        if (salts.length > 0 && results && results.first) {
+            const collected = [new Uint8Array(results.first)];
+            if (results.second) {
+                collected.push(new Uint8Array(results.second));
+            }
+            if (collected.length === salts.length) {
+                seeds = collected;
+            }
+        }
+
         const meta = extractRegistrationMetadata(credential);
         return {
-            credentialId: new Uint8Array(credential.rawId),
-            userId: resolvedUserId,
-            aaguid: meta ? meta.aaguid : null,
-            backupEligible: meta ? meta.backupEligible : null,
+            credential: {
+                credentialId: new Uint8Array(credential.rawId),
+                userId: resolvedUserId,
+                aaguid: meta ? meta.aaguid : null,
+                backupEligible: meta ? meta.backupEligible : null,
+            },
+            seeds,
         };
     }