@breeztech/breez-sdk-spark 0.18.0 → 0.19.0

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

@@ -668,7 +668,7 @@ class PostgresTokenStore {
         let outputs = outputRows.rows.map((row) => this._outputFromRow(row));
 
         // Filter by preferred if provided
-        if (preferredOutputs && preferredOutputs.length > 0) {
+        if (preferredOutputs) {
           const preferredOutpoints = new Set(
             preferredOutputs.map((p) => `${p.prevTxHash}:${p.prevTxVout}`)
           );
@@ -677,74 +677,11 @@ class PostgresTokenStore {
           );
         }
 
-        // Select outputs based on target
-        let selectedOutputs;
-
-        if (target.type === "minTotalValue") {
-          const amount = BigInt(target.value);
-
-          // Check sufficiency
-          const totalAvailable = outputs.reduce(
-            (sum, o) => sum + BigInt(o.output.tokenAmount),
-            0n
-          );
-          if (totalAvailable < amount) {
-            throw new TokenStoreError("InsufficientFunds");
-          }
-
-          // Try exact match first
-          const exactMatch = outputs.find(
-            (o) => BigInt(o.output.tokenAmount) === amount
-          );
-          if (exactMatch) {
-            selectedOutputs = [exactMatch];
-          } else {
-            // Sort by selection strategy
-            if (selectionStrategy === "LargestFirst") {
-              outputs.sort(
-                (a, b) =>
-                  Number(BigInt(b.output.tokenAmount) - BigInt(a.output.tokenAmount))
-              );
-            } else {
-              // Default: SmallestFirst
-              outputs.sort(
-                (a, b) =>
-                  Number(BigInt(a.output.tokenAmount) - BigInt(b.output.tokenAmount))
-              );
-            }
-
-            selectedOutputs = [];
-            let remaining = amount;
-            for (const output of outputs) {
-              if (remaining <= 0n) break;
-              selectedOutputs.push(output);
-              remaining -= BigInt(output.output.tokenAmount);
-            }
-            if (remaining > 0n) {
-              throw new TokenStoreError("InsufficientFunds");
-            }
-          }
-        } else if (target.type === "maxOutputCount") {
-          const count = target.value;
-
-          // Sort by selection strategy
-          if (selectionStrategy === "LargestFirst") {
-            outputs.sort(
-              (a, b) =>
-                Number(BigInt(b.output.tokenAmount) - BigInt(a.output.tokenAmount))
-            );
-          } else {
-            // Default: SmallestFirst
-            outputs.sort(
-              (a, b) =>
-                Number(BigInt(a.output.tokenAmount) - BigInt(b.output.tokenAmount))
-            );
-          }
-
-          selectedOutputs = outputs.slice(0, count);
-        } else {
-          throw new TokenStoreError(`Unknown target type: ${target.type}`);
-        }
+        const selectedOutputs = this._selectOutputs(
+          outputs,
+          target,
+          selectionStrategy
+        );
 
         // Create reservation
         const reservationId = this._generateId();
@@ -785,6 +722,207 @@ class PostgresTokenStore {
     }
   }
 
+  _selectOutputs(outputs, target, selectionStrategy) {
+    if (target.type === "minTotalValue") {
+      const amount = BigInt(target.value);
+      const totalAvailable = outputs.reduce(
+        (sum, o) => sum + BigInt(o.output.tokenAmount),
+        0n
+      );
+      if (totalAvailable < amount) {
+        throw new TokenStoreError("InsufficientFunds");
+      }
+
+      const exactMatch = outputs.find(
+        (o) => BigInt(o.output.tokenAmount) === amount
+      );
+      if (exactMatch) {
+        return [exactMatch];
+      }
+
+      if (selectionStrategy === "LargestFirst") {
+        outputs.sort(
+          (a, b) =>
+            Number(BigInt(b.output.tokenAmount) - BigInt(a.output.tokenAmount))
+        );
+      } else {
+        outputs.sort(
+          (a, b) =>
+            Number(BigInt(a.output.tokenAmount) - BigInt(b.output.tokenAmount))
+        );
+      }
+
+      const selected = [];
+      let remaining = amount;
+      for (const output of outputs) {
+        if (remaining <= 0n) break;
+        selected.push(output);
+        remaining -= BigInt(output.output.tokenAmount);
+      }
+      if (remaining > 0n) {
+        throw new TokenStoreError("InsufficientFunds");
+      }
+      return selected;
+    }
+
+    if (target.type === "maxOutputCount") {
+      const count = target.value;
+      if (selectionStrategy === "LargestFirst") {
+        outputs.sort(
+          (a, b) =>
+            Number(BigInt(b.output.tokenAmount) - BigInt(a.output.tokenAmount))
+        );
+      } else {
+        outputs.sort(
+          (a, b) =>
+            Number(BigInt(a.output.tokenAmount) - BigInt(b.output.tokenAmount))
+        );
+      }
+      return outputs.slice(0, count);
+    }
+
+    throw new TokenStoreError(`Unknown target type: ${target.type}`);
+  }
+
+  async selectTokenOutputs(
+    tokenIdentifier,
+    target,
+    preferredOutputs,
+    selectionStrategy
+  ) {
+    try {
+      if (target.type === "minTotalValue" && (!target.value || target.value === "0")) {
+        throw new TokenStoreError("Amount to reserve must be greater than zero");
+      }
+      if (target.type === "maxOutputCount" && (!target.value || target.value === 0)) {
+        throw new TokenStoreError("Count to reserve must be greater than zero");
+      }
+
+      const metadataResult = await this.pool.query(
+        "SELECT * FROM brz_token_metadata WHERE user_id = $1 AND identifier = $2",
+        [this.identity, tokenIdentifier]
+      );
+      if (metadataResult.rows.length === 0) {
+        throw new TokenStoreError(
+          `Token outputs not found for identifier: ${tokenIdentifier}`
+        );
+      }
+      const metadata = this._metadataFromRow(metadataResult.rows[0]);
+
+      const outputRows = await this.pool.query(
+        `SELECT o.owner_public_key, o.revocation_commitment,
+                o.withdraw_bond_sats, o.withdraw_relative_block_locktime,
+                o.token_public_key, o.token_amount, o.token_identifier,
+                o.prev_tx_hash, o.prev_tx_vout
+         FROM brz_token_outputs o
+         WHERE o.user_id = $1
+           AND o.token_identifier = $2
+           AND o.reservation_id IS NULL`,
+        [this.identity, tokenIdentifier]
+      );
+
+      let outputs = outputRows.rows.map((row) => this._outputFromRow(row));
+
+      if (preferredOutputs) {
+        const preferredOutpoints = new Set(
+          preferredOutputs.map((p) => `${p.prevTxHash}:${p.prevTxVout}`)
+        );
+        outputs = outputs.filter((o) =>
+          preferredOutpoints.has(`${o.prevTxHash}:${o.prevTxVout}`)
+        );
+      }
+
+      const selectedOutputs = this._selectOutputs(
+        outputs,
+        target,
+        selectionStrategy
+      );
+      return { metadata, outputs: selectedOutputs };
+    } catch (error) {
+      if (error instanceof TokenStoreError) throw error;
+      throw new TokenStoreError(
+        `Failed to select token outputs: ${error.message}`,
+        error
+      );
+    }
+  }
+
+  async reserveTokenOutputsByOutpoints(tokenIdentifier, outpoints, purpose) {
+    try {
+      if (!outpoints || outpoints.length === 0) {
+        throw new TokenStoreError("No outpoints provided");
+      }
+      return await this._withWriteTransaction(async (client) => {
+        const metadataResult = await client.query(
+          "SELECT * FROM brz_token_metadata WHERE user_id = $1 AND identifier = $2",
+          [this.identity, tokenIdentifier]
+        );
+        if (metadataResult.rows.length === 0) {
+          throw new TokenStoreError(
+            `Token outputs not found for identifier: ${tokenIdentifier}`
+          );
+        }
+        const metadata = this._metadataFromRow(metadataResult.rows[0]);
+
+        const txHashes = outpoints.map((o) => o.prevTxHash);
+        const vouts = outpoints.map((o) => o.prevTxVout);
+        const outputRows = await client.query(
+          `SELECT o.owner_public_key, o.revocation_commitment,
+                  o.withdraw_bond_sats, o.withdraw_relative_block_locktime,
+                  o.token_public_key, o.token_amount, o.token_identifier,
+                  o.prev_tx_hash, o.prev_tx_vout
+           FROM brz_token_outputs o
+           WHERE o.user_id = $1
+             AND o.token_identifier = $2
+             AND o.reservation_id IS NULL
+             AND (o.prev_tx_hash, o.prev_tx_vout) IN (
+               SELECT * FROM UNNEST($3::text[], $4::int[])
+             )`,
+          [this.identity, tokenIdentifier, txHashes, vouts]
+        );
+
+        const selectedOutputs = outputRows.rows.map((row) =>
+          this._outputFromRow(row)
+        );
+
+        const distinct = new Set(
+          outpoints.map((o) => `${o.prevTxHash}:${o.prevTxVout}`)
+        );
+        if (selectedOutputs.length !== distinct.size) {
+          throw new TokenStoreError("InsufficientFunds");
+        }
+
+        const reservationId = this._generateId();
+        await client.query(
+          "INSERT INTO brz_token_reservations (user_id, id, purpose) VALUES ($1, $2, $3)",
+          [this.identity, reservationId, purpose]
+        );
+        await client.query(
+          `UPDATE brz_token_outputs SET reservation_id = $1
+           WHERE user_id = $4
+             AND (prev_tx_hash, prev_tx_vout) IN (
+               SELECT * FROM UNNEST($2::text[], $3::int[])
+             )`,
+          [reservationId, txHashes, vouts, this.identity]
+        );
+
+        return {
+          id: reservationId,
+          tokenOutputs: {
+            metadata,
+            outputs: selectedOutputs,
+          },
+        };
+      });
+    } catch (error) {
+      if (error instanceof TokenStoreError) throw error;
+      throw new TokenStoreError(
+        `Failed to reserve token outputs by outpoints: ${error.message}`,
+        error
+      );
+    }
+  }
+
   /**
    * Cancel a reservation, releasing reserved outputs.
    * @param {string} id - Reservation ID

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

@@ -40,6 +40,35 @@ const RESERVATION_TIMEOUT_SECS = 300; // 5 minutes
  */
 const SPENT_MARKER_CLEANUP_THRESHOLD_MS = 5 * 60 * 1000; // 5 minutes
 
+/**
+ * Slim projection: only (id, value) for leaves the selection might use.
+ * Includes all leaves with value <= $2 (covers exact-match + the small-leaf
+ * accumulators for the minimum-amount path) plus the single smallest leaf
+ * with value > $2 (covers the minimum-amount fallback case where one larger
+ * leaf is sufficient). $1 is the user id.
+ */
+const SLIM_LEAF_CANDIDATES_SQL = `
+  SELECT id, (data->>'value')::bigint AS value
+  FROM brz_tree_leaves
+  WHERE user_id = $1
+    AND status = 'Available'
+    AND is_missing_from_operators = FALSE
+    AND reservation_id IS NULL
+    AND (
+      (data->>'value')::bigint <= $2
+      OR id = (
+        SELECT id FROM brz_tree_leaves
+        WHERE user_id = $1
+          AND status = 'Available'
+          AND is_missing_from_operators = FALSE
+          AND reservation_id IS NULL
+          AND (data->>'value')::bigint > $2
+        ORDER BY (data->>'value')::bigint
+        LIMIT 1
+      )
+    )
+`;
+
 /**
  * Derive a stable per-tenant 64-bit advisory-lock key by hashing a domain
  * prefix together with the identity pubkey and folding the first 8 bytes of
@@ -217,6 +246,34 @@ class PostgresTreeStore {
     }
   }
 
+  async getVerifiedLeafKeys() {
+    try {
+      // Project just the two pubkeys out of the JSON, skipping each leaf's
+      // `data` blob (up to five transactions). The filter matches the verified
+      // categories the SDK expects: every reserved leaf plus every Available
+      // one, and nothing non-Available and unreserved.
+      const result = await this.pool.query(
+        `
+        SELECT l.id AS id,
+               l.data->>'verifying_public_key' AS verifying,
+               l.data->'signing_keyshare'->>'public_key' AS keyshare
+        FROM brz_tree_leaves l
+        LEFT JOIN brz_tree_reservations r
+          ON l.reservation_id = r.id AND l.user_id = r.user_id
+        WHERE l.user_id = $1
+          AND (r.purpose IS NOT NULL OR l.status = 'Available')
+      `,
+        [this.identity]
+      );
+      return result.rows.map((row) => [row.id, row.verifying, row.keyshare]);
+    } catch (error) {
+      throw new TreeStoreError(
+        `Failed to get verified leaf keys: ${error.message}`,
+        error
+      );
+    }
+  }
+
   async getLeaves() {
     try {
       const result = await this.pool.query(
@@ -485,35 +542,10 @@ class PostgresTreeStore {
         );
         const available = Number(totalResult.rows[0].total);
 
-        // Slim projection: only (id, value) for leaves the selection might use.
-        // Includes all leaves with value <= maxTarget (covers exact-match + the
-        // small-leaf accumulators for the minimum-amount path) plus the single
-        // smallest leaf with value > maxTarget (covers the minimum-amount
-        // fallback case where one larger leaf is sufficient).
-        const slimResult = await client.query(
-          `
-          SELECT id, (data->>'value')::bigint AS value
-          FROM brz_tree_leaves
-          WHERE user_id = $1
-            AND status = 'Available'
-            AND is_missing_from_operators = FALSE
-            AND reservation_id IS NULL
-            AND (
-              (data->>'value')::bigint <= $2
-              OR id = (
-                SELECT id FROM brz_tree_leaves
-                WHERE user_id = $1
-                  AND status = 'Available'
-                  AND is_missing_from_operators = FALSE
-                  AND reservation_id IS NULL
-                  AND (data->>'value')::bigint > $2
-                ORDER BY (data->>'value')::bigint
-                LIMIT 1
-              )
-            )
-        `,
-          [this.identity, maxTarget]
-        );
+        const slimResult = await client.query(SLIM_LEAF_CANDIDATES_SQL, [
+          this.identity,
+          maxTarget,
+        ]);
 
         const slimLeaves = slimResult.rows.map((r) => ({
           id: r.id,
@@ -594,6 +626,87 @@ class PostgresTreeStore {
     }
   }
 
+  async trySelectLeaves(targetAmounts) {
+    try {
+      const targetAmount = targetAmounts ? this._totalSats(targetAmounts) : 0;
+      const maxTarget = this._maxTargetForPrefilter(targetAmounts);
+
+      return await this._withTransaction(async (client) => {
+        const slimResult = await client.query(SLIM_LEAF_CANDIDATES_SQL, [
+          this.identity,
+          maxTarget,
+        ]);
+
+        const slimLeaves = slimResult.rows.map((r) => ({
+          id: r.id,
+          value: Number(r.value),
+        }));
+
+        const selected = this._selectLeavesByTargetAmounts(slimLeaves, targetAmounts);
+        if (selected !== null && selected.length > 0) {
+          const fullLeaves = await this._fetchFullLeavesByIds(
+            client,
+            selected.map((l) => l.id)
+          );
+          return { type: "exact", leaves: fullLeaves };
+        }
+
+        const minSelected = this._selectLeavesByMinimumAmount(slimLeaves, targetAmount);
+        if (minSelected !== null) {
+          const fullLeaves = await this._fetchFullLeavesByIds(
+            client,
+            minSelected.map((l) => l.id)
+          );
+          return { type: "swapNeeded", leaves: fullLeaves };
+        }
+
+        return { type: "insufficientFunds" };
+      });
+    } catch (error) {
+      if (error instanceof TreeStoreError) throw error;
+      throw new TreeStoreError(
+        `Failed to try select leaves: ${error.message}`,
+        error
+      );
+    }
+  }
+
+  async tryReserveLeavesByIds(leafIds, purpose) {
+    try {
+      return await this._withWriteTransaction(async (client) => {
+        if (!leafIds || leafIds.length === 0) {
+          throw new TreeStoreError("NonReservableLeaves");
+        }
+        // Every requested leaf must be available and unreserved; otherwise
+        // reserve nothing (the transaction rolls back).
+        const availableResult = await client.query(
+          `
+          SELECT id FROM brz_tree_leaves
+          WHERE user_id = $1
+            AND id = ANY($2)
+            AND status = 'Available'
+            AND is_missing_from_operators = FALSE
+            AND reservation_id IS NULL
+        `,
+          [this.identity, leafIds]
+        );
+        if (availableResult.rows.length !== leafIds.length) {
+          throw new TreeStoreError("NonReservableLeaves");
+        }
+        const fullLeaves = await this._fetchFullLeavesByIds(client, leafIds);
+        const reservationId = this._generateId();
+        await this._createReservation(client, reservationId, fullLeaves, purpose, 0);
+        return { id: reservationId, leaves: fullLeaves };
+      });
+    } catch (error) {
+      if (error instanceof TreeStoreError) throw error;
+      throw new TreeStoreError(
+        `Failed to try reserve leaves by ids: ${error.message}`,
+        error
+      );
+    }
+  }
+
   _maxTargetForPrefilter(targetAmounts) {
     if (!targetAmounts) return Number.MAX_SAFE_INTEGER;
     if (targetAmounts.type === "amountAndFee") {
@@ -612,10 +725,23 @@ class PostgresTreeStore {
   async _fetchFullLeavesByIds(client, ids) {
     if (!ids || ids.length === 0) return [];
     const result = await client.query(
-      "SELECT data FROM brz_tree_leaves WHERE user_id = $2 AND id = ANY($1)",
+      "SELECT id, data FROM brz_tree_leaves WHERE user_id = $2 AND id = ANY($1)",
       [ids, this.identity]
     );
-    return result.rows.map((r) => r.data);
+    const byId = new Map(result.rows.map((r) => [r.id, r.data]));
+    const ordered = ids
+      .map((id) => {
+        const data = byId.get(id);
+        byId.delete(id);
+        return data;
+      })
+      .filter((data) => data !== undefined);
+    if (ordered.length !== ids.length) {
+      throw new TreeStoreError(
+        `Could not resolve full data for all selected leaves (wanted ${ids.length}, got ${ordered.length})`
+      );
+    }
+    return ordered;
   }
 
   /**

package/package.json

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

package/ssr/index.js

@@ -73,6 +73,11 @@ export function defaultServerConfig(...args) {
   return _module.defaultServerConfig(...args);
 }
 
+export function defaultSessionStore(...args) {
+  if (!_module) _notInitialized('defaultSessionStore');
+  return _module.defaultSessionStore(...args);
+}
+
 export function defaultStorage(...args) {
   if (!_module) _notInitialized('defaultStorage');
   return _module.defaultStorage(...args);
@@ -137,6 +142,13 @@ export class BreezSdk {
   }
 }
 
+export class DefaultSessionStore {
+  constructor(...args) {
+    if (!_module) _notInitialized('new DefaultSessionStore');
+    return new _module.DefaultSessionStore(...args);
+  }
+}
+
 export class ExternalBreezSignerHandle {
   constructor(...args) {
     if (!_module) _notInitialized('new ExternalBreezSignerHandle');