diff --git a/docs/performance/transfer-filter-preparation-20261004/README.md b/docs/performance/transfer-filter-preparation-20261004/README.md
new file mode 100644
index 0000000..b2cba58
--- /dev/null
+++ b/docs/performance/transfer-filter-preparation-20261004/README.md
@@ -0,0 +1,40 @@
+# Query-invariant transfer filter preparation
+
+Continuation of RemitFlow Frontend #281 on the existing PR #298. The earlier bounded-heap selector is retained; this comparison starts from that already-optimized implementation, not the old full sort.
+
+The status alias, folded search term and date-window cutoff are prepared once per invocation. Rows are still read and matched on every query; no result cache or stale-window reuse is introduced. Empty filters bypass the matcher. Actor visibility, returned row identity, stable top-k membership, totals and scope keys are retained.
+
+## Focused native execution
+
+Node v22.23.3; Vitest 4.1.10; Prettier 3.9.6; linux/x64; AMD EPYC 7763 64-Core Processor.
+The existing 11 utility cases and two new maintained regressions passed together: **13 passed, zero failures or skipped tests**. The new cases cover one clock read per query, inclusive date boundaries, fresh time on subsequent calls, unbounded presets and invalid/oversized windows.
+The original repository Vite configuration, jsdom setup and locked dependencies were used. Only these two utility test files ran; no full application suite, build, browser or provider execution is claimed.
+
+[Execution run](https://github.com/woahwhattheheck/RemitFlow-Frontend/actions/runs/37200367081). Candidate before formatting: b3af1368de7e2d043a79ae49fe912584375eadfa. Tests and timings below executed the formatted files committed with this report.
+
+## Complete-selector timings
+
+Synthetic histories; three warmups followed by nine paired samples with alternating order. Fixture creation, assertions, garbage collection and operation counting are outside the timed selector call. All paired outputs and row references matched; a further 10,368 untimed compatibility comparisons passed.
+
+| Workload | Baseline ms | Prepared ms | Time reduction |
+| ---------------------- | ----------: | ----------: | -------------: |
+| 5k all time | 3.753 | 3.100 | 17.40% |
+| 100k all time | 38.884 | 30.025 | 22.78% |
+| 100k date window | 77.677 | 41.512 | 46.56% |
+| 100k status and search | 23.599 | 20.468 | 13.27% |
+| 100k combined filters | 37.811 | 26.264 | 30.54% |
+
+All raw paired samples, output digests, source Git blobs and separately measured operation counts are in [results.json](results.json). Negative reductions, if present, are regressions, not speedups. These measurements exclude localStorage decoding, schema validation, the simulated API delay, React rendering and network/provider work; they are not whole-page or fleet-throughput results.
+
+An earlier local prototype without the empty-filter bypass regressed the 5,000-row all-time case by 15.93% in one paired measurement. That prototype was rejected. The revised local pass measured 1.536 versus 1.542 ms for that small workload (effectively unchanged), 69.875 versus 40.020 ms for the 100,000-row date window and 32.628 versus 22.354 ms for combined filters. Those exploratory Node 22.16.0 observations are separate from the source-bound execution above.
+
+## Reproduce
+
+```bash
+git show ecefe06d68ca6838434b755525cfc3cc6c701d4f:src/utils/transferSearch.js > src/utils/transferSearch.baseline.js
+node --expose-gc scripts/bench-transfer-filter-preparation.mjs src/utils/transferSearch.baseline.js
+npx vitest run test/unit/transfer-search.test.js test/unit/transfer-filter-preparation.test.js
+rm src/utils/transferSearch.baseline.js
+```
+
+No existing test, package manifest, lockfile, UI or API path was changed. The temporary execution workflow is not part of the product result. Original contribution and claim custody remain unchanged; this report establishes neither maintainer acceptance nor an award/payment.
diff --git a/docs/performance/transfer-filter-preparation-20261004/results.json b/docs/performance/transfer-filter-preparation-20261004/results.json
new file mode 100644
index 0000000..ab2568c
--- /dev/null
+++ b/docs/performance/transfer-filter-preparation-20261004/results.json
@@ -0,0 +1,383 @@
+{
+ "schema": "transfer-filter-preparation-benchmark/v1",
+ "executed_at": "2026-10-04T11:56:10.496Z",
+ "node": "v22.23.3",
+ "platform": "linux/x64",
+ "cpu": "AMD EPYC 7763 64-Core Processor",
+ "source": {
+ "baseline_blob": "a75e2e4fe88e16cb0b03ed97aa0a1c18dbba1274",
+ "candidate_blob": "f072d7879d4bceb74d3635f6bfda0797e7f549a0"
+ },
+ "method": "3 warmups; 9 paired samples, alternating order; synthetic fixed records; setup/assertions/GC/counting outside timed calls",
+ "scope": "Complete production applyTransferSearch and its actual dependency modules, not storage/API/React/browser/provider latency.",
+ "compatibility_checks": 10368,
+ "observations": [
+ {
+ "name": "5k all time",
+ "rows": 5000,
+ "query": {
+ "actorId": "demo"
+ },
+ "total_matched": 4288,
+ "returned": 100,
+ "baseline_median_ms": 3.7526440000000036,
+ "candidate_median_ms": 3.0997669999999857,
+ "reduction_percent": 17.397786733833996,
+ "operation_counts": {
+ "baseline": {
+ "date_constructions": 0,
+ "lowercase_calls": 4288,
+ "string_match_calls": 4288
+ },
+ "candidate": {
+ "date_constructions": 0,
+ "lowercase_calls": 1,
+ "string_match_calls": 1
+ }
+ },
+ "result_sha256": "af8fc4354239ad98cc6421adcdd67840ffcfd6f57d63e1397062a3115b9113b6",
+ "pairs": [
+ {
+ "order": ["baseline", "candidate"],
+ "baseline": 3.7526440000000036,
+ "candidate": 5.348464000000007
+ },
+ {
+ "order": ["candidate", "baseline"],
+ "candidate": 3.5111739999999827,
+ "baseline": 3.810030999999981
+ },
+ {
+ "order": ["baseline", "candidate"],
+ "baseline": 3.834937000000025,
+ "candidate": 3.110306000000037
+ },
+ {
+ "order": ["candidate", "baseline"],
+ "candidate": 3.0997669999999857,
+ "baseline": 3.839615999999978
+ },
+ {
+ "order": ["baseline", "candidate"],
+ "baseline": 2.1969440000000304,
+ "candidate": 1.7528870000000438
+ },
+ {
+ "order": ["candidate", "baseline"],
+ "candidate": 2.3584249999999543,
+ "baseline": 3.0319599999999696
+ },
+ {
+ "order": ["baseline", "candidate"],
+ "baseline": 2.705592000000024,
+ "candidate": 3.094547000000034
+ },
+ {
+ "order": ["candidate", "baseline"],
+ "candidate": 3.2347990000000095,
+ "baseline": 3.7058159999999702
+ },
+ {
+ "order": ["baseline", "candidate"],
+ "baseline": 3.8358690000000024,
+ "candidate": 3.0322309999999675
+ }
+ ]
+ },
+ {
+ "name": "100k all time",
+ "rows": 100000,
+ "query": {
+ "actorId": "demo"
+ },
+ "total_matched": 85714,
+ "returned": 100,
+ "baseline_median_ms": 38.88385699999981,
+ "candidate_median_ms": 30.024726999999984,
+ "reduction_percent": 22.783567998410923,
+ "operation_counts": {
+ "baseline": {
+ "date_constructions": 0,
+ "lowercase_calls": 85714,
+ "string_match_calls": 85714
+ },
+ "candidate": {
+ "date_constructions": 0,
+ "lowercase_calls": 1,
+ "string_match_calls": 1
+ }
+ },
+ "result_sha256": "e70cbd4515bd5b7a648f095dde799467c191ef6591ba8d60c8b88b342409cb90",
+ "pairs": [
+ {
+ "order": ["baseline", "candidate"],
+ "baseline": 41.91509599999995,
+ "candidate": 33.09540900000002
+ },
+ {
+ "order": ["candidate", "baseline"],
+ "candidate": 31.61123299999997,
+ "baseline": 43.19093299999997
+ },
+ {
+ "order": ["baseline", "candidate"],
+ "baseline": 36.904979000000026,
+ "candidate": 29.873694999999998
+ },
+ {
+ "order": ["candidate", "baseline"],
+ "candidate": 29.382939999999962,
+ "baseline": 37.878693999999996
+ },
+ {
+ "order": ["baseline", "candidate"],
+ "baseline": 37.82792900000004,
+ "candidate": 29.612397999999985
+ },
+ {
+ "order": ["candidate", "baseline"],
+ "candidate": 32.902851000000055,
+ "baseline": 41.05498299999999
+ },
+ {
+ "order": ["baseline", "candidate"],
+ "baseline": 36.653589999999895,
+ "candidate": 29.378081000000066
+ },
+ {
+ "order": ["candidate", "baseline"],
+ "candidate": 30.024726999999984,
+ "baseline": 38.88385699999981
+ },
+ {
+ "order": ["baseline", "candidate"],
+ "baseline": 40.884575999999925,
+ "candidate": 32.89763100000005
+ }
+ ]
+ },
+ {
+ "name": "100k date window",
+ "rows": 100000,
+ "query": {
+ "actorId": "demo",
+ "range": "30d"
+ },
+ "total_matched": 21445,
+ "returned": 100,
+ "baseline_median_ms": 77.67733499999986,
+ "candidate_median_ms": 41.512255000000096,
+ "reduction_percent": 46.55808544410004,
+ "operation_counts": {
+ "baseline": {
+ "date_constructions": 171428,
+ "lowercase_calls": 85714,
+ "string_match_calls": 85714
+ },
+ "candidate": {
+ "date_constructions": 85715,
+ "lowercase_calls": 1,
+ "string_match_calls": 1
+ }
+ },
+ "result_sha256": "74024fb5b745a035677c5a899ffca5d562db9816715203d1d2aacd66db985ad0",
+ "pairs": [
+ {
+ "order": ["baseline", "candidate"],
+ "baseline": 77.11932500000012,
+ "candidate": 42.58652699999993
+ },
+ {
+ "order": ["candidate", "baseline"],
+ "candidate": 39.15601400000014,
+ "baseline": 76.42492099999981
+ },
+ {
+ "order": ["baseline", "candidate"],
+ "baseline": 80.41769300000033,
+ "candidate": 43.91076500000008
+ },
+ {
+ "order": ["candidate", "baseline"],
+ "candidate": 38.1670610000001,
+ "baseline": 74.1527659999997
+ },
+ {
+ "order": ["baseline", "candidate"],
+ "baseline": 80.388508,
+ "candidate": 41.512255000000096
+ },
+ {
+ "order": ["candidate", "baseline"],
+ "candidate": 41.521818999999596,
+ "baseline": 77.67733499999986
+ },
+ {
+ "order": ["baseline", "candidate"],
+ "baseline": 78.02949099999978,
+ "candidate": 39.358372000000145
+ },
+ {
+ "order": ["candidate", "baseline"],
+ "candidate": 42.156524999999874,
+ "baseline": 74.95974699999988
+ },
+ {
+ "order": ["baseline", "candidate"],
+ "baseline": 77.83227399999987,
+ "candidate": 39.81588000000011
+ }
+ ]
+ },
+ {
+ "name": "100k status and search",
+ "rows": 100000,
+ "query": {
+ "actorId": "demo",
+ "status": "submitted",
+ "search": " ALICE "
+ },
+ "total_matched": 22857,
+ "returned": 100,
+ "baseline_median_ms": 23.599294999999984,
+ "candidate_median_ms": 20.46779400000014,
+ "reduction_percent": 13.269468431153753,
+ "operation_counts": {
+ "baseline": {
+ "date_constructions": 0,
+ "lowercase_calls": 68570,
+ "string_match_calls": 22857
+ },
+ "candidate": {
+ "date_constructions": 0,
+ "lowercase_calls": 34286,
+ "string_match_calls": 1
+ }
+ },
+ "result_sha256": "274de23d2629ae95bc92c3234c680e046caff8acb836956fe2f17e30c96736a7",
+ "pairs": [
+ {
+ "order": ["baseline", "candidate"],
+ "baseline": 29.14542900000015,
+ "candidate": 22.70290299999988
+ },
+ {
+ "order": ["candidate", "baseline"],
+ "candidate": 19.512673000000177,
+ "baseline": 29.16711899999973
+ },
+ {
+ "order": ["baseline", "candidate"],
+ "baseline": 22.40157100000033,
+ "candidate": 19.63978999999972
+ },
+ {
+ "order": ["candidate", "baseline"],
+ "candidate": 20.533166000000165,
+ "baseline": 23.599294999999984
+ },
+ {
+ "order": ["baseline", "candidate"],
+ "baseline": 22.065374000000247,
+ "candidate": 20.46779400000014
+ },
+ {
+ "order": ["candidate", "baseline"],
+ "candidate": 19.539984000000004,
+ "baseline": 21.87729300000001
+ },
+ {
+ "order": ["baseline", "candidate"],
+ "baseline": 28.005221999999776,
+ "candidate": 20.249667000000045
+ },
+ {
+ "order": ["candidate", "baseline"],
+ "candidate": 23.231468999999834,
+ "baseline": 24.938012000000526
+ },
+ {
+ "order": ["baseline", "candidate"],
+ "baseline": 21.595057000000452,
+ "candidate": 21.847137000000657
+ }
+ ]
+ },
+ {
+ "name": "100k combined filters",
+ "rows": 100000,
+ "query": {
+ "actorId": "demo",
+ "status": "settled",
+ "search": " ALICE ",
+ "range": "90d",
+ "limit": 500
+ },
+ "total_matched": 17145,
+ "returned": 500,
+ "baseline_median_ms": 37.81098099999963,
+ "candidate_median_ms": 26.264164999999593,
+ "reduction_percent": 30.53826082957263,
+ "operation_counts": {
+ "baseline": {
+ "date_constructions": 45714,
+ "lowercase_calls": 68572,
+ "string_match_calls": 22857
+ },
+ "candidate": {
+ "date_constructions": 22858,
+ "lowercase_calls": 34287,
+ "string_match_calls": 1
+ }
+ },
+ "result_sha256": "c18859b9b94bbbef72690fbdd332764c4fb3c1ace6e617a2c15e4e60118cce45",
+ "pairs": [
+ {
+ "order": ["baseline", "candidate"],
+ "baseline": 36.961607000000186,
+ "candidate": 25.90255100000013
+ },
+ {
+ "order": ["candidate", "baseline"],
+ "candidate": 25.181555000000117,
+ "baseline": 37.81098099999963
+ },
+ {
+ "order": ["baseline", "candidate"],
+ "baseline": 40.81570499999998,
+ "candidate": 30.698475999999573
+ },
+ {
+ "order": ["candidate", "baseline"],
+ "candidate": 26.264164999999593,
+ "baseline": 40.82644600000003
+ },
+ {
+ "order": ["baseline", "candidate"],
+ "baseline": 43.52538200000072,
+ "candidate": 28.478516000000127
+ },
+ {
+ "order": ["candidate", "baseline"],
+ "candidate": 24.604769999999917,
+ "baseline": 37.18445199999951
+ },
+ {
+ "order": ["baseline", "candidate"],
+ "baseline": 36.857842999999775,
+ "candidate": 25.36314500000026
+ },
+ {
+ "order": ["candidate", "baseline"],
+ "candidate": 35.77864199999931,
+ "baseline": 37.269722
+ },
+ {
+ "order": ["baseline", "candidate"],
+ "baseline": 43.32392400000026,
+ "candidate": 28.913426000000072
+ }
+ ]
+ }
+ ]
+}
diff --git a/docs/performance/transfer-search-20261004/README.md b/docs/performance/transfer-search-20261004/README.md
new file mode 100644
index 0000000..c2486f8
--- /dev/null
+++ b/docs/performance/transfer-search-20261004/README.md
@@ -0,0 +1,88 @@
+# Capped transfer search performance
+
+Issue: [RemitFlow Frontend #281](https://github.com/RemitFlow/RemitFlow-Frontend/issues/281)
+Existing submission: [PR #298](https://github.com/RemitFlow/RemitFlow-Frontend/pull/298)
+
+`applyTransferSearch` previously built two full arrays, sorted every matching
+transfer and then returned at most 500 rows. Its comparator reparsed each
+timestamp on every comparison. Large unsorted histories therefore spent most
+of their query time sorting rows that would never be returned.
+
+The selector now scans the history once and retains only the best requested
+rows in a bounded heap. It parses each matching timestamp once, sorts the
+retained rows, and still counts every match. The public `stableSortTransfers`
+helper and the actor, status, search and date predicates are unchanged.
+
+## Observed production-module timings
+
+Node **24.19.0**, Linux x64. Each row below is the median of five paired
+measurements, alternating execution order after one warmup per version.
+Fixtures, garbage collection and output assertions were outside the timed
+call. The timed function is the actual imported `applyTransferSearch`.
+
+| History | Result cap | Before, ms | After, ms | Speedup |
+| ------------------------------ | ---------: | ---------: | --------: | ------: |
+| 5,000 shuffled transfers | 100 | 22.827 | 2.484 | 9.19x |
+| 100,000 shuffled transfers | 100 | 776.075 | 26.912 | 28.84x |
+| 100,000 oldest-first transfers | 500 | 44.631 | 31.982 | 1.40x |
+| 100,000 newest-first transfers | 500 | 46.296 | 25.439 | 1.82x |
+
+Every timed result matched the baseline's complete return value and original
+row references. The 100,000-row shuffled case reduced `Date.parse` calls from
+3,031,310 to 100,000 and sorted 100 rows instead of 100,000. Operation counts
+were measured in separate, untimed calls. Full paired samples and source
+hashes are retained in [results.json](results.json).
+
+These measurements cover the repository's localStorage demo query selector.
+They exclude storage parsing, transfer-schema validation, the API's simulated
+400 ms delay, React rendering and external providers. They establish neither
+end-to-end page latency nor live-provider throughput. Heap retention is bounded
+by the normalized result limit; no measured peak-memory result is claimed.
+
+## Compatibility and focused validation
+
+The selector preserves descending creation time, descending exact ID-string
+order and original input order for identical time/ID keys. It returns the same
+`items`, `totalMatched`, `capped` and `scopeKey`, and preserves row references.
+It does not mutate inputs or change actor visibility, filters, query caps,
+navigation, debounce or request cancellation.
+
+The maintained `test/unit/transfer-search.test.js` file passed **11/11** cases
+under Vitest **4.1.10** and Node **24.19.0**: all nine existing cases plus two
+focused regressions. New coverage compares against the unchanged public sort
+across caps and filters, duplicate keys at the cap boundary, frozen inputs,
+row identity, sparse legacy histories, invalid/epoch/pre-1970 timestamps and
+distinct Unicode IDs. Independent source review found no blockers.
+
+The run used the installed Vitest package and a Node-only configuration for
+this pure utility file. No dependency installation or assertion substitution
+was used. The repository-wide test suite, production build and hosted CI were
+not rerun for this utility continuation; earlier PR evidence retains its own
+source revision and limitations. No full-suite or sponsor-acceptance claim is
+made here.
+
+## Reproduce
+
+From a checkout containing this change and the baseline commit, stage the old
+selector beside the current one so both use the same unchanged dependencies:
+
+```bash
+git show 09cad8dff6d55a35b39d6836d31d045cdc1b938b:src/utils/transferSearch.js > src/utils/transferSearch.baseline.js
+node --expose-gc scripts/bench-transfer-search.mjs src/utils/transferSearch.baseline.js
+npx vitest run test/unit/transfer-search.test.js
+```
+
+The benchmark needs Node only and writes JSON to stdout. An optional second
+path selects a different candidate module. It asserts complete baseline
+equivalence for every sample and reports both input source hashes. The
+baseline staging file is temporary and is not part of the contribution.
+
+| Executed source | Git blob |
+| -------------------- | ------------------------------------------ |
+| Baseline selector | `be8db651d5c2457323d6f8373a170a41d8b99b87` |
+| Updated selector | `a75e2e4fe88e16cb0b03ed97aa0a1c18dbba1274` |
+| Maintained unit file | `22be7a01462fd6a612d40cdc9e34f0c9f1f443ea` |
+
+The original contribution and claim remain unchanged. This is performance
+follow-through on the existing submission; it does not establish a new award
+or payment.
diff --git a/docs/performance/transfer-search-20261004/results.json b/docs/performance/transfer-search-20261004/results.json
new file mode 100644
index 0000000..7f62886
--- /dev/null
+++ b/docs/performance/transfer-search-20261004/results.json
@@ -0,0 +1,178 @@
+{
+ "runtime": {
+ "node": "v24.19.0",
+ "platform": "linux",
+ "arch": "x64"
+ },
+ "sources": {
+ "baselineBlob": "be8db651d5c2457323d6f8373a170a41d8b99b87",
+ "candidateBlob": "a75e2e4fe88e16cb0b03ed97aa0a1c18dbba1274"
+ },
+ "method": {
+ "rounds": 5,
+ "warmupsPerVersion": 1,
+ "order": "alternating before/after",
+ "gcBeforeEachSample": true,
+ "timingIncludes": "actual applyTransferSearch only; fixtures/assertions outside timing",
+ "operationCounts": "separate untimed production calls",
+ "providerRequests": 0
+ },
+ "scenarios": [
+ {
+ "count": 5000,
+ "order": "shuffled",
+ "limit": 100,
+ "samples": [
+ {
+ "before": 33.71209999999999,
+ "after": 2.137278000000009
+ },
+ {
+ "after": 2.483734999999996,
+ "before": 27.878434999999996
+ },
+ {
+ "before": 20.951795000000004,
+ "after": 3.445317999999986
+ },
+ {
+ "after": 2.557780999999977,
+ "before": 22.238653
+ },
+ {
+ "before": 22.827020000000005,
+ "after": 1.8687130000000138
+ }
+ ],
+ "baselineMedianMs": 22.827020000000005,
+ "candidateMedianMs": 2.483734999999996,
+ "speedup": 9.190602056982748,
+ "baselineOperations": {
+ "dateParseCalls": 110108,
+ "sortedLengths": [5000]
+ },
+ "candidateOperations": {
+ "dateParseCalls": 5000,
+ "sortedLengths": [100]
+ },
+ "identicalResults": true
+ },
+ {
+ "count": 100000,
+ "order": "shuffled",
+ "limit": 100,
+ "samples": [
+ {
+ "before": 768.0208469999998,
+ "after": 26.91173000000026
+ },
+ {
+ "after": 29.546558000000005,
+ "before": 922.863077
+ },
+ {
+ "before": 776.0745080000002,
+ "after": 25.353613999999652
+ },
+ {
+ "after": 27.637462000000596,
+ "before": 679.0042330000006
+ },
+ {
+ "before": 855.1001800000004,
+ "after": 23.976690999999846
+ }
+ ],
+ "baselineMedianMs": 776.0745080000002,
+ "candidateMedianMs": 26.91173000000026,
+ "speedup": 28.837778470577426,
+ "baselineOperations": {
+ "dateParseCalls": 3031310,
+ "sortedLengths": [100000]
+ },
+ "candidateOperations": {
+ "dateParseCalls": 100000,
+ "sortedLengths": [100]
+ },
+ "identicalResults": true
+ },
+ {
+ "count": 100000,
+ "order": "ascending",
+ "limit": 500,
+ "samples": [
+ {
+ "before": 44.33002699999997,
+ "after": 33.507582000000184
+ },
+ {
+ "after": 31.485877000000073,
+ "before": 44.50824499999999
+ },
+ {
+ "before": 46.68953899999997,
+ "after": 31.618967999999768
+ },
+ {
+ "after": 32.851283999999396,
+ "before": 44.630928999999924
+ },
+ {
+ "before": 45.76722100000006,
+ "after": 31.98176499999954
+ }
+ ],
+ "baselineMedianMs": 44.630928999999924,
+ "candidateMedianMs": 31.98176499999954,
+ "speedup": 1.3955117549015998,
+ "baselineOperations": {
+ "dateParseCalls": 199998,
+ "sortedLengths": [100000]
+ },
+ "candidateOperations": {
+ "dateParseCalls": 100000,
+ "sortedLengths": [500]
+ },
+ "identicalResults": true
+ },
+ {
+ "count": 100000,
+ "order": "descending",
+ "limit": 500,
+ "samples": [
+ {
+ "before": 51.15443300000061,
+ "after": 26.590165999999954
+ },
+ {
+ "after": 25.439112999999452,
+ "before": 46.29600699999992
+ },
+ {
+ "before": 65.55661699999928,
+ "after": 36.23268499999995
+ },
+ {
+ "after": 24.899862000000212,
+ "before": 44.26636099999996
+ },
+ {
+ "before": 43.51811400000042,
+ "after": 22.59087400000044
+ }
+ ],
+ "baselineMedianMs": 46.29600699999992,
+ "candidateMedianMs": 25.439112999999452,
+ "speedup": 1.8198750483163826,
+ "baselineOperations": {
+ "dateParseCalls": 199998,
+ "sortedLengths": [100000]
+ },
+ "candidateOperations": {
+ "dateParseCalls": 100000,
+ "sortedLengths": [500]
+ },
+ "identicalResults": true
+ }
+ ]
+}
diff --git a/docs/validation/actor-scoped-transfer-validation.md b/docs/validation/actor-scoped-transfer-validation.md
new file mode 100644
index 0000000..947f009
--- /dev/null
+++ b/docs/validation/actor-scoped-transfer-validation.md
@@ -0,0 +1,76 @@
+# Actor-scoped transfer validation
+
+Issue: [RemitFlow Frontend #281](https://github.com/RemitFlow/RemitFlow-Frontend/issues/281)
+Existing submission: [PR #298](https://github.com/RemitFlow/RemitFlow-Frontend/pull/298)
+
+## Problem and repair
+
+The simulated localStorage API shares a transfer collection across wallets.
+Previously, `listTransfers` validated that entire collection before selecting
+the requesting actor's rows. As a result, the validity of a different wallet's
+records could change this wallet's error behavior.
+
+| Stored rows | Before | Repaired behavior |
+| ------------------------------------------------------- | -------------------------------------------------------- | ---------------------------------------- |
+| Only a corrupt foreign-wallet row | Schema error for an empty current-wallet history | Empty list |
+| Valid current-wallet row and corrupt foreign-wallet row | Correct list, but foreign schema diagnostics were logged | Correct list without foreign diagnostics |
+| Corrupt current-wallet row and valid foreign-wallet row | Empty list concealed the current wallet's schema failure | `ContractViolationError` |
+
+The API now uses the existing `isVisibleToActor` predicate on raw rows before
+validating individual transfers. It still passes a non-array top-level response
+to the schema validator, so malformed response structure remains an error.
+Visible corrupt records retain the existing validation policy.
+
+The same visibility options are reused for the final search. Legacy records
+without an actor remain visible only to the demo actor. The query actor is
+normalized as before, while stored actor strings retain exact matching.
+Cancellation, filtering, stable order and result caps keep their existing paths.
+
+This changes the localStorage demonstration API; it does not establish a
+server-side authorization boundary for an external service.
+
+## Source and execution evidence
+
+The repaired source commit is
+[`935caeb37e3932f85c2555f9086bde2c771c20bd`](https://github.com/woahwhattheheck/RemitFlow-Frontend/commit/935caeb37e3932f85c2555f9086bde2c771c20bd),
+a direct child of `21fccd57636a96d6c844289157e9c4693419a478`.
+The preceding navigation and capped-selector changes are preserved.
+
+| Executed file | Git blob |
+| ----------------------------------------- | ------------------------------------------ |
+| `src/services/api.js` | `1ec5dcd1f163d536c2f2cb6059fa6218c92f7d41` |
+| `test/unit/list-transfers-search.test.js` | `2d2c4753103589a1c53421a7e8a66734f566e0ef` |
+
+Two focused executions completed on 2026-10-04:
+
+- **Direct production API replay: 9 passed, 0 failed.** Node 24.19.0 imported
+ the changed API and actual contract modules, using synthetic JSON through an
+ in-memory localStorage interface and the API's real 400 ms timers. It covered
+ the three reproduced failures, current-wallet corruption alone, valid mixed
+ actors, demo and non-demo legacy visibility, a non-array response, and query
+ trimming with exact stored actor strings.
+- **Maintained unit file: 12 passed, 0 failed, 1.86 seconds.** Node 24.19.0 and
+ Vitest 4.1.10 ran all five existing cases and seven added regressions together
+ at the source commit above. No test cases were removed or weakened. The
+ retained installed runtime's package manifest, lockfile, Vite configuration
+ and test setup matched this checkout by Git blob; no source changes or new
+ dependency installation were needed for that run.
+
+Run the maintained selection from an installed checkout:
+
+```bash
+node node_modules/vitest/vitest.mjs run test/unit/list-transfers-search.test.js --maxWorkers=1 --fileParallelism=false
+```
+
+The observed run set `TMPDIR` to a writable task-owned tmpfs directory because
+the shared cloud disk was full. An earlier dependency-install attempt in a
+different checkout stopped with `ENOSPC`; it did not produce a test result or
+change dependencies or lockfiles. Reusing the compatible installed runtime
+closed that execution gap.
+
+Both edited JavaScript files also passed syntax checks, and the source diff
+passed whitespace checks. No repository-wide suite, production build, browser,
+wallet or external-provider run was repeated for this repair. Earlier
+[selector performance evidence](../performance/transfer-search-20261004/README.md)
+retains its own source revision and measurement scope. These results establish
+neither sponsor acceptance nor an award or payment.
diff --git a/docs/validation/rf298-existing-ci-relay17-20261004/README.md b/docs/validation/rf298-existing-ci-relay17-20261004/README.md
new file mode 100644
index 0000000..53c03b8
--- /dev/null
+++ b/docs/validation/rf298-existing-ci-relay17-20261004/README.md
@@ -0,0 +1,58 @@
+# PR298: required local checks pass on the composed source
+
+The complete package selection passes on [1e702e64](https://github.com/woahwhattheheck/RemitFlow-Frontend/commit/1e702e6437deee1bc1b0d75f5a3189abd178a226): **504 passed, zero failed or skipped, across all 53 files**. The final tree is `50b2704afb930440c23d30f6ab1dd7bbbf7fbf85`.
+
+[Issue281](https://github.com/RemitFlow/RemitFlow-Frontend/issues/281) requires existing tests and CI to remain passing without weakening unrelated tests. This continuation keeps the original [PR298](https://github.com/RemitFlow/RemitFlow-Frontend/pull/298), the earlier actor and navigation corrections, the bounded selector, and the later query-invariant filter preparation.
+
+## Final executed gates
+
+| Gate | Result |
+| ------------------------ | -------------------------------------------------------------------------------------------- |
+| Existing Prettier check | Passed; existing configuration and ignores unchanged |
+| Complete package tests | 504 passed / 0 failed / 0 skipped; 53/53 files passed |
+| Test duration | Vitest 69.54 s; complete process 70.096 s |
+| Production build | Passed; Vite 1.75 s; complete command 2.078 s |
+| Critical audit threshold | Exit 0; zero critical findings |
+| Remaining audit findings | 20 high, 12 moderate, 2 low |
+| Source identity | All 355 tracked blobs matched before execution and remained unchanged after testing/building |
+
+The final suite ran once with the complete package file selection, no retries, exclusions, altered timeouts or snapshot changes. It includes the original race, cancellation, actor-scope, pagination and scale cases and the new filter-preparation cases. Node 24.19.0 and Vitest 4.1.10 used the retained installation after package, lockfile, Vite configuration and test setup matched exactly.
+
+The audit executed once at 11:56:36–11:56:56 UTC on 2026-10-04. The final composition has identical package/lock bytes, so that dated result was reused. It passes the workflow's critical threshold while retaining the 34 findings above.
+
+## Changes and composition
+
+The four maintained send/quote fixtures now traverse the actual review, confirmation, result and receipt flow and assert the existing canonical-decimal contract. Their 22 original case titles remain. Exact amounts, fees, receipt reconciliation, negative/unquotable input, offline blocking, retry and transfer-creation assertions are retained.
+
+The only functional send-page change gives an otherwise valid amount with no available quote the pricing explanation expected by the maintained test. Required Prettier output covers the remaining flagged files. From the final parent 71746fa5, 19 paths change and 336 tracked paths remain unchanged.
+
+A first composition passed 502 tests across 52 files. Before its publication, a concurrent selector preparation contribution advanced the original branch. A non-force update rejected the outdated parent with 422. Its five files were then incorporated, the two new report files were formatted, and the final 504-case composition above was executed. Both raw runs remain separately identified in the archive; the earlier result is not represented as the final source.
+
+The peer selector `f072d7879d4bceb74d3635f6bfda0797e7f549a0`, benchmark script `1bcf4b3f4d44596fe3381d4631cde0481e85aca9`, and added test `cea83462b01de6fa1631a6bfeaa25fbdb522f980` are preserved byte for byte. Formatting of both historical benchmark JSON documents preserves every measurement and source pin.
+
+## Performance evidence retained
+
+The [earlier bounded-selector report](../../performance/transfer-search-20261004/README.md) and [query-invariant filter-preparation report](../../performance/transfer-filter-preparation-20261004/README.md) retain their own executed sources, environments, paired samples and scope. This continuation did not rerun either benchmark or combine their speedups.
+
+The final package's scale and performance tests pass. The validation-command durations in this report are not application or network throughput measurements.
+
+## Reproduce and inspect
+
+From an installed checkout of the source commit:
+
+```bash
+npm test -- --maxWorkers=2
+npm run format:check
+npm audit --audit-level=critical
+npm run build
+```
+
+The local test command used the default and JSON reporters and imported the actual repository Vite configuration with only `cacheDir` redirected to a task directory. `TMPDIR` and npm's cache/log locations were similarly redirected because the shared root filesystem was full. The exact wrappers/configuration are in the archive; dependencies were not reinstalled or changed.
+
+[receipt.json](receipt.json) records commands, source identities, timestamps, hosted status and archive/member hashes. [evidence.zip](evidence.zip) preserves raw Vitest output and JSON, formatter output, audit JSON, build output, source manifests, exact diffs and the separately identified intermediate execution. Raw execution files in the archive are unchanged.
+
+## Hosted and execution boundary
+
+At the published source, [CI 37201143157](https://github.com/RemitFlow/RemitFlow-Frontend/actions/runs/37201143157) and [Lighthouse CI 37201143084](https://github.com/RemitFlow/RemitFlow-Frontend/actions/runs/37201143084) report `action_required`. Local gate results do not establish hosted approval or maintainer acceptance.
+
+The app tests use the repository's demonstration wallet and transfer service in jsdom. The archive retains React/Vite warnings. No live-wallet, provider, settlement or whole-page performance result is established here. The original contribution and metadata handoff remain in place.
diff --git a/docs/validation/rf298-existing-ci-relay17-20261004/evidence.zip b/docs/validation/rf298-existing-ci-relay17-20261004/evidence.zip
new file mode 100644
index 0000000..6069ed2
Binary files /dev/null and b/docs/validation/rf298-existing-ci-relay17-20261004/evidence.zip differ
diff --git a/docs/validation/rf298-existing-ci-relay17-20261004/receipt.json b/docs/validation/rf298-existing-ci-relay17-20261004/receipt.json
new file mode 100644
index 0000000..950d669
--- /dev/null
+++ b/docs/validation/rf298-existing-ci-relay17-20261004/receipt.json
@@ -0,0 +1,303 @@
+{
+ "schema": "rf298-existing-ci/v1",
+ "recorded_at": "2026-10-04T12:12:51.298448+00:00",
+ "source_commit": "1e702e6437deee1bc1b0d75f5a3189abd178a226",
+ "parent": "71746fa5552f2dbb0ad3727637b52b9f64747410",
+ "tree": "50b2704afb930440c23d30f6ab1dd7bbbf7fbf85",
+ "source_files": 355,
+ "source_files_unchanged_after_execution": true,
+ "final_run": {
+ "repository": "woahwhattheheck/RemitFlow-Frontend",
+ "parent": "71746fa5552f2dbb0ad3727637b52b9f64747410",
+ "tested_tree": "50b2704afb930440c23d30f6ab1dd7bbbf7fbf85",
+ "source_files": 355,
+ "node": "v24.19.0",
+ "commands": [
+ {
+ "gate": "tests",
+ "command": [
+ "node",
+ "node_modules/vitest/vitest.mjs",
+ "run",
+ "test/integration",
+ "test/unit",
+ "test/components",
+ "test/services",
+ "test/lighthouse-config.test.js",
+ "test/security",
+ "--config",
+ "relay17.vitest.config.mjs",
+ "--maxWorkers=2",
+ "--reporter=default",
+ "--reporter=json",
+ "--outputFile.json=/dev/shm/relay17-rf298-evidence/vitest-results.json"
+ ],
+ "started_at": "2026-10-04T12:07:02.842160+00:00",
+ "finished_at": "2026-10-04T12:08:12.938097+00:00",
+ "elapsed_seconds": 70.09594242300227,
+ "exit_code": 0
+ },
+ {
+ "gate": "build",
+ "command": ["npm", "run", "build"],
+ "started_at": "2026-10-04T12:08:12.945742+00:00",
+ "finished_at": "2026-10-04T12:08:15.023921+00:00",
+ "elapsed_seconds": 2.078225809003925,
+ "exit_code": 0
+ }
+ ],
+ "source_unchanged_after": true
+ },
+ "tests": {
+ "passed": 504,
+ "failed": 0,
+ "skipped": 0,
+ "pending": 0,
+ "todo": 0,
+ "files_passed": 53,
+ "files_total": 53,
+ "vitest_seconds": 69.54
+ },
+ "audit": {
+ "gate": {
+ "gate": "audit",
+ "command": [
+ "npm",
+ "audit",
+ "--audit-level=critical",
+ "--json",
+ "--fetch-retries=0",
+ "--fetch-timeout=20000"
+ ],
+ "started_at": "2026-10-04T11:56:36.112260+00:00",
+ "finished_at": "2026-10-04T11:56:56.026595+00:00",
+ "elapsed_seconds": 19.914345624994894,
+ "exit_code": 0
+ },
+ "vulnerabilities": {
+ "info": 0,
+ "low": 2,
+ "moderate": 12,
+ "high": 20,
+ "critical": 0,
+ "total": 34
+ },
+ "reuse": "One audit on byte-identical package and lock in the first composition; not rerun after the selector-only concurrent source change.",
+ "package_blob": "625d0f3895fcc7afbfcfa131713249f5cd65dcd6",
+ "lock_blob": "70d29c1865dac7ce76ba7d4e6ca5ee454be54aae"
+ },
+ "format": {
+ "version": "3.9.6",
+ "result": "pass",
+ "initial_flagged_files": 14,
+ "additional_peer_report_files": 2,
+ "config_and_ignores_unchanged": true
+ },
+ "intermediate_run": {
+ "tested_tree": "a12311c454b4c6c1845437f651839212143c4971",
+ "passed": 502,
+ "failed": 0,
+ "files": 52,
+ "publication": "Not advanced after the non-force ref update returned422 for a concurrent source change; preserved only as intermediate evidence."
+ },
+ "hosted": [
+ {
+ "id": 37201143157,
+ "name": "CI",
+ "status": "completed",
+ "conclusion": "action_required",
+ "url": "https://github.com/RemitFlow/RemitFlow-Frontend/actions/runs/37201143157",
+ "head": "1e702e6437deee1bc1b0d75f5a3189abd178a226"
+ },
+ {
+ "id": 37201143084,
+ "name": "Lighthouse CI",
+ "status": "completed",
+ "conclusion": "action_required",
+ "url": "https://github.com/RemitFlow/RemitFlow-Frontend/actions/runs/37201143084",
+ "head": "1e702e6437deee1bc1b0d75f5a3189abd178a226"
+ }
+ ],
+ "archive": {
+ "path": "evidence.zip",
+ "bytes": 147628,
+ "sha256": "e853b730426ab43c783ec90a13f59210f62eb89ea62d18a27051e0f320800442",
+ "members": [
+ {
+ "path": "baseline-manifest.json",
+ "bytes": 56812,
+ "sha256": "b83aedae9147f858dfc208cdb2d4ddd4f7c7ec2170a6fa2fb9647ff61f8fc76e"
+ },
+ {
+ "path": "candidate-manifest.json",
+ "bytes": 56815,
+ "sha256": "14ddb3a4ac858a746ae8ca87d10d91c12f210c623243b183710c8fea89ca6fae"
+ },
+ {
+ "path": "changes.json",
+ "bytes": 3400,
+ "sha256": "1b78beab07c34a14c2bf9b7ea9557006cf1d37acf63669311c0fd23f558f4c5d"
+ },
+ {
+ "path": "candidate.patch",
+ "bytes": 46481,
+ "sha256": "9bdbb1666fa4ea58a4f2c0c92e7c745c2767c05726f3677dbf41306d7cb85767"
+ },
+ {
+ "path": "run-receipt.json",
+ "bytes": 1264,
+ "sha256": "55fe4e6f306e2de79c3e47c6fa3e12b6e8a61976a93ee7a222e24a64ec89efc8"
+ },
+ {
+ "path": "vitest-results.json",
+ "bytes": 152453,
+ "sha256": "26e84510765fb3958816674d2b80455813b70eca97eecfcc4aafa9bd7b0cfbd1"
+ },
+ {
+ "path": "vitest-output.log",
+ "bytes": 7382,
+ "sha256": "5f754c51ba442a5d808237d377160c94e12969cdceb77031a3de9036850da18b"
+ },
+ {
+ "path": "tests-stderr.log",
+ "bytes": 29742,
+ "sha256": "5f11c3a42cf601f1e9006f308a13354ba47b06265b74570e7dee4412047c83cc"
+ },
+ {
+ "path": "audit-results.json",
+ "bytes": 51078,
+ "sha256": "8b87a13f1e39c94f710de1e541d3ba88f8a47661af825c6004a41b2a812eb5a8"
+ },
+ {
+ "path": "audit-stderr.log",
+ "bytes": 307,
+ "sha256": "7d61cb2e2deb776dfec4d6f54693f9edeed0af5c4da52f091c53c995d862fb65"
+ },
+ {
+ "path": "build-output.log",
+ "bytes": 378,
+ "sha256": "a6a66c90918c89197a621a39ee35e68aba57a7291fe2b9a044213efe96900bae"
+ },
+ {
+ "path": "build-stderr.log",
+ "bytes": 99,
+ "sha256": "7125f194612fcff2f454c05d848e7cb71facc1967b4d5017e25b34fdee3ba74f"
+ },
+ {
+ "path": "format-before.log",
+ "bytes": 714,
+ "sha256": "2229fe8e82e708d83c8733a186f8ddc75984b53ec73f71356ab7214b5f0cd1e8"
+ },
+ {
+ "path": "format-write.log",
+ "bytes": 584,
+ "sha256": "0a4a70c0a7fc4fdcff48a70a198ba40f68857e2839b23754e23d9928f7e0b0fe"
+ },
+ {
+ "path": "format-after.log",
+ "bytes": 66,
+ "sha256": "17aa973d3f004560237d9a95171210b0671deff23d61628eecf7322ff5938f20"
+ },
+ {
+ "path": "final-format-before.log",
+ "bytes": 245,
+ "sha256": "31d8413491152aadf64d0be0232aad49eeb24c429c9f89591c1ad86cbab88fa7"
+ },
+ {
+ "path": "final-format-write.log",
+ "bytes": 142,
+ "sha256": "b89b060de24f16590e81f75fb6fa43bad31c2d4ad0345a447d8c58d5da17a3cd"
+ },
+ {
+ "path": "final-format-after.log",
+ "bytes": 66,
+ "sha256": "17aa973d3f004560237d9a95171210b0671deff23d61628eecf7322ff5938f20"
+ },
+ {
+ "path": "run-final.py",
+ "bytes": 3650,
+ "sha256": "b3bf2da62415507d43b02a0f95ff81fef4562e1e04ebf0bcb4ac5588add35fcf"
+ },
+ {
+ "path": "relay17.vitest.config.mjs",
+ "bytes": 107,
+ "sha256": "13a91081d6818081c932e1fcaba7c9e5fbfaa4f474de6abe2fe5f7680abfcdc1"
+ },
+ {
+ "path": "peer-integration-review.json",
+ "bytes": 2606,
+ "sha256": "97837abce4ce4b0af68b03930d265e8ad25c5cdd42ce0b821e444797ef4afa11"
+ },
+ {
+ "path": "initial-composition/baseline-manifest.json",
+ "bytes": 41306,
+ "sha256": "e57c83389ed09d29f80451177aec8506992ff431cbd8ee0c607aa15b03b89c2b"
+ },
+ {
+ "path": "initial-composition/candidate-manifest.json",
+ "bytes": 56071,
+ "sha256": "6ac9a037cc49f52a709cf965a263ff11db9aa75889e2660ba1622e956dccfa54"
+ },
+ {
+ "path": "initial-composition/changes.json",
+ "bytes": 3159,
+ "sha256": "49032fe72e060eb578b4a91b067516d353848fe00caa8aaba0f4adbcca7a361a"
+ },
+ {
+ "path": "initial-composition/candidate.patch",
+ "bytes": 33220,
+ "sha256": "cfcf0f271ac303e69b1e93c118a4034f33466ca6abc99388bfc87523f824aa40"
+ },
+ {
+ "path": "initial-composition/run-receipt.json",
+ "bytes": 1653,
+ "sha256": "33459b9b6a670e5c669892ca6ba3c091da8c5a18e31e8f76fe215163653a4912"
+ },
+ {
+ "path": "initial-composition/vitest-results.json",
+ "bytes": 151620,
+ "sha256": "e807f1c5466358dc55111d61f65624f0c3789cad9ae51d508b0a6fc46d5e76fb"
+ },
+ {
+ "path": "initial-composition/vitest-output.log",
+ "bytes": 7455,
+ "sha256": "5ebba564b9214b09c877e8d3d805d9614d116efdd8a294dd535fdc11ccdbaf24"
+ },
+ {
+ "path": "initial-composition/tests-stderr.log",
+ "bytes": 32477,
+ "sha256": "07b47e4028072e0f21fbf071ab4cab2ffb1c109d16587358efb6e9e191411288"
+ },
+ {
+ "path": "initial-composition/build-output.log",
+ "bytes": 378,
+ "sha256": "42fa9432279dbe2378736c21c5a1ae37f2e66873c498d73e53b862b01b2e7db1"
+ },
+ {
+ "path": "initial-composition/build-stderr.log",
+ "bytes": 99,
+ "sha256": "7125f194612fcff2f454c05d848e7cb71facc1967b4d5017e25b34fdee3ba74f"
+ },
+ {
+ "path": "initial-composition/run.py",
+ "bytes": 3593,
+ "sha256": "a7fdcb0db8477d15230848c7362a5fc4addf7d2edb82fed8ac130a43c9339c6b"
+ },
+ {
+ "path": "initial-composition/relay17.vitest.config.mjs",
+ "bytes": 107,
+ "sha256": "13a91081d6818081c932e1fcaba7c9e5fbfaa4f474de6abe2fe5f7680abfcdc1"
+ },
+ {
+ "path": "initial-composition/source-review.json",
+ "bytes": 1650,
+ "sha256": "6043c540de79c5f02383a3be5741b652e24d7451f331244b495ca69b3255427d"
+ },
+ {
+ "path": "initial-composition/SOURCE_REVIEW.md",
+ "bytes": 2412,
+ "sha256": "c69a2b239b635ed6712ab4a275c9a28fc73cdadfe5d8d6380a79fcd79c9ba5e7"
+ }
+ ]
+ }
+}
diff --git a/scripts/bench-transfer-filter-preparation.mjs b/scripts/bench-transfer-filter-preparation.mjs
new file mode 100644
index 0000000..1bcf4b3
--- /dev/null
+++ b/scripts/bench-transfer-filter-preparation.mjs
@@ -0,0 +1,277 @@
+#!/usr/bin/env node
+// Compare complete production selectors; no benchmark replacement of product code.
+import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { performance } from 'node:perf_hooks';
+import os from 'node:os';
+
+const [baselineArg, candidateArg = 'src/utils/transferSearch.js'] =
+ process.argv.slice(2);
+if (!baselineArg) {
+ console.error(
+ 'Usage: node --expose-gc scripts/bench-transfer-filter-preparation.mjs BASELINE [CANDIDATE]',
+ );
+ process.exit(2);
+}
+const baselinePath = resolve(baselineArg);
+const candidatePath = resolve(candidateArg);
+const baseline = await import(pathToFileURL(baselinePath));
+const candidate = await import(pathToFileURL(candidatePath));
+const gitBlob = (path) => {
+ const bytes = readFileSync(path);
+ return createHash('sha1')
+ .update(`blob ${bytes.length}\0`)
+ .update(bytes)
+ .digest('hex');
+};
+const now = new Date('2026-10-04T12:00:00.000Z');
+const options = { now, legacyActorId: 'demo' };
+let seed = 20261004;
+const random = () =>
+ (seed = (Math.imul(seed, 1664525) + 1013904223) >>> 0) / 2 ** 32;
+function makeHistory(count) {
+ const statuses = ['pending', 'submitted', 'completed', 'settled', 'failed'];
+ const rows = Array.from({ length: count }, (_, index) => ({
+ id: String(index).padStart(8, '0'),
+ actorId: index % 7 === 0 ? 'other' : 'demo',
+ recipient: index % 3 === 0 ? 'BOB' : 'Alice Smith',
+ status: statuses[index % statuses.length],
+ createdAt: new Date(
+ now.getTime() - (index % 120) * 86400000 - (index % 1000),
+ ).toISOString(),
+ }));
+ for (let i = rows.length - 1; i > 0; i -= 1) {
+ const j = Math.floor(random() * (i + 1));
+ [rows[i], rows[j]] = [rows[j], rows[i]];
+ }
+ return Object.freeze(rows.map(Object.freeze));
+}
+const large = makeHistory(100_000);
+const small = large.slice(0, 5_000);
+const cases = [
+ ['5k all time', small, { actorId: 'demo' }],
+ ['100k all time', large, { actorId: 'demo' }],
+ ['100k date window', large, { actorId: 'demo', range: '30d' }],
+ [
+ '100k status and search',
+ large,
+ { actorId: 'demo', status: 'submitted', search: ' ALICE ' },
+ ],
+ [
+ '100k combined filters',
+ large,
+ {
+ actorId: 'demo',
+ status: 'settled',
+ search: ' ALICE ',
+ range: '90d',
+ limit: 500,
+ },
+ ],
+];
+function compareResults(expected, actual) {
+ assert.deepEqual(actual, expected);
+ assert.equal(actual.items.length, expected.items.length);
+ actual.items.forEach((item, index) =>
+ assert.strictEqual(item, expected.items[index]),
+ );
+}
+const median = (samples) =>
+ [...samples].sort((a, b) => a - b)[Math.floor(samples.length / 2)];
+function measure(selector, rows, query) {
+ globalThis.gc?.();
+ const start = performance.now();
+ const result = selector.applyTransferSearch(rows, query, options);
+ return { result, ms: performance.now() - start };
+}
+function operationCounts(selector, rows, query) {
+ // Instrumentation is separate from all timing calls and restored in finally.
+ const NativeDate = globalThis.Date;
+ const originalLower = String.prototype.toLowerCase;
+ const originalMatch = String.prototype.match;
+ const counts = {
+ date_constructions: 0,
+ lowercase_calls: 0,
+ string_match_calls: 0,
+ };
+ globalThis.Date = new Proxy(NativeDate, {
+ construct(target, args, newTarget) {
+ counts.date_constructions += 1;
+ return Reflect.construct(target, args, newTarget);
+ },
+ });
+ String.prototype.toLowerCase = function (...args) {
+ counts.lowercase_calls += 1;
+ return Reflect.apply(originalLower, this, args);
+ };
+ String.prototype.match = function (...args) {
+ counts.string_match_calls += 1;
+ return Reflect.apply(originalMatch, this, args);
+ };
+ try {
+ return {
+ counts,
+ result: selector.applyTransferSearch(rows, query, options),
+ };
+ } finally {
+ globalThis.Date = NativeDate;
+ String.prototype.toLowerCase = originalLower;
+ String.prototype.match = originalMatch;
+ }
+}
+const observations = [];
+for (const [name, rows, query] of cases) {
+ const expected = baseline.applyTransferSearch(rows, query, options);
+ for (let warmup = 0; warmup < 3; warmup += 1) {
+ compareResults(
+ expected,
+ baseline.applyTransferSearch(rows, query, options),
+ );
+ compareResults(
+ expected,
+ candidate.applyTransferSearch(rows, query, options),
+ );
+ }
+ const pairs = [];
+ for (let repeat = 0; repeat < 9; repeat += 1) {
+ const order =
+ repeat % 2 === 0 ? ['baseline', 'candidate'] : ['candidate', 'baseline'];
+ const pair = { order };
+ for (const key of order) {
+ const measured = measure(
+ key === 'baseline' ? baseline : candidate,
+ rows,
+ query,
+ );
+ compareResults(expected, measured.result);
+ pair[key] = measured.ms;
+ }
+ pairs.push(pair);
+ }
+ const oldCounts = operationCounts(baseline, rows, query);
+ const newCounts = operationCounts(candidate, rows, query);
+ compareResults(expected, oldCounts.result);
+ compareResults(expected, newCounts.result);
+ const baselineMedian = median(pairs.map((pair) => pair.baseline));
+ const candidateMedian = median(pairs.map((pair) => pair.candidate));
+ observations.push({
+ name,
+ rows: rows.length,
+ query,
+ total_matched: expected.totalMatched,
+ returned: expected.items.length,
+ baseline_median_ms: baselineMedian,
+ candidate_median_ms: candidateMedian,
+ reduction_percent: 100 * (1 - candidateMedian / baselineMedian),
+ operation_counts: {
+ baseline: oldCounts.counts,
+ candidate: newCounts.counts,
+ },
+ result_sha256: createHash('sha256')
+ .update(JSON.stringify(expected))
+ .digest('hex'),
+ pairs,
+ });
+}
+// Differential compatibility checks are untimed and use unchanged row identities.
+let compatibility = 0;
+const dates = [
+ undefined,
+ null,
+ '',
+ 'bad',
+ 0,
+ -1,
+ '0',
+ '1970-01-01T00:00:00Z',
+ '1969-12-31T23:59:59Z',
+ '2026-10-04T12:00:00Z',
+ '2026-09-27T12:00:00Z',
+ '2026-09-27T11:59:59.999Z',
+ new Date('2026-09-27T12:00:00Z'),
+ new Date(NaN),
+ '2027-01-01T00:00:00Z',
+];
+const ranges = [
+ '',
+ '0d',
+ '0007d',
+ '7d',
+ '30d',
+ '90d',
+ 'unknown',
+ '99999999999999999d',
+ '9'.repeat(400) + 'd',
+];
+const edgeRows = Object.freeze(
+ dates
+ .flatMap((createdAt, index) => [
+ {
+ id: `a${index}`,
+ createdAt,
+ recipient: 'Alice',
+ status: 'settled',
+ actorId: 'demo',
+ },
+ { id: `b${index}`, createdAt, recipient: 'BOB', status: 'submitted' },
+ {
+ id: `c${index}`,
+ createdAt,
+ recipient: 'Älice',
+ status: 'failed',
+ actorId: 'other',
+ },
+ ])
+ .map(Object.freeze),
+);
+for (const instant of [now, new Date(NaN)]) {
+ for (const range of ranges) {
+ for (const status of ['', 'settled', 'submitted', 'invalid']) {
+ for (const search of ['', ' ALICE ', 'nobody']) {
+ const filters = { range, status, search };
+ for (const row of edgeRows) {
+ assert.equal(
+ candidate.matchesTransferFilters(row, filters, instant),
+ baseline.matchesTransferFilters(row, filters, instant),
+ );
+ compatibility += 1;
+ }
+ for (const limit of [1, 10, 500]) {
+ const query = { actorId: 'demo', ...filters, limit };
+ const opt = { ...options, now: instant };
+ compareResults(
+ baseline.applyTransferSearch(edgeRows, query, opt),
+ candidate.applyTransferSearch(edgeRows, query, opt),
+ );
+ compatibility += 1;
+ }
+ }
+ }
+ }
+}
+console.log(
+ JSON.stringify(
+ {
+ schema: 'transfer-filter-preparation-benchmark/v1',
+ executed_at: new Date().toISOString(),
+ node: process.version,
+ platform: `${process.platform}/${process.arch}`,
+ cpu: os.cpus()[0]?.model,
+ source: {
+ baseline_blob: gitBlob(baselinePath),
+ candidate_blob: gitBlob(candidatePath),
+ },
+ method:
+ '3 warmups; 9 paired samples, alternating order; synthetic fixed records; setup/assertions/GC/counting outside timed calls',
+ scope:
+ 'Complete production applyTransferSearch and its actual dependency modules, not storage/API/React/browser/provider latency.',
+ compatibility_checks: compatibility,
+ observations,
+ },
+ null,
+ 2,
+ ),
+);
diff --git a/scripts/bench-transfer-search.mjs b/scripts/bench-transfer-search.mjs
new file mode 100644
index 0000000..94dde7f
--- /dev/null
+++ b/scripts/bench-transfer-search.mjs
@@ -0,0 +1,154 @@
+import assert from 'node:assert/strict';
+import { createHash } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { performance } from 'node:perf_hooks';
+import { pathToFileURL } from 'node:url';
+
+const args = process.argv.slice(2);
+const baselinePath = args[0];
+const candidatePath = args[1] ?? 'src/utils/transferSearch.js';
+if (!baselinePath) {
+ throw new Error(
+ 'Usage: node --expose-gc bench-transfer-search.mjs BASELINE [CANDIDATE]',
+ );
+}
+const before = await import(pathToFileURL(resolve(baselinePath)).href);
+const after = await import(pathToFileURL(resolve(candidatePath)).href);
+const now = new Date('2026-10-04T00:00:00Z');
+const rounds = 5;
+
+function blob(path) {
+ const data = readFileSync(path);
+ return createHash('sha1')
+ .update(`blob ${data.length}\0`)
+ .update(data)
+ .digest('hex');
+}
+
+function fixture(count, order) {
+ return Array.from({ length: count }, (_, i) => {
+ const rank =
+ order === 'shuffled'
+ ? (i * 7919) % count
+ : order === 'ascending'
+ ? i
+ : count - i - 1;
+ return {
+ id: `tx_${i}`,
+ actorId: 'GACTOR_A',
+ recipient: 'amina@example.com',
+ status: 'completed',
+ createdAt: new Date(1700000000000 + rank * 1000).toISOString(),
+ };
+ });
+}
+
+function measure(fn, rows, query) {
+ if (global.gc) global.gc();
+ const start = performance.now();
+ const result = fn(rows, query, { now });
+ return { ms: performance.now() - start, result };
+}
+
+function countOperations(fn, rows, query) {
+ const originalParse = Date.parse;
+ const originalSort = Array.prototype.sort;
+ let dateParseCalls = 0;
+ const sortedLengths = [];
+ Date.parse = (...values) => {
+ dateParseCalls += 1;
+ return originalParse(...values);
+ };
+ Array.prototype.sort = function (...values) {
+ sortedLengths.push(this.length);
+ return originalSort.apply(this, values);
+ };
+ try {
+ fn(rows, query, { now });
+ return { dateParseCalls, sortedLengths };
+ } finally {
+ Date.parse = originalParse;
+ Array.prototype.sort = originalSort;
+ }
+}
+
+function median(values) {
+ return [...values].sort((a, b) => a - b)[Math.floor(values.length / 2)];
+}
+
+const report = {
+ runtime: {
+ node: process.version,
+ platform: process.platform,
+ arch: process.arch,
+ },
+ sources: {
+ baselineBlob: blob(baselinePath),
+ candidateBlob: blob(candidatePath),
+ },
+ method: {
+ rounds,
+ warmupsPerVersion: 1,
+ order: 'alternating before/after',
+ gcBeforeEachSample: Boolean(global.gc),
+ timingIncludes:
+ 'actual applyTransferSearch only; fixtures/assertions outside timing',
+ operationCounts: 'separate untimed production calls',
+ providerRequests: 0,
+ },
+ scenarios: [],
+};
+for (const [count, order, limit] of [
+ [5000, 'shuffled', 100],
+ [100000, 'shuffled', 100],
+ [100000, 'ascending', 500],
+ [100000, 'descending', 500],
+]) {
+ const rows = fixture(count, order);
+ const query = { actorId: 'GACTOR_A', limit };
+ const expected = before.applyTransferSearch(rows, query, { now });
+ assert.deepEqual(after.applyTransferSearch(rows, query, { now }), expected);
+ const samples = [];
+ for (let round = 0; round < rounds; round += 1) {
+ const calls = round % 2 === 0 ? ['before', 'after'] : ['after', 'before'];
+ const pair = {};
+ for (const name of calls) {
+ const fn =
+ name === 'before'
+ ? before.applyTransferSearch
+ : after.applyTransferSearch;
+ const sample = measure(fn, rows, query);
+ assert.deepEqual(sample.result, expected);
+ assert.equal(sample.result.totalMatched, count);
+ sample.result.items.forEach((row, i) =>
+ assert.equal(row, expected.items[i]),
+ );
+ pair[name] = sample.ms;
+ }
+ samples.push(pair);
+ }
+ const baselineMedianMs = median(samples.map((pair) => pair.before));
+ const candidateMedianMs = median(samples.map((pair) => pair.after));
+ report.scenarios.push({
+ count,
+ order,
+ limit,
+ samples,
+ baselineMedianMs,
+ candidateMedianMs,
+ speedup: baselineMedianMs / candidateMedianMs,
+ baselineOperations: countOperations(
+ before.applyTransferSearch,
+ rows,
+ query,
+ ),
+ candidateOperations: countOperations(
+ after.applyTransferSearch,
+ rows,
+ query,
+ ),
+ identicalResults: true,
+ });
+}
+console.log(JSON.stringify(report, null, 2));
diff --git a/src/context/AppContext.jsx b/src/context/AppContext.jsx
index 336af1b..452bf9f 100644
--- a/src/context/AppContext.jsx
+++ b/src/context/AppContext.jsx
@@ -1,4 +1,3 @@
-
import { createContext, useContext, useEffect, useState } from 'react';
import {
connectWallet,
diff --git a/src/hooks/useTransfers.js b/src/hooks/useTransfers.js
index dea1e61..4819116 100644
--- a/src/hooks/useTransfers.js
+++ b/src/hooks/useTransfers.js
@@ -1,28 +1,114 @@
-
-import { useCallback, useEffect, useState } from 'react';
+import {
+ useCallback,
+ useEffect,
+ useLayoutEffect,
+ useRef,
+ useState,
+} from 'react';
import { listTransfers, createTransfer } from '../services/api.js';
import { ContractViolationError } from '../services/contracts/schema.js';
import { getUserErrorMessage, normalizeError } from '../services/errors.js';
+import { DEMO_PUBLIC_KEY } from '../services/wallet.js';
+import {
+ DEFAULT_RESULT_CAP,
+ applyTransferSearch,
+ isVisibleToActor,
+ normalizeTransferQuery,
+ transferQueryScopeKey,
+} from '../utils/transferSearch.js';
+
+function isAbortError(err) {
+ return (
+ err?.name === 'AbortError' ||
+ err?.code === 'ERR_CANCELED' ||
+ err?.code === 'ECONNABORTED'
+ );
+}
/**
* Hook for loading and creating transfers.
+ *
+ * List requests always carry an actor scope, honour AbortSignal cancellation,
+ * and ignore stale responses so a slow reply for an old filter cannot
+ * overwrite the current result set.
+ *
+ * @param {{
+ * actorId?: string,
+ * filters?: {search?: string, status?: string, range?: string},
+ * limit?: number,
+ * }} [options]
* @returns {{transfers: Array, loading: boolean, error: string|null,
* retryable: boolean, reload: Function|undefined, addTransfer: Function}}
*/
-export function useTransfers() {
+export function useTransfers(options = {}) {
+ const actorId = options.actorId || DEMO_PUBLIC_KEY;
+ const filters = options.filters || {};
+ const limit = options.limit ?? DEFAULT_RESULT_CAP;
+
const [transfers, setTransfers] = useState([]);
const [loading, setLoading] = useState(true);
const [error, setError] = useState(null);
const [retryable, setRetryable] = useState(false);
+ const requestGen = useRef(0);
+ const abortRef = useRef(null);
+ const activeScopeRef = useRef(null);
+
+ const scopeKey = transferQueryScopeKey({
+ actorId,
+ search: filters.search,
+ status: filters.status,
+ range: filters.range,
+ limit,
+ });
+
+ useLayoutEffect(() => {
+ // A new committed lifecycle stays distinct even after A -> B -> A.
+ activeScopeRef.current = { key: scopeKey };
+ return () => {
+ activeScopeRef.current = null;
+ requestGen.current += 1;
+ abortRef.current?.abort();
+ };
+ }, [scopeKey]);
+
const reload = useCallback(async () => {
+ const expectedScope = activeScopeRef.current;
+ // A retained callback for an old query must not cancel the active one.
+ if (!expectedScope || expectedScope.key !== scopeKey) return;
+ const gen = ++requestGen.current;
+
+ if (abortRef.current) {
+ abortRef.current.abort();
+ }
+ const controller = new AbortController();
+ abortRef.current = controller;
+ const isCurrent = () =>
+ activeScopeRef.current === expectedScope &&
+ gen === requestGen.current &&
+ !controller.signal.aborted;
+
setLoading(true);
setError(null);
setRetryable(false);
try {
- const data = await listTransfers();
+ const data = await listTransfers({
+ actorId,
+ search: filters.search,
+ status: filters.status,
+ range: filters.range,
+ limit,
+ signal: controller.signal,
+ });
+ // Drop stale replies: a newer filter/request already superseded this one.
+ if (!isCurrent()) {
+ return;
+ }
setTransfers(data);
} catch (err) {
+ if (isAbortError(err) || !isCurrent()) {
+ return;
+ }
if (err instanceof ContractViolationError) {
// A schema change, not a flaky request. Retrying will not help, and
// showing an empty list would imply the transfers no longer exist.
@@ -37,19 +123,57 @@ export function useTransfers() {
setRetryable(normalized.retryable);
}
} finally {
- setLoading(false);
+ if (isCurrent()) {
+ setLoading(false);
+ }
}
- }, []);
+ }, [actorId, filters.search, filters.status, filters.range, limit, scopeKey]);
useEffect(() => {
reload();
+ return () => {
+ if (abortRef.current) {
+ abortRef.current.abort();
+ }
+ };
}, [reload]);
- const addTransfer = useCallback(async (payload) => {
- const created = await createTransfer(payload);
- setTransfers((prev) => [created, ...prev]);
- return created;
- }, []);
+ const addTransfer = useCallback(
+ async (payload) => {
+ const expectedScope = activeScopeRef.current;
+ const isCurrent = () =>
+ expectedScope &&
+ expectedScope.key === scopeKey &&
+ activeScopeRef.current === expectedScope;
+ const created = await createTransfer({
+ ...payload,
+ actorId: payload?.actorId || actorId,
+ });
+ // Creation still succeeds for its caller when its old view has retired.
+ if (!isCurrent()) return created;
+ setTransfers((prev) => {
+ if (!isCurrent()) return prev;
+ const query = normalizeTransferQuery({
+ actorId,
+ search: filters.search,
+ status: filters.status,
+ range: filters.range,
+ limit,
+ });
+ const visibility = { legacyActorId: DEMO_PUBLIC_KEY };
+ // Another actor's colliding ID must not replace this actor's row.
+ if (!isVisibleToActor(created, query.actorId, visibility)) return prev;
+ // Match the list API's actor, date, status, sort and cap semantics.
+ return applyTransferSearch(
+ [created, ...prev.filter((row) => row.id !== created.id)],
+ query,
+ visibility,
+ ).items;
+ });
+ return created;
+ },
+ [actorId, filters.search, filters.status, filters.range, limit, scopeKey],
+ );
// Existing consumers use reload for both pull-to-refresh and the error-state
// retry action. Withhold it only while a non-retryable error is displayed.
diff --git a/src/pages/SendMoney.jsx b/src/pages/SendMoney.jsx
index c1e03f0..3fdb4e4 100644
--- a/src/pages/SendMoney.jsx
+++ b/src/pages/SendMoney.jsx
@@ -9,7 +9,11 @@ import Modal from '../components/Modal.jsx';
import { buildQuote } from '../services/quote.js';
import { ContractViolationError } from '../services/contracts/schema.js';
import { getUserErrorMessage, normalizeError } from '../services/errors.js';
-import { formatAmount, formatCurrencyInput, parseCurrencyInput } from '../utils/format.js';
+import {
+ formatAmount,
+ formatCurrencyInput,
+ parseCurrencyInput,
+} from '../utils/format.js';
import {
isPositiveAmount,
validateRecipient,
@@ -36,7 +40,7 @@ import './SendMoney.css';
export default function SendMoney() {
const navigate = useNavigate();
const { wallet, isConnected, connect } = useWallet();
- const { addTransfer } = useTransfers();
+ const { addTransfer } = useTransfers({ actorId: wallet?.publicKey });
const { locale } = useApp();
const isOnline = useOnlineStatus();
@@ -167,7 +171,9 @@ export default function SendMoney() {
}
const finalQuote = buildQuote(parsedAmount.value, from, to);
if (!finalQuote) {
- applyErrors({ amount: 'Enter an amount greater than zero.' });
+ setSubmitError(
+ 'We could not price this transfer. Check the amount and currencies.',
+ );
return;
}
@@ -187,18 +193,23 @@ export default function SendMoney() {
submissionLock.current = true;
setSubmitting(true);
try {
- if (!isConnected) {
- await connect();
+ const account = isConnected ? wallet : await connect();
+ if (!account?.publicKey) {
+ throw new Error('Connect a wallet before sending.');
}
// Rebuild at confirmation time so the committed amounts match the note:
// rates are indicative and update at confirmation.
- const parsedAmount = parseCurrencyInput(amount, { currency: from, locale });
+ const parsedAmount = parseCurrencyInput(amount, {
+ currency: from,
+ locale,
+ });
if (!parsedAmount.ok) {
setSubmitError(parsedAmount.error);
return;
}
- const finalQuote = pendingQuote ?? buildQuote(parsedAmount.value, from, to);
+ const finalQuote =
+ pendingQuote ?? buildQuote(parsedAmount.value, from, to);
if (!finalQuote) {
setSubmitError(
'We could not price this transfer. Check the amount and the selected currencies.',
@@ -210,6 +221,7 @@ export default function SendMoney() {
// can reproduce exactly what was quoted rather than re-deriving it from
// a rate that may since have moved.
const created = await addTransfer({
+ actorId: account.publicKey,
recipient,
from,
to,
@@ -235,18 +247,19 @@ export default function SendMoney() {
);
} else {
const normalized = normalizeError(err, { source: 'api' });
- // A transfer can be interrupted mid-signature by a connection drop.
- // The honest message here is "unknown", not "failed": the backend may
- // have accepted the transfer even though the response never arrived.
- // The transfers page reconciles real status on reconnect.
- // Read the current connectivity directly (not from the render closure)
- // so that a mid-flight disconnect produces the correct message.
- const connectedNow = typeof navigator !== 'undefined' && navigator.onLine;
- setSubmitError(
- connectedNow
- ? getUserErrorMessage(normalized)
- : 'Connection lost while sending. Reconnect to check your transfer status.',
- );
+ // A transfer can be interrupted mid-signature by a connection drop.
+ // The honest message here is "unknown", not "failed": the backend may
+ // have accepted the transfer even though the response never arrived.
+ // The transfers page reconciles real status on reconnect.
+ // Read the current connectivity directly (not from the render closure)
+ // so that a mid-flight disconnect produces the correct message.
+ const connectedNow =
+ typeof navigator !== 'undefined' && navigator.onLine;
+ setSubmitError(
+ connectedNow
+ ? getUserErrorMessage(normalized)
+ : 'Connection lost while sending. Reconnect to check your transfer status.',
+ );
}
} finally {
submissionLock.current = false;
@@ -292,8 +305,8 @@ export default function SendMoney() {
role="status"
aria-live="polite"
>
- ✓ Back online. Your form was not submitted while you were
- offline — review it and send when ready.
+ ✓ Back online. Your form was not submitted while you were offline
+ — review it and send when ready.
)}
diff --git a/src/pages/Transfers.jsx b/src/pages/Transfers.jsx
index def8104..7f5ecbd 100644
--- a/src/pages/Transfers.jsx
+++ b/src/pages/Transfers.jsx
@@ -1,11 +1,20 @@
-import { useCallback, useEffect, useMemo, useState } from 'react';
-import { Link, useSearchParams } from 'react-router-dom';
+import {
+ useCallback,
+ useEffect,
+ useLayoutEffect,
+ useMemo,
+ useRef,
+ useState,
+} from 'react';
+import {
+ Link,
+ useLocation,
+ useNavigationType,
+ useSearchParams,
+} from 'react-router-dom';
import Chart from '../components/Chart.jsx';
import { formatMoney, parseDecimal } from '../utils/money.js';
-import {
- TRANSFER_STATUSES,
- normalizeStatus,
-} from '../services/contracts/transfer.js';
+import { TRANSFER_STATUSES } from '../services/contracts/transfer.js';
import TransferRow from '../components/TransferRow.jsx';
import { TRANSFER_STATUS_LABELS } from '../components/StatusBadge.jsx';
import Skeleton from '../components/Skeleton.jsx';
@@ -18,7 +27,12 @@ import SelectionToolbar from '../components/SelectionToolbar.jsx';
import { useTransfers } from '../hooks/useTransfers.js';
import { useOnlineStatus } from '../hooks/useOnlineStatus.js';
import { useApp } from '../context/AppContext.jsx';
-import { DATE_RANGE_PRESETS, isWithinDateRange } from '../utils/dateRange.js';
+import { DATE_RANGE_PRESETS } from '../utils/dateRange.js';
+import { DEMO_PUBLIC_KEY } from '../services/wallet.js';
+import {
+ DEFAULT_RESULT_CAP,
+ SEARCH_DEBOUNCE_MS,
+} from '../utils/transferSearch.js';
import './Transfers.css';
// Derived from the contract so a new lifecycle state cannot be filterable in
@@ -35,13 +49,17 @@ const PAGE_SIZE = 5;
/**
* Transfers page: lists all transfers with their status.
- * Filter state is synced to the URL query string.
+ * Filter state is synced to the URL query string. Free-text search is
+ * debounced before it drives the actor-scoped list query so keystrokes do
+ * not fan out requests; obsolete in-flight queries are aborted by the hook.
*/
export default function Transfers() {
- const { transfers, loading, error, reload } = useTransfers();
- const { locale } = useApp();
+ const { locale, wallet } = useApp();
+ const actorId = wallet?.publicKey || DEMO_PUBLIC_KEY;
const isOnline = useOnlineStatus();
const [searchParams, setSearchParams] = useSearchParams();
+ const location = useLocation();
+ const navigationType = useNavigationType();
// Becomes true while the browser is offline, then flips back to false the
// moment connectivity returns so we can reconcile transfers against the
@@ -49,9 +67,68 @@ export default function Transfers() {
const [wasOffline, setWasOffline] = useState(false);
const [syncingAfterReconnect, setSyncingAfterReconnect] = useState(false);
- const search = searchParams.get('search') || '';
const status = searchParams.get('status') || '';
const range = searchParams.get('range') || '';
+ const urlSearch = searchParams.get('search') || '';
+
+ // Only a user edit may schedule a URL write. Navigation is authoritative.
+ const [searchDraft, setSearchDraft] = useState(urlSearch);
+ const pendingSearch = useRef(null);
+
+ useLayoutEffect(() => {
+ const pending = pendingSearch.current;
+ // POP also retires a draft when history changes only status/range.
+ // Local filter controls use PUSH and may preserve an unfinished edit.
+ if (
+ navigationType === 'POP' ||
+ !pending ||
+ pending.baseSearch !== urlSearch
+ ) {
+ pendingSearch.current = null;
+ setSearchDraft(urlSearch);
+ }
+ }, [urlSearch, location.key, location.search, navigationType]);
+
+ useEffect(() => {
+ const pending = pendingSearch.current;
+ if (
+ !pending ||
+ pending.value !== searchDraft ||
+ pending.baseSearch !== urlSearch
+ ) {
+ return;
+ }
+ const timer = setTimeout(() => {
+ if (pendingSearch.current !== pending) return;
+ pendingSearch.current = null;
+ setSearchParams(
+ (prev) => {
+ if ((prev.get('search') || '') !== pending.baseSearch) return prev;
+ const next = new URLSearchParams(prev);
+ if (pending.value) next.set('search', pending.value);
+ else next.delete('search');
+ return next;
+ },
+ { replace: true },
+ );
+ }, SEARCH_DEBOUNCE_MS);
+ return () => clearTimeout(timer);
+ }, [searchDraft, urlSearch, setSearchParams]);
+
+ const queryFilters = useMemo(
+ () => ({
+ search: urlSearch,
+ status,
+ range,
+ }),
+ [urlSearch, status, range],
+ );
+
+ const { transfers, loading, error, reload } = useTransfers({
+ actorId,
+ filters: queryFilters,
+ limit: DEFAULT_RESULT_CAP,
+ });
// Selection state
const [selectedIds, setSelectedIds] = useState(() => new Set());
@@ -60,39 +137,29 @@ export default function Transfers() {
// Pagination state
const [page, setPage] = useState(1);
- // Reset page and selection when filters change
+ // Reset page and selection when the actor or committed filters change.
useEffect(() => {
setPage(1);
setSelectedIds(new Set());
setSelectAllAcross(false);
- }, [search, status, range]);
+ }, [actorId, urlSearch, status, range]);
- // Normalise the query-string status so a legacy or provider spelling in a
- // shared/bookmarked URL (?status=settled) still selects the right rows.
- const canonicalStatus = normalizeStatus(status);
// Track connectivity so that a reconnect triggers an automatic reload.
// The reload reconciles the true status of transfers that may have been
// created or settled while the connection was down — without resubmitting
// anything.
useEffect(() => {
- if (isOnline && wasOffline && !loading) {
+ if (isOnline && wasOffline && !loading && reload) {
setSyncingAfterReconnect(true);
- reload().finally(() => {
+ Promise.resolve(reload()).finally(() => {
setSyncingAfterReconnect(false);
});
}
setWasOffline(!isOnline);
}, [isOnline, wasOffline, loading, reload]);
- const filteredTransfers = useMemo(() => {
- return transfers.filter((t) => {
- if (status && normalizeStatus(t.status) !== canonicalStatus) return false;
- if (search && !t.recipient.toLowerCase().includes(search.toLowerCase()))
- return false;
- if (!isWithinDateRange(t.createdAt, range)) return false;
- return true;
- });
- }, [transfers, search, status, canonicalStatus, range]);
+ // API already applies actor scope, filters, stable sort, and the result cap.
+ const filteredTransfers = transfers;
// Paginated data
const totalPages = Math.ceil(filteredTransfers.length / PAGE_SIZE) || 1;
@@ -115,13 +182,11 @@ export default function Transfers() {
const handleSearchChange = useCallback(
(e) => {
const value = e.target.value;
- setSearchParams((prev) => {
- if (value) prev.set('search', value);
- else prev.delete('search');
- return prev;
- });
+ pendingSearch.current =
+ value === urlSearch ? null : { value, baseSearch: urlSearch };
+ setSearchDraft(value);
},
- [setSearchParams],
+ [urlSearch],
);
const handleStatusChange = useCallback(
@@ -148,7 +213,7 @@ export default function Transfers() {
[setSearchParams],
);
- const hasActiveFilters = Boolean(search || status || range);
+ const hasActiveFilters = Boolean(urlSearch || status || range);
// Selection handlers
const handleToggleSelect = useCallback((id) => {
@@ -188,6 +253,12 @@ export default function Transfers() {
setSelectAllAcross(false);
}, []);
+ const handleClearFilters = useCallback(() => {
+ pendingSearch.current = null;
+ setSearchDraft('');
+ setSearchParams({});
+ }, [setSearchParams]);
+
const renderContent = () => {
if (loading) {
return (
@@ -215,7 +286,7 @@ export default function Transfers() {
}
action={
hasActiveFilters ? (
-
+
) : (
@@ -288,7 +359,7 @@ export default function Transfers() {
type="search"
className="transfers-filters-search"
placeholder="Search by recipient…"
- value={search}
+ value={searchDraft}
onChange={handleSearchChange}
aria-label="Search transfers by recipient"
/>
diff --git a/src/services/api.js b/src/services/api.js
index d8d2797..1ec5dcd 100644
--- a/src/services/api.js
+++ b/src/services/api.js
@@ -11,6 +11,14 @@ import {
parseTransferList,
transferContract,
} from './contracts/transfer.js';
+import { DEMO_PUBLIC_KEY } from './wallet.js';
+import {
+ DEFAULT_RESULT_CAP,
+ applyTransferSearch,
+ isVisibleToActor,
+ normalizeTransferQuery,
+ requireActorId,
+} from '../utils/transferSearch.js';
const STORAGE_KEY = 'remitflow.transfers';
@@ -25,6 +33,7 @@ const SEED_TRANSFERS = [
receiveAmount: 294620,
status: 'completed',
createdAt: '2026-05-28T10:15:00Z',
+ actorId: DEMO_PUBLIC_KEY,
},
{
id: 'tx_1002',
@@ -35,6 +44,7 @@ const SEED_TRANSFERS = [
receiveAmount: 9920,
status: 'pending',
createdAt: '2026-06-02T08:42:00Z',
+ actorId: DEMO_PUBLIC_KEY,
},
];
@@ -67,20 +77,68 @@ function reportRejected(rejected) {
}
}
+function abortedError() {
+ if (typeof DOMException === 'function') {
+ return new DOMException(
+ 'The transfer list request was aborted.',
+ 'AbortError',
+ );
+ }
+ const err = new Error('The transfer list request was aborted.');
+ err.name = 'AbortError';
+ return err;
+}
+
/**
- * List all transfers, newest first.
+ * List transfers for one actor, newest first, with optional filters.
+ *
+ * Every call must carry `actorId` so results cannot cross wallet scope.
+ * Pass `signal` to cancel an obsolete in-flight query when filters change.
+ * Results are stably sorted and capped so large histories stay responsive.
*
* One malformed record is dropped and logged so the rest of the list still
* renders. A response where *every* record fails is a schema change, not bad
* data, and is raised so the UI can say so instead of showing "no transfers".
*
- * @returns {Promise} contract-normalised transfers
+ * @param {{
+ * actorId?: string,
+ * search?: string,
+ * status?: string,
+ * range?: string,
+ * limit?: number,
+ * signal?: AbortSignal,
+ * }} [options]
+ * @returns {Promise} contract-normalised transfers
*/
-export function listTransfers() {
+export function listTransfers(options = {}) {
+ const actorId = requireActorId(options.actorId ?? DEMO_PUBLIC_KEY);
+ const query = normalizeTransferQuery({
+ actorId,
+ search: options.search,
+ status: options.status,
+ range: options.range,
+ limit: options.limit ?? DEFAULT_RESULT_CAP,
+ });
+ const signal = options.signal;
+
return new Promise((resolve, reject) => {
- setTimeout(() => {
+ if (signal?.aborted) {
+ reject(abortedError());
+ return;
+ }
+
+ const timer = setTimeout(() => {
try {
- const { transfers, rejected, breaking } = parseTransferList(read(), {
+ const raw = read();
+ const visibility = { legacyActorId: DEMO_PUBLIC_KEY };
+ // Validate this actor's response, not every wallet in shared storage.
+ // Foreign records must neither cause nor mask our schema failures.
+ const visible = Array.isArray(raw)
+ ? raw.filter((transfer) =>
+ isVisibleToActor(transfer, query.actorId, visibility),
+ )
+ : raw;
+ const { transfers, rejected, breaking } = parseTransferList(visible, {
source: 'listTransfers',
});
if (breaking) {
@@ -94,15 +152,21 @@ export function listTransfers() {
);
}
if (rejected.length) reportRejected(rejected);
- resolve(
- transfers
- .slice()
- .sort((a, b) => new Date(b.createdAt) - new Date(a.createdAt)),
- );
+
+ const { items } = applyTransferSearch(transfers, query, visibility);
+ resolve(items);
} catch (error) {
reject(error);
}
}, 400);
+
+ if (signal) {
+ const onAbort = () => {
+ clearTimeout(timer);
+ reject(abortedError());
+ };
+ signal.addEventListener('abort', onAbort, { once: true });
+ }
});
}
@@ -120,12 +184,17 @@ export function createTransfer(payload) {
return new Promise((resolve, reject) => {
setTimeout(() => {
try {
+ const actorId =
+ typeof payload?.actorId === 'string' && payload.actorId.trim()
+ ? payload.actorId.trim()
+ : DEMO_PUBLIC_KEY;
const transfer = parseTransfer(
{
id: 'tx_' + Date.now(),
status: 'pending',
createdAt: new Date().toISOString(),
...payload,
+ actorId,
},
{ source: 'createTransfer' },
);
diff --git a/src/services/contracts/transfer.js b/src/services/contracts/transfer.js
index ce4e901..e95c76f 100644
--- a/src/services/contracts/transfer.js
+++ b/src/services/contracts/transfer.js
@@ -68,6 +68,8 @@ export const transferContract = defineContract({
rate: { type: 'decimal', required: false, min: 0 },
expiresAt: { type: 'timestamp', required: false },
failureReason: { type: 'string', required: false, nullable: true },
+ // Sender scope. Absent on legacy records; list queries always supply actorId.
+ actorId: { type: 'string', required: false, minLength: 1 },
},
});
diff --git a/src/services/errors.js b/src/services/errors.js
index bab520f..4ecc020 100644
--- a/src/services/errors.js
+++ b/src/services/errors.js
@@ -86,7 +86,9 @@ export function normalizeError(error, { source = 'api' } = {}) {
}
export function getUserErrorMessage(normalizedError) {
- return SAFE_MESSAGES[normalizedError?.code] ?? SAFE_MESSAGES[ERROR_CODES.UNKNOWN];
+ return (
+ SAFE_MESSAGES[normalizedError?.code] ?? SAFE_MESSAGES[ERROR_CODES.UNKNOWN]
+ );
}
export function canRetry(normalizedError) {
diff --git a/src/services/wallet.js b/src/services/wallet.js
index 73e5929..34ae28a 100644
--- a/src/services/wallet.js
+++ b/src/services/wallet.js
@@ -5,7 +5,7 @@
const STORAGE_KEY = 'remitflow.wallet';
// A deterministic fake Stellar public key for demo purposes.
-const DEMO_PUBLIC_KEY =
+export const DEMO_PUBLIC_KEY =
'GBQAZ7Z3X7DEMOPUBLICKEY4REMITFLOWWALLET123456789ABCDEF';
/**
diff --git a/src/utils/transferSearch.js b/src/utils/transferSearch.js
new file mode 100644
index 0000000..f072d78
--- /dev/null
+++ b/src/utils/transferSearch.js
@@ -0,0 +1,227 @@
+/**
+ * Deterministic transfer search, filter, sort, and result capping.
+ *
+ * Client-side filter fan-out races and unbounded scans get slow as history
+ * grows. These helpers define one canonical filter/sort/scope semantics used
+ * by the list API and the Transfers page so stale responses, missing actor
+ * scope, and uncapped result sets cannot silently corrupt the UI.
+ */
+
+import { normalizeStatus } from '../services/contracts/transfer.js';
+import { getDateRangeDays } from './dateRange.js';
+
+/** Debounce window for free-text search queries (ms). */
+export const SEARCH_DEBOUNCE_MS = 300;
+
+/** Default maximum rows a single list query may return. */
+export const DEFAULT_RESULT_CAP = 100;
+
+/** Hard ceiling — callers may request less, never more. */
+export const MAX_RESULT_CAP = 500;
+
+/**
+ * @param {unknown} actorId
+ * @returns {string}
+ */
+export function requireActorId(actorId) {
+ if (typeof actorId !== 'string' || actorId.trim() === '') {
+ throw new Error('actorId is required on every transfer list request');
+ }
+ return actorId.trim();
+}
+
+/**
+ * Canonical filter bag bound into every request and stale-response check.
+ * @param {{search?: string, status?: string, range?: string, actorId?: string, limit?: number}} input
+ */
+export function normalizeTransferQuery(input = {}) {
+ const actorId = requireActorId(input.actorId);
+ const search = String(input.search ?? '').trim();
+ const statusRaw = String(input.status ?? '').trim();
+ const status = statusRaw ? (normalizeStatus(statusRaw) ?? statusRaw) : '';
+ const range = String(input.range ?? '').trim();
+ const requested =
+ Number.isFinite(input.limit) && input.limit > 0
+ ? Math.floor(input.limit)
+ : DEFAULT_RESULT_CAP;
+ const limit = Math.min(Math.max(requested, 1), MAX_RESULT_CAP);
+
+ return { actorId, search, status, range, limit };
+}
+
+/**
+ * Stable string identity for a query — used to ignore stale responses.
+ * @param {{search?: string, status?: string, range?: string, actorId?: string, limit?: number}} query
+ */
+export function transferQueryScopeKey(query) {
+ const normalized = normalizeTransferQuery(query);
+ return JSON.stringify(normalized);
+}
+
+/**
+ * Whether a transfer belongs to the requesting actor.
+ * Legacy rows without actorId are only visible to the supplied legacyActor
+ * (the historical demo owner) so migration does not leak across wallets.
+ *
+ * @param {object} transfer
+ * @param {string} actorId
+ * @param {{legacyActorId?: string}} [options]
+ */
+export function isVisibleToActor(transfer, actorId, options = {}) {
+ if (!actorId) return false;
+ const owner = transfer?.actorId;
+ if (typeof owner === 'string' && owner.length > 0) {
+ return owner === actorId;
+ }
+ const legacy = options.legacyActorId;
+ return Boolean(legacy) && actorId === legacy;
+}
+
+/**
+ * Apply status / search / date-range predicates (actor scope is separate).
+ * @param {object} transfer
+ * @param {{search?: string, status?: string, range?: string}} filters
+ * @param {Date} [now]
+ */
+export function matchesTransferFilters(
+ transfer,
+ filters = {},
+ now = new Date(),
+) {
+ const matches = prepareTransferFilters(filters, now);
+ return matches ? matches(transfer) : true;
+}
+
+/** Prepare only query-owned values; each invocation still reads fresh rows. */
+function prepareTransferFilters(filters, now) {
+ const status = filters.status
+ ? (normalizeStatus(filters.status) ?? filters.status)
+ : '';
+ const search = String(filters.search ?? '')
+ .trim()
+ .toLowerCase();
+ const days = getDateRangeDays(filters.range ?? '');
+ // Keep Date's clipping/invalid-window semantics, including oversized presets.
+ const cutoff = days
+ ? new Date(now.getTime() - days * 86_400_000).getTime()
+ : null;
+
+ if (!status && !search && cutoff === null) return null;
+
+ return (transfer) => {
+ if (status && normalizeStatus(transfer.status) !== status) return false;
+ if (
+ search &&
+ !String(transfer.recipient ?? '')
+ .toLowerCase()
+ .includes(search)
+ ) {
+ return false;
+ }
+ return cutoff === null || new Date(transfer.createdAt).getTime() >= cutoff;
+ };
+}
+
+/**
+ * Newest-first ordering with descending exact ID strings as the tie-breaker.
+ * @param {object[]} transfers
+ * @returns {object[]}
+ */
+export function stableSortTransfers(transfers) {
+ return (transfers ?? []).slice().sort((a, b) => {
+ const aTime = Date.parse(a?.createdAt ?? '') || 0;
+ const bTime = Date.parse(b?.createdAt ?? '') || 0;
+ if (bTime !== aTime) return bTime - aTime;
+ // Locale collation can equate distinct IDs; compare their exact strings.
+ const aId = String(a?.id ?? '');
+ const bId = String(b?.id ?? '');
+ return aId < bId ? 1 : aId > bId ? -1 : 0;
+ });
+}
+
+function compareSearchEntries(a, b) {
+ if (b.time !== a.time) return b.time - a.time;
+ if (a.id !== b.id) return a.id < b.id ? 1 : -1;
+ // Array.sort is stable: identical keys retain their original input order.
+ return a.index - b.index;
+}
+
+/** Keep only the best `limit` rows, with the worst retained row at the root. */
+function retainSearchEntry(heap, entry, limit) {
+ if (heap.length < limit) {
+ let child = heap.length;
+ heap.push(entry);
+ while (child > 0) {
+ const parent = Math.floor((child - 1) / 2);
+ if (compareSearchEntries(heap[parent], entry) >= 0) break;
+ heap[child] = heap[parent];
+ child = parent;
+ }
+ heap[child] = entry;
+ return;
+ }
+
+ if (compareSearchEntries(entry, heap[0]) >= 0) return;
+ let parent = 0;
+ while (parent * 2 + 1 < heap.length) {
+ let child = parent * 2 + 1;
+ if (
+ child + 1 < heap.length &&
+ compareSearchEntries(heap[child + 1], heap[child]) > 0
+ ) {
+ child += 1;
+ }
+ if (compareSearchEntries(entry, heap[child]) >= 0) break;
+ heap[parent] = heap[child];
+ parent = child;
+ }
+ heap[parent] = entry;
+}
+
+/**
+ * Filter by actor + predicates and select a stable, capped result.
+ * Only the retained rows are sorted; each matching timestamp is parsed once.
+ *
+ * @param {object[]} transfers
+ * @param {{search?: string, status?: string, range?: string, actorId: string, limit?: number}} query
+ * @param {{now?: Date, legacyActorId?: string}} [options]
+ * @returns {{items: object[], totalMatched: number, capped: boolean, scopeKey: string}}
+ */
+export function applyTransferSearch(transfers, query, options = {}) {
+ const normalized = normalizeTransferQuery(query);
+ const now = options.now ?? new Date();
+ const matchesFilters = prepareTransferFilters(normalized, now);
+ const selected = [];
+ let totalMatched = 0;
+ const visibility = { legacyActorId: options.legacyActorId };
+ // forEach, like filter, skips sparse-array holes.
+ (transfers ?? []).forEach((transfer, index) => {
+ if (
+ !isVisibleToActor(transfer, normalized.actorId, visibility) ||
+ (matchesFilters && !matchesFilters(transfer))
+ ) {
+ return;
+ }
+ totalMatched += 1;
+ retainSearchEntry(
+ selected,
+ {
+ transfer,
+ time: Date.parse(transfer?.createdAt ?? '') || 0,
+ id: String(transfer?.id ?? ''),
+ index,
+ },
+ normalized.limit,
+ );
+ });
+ const items = selected
+ .sort(compareSearchEntries)
+ .map((entry) => entry.transfer);
+
+ return {
+ items,
+ totalMatched,
+ capped: totalMatched > normalized.limit,
+ scopeKey: transferQueryScopeKey(normalized),
+ };
+}
diff --git a/test/components/WalletButton.test.jsx b/test/components/WalletButton.test.jsx
index 46287e2..701fc6f 100644
--- a/test/components/WalletButton.test.jsx
+++ b/test/components/WalletButton.test.jsx
@@ -1,4 +1,3 @@
-
import { describe, expect, it, vi } from 'vitest';
import { render, screen, waitFor } from '@testing-library/react';
import userEvent from '@testing-library/user-event';
@@ -118,7 +117,9 @@ describe('WalletButton', () => {
);
await waitFor(() => {
- expect(screen.queryByText(/something went wrong/i)).not.toBeInTheDocument();
+ expect(
+ screen.queryByText(/something went wrong/i),
+ ).not.toBeInTheDocument();
expect(screen.getByText(/500 XLM/)).toBeInTheDocument();
});
});
diff --git a/test/integration/offline-reconnect.test.jsx b/test/integration/offline-reconnect.test.jsx
index 10a8761..a6de581 100644
--- a/test/integration/offline-reconnect.test.jsx
+++ b/test/integration/offline-reconnect.test.jsx
@@ -1,4 +1,11 @@
-import { act, fireEvent, render, screen, waitFor } from '@testing-library/react';
+import {
+ act,
+ fireEvent,
+ render,
+ screen,
+ waitFor,
+ within,
+} from '@testing-library/react';
import userEvent from '@testing-library/user-event';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import App from '../../src/App.jsx';
@@ -43,6 +50,8 @@ describe('Offline and reconnect state for transfer mutations', () => {
});
window.history.pushState({}, '', '/send');
localStorage.clear();
+ // These cases exercise connectivity, not the demo wallet's random refusal.
+ vi.spyOn(Math, 'random').mockReturnValue(0.5);
});
afterEach(() => {
@@ -80,9 +89,7 @@ describe('Offline and reconnect state for transfer mutations', () => {
goOffline();
expect(
- await screen.findByText(
- /you're offline\. some features may not work/i,
- ),
+ await screen.findByText(/you're offline\. some features may not work/i),
).toBeInTheDocument();
});
@@ -119,14 +126,38 @@ describe('Offline and reconnect state for transfer mutations', () => {
goOnline();
// After reconnecting, the button should change back to "Review & Send" and be enabled.
- const submitButton = await screen.findByRole('button', {
- name: /review & send/i,
- }, { timeout: 5000 });
+ const submitButton = await screen.findByRole(
+ 'button',
+ {
+ name: /review & send/i,
+ },
+ { timeout: 5000 },
+ );
expect(submitButton).toBeEnabled();
+ expect(createTransfer).not.toHaveBeenCalled();
await user.click(submitButton);
-
- await screen.findByRole('heading', { name: /your transfers/i }, { timeout: 10000 });
+ const confirmation = await screen.findByRole('dialog', {
+ name: /confirm your transfer/i,
+ });
+ expect(createTransfer).not.toHaveBeenCalled();
+ await user.click(
+ within(confirmation).getByRole('button', { name: /confirm transfer/i }),
+ );
+ const result = await screen.findByRole(
+ 'dialog',
+ { name: /transfer submitted/i },
+ { timeout: 5000 },
+ );
+ await user.click(
+ within(result).getByRole('button', { name: /view transfers/i }),
+ );
+
+ await screen.findByRole(
+ 'heading',
+ { name: /your transfers/i },
+ { timeout: 10000 },
+ );
expect(createTransfer).toHaveBeenCalledTimes(1);
});
@@ -170,9 +201,15 @@ describe('Offline and reconnect state for transfer mutations', () => {
await fillValidForm(user);
- // Start the submission.
- const submitButton = screen.getByRole('button', { name: /review & send/i });
- fireEvent.click(submitButton);
+ // Review first, then dispatch through the actual confirmation dialog.
+ await user.click(screen.getByRole('button', { name: /review & send/i }));
+ const confirmation = await screen.findByRole('dialog', {
+ name: /confirm your transfer/i,
+ });
+ expect(createTransfer).not.toHaveBeenCalled();
+ await user.click(
+ within(confirmation).getByRole('button', { name: /confirm transfer/i }),
+ );
// After the catch block runs, the error message should be about
// connection loss, NOT a generic "could not submit" message.
@@ -185,5 +222,6 @@ describe('Offline and reconnect state for transfer mutations', () => {
expect(
screen.queryByText(/could not submit the transfer\./i),
).not.toBeInTheDocument();
+ expect(createTransfer).toHaveBeenCalledTimes(1);
});
-});
\ No newline at end of file
+});
diff --git a/test/integration/send-money-form.test.jsx b/test/integration/send-money-form.test.jsx
index 43a7381..9ae992d 100644
--- a/test/integration/send-money-form.test.jsx
+++ b/test/integration/send-money-form.test.jsx
@@ -1,4 +1,3 @@
-
import {
act,
fireEvent,
@@ -61,6 +60,8 @@ describe('Send money form flows', () => {
beforeEach(() => {
window.history.pushState({}, '', '/send');
localStorage.clear();
+ // Keep the mock wallet's random rejection out of submission-guard tests.
+ vi.spyOn(Math, 'random').mockReturnValue(0.5);
});
afterEach(() => {
@@ -113,7 +114,9 @@ describe('Send money form flows', () => {
within(dialog).getByRole('button', { name: /confirm transfer/i }),
);
- expect(screen.getByRole('button', { name: /sending/i })).toBeDisabled();
+ expect(
+ within(dialog).getByRole('button', { name: /sending/i }),
+ ).toBeDisabled();
expect(createTransfer).not.toHaveBeenCalled();
const resultDialog = await screen.findByRole(
@@ -200,7 +203,9 @@ describe('Send money form flows', () => {
within(dialog).getByRole('button', { name: /confirm transfer/i }),
);
- expect(await screen.findByText(/something went wrong/i)).toBeInTheDocument();
+ expect(
+ await screen.findByText(/something went wrong/i),
+ ).toBeInTheDocument();
const retryButton = screen.getByRole('button', { name: /review & send/i });
expect(retryButton).toBeEnabled();
diff --git a/test/integration/send-money-precision.test.jsx b/test/integration/send-money-precision.test.jsx
index f5cf076..136b66c 100644
--- a/test/integration/send-money-precision.test.jsx
+++ b/test/integration/send-money-precision.test.jsx
@@ -22,6 +22,32 @@ async function fillForm(user, { amount, to = 'NGN' } = {}) {
return amountField;
}
+async function reviewAndConfirm(user) {
+ await user.click(screen.getByRole('button', { name: /review & send/i }));
+ const dialog = await screen.findByRole('dialog', {
+ name: /confirm your transfer/i,
+ });
+ await user.click(
+ within(dialog).getByRole('button', { name: /confirm transfer/i }),
+ );
+}
+
+async function viewSubmittedTransfer(user) {
+ const dialog = await screen.findByRole(
+ 'dialog',
+ { name: /transfer submitted/i },
+ { timeout: 5000 },
+ );
+ await user.click(
+ within(dialog).getByRole('button', { name: /view transfers/i }),
+ );
+ await screen.findByRole(
+ 'heading',
+ { name: /your transfers/i },
+ { timeout: 5000 },
+ );
+}
+
describe('Send flow — amount parsing regressions', () => {
beforeEach(() => {
window.history.pushState({}, '', '/send');
@@ -44,17 +70,22 @@ describe('Send flow — amount parsing regressions', () => {
});
it('keeps a negative amount negative so validation can reject it', async () => {
+ const createTransfer = vi.spyOn(api, 'createTransfer');
const user = userEvent.setup();
render();
// "-5" used to be silently rewritten to "5.00" and sent as a real transfer.
await fillForm(user, { amount: '-5' });
- expect(screen.getByLabelText(/^amount$/i)).toHaveValue(-5);
+ expect(screen.getByLabelText(/^amount$/i)).toHaveValue('-5.00');
await user.click(screen.getByRole('button', { name: /review & send/i }));
expect(
- await screen.findByText(/enter an amount greater than zero/i),
+ await screen.findByText(/amount cannot be negative/i),
).toBeInTheDocument();
+ expect(createTransfer).not.toHaveBeenCalled();
+ expect(
+ screen.queryByRole('dialog', { name: /confirm your transfer/i }),
+ ).not.toBeInTheDocument();
});
it('submits the exponent amount that the field actually held', async () => {
@@ -63,13 +94,8 @@ describe('Send flow — amount parsing regressions', () => {
render();
await fillForm(user, { amount: '1e3' });
- await user.click(screen.getByRole('button', { name: /review & send/i }));
-
- await screen.findByRole(
- 'heading',
- { name: /your transfers/i },
- { timeout: 5000 },
- );
+ await reviewAndConfirm(user);
+ await viewSubmittedTransfer(user);
expect(createTransfer).toHaveBeenCalledTimes(1);
expect(createTransfer.mock.calls[0][0]).toMatchObject({
sendAmount: '1000',
@@ -96,13 +122,8 @@ describe('Send flow — the receipt matches the quote', () => {
render();
await fillForm(user, { amount: '200' });
- await user.click(screen.getByRole('button', { name: /review & send/i }));
-
- await screen.findByRole(
- 'heading',
- { name: /your transfers/i },
- { timeout: 5000 },
- );
+ await reviewAndConfirm(user);
+ await viewSubmittedTransfer(user);
// 200.00 - 1.10 fee = 198.90, at 1480.5 NGN/USD = 294471.45 exactly.
const payload = createTransfer.mock.calls[0][0];
@@ -141,12 +162,8 @@ describe('Send flow — the receipt matches the quote', () => {
).toBeInTheDocument();
});
- await user.click(screen.getByRole('button', { name: /review & send/i }));
- await screen.findByRole(
- 'heading',
- { name: /your transfers/i },
- { timeout: 5000 },
- );
+ await reviewAndConfirm(user);
+ await viewSubmittedTransfer(user);
// The number on the receipt is the number that was quoted, to the cent.
// The seeded demo transfer shares this recipient, so find the row by the
@@ -205,7 +222,7 @@ describe('Send flow — contract failures do not submit', () => {
render();
await fillForm(user, { amount: '200' });
- await user.click(screen.getByRole('button', { name: /review & send/i }));
+ await reviewAndConfirm(user);
expect(
await screen.findByText(/rejected before it was sent/i, undefined, {
diff --git a/test/integration/transfers-filter.test.jsx b/test/integration/transfers-filter.test.jsx
index fb9dead..fd7bcbd 100644
--- a/test/integration/transfers-filter.test.jsx
+++ b/test/integration/transfers-filter.test.jsx
@@ -2,6 +2,7 @@ import { render, screen, waitFor } from '@testing-library/react';
import userEvent from '@testing-library/user-event';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import App from '../../src/App.jsx';
+import * as walletService from '../../src/services/wallet.js';
const TRANSFERS = [
{
@@ -112,8 +113,10 @@ describe('Transfers page filter sync', () => {
await waitFor(() => {
expect(window.location.search).toBe('');
});
- expect(screen.getByText(/amina@exam/)).toBeInTheDocument();
- expect(screen.getByText(/GBQAZ7Z3X7/)).toBeInTheDocument();
+ await waitFor(() => {
+ expect(screen.getByText(/amina@exam/)).toBeInTheDocument();
+ expect(screen.getByText(/GBQAZ7Z3X7/)).toBeInTheDocument();
+ });
});
it('filters by date-range preset and syncs to URL', async () => {
@@ -141,3 +144,91 @@ describe('Transfers page filter sync', () => {
expect(screen.queryByText(/amina@exam/)).not.toBeInTheDocument();
});
});
+
+describe('Transfers wallet scope', () => {
+ beforeEach(() => {
+ localStorage.clear();
+ window.history.pushState({}, '', '/transfers?status=completed');
+ });
+
+ afterEach(() => {
+ vi.restoreAllMocks();
+ localStorage.clear();
+ });
+
+ it.each(['individual', 'across pages'])(
+ 'resets pagination and %s selection when the wallet changes',
+ async (selection) => {
+ const user = userEvent.setup();
+ const wallet = { publicKey: 'GWALLET_A', balance: 1000 };
+ const makeTransfers = (actorId, count, prefix) =>
+ Array.from({ length: count }, (_, i) => ({
+ ...TRANSFERS[0],
+ id: `${prefix}_${i}`,
+ recipient: `${prefix}${i}@example.com`,
+ actorId,
+ }));
+ localStorage.setItem('remitflow.wallet', JSON.stringify(wallet));
+ localStorage.setItem(
+ 'remitflow.transfers',
+ JSON.stringify([
+ ...makeTransfers(wallet.publicKey, 7, 'walletA'),
+ ...makeTransfers(walletService.DEMO_PUBLIC_KEY, 3, 'demo'),
+ ]),
+ );
+ vi.spyOn(walletService, 'connectWallet').mockResolvedValue(wallet);
+
+ render();
+ const next = await screen.findByRole('button', { name: /next/i });
+ await user.click(next);
+ expect(screen.getByText(/page 2 of 2/i)).toBeInTheDocument();
+
+ if (selection === 'across pages') {
+ await user.click(
+ screen.getByLabelText(/select all transfers on this page/i),
+ );
+ await user.click(
+ screen.getByRole('button', { name: /select all 7 transfers/i }),
+ );
+ expect(screen.getByText('7 transfers selected')).toBeInTheDocument();
+ } else {
+ await user.click(
+ screen.getAllByRole('checkbox', { name: /select transfer to/i })[0],
+ );
+ expect(screen.getByText('1 transfer selected')).toBeInTheDocument();
+ }
+
+ // Keep the page mounted while the real context and list API switch
+ // from the connected wallet to the smaller demo-actor history.
+ await user.click(
+ screen.getAllByRole('button', { name: /disconnect/i })[0],
+ );
+ await waitFor(() => {
+ const rows = screen.getAllByRole('checkbox', {
+ name: /select transfer to demo/i,
+ });
+ expect(rows).toHaveLength(3);
+ rows.forEach((row) => expect(row).not.toBeChecked());
+ });
+ expect(screen.getByText('Select all')).toBeInTheDocument();
+ expect(
+ screen.queryByRole('navigation', { name: /pagination/i }),
+ ).not.toBeInTheDocument();
+ expect(window.location.search).toBe('?status=completed');
+
+ // Returning to the original wallet must not resurrect its old page
+ // or selection. Only the wallet adapter is mocked; view/data are real.
+ await user.click(
+ screen.getAllByRole('button', { name: /connect wallet/i })[0],
+ );
+ await screen.findByText(/page 1 of 2/i);
+ const rows = screen.getAllByRole('checkbox', {
+ name: /select transfer to walletA/i,
+ });
+ expect(rows).toHaveLength(5);
+ rows.forEach((row) => expect(row).not.toBeChecked());
+ expect(screen.getByText('Select all')).toBeInTheDocument();
+ expect(window.location.search).toBe('?status=completed');
+ },
+ );
+});
diff --git a/test/integration/transfers-search-navigation.test.jsx b/test/integration/transfers-search-navigation.test.jsx
new file mode 100644
index 0000000..422ec66
--- /dev/null
+++ b/test/integration/transfers-search-navigation.test.jsx
@@ -0,0 +1,136 @@
+import {
+ act,
+ fireEvent,
+ render,
+ screen,
+ waitFor,
+} from '@testing-library/react';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import App from '../../src/App.jsx';
+import * as api from '../../src/services/api.js';
+
+const ROWS = [
+ {
+ id: 'nav_a',
+ recipient: 'amina@example.com',
+ from: 'USD',
+ to: 'NGN',
+ sendAmount: 200,
+ receiveAmount: 294620,
+ status: 'completed',
+ createdAt: '2026-06-02T10:15:00Z',
+ },
+ {
+ id: 'nav_b',
+ recipient: 'ben@example.com',
+ from: 'USD',
+ to: 'INR',
+ sendAmount: 120,
+ receiveAmount: 9920,
+ status: 'pending',
+ createdAt: '2026-06-02T08:42:00Z',
+ },
+];
+const settle = () =>
+ act(async () => {
+ await new Promise((resolve) => setTimeout(resolve, 650));
+ });
+const searchInput = () => screen.getByLabelText(/search transfers/i);
+function popTo(query) {
+ act(() => {
+ window.history.pushState({}, '', `/transfers${query}`);
+ window.dispatchEvent(new PopStateEvent('popstate'));
+ });
+}
+async function open(query = '') {
+ window.history.pushState({}, '', `/transfers${query}`);
+ render();
+ await screen.findByRole('heading', { name: /your transfers/i });
+ await waitFor(() =>
+ expect(document.querySelector('.skeleton')).not.toBeInTheDocument(),
+ );
+ await settle();
+}
+
+describe('Transfer search URL navigation', () => {
+ beforeEach(() => {
+ localStorage.clear();
+ localStorage.setItem('remitflow.transfers', JSON.stringify(ROWS));
+ });
+ afterEach(() => {
+ vi.restoreAllMocks();
+ localStorage.clear();
+ });
+
+ it('keeps a navigated search instead of restoring the settled old query', async () => {
+ await open('?search=amina');
+ popTo('?search=ben');
+ await settle();
+ expect(window.location.search).toBe('?search=ben');
+ expect(searchInput()).toHaveValue('ben');
+ await screen.findByRole('checkbox', { name: /select transfer to ben/i });
+ expect(
+ screen.queryByRole('checkbox', { name: /select transfer to amina/i }),
+ ).not.toBeInTheDocument();
+ });
+
+ it('retires an unfinished search when history changes the search', async () => {
+ await open('?search=amina');
+ fireEvent.change(searchInput(), { target: { value: 'cancelled-draft' } });
+ popTo('?search=ben');
+ await settle();
+ expect(window.location.search).toBe('?search=ben');
+ expect(searchInput()).toHaveValue('ben');
+ await screen.findByRole('checkbox', { name: /select transfer to ben/i });
+ });
+
+ it('retires an unfinished search on POP even when only another filter changes', async () => {
+ await open('?search=amina');
+ fireEvent.change(searchInput(), { target: { value: 'cancelled-draft' } });
+ popTo('?search=amina&status=completed');
+ await settle();
+ expect(window.location.search).toBe('?search=amina&status=completed');
+ expect(searchInput()).toHaveValue('amina');
+ await screen.findByRole('checkbox', { name: /select transfer to amina/i });
+ });
+
+ it('clears a committed search without resurrecting it after the debounce', async () => {
+ await open('?search=missing&status=failed');
+ fireEvent.click(
+ await screen.findByRole('button', { name: /clear filters/i }),
+ );
+ await settle();
+ expect(window.location.search).toBe('');
+ expect(searchInput()).toHaveValue('');
+ await screen.findByRole('checkbox', { name: /select transfer to amina/i });
+ await screen.findByRole('checkbox', { name: /select transfer to ben/i });
+ });
+
+ it('preserves an unfinished edit when a local status control changes', async () => {
+ await open();
+ fireEvent.change(searchInput(), { target: { value: 'amina' } });
+ fireEvent.change(screen.getByLabelText(/filter by status/i), {
+ target: { value: 'completed' },
+ });
+ await settle();
+ const params = new URLSearchParams(window.location.search);
+ expect(params.get('search')).toBe('amina');
+ expect(params.get('status')).toBe('completed');
+ expect(searchInput()).toHaveValue('amina');
+ await screen.findByRole('checkbox', { name: /select transfer to amina/i });
+ });
+
+ it('issues one real list query for a burst of edits and uses the final term', async () => {
+ const calls = vi.spyOn(api, 'listTransfers');
+ await open();
+ calls.mockClear();
+ fireEvent.change(searchInput(), { target: { value: 'am' } });
+ fireEvent.change(searchInput(), { target: { value: 'ami' } });
+ fireEvent.change(searchInput(), { target: { value: 'amina' } });
+ await settle();
+ expect(calls).toHaveBeenCalledTimes(1);
+ expect(calls.mock.calls[0][0]).toMatchObject({ search: 'amina' });
+ expect(window.location.search).toBe('?search=amina');
+ await screen.findByRole('checkbox', { name: /select transfer to amina/i });
+ });
+});
diff --git a/test/integration/transfers-search-scale.test.jsx b/test/integration/transfers-search-scale.test.jsx
new file mode 100644
index 0000000..0265197
--- /dev/null
+++ b/test/integration/transfers-search-scale.test.jsx
@@ -0,0 +1,64 @@
+import { render, screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import App from '../../src/App.jsx';
+import { DEMO_PUBLIC_KEY } from '../../src/services/wallet.js';
+
+function buildHistory(count) {
+ return Array.from({ length: count }, (_, i) => ({
+ id: `tx_${String(i).padStart(4, '0')}`,
+ recipient:
+ i === 7
+ ? 'amina@example.com'
+ : `user${String(i).padStart(4, '0')}@example.com`,
+ from: 'USD',
+ to: 'NGN',
+ sendAmount: 10 + i,
+ receiveAmount: 1000 + i,
+ status: i % 2 === 0 ? 'completed' : 'pending',
+ createdAt: new Date(Date.UTC(2026, 5, 1, 12, 0, i)).toISOString(),
+ actorId: DEMO_PUBLIC_KEY,
+ }));
+}
+
+describe('Transfers search at scale', () => {
+ beforeEach(() => {
+ window.history.pushState({}, '', '/transfers');
+ localStorage.setItem(
+ 'remitflow.transfers',
+ JSON.stringify(buildHistory(120)),
+ );
+ });
+
+ afterEach(() => {
+ localStorage.clear();
+ });
+
+ it('keeps pagination responsive on a capped large history', async () => {
+ render();
+ await screen.findByRole('heading', { name: /your transfers/i });
+ await waitFor(() => {
+ expect(screen.getByLabelText(/search transfers/i)).toBeInTheDocument();
+ });
+
+ // Page size is 5; capped list still exposes next page.
+ const next = await screen.findByRole('button', { name: /next/i });
+ expect(next).toBeEnabled();
+ });
+
+ it('debounces search into the URL and finds the matching recipient', async () => {
+ const user = userEvent.setup();
+ render();
+ await screen.findByRole('heading', { name: /your transfers/i });
+
+ await user.type(screen.getByLabelText(/search transfers/i), 'amina');
+
+ await waitFor(
+ () => {
+ expect(window.location.search).toContain('search=amina');
+ expect(screen.getByText(/amina@exam/)).toBeInTheDocument();
+ },
+ { timeout: 4000 },
+ );
+ });
+});
diff --git a/test/unit/AppContext.wallet.test.jsx b/test/unit/AppContext.wallet.test.jsx
index 20c04bf..4436e1d 100644
--- a/test/unit/AppContext.wallet.test.jsx
+++ b/test/unit/AppContext.wallet.test.jsx
@@ -1,4 +1,3 @@
-
import { describe, expect, it, beforeEach, vi } from 'vitest';
import { render, screen, waitFor } from '@testing-library/react';
import { AppProvider, useApp } from '../../src/context/AppContext.jsx';
diff --git a/test/unit/list-transfers-search.test.js b/test/unit/list-transfers-search.test.js
new file mode 100644
index 0000000..38d30c0
--- /dev/null
+++ b/test/unit/list-transfers-search.test.js
@@ -0,0 +1,237 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import * as api from '../../src/services/api.js';
+import { ContractViolationError } from '../../src/services/contracts/schema.js';
+import { DEMO_PUBLIC_KEY } from '../../src/services/wallet.js';
+
+const STORAGE_KEY = 'remitflow.transfers';
+
+function seed(rows) {
+ localStorage.setItem(STORAGE_KEY, JSON.stringify(rows));
+}
+
+function transfer(overrides = {}) {
+ return {
+ id: 'tx_mine',
+ recipient: 'me@example.com',
+ from: 'USD',
+ to: 'NGN',
+ sendAmount: 10,
+ receiveAmount: 20,
+ status: 'completed',
+ createdAt: '2026-06-01T00:00:00Z',
+ actorId: DEMO_PUBLIC_KEY,
+ ...overrides,
+ };
+}
+
+describe('listTransfers search / cancellation / scope', () => {
+ beforeEach(() => {
+ vi.useFakeTimers();
+ localStorage.clear();
+ });
+
+ afterEach(() => {
+ vi.restoreAllMocks();
+ vi.useRealTimers();
+ localStorage.clear();
+ });
+
+ it('requires actor scope and hides other actors', async () => {
+ seed([
+ {
+ id: 'tx_mine',
+ recipient: 'me@example.com',
+ from: 'USD',
+ to: 'NGN',
+ sendAmount: 10,
+ receiveAmount: 20,
+ status: 'completed',
+ createdAt: '2026-06-01T00:00:00Z',
+ actorId: DEMO_PUBLIC_KEY,
+ },
+ {
+ id: 'tx_theirs',
+ recipient: 'them@example.com',
+ from: 'USD',
+ to: 'NGN',
+ sendAmount: 10,
+ receiveAmount: 20,
+ status: 'completed',
+ createdAt: '2026-06-02T00:00:00Z',
+ actorId: 'GOTHERWALLET',
+ },
+ ]);
+
+ const pending = api.listTransfers({ actorId: DEMO_PUBLIC_KEY });
+ await vi.advanceTimersByTimeAsync(400);
+ const rows = await pending;
+ expect(rows.map((r) => r.id)).toEqual(['tx_mine']);
+ });
+
+ it('rejects when actorId is missing and no fallback is provided via empty string', async () => {
+ expect(() => api.listTransfers({ actorId: '' })).toThrow(/actorId/i);
+ });
+
+ it.each([
+ { name: 'an empty actor history', ownRows: [], expectedIds: [] },
+ {
+ name: 'a valid actor history',
+ ownRows: [transfer()],
+ expectedIds: ['tx_mine'],
+ },
+ ])(
+ 'ignores foreign corrupt rows for $name',
+ async ({ ownRows, expectedIds }) => {
+ const errorLog = vi.spyOn(console, 'error').mockImplementation(() => {});
+ seed([
+ ...ownRows,
+ transfer({
+ id: 'tx_foreign',
+ actorId: 'GOTHERWALLET',
+ recipient: null,
+ }),
+ ]);
+
+ const pending = api.listTransfers({ actorId: DEMO_PUBLIC_KEY });
+ await vi.advanceTimersByTimeAsync(400);
+ const rows = await pending;
+
+ expect(rows.map((row) => row.id)).toEqual(expectedIds);
+ expect(errorLog).not.toHaveBeenCalled();
+ },
+ );
+
+ it('does not let a foreign valid row mask an actor-wide schema failure', async () => {
+ const errorLog = vi.spyOn(console, 'error').mockImplementation(() => {});
+ seed([
+ transfer({ recipient: null }),
+ transfer({ id: 'tx_foreign', actorId: 'GOTHERWALLET' }),
+ ]);
+
+ const pending = api.listTransfers({ actorId: DEMO_PUBLIC_KEY });
+ const rejection = expect(pending).rejects.toBeInstanceOf(
+ ContractViolationError,
+ );
+ await vi.advanceTimersByTimeAsync(400);
+ await rejection;
+ expect(errorLog).not.toHaveBeenCalled();
+ });
+
+ it('still rejects a non-array response before interpreting actor visibility', async () => {
+ seed({ error: 'unexpected response' });
+
+ const pending = api.listTransfers({ actorId: DEMO_PUBLIC_KEY });
+ const rejection = expect(pending).rejects.toBeInstanceOf(
+ ContractViolationError,
+ );
+ await vi.advanceTimersByTimeAsync(400);
+ await rejection;
+ });
+
+ it.each([
+ { actorId: DEMO_PUBLIC_KEY, expectedIds: ['tx_legacy'] },
+ { actorId: 'GOTHERWALLET', expectedIds: [] },
+ ])(
+ 'retains legacy visibility for $actorId',
+ async ({ actorId, expectedIds }) => {
+ seed([transfer({ id: 'tx_legacy', actorId: undefined })]);
+
+ const pending = api.listTransfers({ actorId });
+ await vi.advanceTimersByTimeAsync(400);
+ expect((await pending).map((row) => row.id)).toEqual(expectedIds);
+ },
+ );
+
+ it('normalizes the query actor without changing stored actor strings', async () => {
+ seed([
+ transfer(),
+ transfer({ id: 'tx_padded', actorId: ` ${DEMO_PUBLIC_KEY} ` }),
+ ]);
+
+ const pending = api.listTransfers({ actorId: ` ${DEMO_PUBLIC_KEY} ` });
+ await vi.advanceTimersByTimeAsync(400);
+ expect((await pending).map((row) => row.id)).toEqual(['tx_mine']);
+ });
+
+ it('cancels an obsolete in-flight query via AbortSignal', async () => {
+ seed([
+ {
+ id: 'tx_1',
+ recipient: 'amina@example.com',
+ from: 'USD',
+ to: 'NGN',
+ sendAmount: 10,
+ receiveAmount: 20,
+ status: 'completed',
+ createdAt: '2026-06-01T00:00:00Z',
+ actorId: DEMO_PUBLIC_KEY,
+ },
+ ]);
+
+ const controller = new AbortController();
+ const pending = api.listTransfers({
+ actorId: DEMO_PUBLIC_KEY,
+ signal: controller.signal,
+ });
+ controller.abort();
+ await expect(pending).rejects.toMatchObject({ name: 'AbortError' });
+ });
+
+ it('caps large result sets', async () => {
+ const rows = Array.from({ length: 250 }, (_, i) => ({
+ id: `tx_${i}`,
+ recipient: `user${i}@example.com`,
+ from: 'USD',
+ to: 'NGN',
+ sendAmount: 10,
+ receiveAmount: 20,
+ status: 'completed',
+ createdAt: new Date(Date.UTC(2026, 5, 1, 0, 0, i)).toISOString(),
+ actorId: DEMO_PUBLIC_KEY,
+ }));
+ seed(rows);
+
+ const pending = api.listTransfers({
+ actorId: DEMO_PUBLIC_KEY,
+ limit: 40,
+ });
+ await vi.advanceTimersByTimeAsync(400);
+ const result = await pending;
+ expect(result).toHaveLength(40);
+ });
+
+ it('applies search filter server-side', async () => {
+ seed([
+ {
+ id: 'tx_1',
+ recipient: 'amina@example.com',
+ from: 'USD',
+ to: 'NGN',
+ sendAmount: 10,
+ receiveAmount: 20,
+ status: 'completed',
+ createdAt: '2026-06-01T00:00:00Z',
+ actorId: DEMO_PUBLIC_KEY,
+ },
+ {
+ id: 'tx_2',
+ recipient: 'bola@example.com',
+ from: 'USD',
+ to: 'NGN',
+ sendAmount: 10,
+ receiveAmount: 20,
+ status: 'pending',
+ createdAt: '2026-06-02T00:00:00Z',
+ actorId: DEMO_PUBLIC_KEY,
+ },
+ ]);
+
+ const pending = api.listTransfers({
+ actorId: DEMO_PUBLIC_KEY,
+ search: 'bola',
+ });
+ await vi.advanceTimersByTimeAsync(400);
+ const result = await pending;
+ expect(result.map((r) => r.id)).toEqual(['tx_2']);
+ });
+});
diff --git a/test/unit/quote.test.js b/test/unit/quote.test.js
index 0fcfe52..9461138 100644
--- a/test/unit/quote.test.js
+++ b/test/unit/quote.test.js
@@ -4,18 +4,26 @@ import { buildQuote } from '../../src/services/quote.js';
describe('buildQuote', () => {
it('keeps submitted, fee, and receipt amounts as canonical decimal strings', () => {
const quote = buildQuote('100.10', 'USD', 'NGN');
+ // The quote contract removes redundant zeros while preserving exact values.
expect(quote).toMatchObject({
- sendAmount: '100.10',
- fee: '0.60',
- amountAfterFee: '99.50',
+ sendAmount: '100.1',
+ fee: '0.6',
+ amountAfterFee: '99.5',
receiveAmount: '147309.75',
});
});
it('regresses binary floating-point drift at the receipt boundary', () => {
const quote = buildQuote('0.30', 'USD', 'MXN');
- expect(quote.sendAmount).toBe('0.30');
- expect(quote.amountAfterFee).toBe('0.00');
- expect(quote.receiveAmount).toBe('0.00');
+ expect(quote.sendAmount).toBe('0.3');
+ // The minimum fee is 0.25: 0.05 * 17.1 = 0.855, rounded to 0.86 MXN.
+ expect(quote.fee).toBe('0.25');
+ expect(quote.amountAfterFee).toBe('0.05');
+ expect(quote.receiveAmount).toBe('0.86');
+
+ expect(buildQuote('0.20', 'USD', 'MXN')).toMatchObject({
+ amountAfterFee: '0',
+ receiveAmount: '0',
+ });
});
});
diff --git a/test/unit/transfer-filter-preparation.test.js b/test/unit/transfer-filter-preparation.test.js
new file mode 100644
index 0000000..cea8346
--- /dev/null
+++ b/test/unit/transfer-filter-preparation.test.js
@@ -0,0 +1,55 @@
+import { describe, expect, it } from 'vitest';
+import { applyTransferSearch } from '../../src/utils/transferSearch.js';
+
+const rows = Object.freeze(
+ Array.from({ length: 40 }, (_, index) =>
+ Object.freeze({
+ id: String(index),
+ actorId: 'demo',
+ recipient: 'Alice',
+ status: 'settled',
+ createdAt: '2026-09-27T12:00:00.000Z',
+ }),
+ ),
+);
+
+describe('transfer filter preparation', () => {
+ it('prepares the date window once per query instead of once per row', () => {
+ const now = new Date('2026-10-04T12:00:00.000Z');
+ const instant = now.getTime();
+ let clockReads = 0;
+ now.getTime = () => {
+ clockReads += 1;
+ return instant;
+ };
+ const result = applyTransferSearch(
+ rows,
+ { actorId: 'demo', search: ' ALICE ', status: 'success', range: '7d' },
+ { now },
+ );
+ expect(result.totalMatched).toBe(40);
+ expect(result.items).toHaveLength(40);
+ expect(clockReads).toBe(1);
+ });
+
+ it('refreshes the window for each query and preserves empty and invalid windows', () => {
+ const now = new Date('2026-10-04T12:00:00.000Z');
+ const query = { actorId: 'demo', range: '7d' };
+ expect(applyTransferSearch(rows, query, { now }).totalMatched).toBe(40);
+ now.setTime(now.getTime() + 1);
+ expect(applyTransferSearch(rows, query, { now }).totalMatched).toBe(0);
+ for (const range of ['', '0d', 'unknown']) {
+ expect(
+ applyTransferSearch(rows, { ...query, range }, { now }).totalMatched,
+ ).toBe(40);
+ }
+ for (const range of ['99999999999999999d', `${'9'.repeat(400)}d`]) {
+ expect(
+ applyTransferSearch(rows, { ...query, range }, { now }).totalMatched,
+ ).toBe(0);
+ }
+ expect(
+ applyTransferSearch(rows, query, { now: new Date(NaN) }).totalMatched,
+ ).toBe(0);
+ });
+});
diff --git a/test/unit/transfer-search.test.js b/test/unit/transfer-search.test.js
new file mode 100644
index 0000000..135cf24
--- /dev/null
+++ b/test/unit/transfer-search.test.js
@@ -0,0 +1,263 @@
+import { describe, expect, it } from 'vitest';
+import {
+ DEFAULT_RESULT_CAP,
+ MAX_RESULT_CAP,
+ applyTransferSearch,
+ isVisibleToActor,
+ matchesTransferFilters,
+ normalizeTransferQuery,
+ requireActorId,
+ stableSortTransfers,
+ transferQueryScopeKey,
+} from '../../src/utils/transferSearch.js';
+
+const ACTOR = 'GACTOR_A';
+const OTHER = 'GACTOR_B';
+const LEGACY = 'GLEGACY';
+
+function tx(overrides) {
+ return {
+ id: 'tx_1',
+ recipient: 'amina@example.com',
+ from: 'USD',
+ to: 'NGN',
+ sendAmount: '100',
+ receiveAmount: '1000',
+ status: 'completed',
+ createdAt: '2026-06-01T12:00:00Z',
+ actorId: ACTOR,
+ ...overrides,
+ };
+}
+
+describe('transferSearch scope and filters', () => {
+ it('requires a non-empty actorId on every query', () => {
+ expect(() => requireActorId('')).toThrow(/actorId is required/i);
+ expect(() => requireActorId(null)).toThrow(/actorId is required/i);
+ expect(requireActorId(' GXYZ ')).toBe('GXYZ');
+ });
+
+ it('hides another actor’s transfers and migrates legacy rows safely', () => {
+ expect(isVisibleToActor(tx({ actorId: ACTOR }), ACTOR)).toBe(true);
+ expect(isVisibleToActor(tx({ actorId: OTHER }), ACTOR)).toBe(false);
+ expect(
+ isVisibleToActor(tx({ actorId: undefined }), LEGACY, {
+ legacyActorId: LEGACY,
+ }),
+ ).toBe(true);
+ expect(
+ isVisibleToActor(tx({ actorId: undefined }), ACTOR, {
+ legacyActorId: LEGACY,
+ }),
+ ).toBe(false);
+ });
+
+ it('matches status aliases, recipient search, and date range', () => {
+ const row = tx({ status: 'settled', createdAt: '2026-06-04T00:00:00Z' });
+ const now = new Date('2026-06-05T12:00:00Z');
+ expect(matchesTransferFilters(row, { status: 'completed' }, now)).toBe(
+ true,
+ );
+ expect(matchesTransferFilters(row, { search: 'AMINA' }, now)).toBe(true);
+ expect(matchesTransferFilters(row, { search: 'nope' }, now)).toBe(false);
+ expect(matchesTransferFilters(row, { range: '7d' }, now)).toBe(true);
+ expect(
+ matchesTransferFilters(
+ tx({ createdAt: '2026-01-01T00:00:00Z' }),
+ { range: '7d' },
+ now,
+ ),
+ ).toBe(false);
+ });
+
+ it('stable-sorts by createdAt desc with id as tie-breaker', () => {
+ const rows = [
+ tx({ id: 'tx_a', createdAt: '2026-06-01T00:00:00Z' }),
+ tx({ id: 'tx_c', createdAt: '2026-06-02T00:00:00Z' }),
+ tx({ id: 'tx_b', createdAt: '2026-06-02T00:00:00Z' }),
+ ];
+ expect(stableSortTransfers(rows).map((r) => r.id)).toEqual([
+ 'tx_c',
+ 'tx_b',
+ 'tx_a',
+ ]);
+ });
+
+ it('stabilizes capped membership for canonically equivalent IDs', () => {
+ const rows = [tx({ id: 'tx_\u00e9' }), tx({ id: 'tx_e\u0301' })];
+ const query = { actorId: ACTOR, limit: 1 };
+ const forward = applyTransferSearch(rows, query);
+ const reversed = applyTransferSearch([...rows].reverse(), query);
+
+ expect(reversed.items).toEqual(forward.items);
+ expect(forward.items.map((row) => row.id)).toEqual(['tx_\u00e9']);
+ expect(forward.totalMatched).toBe(2);
+ expect(reversed.totalMatched).toBe(2);
+ expect(forward.capped).toBe(true);
+ expect(reversed.capped).toBe(true);
+ });
+
+ it('caps results and reports totalMatched for large histories', () => {
+ const rows = Array.from({ length: 250 }, (_, i) =>
+ tx({
+ id: `tx_${String(i).padStart(4, '0')}`,
+ createdAt: new Date(Date.UTC(2026, 5, 1, 0, 0, i)).toISOString(),
+ }),
+ );
+ const result = applyTransferSearch(
+ rows,
+ { actorId: ACTOR, limit: 50 },
+ { legacyActorId: LEGACY },
+ );
+ expect(result.items).toHaveLength(50);
+ expect(result.totalMatched).toBe(250);
+ expect(result.capped).toBe(true);
+ expect(result.items[0].id > result.items[49].id).toBe(true);
+ });
+
+ it('keeps the same capped rows as stable sorting across filters and duplicate keys', () => {
+ const rows = Object.freeze(
+ Array.from({ length: 850 }, (_, i) =>
+ Object.freeze(
+ tx({
+ id: `tx_${i % 11}`,
+ actorId: i % 4 === 0 ? OTHER : ACTOR,
+ recipient: i % 3 === 0 ? 'amina@example.com' : 'other@example.com',
+ status: i % 2 === 0 ? 'settled' : 'pending',
+ createdAt: new Date(Date.UTC(2026, 5, 1 + (i % 7))).toISOString(),
+ originalRow: i,
+ }),
+ ),
+ ),
+ );
+ const now = new Date('2026-06-08T12:00:00Z');
+ const queries = [
+ ...[1, 7, 100, 500, 9999].map((limit) => ({ actorId: ACTOR, limit })),
+ {
+ actorId: ACTOR,
+ search: ' AMINA ',
+ status: 'completed',
+ range: '7d',
+ limit: 7,
+ },
+ { actorId: OTHER, status: 'pending', limit: 1 },
+ { actorId: ACTOR, search: 'absent', limit: 100 },
+ ];
+ for (const query of queries) {
+ const normalized = normalizeTransferQuery(query);
+ const matched = rows.filter(
+ (row) =>
+ isVisibleToActor(row, normalized.actorId) &&
+ matchesTransferFilters(row, normalized, now),
+ );
+ const expected = stableSortTransfers(matched).slice(0, normalized.limit);
+ const result = applyTransferSearch(rows, query, { now });
+ expect(result).toEqual({
+ items: expected,
+ totalMatched: matched.length,
+ capped: matched.length > normalized.limit,
+ scopeKey: transferQueryScopeKey(normalized),
+ });
+ result.items.forEach((row, i) => expect(row).toBe(expected[i]));
+ }
+ });
+
+ it('preserves zero-time ordering, Unicode ties and sparse legacy histories', () => {
+ const rows = new Array(12);
+ rows[1] = tx({ id: 'tx_\u00e9', actorId: undefined, createdAt: 'invalid' });
+ rows[3] = tx({
+ id: 'tx_e\u0301',
+ actorId: undefined,
+ createdAt: undefined,
+ });
+ rows[4] = tx({
+ id: 'tx_z',
+ actorId: undefined,
+ createdAt: '1970-01-01T00:00:00Z',
+ });
+ rows[5] = tx({
+ id: 'tx_z',
+ actorId: undefined,
+ createdAt: 'invalid',
+ sendAmount: '200',
+ });
+ rows[7] = tx({
+ id: 'tx_z',
+ actorId: undefined,
+ createdAt: '1969-12-31T00:00:00Z',
+ });
+ rows[9] = tx({ id: 'tx_new', actorId: OTHER });
+ for (const limit of [1, 3, 4, 100]) {
+ const query = { actorId: LEGACY, limit };
+ const options = { legacyActorId: LEGACY };
+ const matched = rows.filter((row) =>
+ isVisibleToActor(row, LEGACY, options),
+ );
+ const expected = stableSortTransfers(matched).slice(0, limit);
+ const result = applyTransferSearch(rows, query, options);
+ expect(result.items).toEqual(expected);
+ expect(result.totalMatched).toBe(5);
+ expect(result.capped).toBe(5 > limit);
+ result.items.forEach((row, i) => expect(row).toBe(expected[i]));
+ }
+ expect(0 in rows).toBe(false);
+ expect(rows).toHaveLength(12);
+ });
+
+ it('normalizes and clamps the query limit', () => {
+ expect(normalizeTransferQuery({ actorId: ACTOR, limit: 9999 }).limit).toBe(
+ MAX_RESULT_CAP,
+ );
+ expect(normalizeTransferQuery({ actorId: ACTOR }).limit).toBe(
+ DEFAULT_RESULT_CAP,
+ );
+ });
+
+ it('builds a stable scope key so stale responses can be detected', () => {
+ const a = transferQueryScopeKey({
+ actorId: ACTOR,
+ search: 'amina',
+ status: 'completed',
+ range: '7d',
+ limit: 100,
+ });
+ const b = transferQueryScopeKey({
+ actorId: ACTOR,
+ search: 'amina',
+ status: 'completed',
+ range: '7d',
+ limit: 100,
+ });
+ const c = transferQueryScopeKey({
+ actorId: ACTOR,
+ search: 'other',
+ status: 'completed',
+ range: '7d',
+ limit: 100,
+ });
+ expect(a).toBe(b);
+ expect(a).not.toBe(c);
+ });
+
+ it('filters at scale within a tight budget', () => {
+ const rows = Array.from({ length: 5000 }, (_, i) =>
+ tx({
+ id: `tx_${i}`,
+ actorId: i % 3 === 0 ? OTHER : ACTOR,
+ recipient: i % 10 === 0 ? 'amina@example.com' : `user${i}@example.com`,
+ status: i % 2 === 0 ? 'completed' : 'pending',
+ createdAt: new Date(Date.UTC(2026, 0, 1 + (i % 150))).toISOString(),
+ }),
+ );
+ const started = performance.now();
+ const result = applyTransferSearch(
+ rows,
+ { actorId: ACTOR, search: 'amina', status: 'completed', limit: 100 },
+ { now: new Date('2026-06-05T12:00:00Z'), legacyActorId: LEGACY },
+ );
+ const elapsed = performance.now() - started;
+ expect(result.items.length).toBeLessThanOrEqual(100);
+ expect(result.items.every((r) => r.actorId === ACTOR)).toBe(true);
+ expect(elapsed).toBeLessThan(100);
+ });
+});
diff --git a/test/unit/useTransfers-search-race.test.jsx b/test/unit/useTransfers-search-race.test.jsx
new file mode 100644
index 0000000..2a2e29c
--- /dev/null
+++ b/test/unit/useTransfers-search-race.test.jsx
@@ -0,0 +1,311 @@
+import { renderHook, waitFor, act } from '@testing-library/react';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { useTransfers } from '../../src/hooks/useTransfers.js';
+import * as api from '../../src/services/api.js';
+import { DEMO_PUBLIC_KEY } from '../../src/services/wallet.js';
+
+function transfer(overrides = {}) {
+ return {
+ id: 'tx_created',
+ recipient: 'amina@example.com',
+ from: 'USD',
+ to: 'NGN',
+ sendAmount: '1',
+ receiveAmount: '2',
+ status: 'completed',
+ createdAt: new Date().toISOString(),
+ actorId: 'GACTOR_A',
+ ...overrides,
+ };
+}
+
+describe('useTransfers race and cancellation', () => {
+ beforeEach(() => {
+ localStorage.clear();
+ });
+
+ afterEach(() => {
+ vi.restoreAllMocks();
+ vi.useRealTimers();
+ localStorage.clear();
+ });
+
+ it('does not let a stale slower response overwrite newer filters', async () => {
+ let resolveSlow;
+ const slow = new Promise((resolve) => {
+ resolveSlow = resolve;
+ });
+
+ const listSpy = vi
+ .spyOn(api, 'listTransfers')
+ .mockImplementation((opts) => {
+ if (opts.search === 'old') {
+ return slow.then(() => [
+ {
+ id: 'tx_old',
+ recipient: 'old@example.com',
+ from: 'USD',
+ to: 'NGN',
+ sendAmount: '1',
+ receiveAmount: '2',
+ status: 'completed',
+ createdAt: '2026-06-01T00:00:00Z',
+ actorId: DEMO_PUBLIC_KEY,
+ },
+ ]);
+ }
+ return Promise.resolve([
+ {
+ id: 'tx_new',
+ recipient: 'new@example.com',
+ from: 'USD',
+ to: 'NGN',
+ sendAmount: '1',
+ receiveAmount: '2',
+ status: 'completed',
+ createdAt: '2026-06-02T00:00:00Z',
+ actorId: DEMO_PUBLIC_KEY,
+ },
+ ]);
+ });
+
+ const { result, rerender } = renderHook(
+ ({ search }) =>
+ useTransfers({
+ actorId: DEMO_PUBLIC_KEY,
+ filters: { search },
+ }),
+ { initialProps: { search: 'old' } },
+ );
+
+ await waitFor(() => {
+ expect(listSpy).toHaveBeenCalled();
+ });
+
+ rerender({ search: 'new' });
+
+ await waitFor(() => {
+ expect(result.current.transfers.map((t) => t.id)).toEqual(['tx_new']);
+ });
+
+ await act(async () => {
+ resolveSlow();
+ await slow;
+ });
+
+ // Stale "old" payload must not clobber the current filter results.
+ expect(result.current.transfers.map((t) => t.id)).toEqual(['tx_new']);
+ });
+
+ it('aborts the previous request when filters change', async () => {
+ const signals = [];
+ vi.spyOn(api, 'listTransfers').mockImplementation((opts) => {
+ signals.push(opts.signal);
+ return new Promise(() => {
+ /* never resolves — cancellation is the assertion */
+ });
+ });
+
+ const { rerender } = renderHook(
+ ({ search }) =>
+ useTransfers({
+ actorId: DEMO_PUBLIC_KEY,
+ filters: { search },
+ }),
+ { initialProps: { search: 'a' } },
+ );
+
+ await waitFor(() => expect(signals.length).toBe(1));
+ rerender({ search: 'ab' });
+ await waitFor(() => expect(signals.length).toBe(2));
+ expect(signals[0].aborted).toBe(true);
+ });
+
+ it('passes actorId on every list request', async () => {
+ const listSpy = vi.spyOn(api, 'listTransfers').mockResolvedValue([]);
+ renderHook(() =>
+ useTransfers({ actorId: 'GCUSTOM', filters: { status: 'pending' } }),
+ );
+ await waitFor(() => expect(listSpy).toHaveBeenCalled());
+ expect(listSpy.mock.calls[0][0]).toMatchObject({
+ actorId: 'GCUSTOM',
+ status: 'pending',
+ });
+ });
+
+ it('keeps a real delayed create in its original wallet after switching', async () => {
+ vi.useFakeTimers();
+ localStorage.setItem('remitflow.transfers', '[]');
+ const { result, rerender } = renderHook(
+ ({ actorId }) => useTransfers({ actorId }),
+ { initialProps: { actorId: 'GACTOR_A' } },
+ );
+ await act(() => vi.advanceTimersByTimeAsync(400));
+
+ let pending;
+ act(() => {
+ pending = result.current.addTransfer(transfer());
+ });
+ rerender({ actorId: 'GACTOR_B' });
+ await act(() => vi.advanceTimersByTimeAsync(400));
+ expect(result.current.loading).toBe(false);
+ await act(() => vi.advanceTimersByTimeAsync(300));
+
+ const created = await pending;
+ expect(created.actorId).toBe('GACTOR_A');
+ expect(JSON.parse(localStorage.getItem('remitflow.transfers'))).toEqual([
+ created,
+ ]);
+ expect(result.current.transfers).toEqual([]);
+ });
+
+ it.each(['new filters', 'return to the original scope'])(
+ 'ignores an old create completion after %s',
+ async (change) => {
+ let finishCreate;
+ vi.spyOn(api, 'createTransfer').mockImplementation(
+ () =>
+ new Promise((resolve) => {
+ finishCreate = resolve;
+ }),
+ );
+ const current = transfer({ id: 'tx_current' });
+ vi.spyOn(api, 'listTransfers').mockResolvedValue([current]);
+ const { result, rerender } = renderHook(
+ ({ search }) =>
+ useTransfers({ actorId: 'GACTOR_A', filters: { search } }),
+ { initialProps: { search: '' } },
+ );
+ await waitFor(() => expect(result.current.loading).toBe(false));
+ let pending;
+ act(() => {
+ pending = result.current.addTransfer(transfer());
+ });
+
+ rerender({ search: 'other' });
+ await waitFor(() => expect(result.current.loading).toBe(false));
+ if (change === 'return to the original scope') {
+ rerender({ search: '' });
+ await waitFor(() => expect(result.current.loading).toBe(false));
+ }
+ const created = transfer();
+ await act(async () => {
+ finishCreate(created);
+ expect(await pending).toBe(created);
+ });
+ expect(result.current.transfers).toEqual([current]);
+ },
+ );
+
+ it('uses canonical date and actor filters for create completions', async () => {
+ vi.spyOn(api, 'listTransfers').mockResolvedValue([]);
+ vi.spyOn(api, 'createTransfer').mockImplementation(
+ async (payload) => payload,
+ );
+ const { result } = renderHook(() =>
+ useTransfers({ actorId: 'GACTOR_A', filters: { range: '7d' } }),
+ );
+ await waitFor(() => expect(result.current.loading).toBe(false));
+
+ await act(async () => {
+ await result.current.addTransfer(
+ transfer({
+ createdAt: new Date(Date.now() - 30 * 86400000).toISOString(),
+ }),
+ );
+ await result.current.addTransfer(transfer({ actorId: 'GACTOR_B' }));
+ });
+ expect(result.current.transfers).toEqual([]);
+ });
+
+ it('merges matching creates once in canonical order after same-scope reload', async () => {
+ const latest = transfer({ id: 'tx_z' });
+ const duplicate = transfer({
+ id: 'tx_b',
+ status: 'settled',
+ createdAt: latest.createdAt,
+ });
+ vi.spyOn(api, 'listTransfers').mockResolvedValue([latest, duplicate]);
+ let finishCreate;
+ vi.spyOn(api, 'createTransfer').mockImplementation(
+ () =>
+ new Promise((resolve) => {
+ finishCreate = resolve;
+ }),
+ );
+ const { result } = renderHook(() =>
+ useTransfers({
+ actorId: 'GACTOR_A',
+ filters: { search: ' AMINA ', status: 'settled' },
+ limit: 2,
+ }),
+ );
+ await waitFor(() => expect(result.current.loading).toBe(false));
+ let pending;
+ act(() => {
+ pending = result.current.addTransfer(transfer());
+ });
+ await act(async () => {
+ await result.current.reload();
+ });
+ const updated = { ...duplicate, status: 'completed', receiveAmount: '3' };
+ await act(async () => {
+ finishCreate(updated);
+ await pending;
+ });
+ expect(result.current.transfers).toEqual([latest, updated]);
+ });
+
+ it("does not replace a current actor row with another actor's colliding ID", async () => {
+ const current = transfer({ id: 'tx_shared' });
+ vi.spyOn(api, 'listTransfers').mockResolvedValue([current]);
+ vi.spyOn(api, 'createTransfer').mockImplementation(
+ async (payload) => payload,
+ );
+ const { result } = renderHook(() =>
+ useTransfers({ actorId: ' GACTOR_A ' }),
+ );
+ await waitFor(() => expect(result.current.loading).toBe(false));
+ await act(async () => {
+ await result.current.addTransfer(
+ transfer({
+ id: 'tx_shared',
+ actorId: 'GACTOR_B',
+ }),
+ );
+ });
+ expect(result.current.transfers).toEqual([current]);
+ });
+
+ it('does not let an obsolete reload abort the current wallet request', async () => {
+ const requests = [];
+ const listSpy = vi.spyOn(api, 'listTransfers').mockImplementation(
+ (options) =>
+ new Promise((resolve) => {
+ requests.push({ ...options, resolve });
+ }),
+ );
+ const { result, rerender } = renderHook(
+ ({ actorId }) => useTransfers({ actorId }),
+ { initialProps: { actorId: 'GACTOR_A' } },
+ );
+ const oldReload = result.current.reload;
+ rerender({ actorId: 'GACTOR_B' });
+ act(() => {
+ oldReload();
+ });
+ expect(listSpy).toHaveBeenCalledTimes(2);
+ expect(requests[1].signal.aborted).toBe(false);
+
+ const current = transfer({ actorId: 'GACTOR_B' });
+ await act(async () => {
+ requests[1].resolve([current]);
+ });
+ await act(async () => {
+ requests[0].resolve([transfer()]);
+ });
+ expect(result.current.transfers).toEqual([current]);
+ expect(result.current.loading).toBe(false);
+ expect(result.current.error).toBeNull();
+ });
+});
diff --git a/test/unit/useTransfers.errors.test.jsx b/test/unit/useTransfers.errors.test.jsx
index 071426f..11741da 100644
--- a/test/unit/useTransfers.errors.test.jsx
+++ b/test/unit/useTransfers.errors.test.jsx
@@ -14,7 +14,9 @@ describe('useTransfers error retry policy', () => {
const { result } = renderHook(() => useTransfers());
await waitFor(() => {
- expect(result.current.error).toBe('Something went wrong. Please try again.');
+ expect(result.current.error).toBe(
+ 'Something went wrong. Please try again.',
+ );
});
expect(result.current.retryable).toBe(false);
diff --git a/vite-plugin-security-headers.js b/vite-plugin-security-headers.js
index af430cf..d3fb1d7 100644
--- a/vite-plugin-security-headers.js
+++ b/vite-plugin-security-headers.js
@@ -66,8 +66,8 @@ export function buildCsp(apiOrig = apiOrigin()) {
const directives = [
"default-src 'self'",
"script-src 'self'",
- "style-src 'self' 'unsafe-inline'", // CSS-in-JS / Vite inlines a tiny style tag
- "img-src 'self' data:", // data: URIs used by chart canvas toDataURL
+ "style-src 'self' 'unsafe-inline'", // CSS-in-JS / Vite inlines a tiny style tag
+ "img-src 'self' data:", // data: URIs used by chart canvas toDataURL
`connect-src ${connectSrc.join(' ')}`,
"font-src 'self'",
"object-src 'none'",
@@ -90,8 +90,7 @@ export const SECURITY_HEADERS = {
'X-Content-Type-Options': 'nosniff',
'X-Frame-Options': 'DENY',
'Referrer-Policy': 'strict-origin-when-cross-origin',
- 'Permissions-Policy':
- 'camera=(), microphone=(), geolocation=(), payment=()',
+ 'Permissions-Policy': 'camera=(), microphone=(), geolocation=(), payment=()',
'Cross-Origin-Opener-Policy': 'same-origin',
'Cross-Origin-Resource-Policy': 'same-origin',
'Strict-Transport-Security': 'max-age=31536000; includeSubDomains',