beignet 0.30.1 → 0.30.2

package/dist/cli/beignet-node.js

@@ -6733,34 +6733,82 @@ class BeignetNode extends events_1.EventEmitter {
         }
     }
     listPayments(filter) {
-        let payments = this.paymentRecords().map((p) => this.toPaymentInfo(p));
-        payments.sort((a, b) => b.createdAt - a.createdAt);
-        if (filter) {
-            if (filter.status) {
-                payments = payments.filter((p) => p.status === filter.status);
-            }
-            if (filter.direction) {
-                payments = payments.filter((p) => p.direction === filter.direction);
+        const since = filter?.since;
+        const status = filter?.status || undefined;
+        const direction = filter?.direction || undefined;
+        const metadata = filter?.metadataKey !== undefined
+            ? { key: filter.metadataKey, value: filter.metadataValue }
+            : undefined;
+        const matches = (p) => {
+            if (since !== undefined && p.createdAt < since)
+                return false;
+            if (status && p.status !== status)
+                return false;
+            if (direction && p.direction !== direction)
+                return false;
+            if (!metadata)
+                return true;
+            if (!p.metadata ||
+                !Object.prototype.hasOwnProperty.call(p.metadata, metadata.key)) {
+                return false;
             }
-            if (filter.since !== undefined) {
-                payments = payments.filter((p) => p.createdAt >= filter.since);
+            return (metadata.value === undefined ||
+                p.metadata[metadata.key] === metadata.value);
+        };
+        const live = new Map();
+        for (const p of this.node.listPayments()) {
+            live.set(p.paymentHash.toString('hex'), p);
+        }
+        const newer = (a, b) => a.createdAt > b.createdAt ||
+            (a.createdAt === b.createdAt && a.paymentHash > b.paymentHash);
+        const liveNewestFirst = [...live]
+            .filter(([, p]) => matches(p))
+            .map(([paymentHash, p]) => ({
+            paymentHash,
+            createdAt: p.createdAt,
+            load: () => p
+        }))
+            .sort((a, b) => (newer(a, b) ? -1 : newer(b, a) ? 1 : 0));
+        const rows = this.storage.paymentsNewestFirst(since, {
+            status,
+            direction,
+            metadata
+        });
+        const nextRow = () => {
+            for (let r = rows.next(); !r.done; r = rows.next()) {
+                if (!live.has(r.value.paymentHash))
+                    return r.value;
             }
-            if (filter.metadataKey !== undefined) {
-                if (filter.metadataValue !== undefined) {
-                    payments = payments.filter((p) => p.metadata?.[filter.metadataKey] === filter.metadataValue);
-                }
-                else {
-                    payments = payments.filter((p) => p.metadata !== undefined && filter.metadataKey in p.metadata);
-                }
+            return undefined;
+        };
+        const offset = filter?.offset !== undefined && filter.offset > 0 ? filter.offset : 0;
+        const limit = filter?.limit !== undefined && filter.limit > 0 ? filter.limit : Infinity;
+        const page = [];
+        let skipped = 0;
+        let i = 0;
+        let row = nextRow();
+        while (page.length < limit) {
+            let next;
+            if (i < liveNewestFirst.length &&
+                (!row || newer(liveNewestFirst[i], row))) {
+                next = liveNewestFirst[i++];
+            }
+            else if (row) {
+                next = row;
+                row = nextRow();
             }
-            if (filter.offset !== undefined && filter.offset > 0) {
-                payments = payments.slice(filter.offset);
+            else {
+                break;
             }
-            if (filter.limit !== undefined && filter.limit > 0) {
-                payments = payments.slice(0, filter.limit);
+            if (skipped < offset) {
+                skipped++;
+                continue;
             }
+            const record = next.load();
+            if (record)
+                page.push(this.toPaymentInfo(record));
         }
-        return payments;
+        return page;
     }
     getPayment(paymentHash) {
         const live = this.livePayment(paymentHash);
@@ -6776,16 +6824,6 @@ class BeignetNode extends events_1.EventEmitter {
         const p = this.node.getPayment(Buffer.from(paymentHash, 'hex'));
         return p ? this.toPaymentInfo(p) : null;
     }
-    paymentRecords() {
-        const byHash = new Map();
-        for (const { paymentHash, payment } of this.storage.loadAllPayments()) {
-            byHash.set(paymentHash, payment);
-        }
-        for (const p of this.node.listPayments()) {
-            byHash.set(p.paymentHash.toString('hex'), p);
-        }
-        return [...byHash.values()];
-    }
     durablePaymentFor(err, hashHex) {
         if (!(err instanceof errors_1.BeignetError) ||
             err.code !== errors_1.BeignetErrorCode.DUPLICATE_PAYMENT) {
@@ -7716,6 +7754,9 @@ class BeignetNode extends events_1.EventEmitter {
             throw new errors_1.BeignetError(errors_1.BeignetErrorCode.INVALID_PARAMS, 'budgetSatsPerDay must be a non-negative integer');
         }
         this._checkDraining();
+        if (this.destroyed) {
+            throw new errors_1.BeignetError(errors_1.BeignetErrorCode.NODE_DESTROYED, 'Node is shutting down; no new rebalances accepted');
+        }
         const holdSats = this.node.rebalanceBudgetSatsPerDay(budgetSatsPerDay);
         if (!Number.isInteger(holdSats) || holdSats < 0) {
             throw new errors_1.BeignetError(errors_1.BeignetErrorCode.INVALID_PARAMS, 'autoRebalance.budgetSatsPerDay must be a non-negative integer');