fix(frontend): order same-timestamp send/receive pairs (receive above send)

[sbpublic]

Motivation

In the activity list, the two legs of a single operation — a swap's send + receive, or a self-transfer — share the same block timestamp. sortTransactions compared only the (second-normalized) timestamp and returned 0 on ties, so these pairs fell back to Array.sort insertion order (driven by token/provider load order). The result looked arbitrary: sometimes the send appeared above the receive, sometimes below.

Changes

• sortTransactions: when timestamps are equal, break the tie deterministically by type — the received leg sorts above the sent one. This is the single comparator the whole activity list uses, so every same-second send/receive pair (swaps, self-transfers, …) now orders consistently.
• sortTransactions: return 0 when both timestamps are nullish (previously 1 — and 1 again when swapped, an antisymmetry-contract violation that left such pairs in engine-dependent order). The single-nullish case still sorts nullish last. (From Copilot review.)

Tests

• Added sortTransactions tests: the received leg sorts above the sent one for a same-timestamp pair (regardless of input order), and the comparator returns 0 for two nullish-timestamp transactions in both argument orders.
• transactions.utils.spec.ts passes in full (78).
• Manual verification on test_fe_3.

Independent of #13242 — based directly on main and mergeable on its own. This is a standalone determinism fix for same-timestamp send/receive ordering (it also covers self-transfers). The full visible swap-pair effect additionally needs #13242's dedup fix (which keeps both legs); the two can land in any order.

---

Model: Claude Opus 4.8 (claude-opus-4-8)

🤖 Generated with Claude Code

[Copilot]

Pull request overview

Ensures the global Activity list orders same-timestamp transaction pairs (swap/self-transfer send+receive legs) deterministically by adding a tie-breaker to the shared sortTransactions comparator and validating it with a unit test.

Changes:

• Add a same-second tie-breaker in sortTransactions that ranks receive above send.
• Introduce a helper to rank transaction types for tie-breaking.
• Add a unit test asserting receive-before-send ordering regardless of input order.

Reviewed changes

Copilot reviewed 2 out of 2 changed files in this pull request and generated 2 comments.

File	Description
src/frontend/src/lib/utils/transactions.utils.ts	Adds type-based tie-breaker for same-timestamp sorting in sortTransactions.
src/frontend/src/tests/lib/utils/transactions.utils.spec.ts	Adds regression test for receive-above-send ordering on timestamp ties.

[zeropath-ai]

✅ No security or compliance issues detected. Reviewed everything up to cf86823.

Security Overview

• 🔎 Scanned files: 2 changed file(s)
• 🔗 Scan Link: https://zeropath.com/app/repositories/00881019-f162-4503-9567-953b0be667d7?scanId=34b96a6c-ff6f-4d99-b84d-d3b9efdd07d2&codeScanTypes=PrScan&tab=issues

Detected Code Changes

Change Type	Relevant files
Enhancement	► src/frontend/src/lib/utils/transactions.utils.ts     Improve transaction sorting logic to handle timestamp ties deterministically by ranking received transactions above sent transactions.     Introduce sameTimestampTypeRank helper function for ranking transaction types.
Enhancement	► src/frontend/src/tests/lib/utils/transactions.utils.spec.ts     Add tests to verify the deterministic sorting of transactions with tied timestamps, specifically ensuring received legs appear before sent legs.     Add a test case for scenarios where both timestamps are nullish.